Skip to content
Skills Library
DevOps & cloud · Tool integration

codealta-fleet

/codealta-fleet

Use this skill to work with the CodeAlta fleet - the machines this computer is paired with or reaches through a CodeAlta Server - to pick a machine for a task (capabilities, tags, readiness, load), start or steer a session on another machine, move a session, place or run an automation on a machine, read the statistics, updates, health and devices of the fleet, read people and access (roles, teams, grants, owners) to propose a change for a person to apply, read the signed policy of the organization and its kill switch, and read and check the audit log.

Repository
codealta ↗
Licence
BSD-2-Clause
Last repository change
13.11.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 13.11.2026, without references to retired models or APIs.

Licence

BSD-2-Clause, otwarta.

What it does and when to use it

Use this skill to work with the CodeAlta fleet - the machines this computer is paired with or reaches through a CodeAlta Server - to pick a machine for a task (capabilities, tags, readiness, load), start or steer a session on another machine, move a session, place or run an automation on a machine, read the statistics, updates, health and devices of the fleet, read people and access (roles, teams, grants, owners) to propose a change for a person to apply, read the signed policy of the organization and its kill switch, and read and check the audit log.

Original author description

Use this skill to work with the CodeAlta fleet - the machines this computer is paired with or reaches through a CodeAlta Server - to pick a machine for a task (capabilities, tags, readiness, load), start or steer a session on another machine, move a session, place or run an automation on a machine, read the statistics, updates, health and devices of the fleet, read people and access (roles, teams, grants, owners) to propose a change for a person to apply, read the signed policy of the organization and its kill switch, and read and check the audit log.

How it works

  1. Pick a machine for a task
  2. Start and steer work elsewhere
  3. Move a session
  4. Automations on machines
  5. Events of other tools
  6. Statistics, updates and health
  7. People and access
  8. Policy and the kill switch
  9. Audit log
  10. Rules
Original SKILL.md headings · 86 lines, 1,992 words
SKILL.md preview
---
name: codealta-fleet
description: Use this skill to work with the CodeAlta fleet - the machines this computer is paired with or reaches through a CodeAlta Server - to pick a machine for a task (capabilities, tags, readiness, load), start or steer a session on another machine, move a session, place or run an automation on a machine, read the statistics, updates, health and devices of the fleet, read people and access (roles, teams, grants, owners) to propose a change for a person to apply, read the signed policy of the organization and its kill switch, and read and check the audit log.
---

# The CodeAlta fleet

The fleet is this computer and the machines it reaches: paired machines, and the machines of an organization through its CodeAlta Server. Use the `alta` tool. Each command answers with JSON records, one per line.

`alta fleet --help` lists the commands of the fleet, and `alta fleet <command> --help` gives the options, the fields of the records and examples of each. This page explains the important ones.

## Pick a machine for a task

1. `alta fleet machine list --ready` lists the machines that take a new session from this computer now. Each record has:
   - `readiness`: `ready`, `not_allowed` (this computer may not start sessions there), `no_provider`, `updating`, or `offline`, `connecting`, `unauthorized`;
   - `working`: how many of its sessions work now, its load;
   - `sessionLimit` and `queued`: how many sessions its owner lets work there at once (absent for no limit), and how many runs wait for their turn there;
   - `os`, `capabilities` (`sandbox`, `moves`), `tags` (given by its owner, such as `gpu`; `labels` repeats them under their former name), `providers`, `permissions`.
2. Choose by what the task needs first, then by load: the system (`os` is `macos` for an iOS build), a tag (`--tag gpu`), a capability (`--capability sandbox`), a provider (`--provider <name>`); among those, a machine with a free seat (`working` under `sessionLimit`, nothing `queued`), then the shortest queue, then the lowest `working`, and `channel` `direct` before `relayed`. A full machine is still `ready`: it takes the work and queues it. Prefer this computer when nothing requires another machine.
3. `alta fleet machine show <machine>` asks the machine for its projects and its ready providers: the project `id` and the provider `key` are what a session there names. A project whose `repository` is the one you work in is the same repository there.

A machine that is not ready is not chosen. Say why to the user when no machine fits: its owner gives a permission, configures a provider, or brings it online.

## Start and steer work elsewhere

- `alta session create --machine <machine> --project <project-id> --stdin` starts a session there, the prompt on stdin. It is your child: its final answer comes back to you, so do not poll it. Without `--project`, the machine takes its project of the same repository as yours. Name a model with `--model-ref <provider>:<model>`; the model tiers of this computer mean nothing there. On a full machine the record says `queued` with `queuePosition`: the prompt waits there for its turn and is sent then, and the answer still comes back to you.
- `alta session send <session-id> --stdin` prompts it again; `alta session report <session-id>` reads where it stands and its answer.
- `alta fleet machine sessions <machine>` lists the sessions of a machine; `yours` marks your children.

## Move a session

- `alta fleet move status <session-id> --machine <machine>` says what a move would meet: `busy`, `targetStatus`, `targetCode`, what stays behind.
- `alta fleet move start <session-id> --machine <machine>` moves it with its conversation and its work in progress; add `--clone` when the machine has no project of its repository and `canClone` is true. Your own session moves when your turn ends: end your turn.

## Automations on machines

- `alta fleet automation list` says where each automation runs, and where its copy stands on its machine; one that runs on the machines with some tags has `tags` and `members`, each machine of its pool with where its copy stands.
- `alta fleet automation place <automation-id> --machine <machine>` makes a disabled automation run on that machine; `--tag gpu --tag linux` on every machine of the user's server that has all these tags (a pool); `--here` brings it back. A person enables it.
- A pool needs a CodeAlta Server: each machine of the pool fires the triggers and claims each due time or event there, and one runs it. It takes schedules, cron, issues, pull requests and Jira; a command, Slack or a hook of a server keep an automation on one machine. A machine that loses a tag, or cannot reach the server, runs nothing of it.
- `alta fleet automation run <automation-id>` runs it now where it runs (for a pool, on the member with the most free seats); `alta fleet automation runs <automation-id>` reads its runs, those its machines reported included, each with its `machineId`.

## Events of other tools

- An automation starts on Jira (a version released, an issue of a JQL query), Slack (a message or a mention, over Socket Mode) or a hook of a server (incident.io, a signed webhook) when its triggers say so (`alta automation create --help`). Their credentials are `${secret:NAME}` references to secrets of the machine that runs it: check them with `alta fleet secret list <machine>`.
- `alta fleet hook list` lists the hooks of the person on a server, with the address each gives a tool and its machine; `--events <hook-id>` says what the machine did with its latest events (`accepted`, `refused` with why, such as a signature that does not verify, `expired`). The server holds no signing secret: the machine checks each event.
- A person makes a hook, tests the connection, looks at a sample event and tries the automation in the Automations tab.
- An automation with `autonomy` (`alta automation show`) calls only the tools it lists by itself, within a rate; anything else waits for its owner (on a server, the team that owns it, who is granted to approve it, or with `approvers = "oncall"` the person on call of its team, read from its `oncall` schedule of incident.io, PagerDuty or Opsgenie when it names one), and the run reads `waiting`. A tool may be pinned (`hash`, `version`), bounded (argument values, `min`/`max`) and checked first (`preconditions`): a call outside its pin or bounds waits for a person, and one whose precondition fails is not made. The machine enforces it: never try to get around a held call. A person answers it, or takes the run over in the Automations tab.

## Statistics, updates and health

- `alta fleet statistics --days 30 --group-by machine,provider` reads the sums of what the person's machines did (runs, tokens, tool calls, estimated costs) from the server.
- `alta fleet update status` reads the versions of the server and of its machines, the update policy and the recent campaigns.
- `alta fleet health` says how each server connection stands, and which machines do not take sessions now, with why.
- `alta fleet machine devices <machine>` lists the devices of a machine this computer manages and what each may do there.
- `alta fleet secret list <machine>` lists the secrets and variables of a machine this computer manages by name (without a machine, of this computer): check that a machine has what a task there names as `${secret:NAME}` before you start it.

## People and access

At a CodeAlta Server, `alta fleet access` reads who is who and who may do what, as far as the person of this computer may see:

- `alta fleet access show` says who the person is there (`role`, `teams`, `capabilities`), whether they sign the access document, and the changes that wait for a signer (`pending`): machines see those once an owner or an admin signs them.
- `alta fleet access people`, `alta fleet access teams`, `alta fleet access grants` list people (role, status, teams), teams (maintainers, members, team machines) and grants.
- `alta fleet access owners` lists machines and automations with their owners: those `paused` wait for their owner to resume them, those whose `ownerSuspended` is true were owned by someone who left and need a new owner.
- `alta fleet access transfers` lists the transfers that concern the person; `alta fleet access review` lists who can do what (for owners, admins and auditors).
- `alta fleet access identities` lists the service identities the automations of a team or of the organization run as, and whether each is `enabled`; `alta fleet access grants` says of a grant of a sealed session whether its grantee has a device that `missingKeys` (a computer of its owner gives it next time it is online).
- `alta fleet access document` says what the signed access document this computer verified gives machines: `teamMachines`, the identities each team runs as (`teamServices`), `organizationMachines` and `organizationServices`, and the owners of automations (`alta.fleet.access.automation`: `owner`, and `paused` while it waits for its owner to resume it). A machine decides by this, not by the server: a change the server shows in `pending` is not followed before a signer signs it.
- `alta fleet access propose <kind> --summary "<why>" --stdin` records a change for a person to apply (`role`, `team-member`, `grant`, `transfer`, `team`), the request as a JSON object on stdin (`alta fleet access propose --help` gives each). It changes nothing by itself: tell the user it waits for them in Settings > Fleet > People and access.

A team machine runs the sessions of its team's members, each seeing only their own, and the automations of the team, which its maintainers publish to it (**Publish to** in the editor of an automation): they run as a service identity of the team, with account credentials only, never a personal plan. A machine of the organization runs the automations of the organization the same way. When a machine refuses work with `not_allowed`, read `alta fleet access show` and `owners` to say who can help.

## Policy and the kill switch

- `alta fleet policy show` says the rules of the organization this computer verified (providers, models, sandbox, network, tools off, who starts where, the longest session, the permission mode) and the `stop` of its kill switch while one holds, with `stopsThisComputer`.
- Read it before starting work on another machine: a machine refuses what the policy does not allow with `policy.refused` and its reason, and every new piece of work with `fleet.stopped` while a stop reaches it. Do not retry or try another machine of the same stop: tell the user, who lifts the stop in Settings > Fleet > Policies.

## Audit log

- `alta fleet audit list` reads who did what, newest first: `--action team.` (an action or a prefix), `--person`, `--device`, `--result failure`, `--since`/`--until`, `--q` words; `--before <sequence>` reads the next page. Owners, admins and auditors read it.
- `alta fleet audit verify` checks the chain of hashes: `valid`, the number of `records`, the `head` hash, or `brokenAt`. A broken chain is for the user at once.
- A person exports the log (CSV, JSON Lines) in Settings > Fleet > Audit: no command writes a file.

## Rules

- **Never more power than the person.** Every command has the access of the person of this computer, and a session you start has your permission mode and your sandbox at most.
- **The fleet is never a way out of a sandbox.** Your sandbox and your permission mode are the floor of what you start or drive on another machine; a sandboxed session reads the fleet and starts, moves or places nothing elsewhere, and one whose sandbox does not allow the fleet (`sandbox.fleetDenied`, as `strict`) does not even read it.
- **Access is read only.** Devices, permissions, roles, teams, grants, transfers, pairing, policies and the kill switch are changed by a person, in Settings > Fleet: propose the change with `alta fleet access propose`, do not look for another way to make it.
- **Secrets are names.** You never read, set or send the value of a secret, nor put one in a prompt: the user sets it, here or on the machine.
- **What runs unattended waits for a person.** An automation you create stays disabled, you enable none (`automation.needsPerson`), and you place a disabled one only: a person enables it; a person starts an update campaign (`alta fleet update start` is refused with `fleet.needsPerson`).
- On `fleet.needsPerson` or `fleet.notAllowed`, stop that step and tell the user what you would do and why. A Private session reaches no other machine.

Versions

The database has no other skills named codealta-fleet.

Database snapshot: 13.11.2026 · package version d26d7edcffcf (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100codealta-monorepo
    Use this skill to set a repository up as a monorepo in CodeAlta, or to change how it is set up - find the folders that are projects of their own (services, apps, libraries, git submodules), propose them with the labels that organize them, write the project map…
  • 95codealta-plugin-runtime
    Use this skill to create, change, build, reload, test or troubleshoot a CodeAlta plugin - C# code that adds commands, dialogs, status items, agent tools, alta commands, prompt text or timeline cards to CodeAlta.
  • 90z23-dev-fleet
    Use when a maintainer coordinates Z23 development machines - orient, check lanes and builds, read the board, run a command on every machine, review a contributor branch, or land a reviewed commit. Read before the first fleet command in a session.
  • 100fleet-health
    One-shot, read-only health snapshot across the personal fleet (DGX Spark, Jetson Orin Nano, homeserver, bond, obvm). Checks uptime, load, disk, memory, and each machine's key inference/service endpoints over SSH and curl, then renders a single status table with a pass/fail…
  • 100concierge
    Operate the fleet from one chat — use in the fleet machine (dm-fleet) at every session start and whenever a message arrives from Telegram, the operator asks "what is going on", wants something sent to the phone, wants a machine told something, answers a gate in words, shares a…
  • 100fleet-operations
    Manage the machines on a Harness account by conversation — read the fleet, link and unlink, rename, note and group, bring a new computer in, remove one. Use in a Machine Monitor workspace whenever the person asks about their computers, what is running on them, or wants one…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.