@ours.network/fleet 1.2.0-nightly.17 → 1.2.0-nightly.19

package/README.md

@@ -376,9 +376,9 @@ preserve at most one recent late occurrence. The trusted authoring file and
 private sealed role snapshot retain exact prompt text; resolved launch, task,
 room, provenance, and audit presentation surfaces show only bytes and SHA-256.
 
-Every packaged `Developer`, `Critic`, and `LocalCoordinator` Agent Template uses
+Every packaged `Developer`, `Engineer`, `Critic`, and `LocalCoordinator` Agent Template uses
 `monitor.mode: fleet` with `monitor.interrupt: after_tool`. Consequently every
-member of the standard `single`, `pair`, and `team` Room Templates resolves to
+member of the standard `single`, `pair`, `team`, and `engineering` Room Templates resolves to
 that policy. A custom Agent Template or explicit per-member override remains
 authoritative and is merged key by key without rewriting unrelated values.
 
@@ -524,7 +524,7 @@ ours-fleet up
 
 ### Rooms and tasks
 
-Init installs editable `single`, `pair`, and `team` definitions under
+Init installs editable `single`, `pair`, `team`, and `engineering` definitions under
 `~/fleet/room_templates/`, plus every exact-cased Agent, Role, and Brain they
 reference. Inspect them with `ours-fleet template list` and
 `ours-fleet template show team`. After configuring the authenticated owner below:
@@ -533,8 +533,25 @@ reference. Inspect them with `ours-fleet template list` and
 ours-fleet task create --title "Solo task" --template single
 ours-fleet task create --title "Reviewed change" --template pair
 ours-fleet task create --title "Phased delivery" --template team
+ours-fleet task create --title "Gated feature build" --template engineering
 ```
 
+`engineering` pairs a gate-pipeline `Engineer` with the standard `Critic`. The
+Engineer works every non-trivial task through ordered gates — scope and a numbered
+Definition of Done before code, an over-engineering check, spec before
+implementation, test-first, review, a sized security pass, docs, and evidence-backed
+DoD verification — invoking an installed gate-pipeline skill when one is present and
+walking the same gates by hand otherwise. The seat is labelled `Engineer`, so a
+gated seat is never mistaken for a plain `Developer`. To make it the default for
+development tasks, set `tasks: { default_room_template: engineering }` in
+`fleet.yaml`.
+
+The `engineering` starter expresses a prompt-level workflow mandate; Fleet does not enforce
+the gates at runtime or install pipeline skills. The Engineer label identifies that mandate,
+not a completed review. When migrating an existing install, a newly added Engineer uses
+the existing Developer template's brain selection and keeps the packaged restrictive permissions.
+Existing customized Engineer files are preserved.
+
 The default `team` gives only its LocalCoordinator Agent Template a 15-minute
 continuity loop. Each idle-only pass uses authenticated assigned-room evidence,
 posts at most one missing interval update or status request, and reports `STALLED`
@@ -588,8 +605,9 @@ non-owner-controlled parent fail closed before host setup and are rechecked unde
 per-setup init lock before publication.
 
 The generated task experiences are fixed consequences, not extra questions: `single`
-uses `Developer`; `pair` uses `Developer` with an independent `Critic`; and `team` uses
-task-local `LocalCoordinator`, `Developer`, and `Critic`. The persistent
+uses `Developer`; `pair` uses `Developer` with an independent `Critic`; `team` uses
+task-local `LocalCoordinator`, `Developer`, and `Critic`; and `engineering` uses the
+gate-pipeline `Engineer` with an independent `Critic`. The persistent
 `FleetCoordinator` uses the separate packaged `Coordinator` contract and coordination
 model.
 
@@ -666,6 +684,29 @@ continuation is serialized per Task and remains alive until convergence or an
 Owner-action blocker. Re-running `task start <id>` safely resumes the same durable
 provisioning operation after the blocker is corrected or a process restarts.
 
+Live health is distinct from durable lifecycle. `task show TASK --json` adds a
+`readiness` observation for active tasks (`ready`, `degraded`, or `unknown`); human
+and authenticated Owner task-show output display the same observation. Task start/work
+continue to reject unavailable health with `task_not_ready`. A same-role untracked
+seat or a changed recorded launch cannot satisfy an original slot. Each control,
+liveness, and production Cowork probe is bounded; members are checked sequentially,
+so total latency grows with room size. These are point-in-time observations, not
+proof that a timed-out session is dead or permission to respawn it.
+
+Before deliberate recovery, Fleet Coordinator must inspect existing room seats and
+the exact old launch's termination record and worklog under `recovery/temporary`.
+Keep original slot records and archives intact; record verified old/new identity
+and launch provenance privately. Never restore archived identity state or reuse
+consumed invites. A same-role seat is only a possible replacement, not proven ownership.
+
+A replacement's empty inbox does not establish that no work is pending. Paginate
+scoped room/operator history to the end, retain the cursor privately, authenticate
+historical Owner instructions from identity metadata, and compare replies, worklogs,
+and already-completed actions before resuming. Ask the Owner when authority or
+completion is uncertain. Transfer only necessary non-secret context; never replay
+instructions blindly. Observation does not adopt seats, launch replacements, change
+lifecycle, or modify retained recovery evidence.
+
 Set `room.anonymous: true` on a room template, or pass `--anonymous` to
 `task create`, `task start`, `task work`, or `room create`, to create an
 anonymous Cowork room. `--no-anonymous` explicitly overrides an anonymous

package/dist/agent-ours/harness.js

@@ -20,12 +20,19 @@ export function prepareManagedHarness(role, stateDir, cwd, descriptor, env) {
         args: [bridge],
         env: [{ name: 'FLEET_OURS_BRIDGE_DESCRIPTOR', value: descriptor }],
     };
+    // Portable allow covers bound identity messaging, not all tools on the server.
+    const tools = role.harness === 'codex' && role.permissions?.approval === 'allow'
+        ? Object.fromEntries([
+            'current_identity', 'get_messages', 'list_history', 'list_contacts', 'send_message',
+        ].map(name => [name, { approval_mode: 'approve' }]))
+        : undefined;
     const native = {
         mcp_servers: {
             ours: {
                 command: process.execPath,
                 args: [bridge],
                 env: { FLEET_OURS_BRIDGE_DESCRIPTOR: descriptor },
+                ...(tools ? { tools } : {}),
             },
         },
         plugins: { 'ours@ours-codex-marketplace': { enabled: false } },
@@ -35,6 +42,7 @@ export function prepareManagedHarness(role, stateDir, cwd, descriptor, env) {
         const config = child.CODEX_CONFIG ? JSON.parse(child.CODEX_CONFIG) : {};
         child.CODEX_CONFIG = JSON.stringify({
             ...config,
+            mcp_servers: { ...config.mcp_servers, ...native.mcp_servers },
             plugins: { ...config.plugins, ...native.plugins },
         });
         // codex-acp otherwise prefers a same-name connector from the user's config.

package/dist/application/task-room-service.d.ts

@@ -1,4 +1,4 @@
-import { type LiveReadinessDeps } from '../rooms-tasks/live-readiness.js';
+import { type LiveReadinessDeps, type TaskReadinessIssue } from '../rooms-tasks/live-readiness.js';
 import { type FleetConfig } from '../config.js';
 import { type CoworkAdapter } from '../rooms-tasks/cowork-adapter.js';
 import { provisionMembers } from '../rooms-tasks/provision.js';
@@ -90,7 +90,9 @@ export declare function resolveRoomLaunchPolicy(template: TemplateSnapshot | und
 export interface TaskRoomServiceDeps {
     liveReadiness?: LiveReadinessDeps;
     loadConfiguration?(path?: string): FleetConfig;
-    cowork?(config: FleetConfig): CoworkAdapter;
+    cowork?(config: FleetConfig, options?: {
+        timeoutMs: number;
+    }): CoworkAdapter;
     binPath?(): string;
     provisionMembers?: typeof provisionMembers;
     moveTaskToList?: typeof moveTaskToList;
@@ -306,6 +308,11 @@ export declare class TaskRoomApplicationService {
         taskId: string;
         outcome?: TaskOutcome;
     }): Promise<TaskSettlementPlan>;
+    /** Point-in-time health, separate from durable provisioning and lifecycle. */
+    observeTaskReadiness(taskId: string): Promise<{
+        state: 'ready';
+    } | TaskReadinessIssue>;
+    private observeLiveReadiness;
     private assertTaskLiveReadiness;
     ensureTaskWork(input: {
         actor: TaskRoomActor;

package/dist/application/task-room-service.js

@@ -663,10 +663,30 @@ export class TaskRoomApplicationService {
             (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
         return this.acceptTerminal(task.task_id, 'done', task.room_id, input.outcome);
     }
-    async assertTaskLiveReadiness(task, room, cfg) {
-        const cowork = this.deps.cowork ? this.deps.cowork(cfg)
-            : createCoworkAdapter({ configPath: cfg.rooms?.cowork?.config });
+    /** Point-in-time health, separate from durable provisioning and lifecycle. */
+    async observeTaskReadiness(taskId) {
+        const task = readTask(taskId);
+        const room = task.room_id ? getRoomRecord(task.room_id) : undefined;
+        try {
+            const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
+            return await this.observeLiveReadiness(task, room, cfg) ?? { state: 'ready' };
+        }
+        catch {
+            return { state: 'unknown', reason: 'readiness_unavailable' };
+        }
+    }
+    async observeLiveReadiness(task, room, cfg) {
+        const cowork = this.deps.cowork ? this.deps.cowork(cfg, { timeoutMs: 2_000 })
+            : createCoworkAdapter({ configPath: cfg.rooms?.cowork?.config, timeoutMs: 2_000 });
         const issue = await taskLiveReadiness(task, room, cowork, this.deps.liveReadiness);
+        if (issue)
+            return issue;
+        if (JSON.stringify(readTask(task.task_id)) !== JSON.stringify(task)
+            || (room && JSON.stringify(getRoomRecord(room.room_id)) !== JSON.stringify(room)))
+            return { state: 'unknown', reason: 'records_changed' };
+    }
+    async assertTaskLiveReadiness(task, room, cfg) {
+        const issue = await this.observeLiveReadiness(task, room, cfg);
         if (issue)
             throw new TaskRoomApplicationError('task_not_ready', `Task readiness is ${issue.state}: ${issue.reason}. Ask Fleet Coordinator to inspect the room and member status and choose supported recovery; do not blindly relaunch or reuse invites.`, { task: task.task_id, room: task.room_id ?? 'missing', readiness: issue.state,
                 reason: issue.reason, ...(issue.member ? { member: issue.member } : {}) });

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.2.0-nightly.17",
-  "buildId": "165e9b4f7cc7",
-  "commit": "e720586890943d424840f0f9b96d0ac5051d8a6c",
+  "version": "1.2.0-nightly.19",
+  "buildId": "1175f8bb300d",
+  "commit": "3872302b8c5bd5f427ad798df3883262a8928554",
   "dirty": true,
-  "builtAt": "2026-09-26T21:55:24.104Z",
+  "builtAt": "2026-09-27T11:02:00.743Z",
   "capabilities": [
     "cowork.http-management-v1",
     "monitor.interrupt.after_tool"

package/dist/docs.d.ts

@@ -4,7 +4,7 @@
  * Keep this concise enough to place directly in an agent context. Unlike
  * Commander's per-command help, this describes how the pieces compose.
  */
-export declare const AI_DOCS = "# ours-fleet reference\n\nours-fleet runs persistent or temporary, identity-bound AI roles through a\nprovider-neutral managed-session interface:\n\n- harness: `claude-code`, `codex` or `hermes`\n- session: `acp` (default) or `codex-app-server` (Codex only)\n- lifetime: permanent (supervised, restartable) or `spawn --temp`\n\n## Codex ACP runtime\n\nFleet bundles codex-acp 1.10.0 (Codex ^0.153.3). Native shell Codex upgrades do\nnot upgrade this dependency. Selection: Agent env.CODEX_PATH, then inherited\nservice CODEX_PATH, then the adapter's bundled Codex. Use an absolute executable\npath without arguments; an empty override selects the bundle. Fleet retains its\npermission proxy around the selected runtime. Custom ACP commands and native\ncodex-app-server sessions own their separate launch behavior.\n\nDoctor reports native and ACP-selected executable paths and versions per configured\nACP Agent, including the platform binary behind the npm launcher, and flags drift\nor unsupported/unknown combinations. Run it in the service's environment; it probes\ncurrent configuration, not existing processes. gpt-6-astra on a bundled ACP launch\nrequires Codex >=0.153.3; older runtimes fail with an actionable launch error.\n\nPersistent overrides belong in Agent env; temporary overrides belong in the Agent\nTemplate before spawning (existing temporary launch snapshots are sealed). Service\noverrides must reach both persistent and temporary services. New temporary\nsupervisors inherit CODEX_PATH (including empty) from the spawning process through\nsystemd-run/launchctl; sealed Agent env still wins. A shell export does\nnot update running services; init does not persist CODEX_PATH. After verification,\nrestart only affected agents, or coordinate replacement of a temporary agent with\na stale sealed override. Reinstall Fleet with optional dependencies to repair its\nbundle. Custom ACP runtime provenance is reported as unknown.\n\n## Discover and validate\n\nHermes uses `harness: hermes`, `session: acp`, and an explicit Brain `model`.\nProvision native provider/credentials with the role stopped, pointing HERMES_HOME\nat `<role-state-dir>/harness/hermes`. Fleet manages model.default and manual\ndangerous-command approvals; the home retains native memory, skills and state.\nUse a literal native model.provider so startup can detect model/provider fallback.\nEvery restart receives the full briefing in a fresh conversation; old ACP IDs\nare not restored. Use Fleet monitoring. Home/plugin MCP providers must be disabled;\nours and optional extras are declared through ACP. Tool availability is unverified\nuntil actual use, without a startup probe prompt.\n\nHermes approval ask/auto/allow maps to default/accept_edits/dont_ask. Terminal and\nwrite_file/patch approval is not universal mediation of browser, memory, skills,\ndelegation or MCP. Fleet waits at most 50 seconds for permission, against the\ntested native dangerous-command timeout of 60 seconds. Workspace confinement is\napproximate without verified OS isolation. Read-only, legacy deny, Fleet provider\noverrides, effort, model_chain, native monitoring and after_tool are unsupported.\nHERMES_HOME is not a complete isolation boundary for native external configuration\nor credential fallbacks. Process supervision uses the existing Fleet lifecycle.\nTested Hermes: 0.21.1, source d15ed4445207dda418b984e8bda0f68f48b8c6f3,\nPython ACP 0.9.0, protocol 1. Unknown builds need compatibility conformance first.\n\n```sh\nours-fleet docs                         # this complete reference (`man` is an alias)\nours-fleet help <command>               # exact flags for one command\nours-fleet config [-c FILE]             # validate and print the merged plan; no changes\nours-fleet doctor [-c FILE] [--harness codex|claude-code|hermes]\nours-fleet version [--json]             # build identity, capabilities, every install on PATH\n```\n\nConfiguration v2 is `~/fleet.yaml` plus typed bare documents under the exact\nstem directories `~/fleet/agents`, `~/fleet/agent_templates`, `~/fleet/roles`, `~/fleet/brains`, and\n`~/fleet/room_templates`.\nThe manifest owns fleet-wide operational defaults and automation; each Agent\nselects one inline/ref Role and Brain and carries its operational fields.\nAgent Templates under `~/fleet/agent_templates` are inert reusable launch definitions;\nonly explicit files under `~/fleet/agents` are persistent lifecycle instances.\nRoom members use `agent_template` and receive immutable content-addressed snapshots.\nAn Agent Template may declare up to 64 temporary-only named `loops`; persistent Agent\ninstances reject them. Each loop requires `interval` (1m..30d) and bounded\nnonblank `prompt`, with optional `enabled` (default true), `initial_delay`\n(default interval, 0s..30d), and `jitter` (default 0s, < interval, <=1h).\nExecution is fixed skip-if-busy with no ordinary missed-tick backlog/replay;\nrestart recovery may preserve at most one recent late occurrence.\nLegacy top-level `roles:` and `fleet.d` are rejected. Validate the complete\ntrusted source set with `config` and `doctor` before starting or restarting.\n\nPermanent `spawn` writes `~/fleet/agents/Name.yaml`. The web console edits an\nexplicit `{manifest, agents, agent_templates}` model while Role/Brain presets remain read-only.\nIts aggregate revision includes every Agent/Role/Brain/Room-template source, previews a\nredacted per-document diff in an exact-stem private staging tree, and saves under\none root lock with a private multi-file backup and full rollback. A no-op is\nbyte-identical and creates no backup.\n\n## Build identity and install provenance\n\n`--version` prints a semver and nothing else, and a semver does NOT identify an\nartifact. Version bumps land in a release commit of their own, so every build cut\nbetween two releases carries the PREVIOUS version while already containing new\nbehaviour. One host ran two installs that both reported 0.16.0 \u2014 same version,\ndifferent build. One accepted `monitor.interrupt: after_tool`, the other\nrejected it as invalid. Their\n`dist/cli.js` were byte-identical \u2014 the divergence was in other modules.\n\nEvery build therefore stamps `dist/build-info.json` with a build id (first 12 hex\nof a sha256 over the rest of `dist/`), the commit it was cut from, and the\ncapability tokens the shipped code declares \u2014 for example\n`monitor.interrupt.after_tool`. Ask any executable what it is:\n\n```sh\nours-fleet version                      # ours-fleet 0.17.0+9f1c2a3b4d5e, capabilities, PATH installs\nours-fleet version --json               # the same as machine-readable JSON, no environment values\n```\n\nRead a capability, never a version number, to decide whether a setting is\nsupported. When a build rejects a value it knows the name of, it says which\ncapability is missing and which build rejected it, because another install on the\nsame host may accept the identical file. `config` prints the build that resolved\nthe plan; `status <Name>` says so when the build reporting on a role is not the\none that created it (roles record their creating build in `creation.json`).\n\n`ours-fleet doctor` runs an `install` check that lists every `ours-fleet` on\nPATH plus the one executing, and FAILS when two installs share a semver but are\ndifferent builds, or when the running artifact is a DIFFERENT artifact from the\none PATH resolves to. A second prefix holding identical content is not a skew\nand is not reported. A PATH entry the shell would not execute \u2014 a directory, or\na file without its execute bit \u2014 is not counted as an install at all.\nInstalls built before this stamp existed report `+unknown`; they are compared by\nhashing their `dist/` instead, so two pre-provenance installs are still told\napart. To fix a flagged host, remove or update the stale install \u2014 do not rely on\nPATH order.\n\n## Lifecycle and console commands\n\n```sh\nours-fleet init [-c FILE]               # interactive missing-default seed; TTY required\nours-fleet up|down [Name...]\nours-fleet restart [Name...]            # preserve/resume harness context\nours-fleet force-restart [Name...]      # fresh context; briefing is reloaded\nours-fleet ls\nours-fleet status|peek|attach|logs Name\nours-fleet logs -f Name\nours-fleet send Name \"prompt\"\nours-fleet rm Name\nours-fleet watchdog-report <name> [run-id] [--list] [--json]\nours-fleet watchdog-run <name>\n```\n\n`init` is an interactive missing-default workflow that preserves existing files byte-for-byte.\nIt names the resolved manifest and split directory, asks a default-No confirmation,\nthen subscriptions (Codex, Claude, or both), model assignment (one explicit model for\nevery job or explicit development/review/coordination choices), one reasoning level,\nand a final default-No review. Quick/Balanced/Thorough generate low/medium/high.\nModel pickers show packaged supported IDs; catalog membership is not a recommendation\nor entitlement claim. Run `ours-fleet doctor` for local Codex availability; Claude\nentitlement is checked when a role launches. The generated brains contain no\n`model_chain`, so Fleet never silently substitutes another model.\n\nAt either confirmation, N, Enter, Escape, Ctrl-C, Ctrl-D, or EOF cancels. In a picker,\nEscape, Ctrl-C, Ctrl-D, or EOF cancels; Enter records the highlight or continues a\nnon-empty multi-select, N is ignored, and an empty subscription selection remains blocked.\nEvery cancellation before final approval performs no host or configuration mutation.\nRedirected/non-TTY invocation is refused with the same guarantee. After the final Yes,\nhost setup precedes publication. Path ownership/type/mode/symlink and\nsame-filesystem checks run before host setup and again under a per-setup lock. Publication\nstages and validates the complete combined setup, backs up whichever old target(s) exist,\nand retains a private recovery record. A hard process/host termination cannot promise\nrollback; inspect host integration and private init stage/recovery evidence.\n\n`peek`, `attach`, and text `send` use the structured agent session.\nAttachment also accepts `/permit <permission-id> <option-id>`, `/interrupt`,\nand `/detach`.\n\n## Local web console\n\nThe npm package includes the web console; installed users do not clone the repo\nor run `npm run build`:\n\n```sh\nnpm i -g @ours.network/fleet\nours-fleet init\nours-fleet doctor\nours-fleet web                         # install/update service, start, pair browser\n```\n\nThe normal command uses stable `http://127.0.0.1:49271/`, installs an\nowner-level systemd user service (Linux) or LaunchAgent (macOS), and opens a\nfive-minute one-use pairing link in the local browser. After pairing, bookmark\nthe plain URL or install the PWA. To pair a new, signed-out, or revoked browser,\nrun `ours-fleet web open`.\n\n```sh\nours-fleet web status\nours-fleet web start|stop|restart\nours-fleet web open\nours-fleet web revoke-all              # revoke every browser and active session\nours-fleet web uninstall\nours-fleet web serve --port 0 --no-open # isolated foreground/testing mode\n```\n\nThe console is IPv4-loopback-only by default. Both `localhost` and\n`127.0.0.1` are accepted locally. For an nginx/TLS reverse proxy, keep the\ndefault bind and declare the exact browser origin:\n\n`ours-fleet web install --public-origin https://fleet.example.com --password-file /secure/fleet-password`\n\nFleet reads the password file during setup and persists only a salted scrypt\nverifier. New browsers authenticate and retain rotating HttpOnly/SameSite\ntrusted-device credentials. If nginx already authenticates, the operator may\ndeliberately select `--no-password`; the CLI and browser warn that anyone\nreaching the origin can control the fleet. First setup requires an explicit\nchoice: `--password-file` or `--pairing` for protected access, or\n`--no-password` for intentional unprotected access.\n\nUse `--bind ADDRESS` only for an intentional direct listen. A non-loopback\nbind is rejected unless `--public-origin` is also present. Host/Origin checks\nuse the declaration and do not trust forwarded headers. Configure nginx to\nproxy HTTP and WebSocket upgrades to `127.0.0.1:49271` and terminate TLS;\nfleet accepts nginx's loopback upstream Host, so no Host rewrite is required.\nBrowser credentials add Secure for HTTPS, and `revoke-all` invalidates all\ntrusted devices. Role creation offers harness-scoped known-model choices\nwhile still accepting a typed model ID; blank explicitly uses the selected\nharness's own default.\n\n## Spawn\n\n```sh\nours-fleet spawn [--temp] [Name | --name Name] \\\n  --brain BRAIN_ID --role ROLE_ID \\\n  --cwd /absolute/path --identity Identity --coordinator Coordinator \\\n  --approval ask|auto|allow \\\n  --filesystem read-only|workspace|unrestricted \\\n  --unattended deny|wait --isolation-file /path/isolation.yaml\n```\n\nPermanent spawn writes `~/fleet/agents/Name.yaml` and starts a supervised role.\n`--temp` writes active state under `~/.ours-fleet/tmp` and starts an independent\ntransient supervisor (a collected systemd unit or submitted launchd job). It is\nnot enabled across reboot and does not die when the role that spawned it restarts.\nBrain definitions own the managed session backend. When a temporary role's bound identity\ncloses or its session ends, the supervisor, monitor and live roster entry retire\ntogether; state moves intact to `~/.ours-fleet/recovery/temporary` with a\ntermination record. Failed launches use the same archive rather than deleting\ntheir briefing, provenance, logs or partial supervisor metadata.\n\nNamed `down` and `rm` commands can target an exact state-backed temporary role\neven though it is absent from merged fleet YAML. The recorded transient unit/job\nis authoritative. Missing/incomplete ownership metadata is reconciled only from\nan exact `_run-temp <role>` process-table match: one match may be adopted, zero\nsettles as stopped, and ambiguity or an unreadable table fails closed. Launching\nrecords receive a bounded grace so a not-yet-registered transient unit cannot be\nmistaken for a stopped one. Stale recorded supervisors are reclaimed in bounded\nbatches by moving their state to the same recovery archive, never by blind deletion.\n\nThe Fleet supervisor creates and binds the assigned identity before the harness\nstarts. Temporary identities survive harness reconnects and are released only when\nthe logical run ends. Permanent identities remain available after the supervisor\nreleases ownership. Agents receive ready tools; no model-owned identity bootstrap\nor onboarding skill is required.\n\nThe temporary supervisor provisions identity and verifies room readiness before\nstarting the harness. After readiness, only sustained authoritative absence\ncloses the role. Unreachable, malformed, or\nvalid-but-empty daemon indexes are ambiguous and reset closure debounce rather\nthan becoming cleanup authority.\n\nInside a managed role, public `ours-fleet` commands cross an authenticated\nsupervisor attribution boundary before Commander parsing. The original CLI remains\nthe executor inside the role's existing OS sandbox, and ordinary CLI validation is\nthe source of truth. Hidden worker entry points remain internal; public lifecycle and\noperator commands are not restricted by the proxy.\n\nCommand invocation, raw argv, read-only work, validation failures, and generic\noutcomes are never forwarded to the Owner-visible channel. Fleet announces only\nconfirmed Agent, Task, and Room lifecycle changes. Local diagnostics retain\nstructurally redacted command metadata. Lifecycle delivery uncertainty is logged,\nnever recursively announced, and never reruns or blindly retries an effect.\nRoom participant summaries describe creation and activation. Fleet has no public\npost-create Room membership mutation, so it does not claim a separate membership event.\n\nOmitted Brain and Role selections, working directory, coordinator, neutral permissions,\nand fleet monitor policy inherit from the calling Agent. Explicit options always win.\nIdentity, mission/profile text, environment, owner routing, auth proxy, room startup,\nisolation, worklog, and sensitive inline Brain values never inherit implicitly.\nThis automatic proxy is a convenience and\nattribution mechanism, not an isolation boundary: an unrestricted role can still\ninvoke another binary path directly. Host/operator shells keep the ordinary direct\nCLI behavior.\n\nBrain owns harness, session, model, reasoning effort, token limits, and native harness\noptions. Removed runtime flags are rejected with migration guidance rather than silently\nreinterpreted. A selection is a stable ID or an explicit `inline:{...}` mapping.\n\nPackaged Developer, Critic, and LocalCoordinator Agent Templates set\n`monitor: { mode: fleet, interrupt: after_tool }`. Every member of the standard\n`single`, `pair`, and `team` Room Templates therefore resolves to fleet-owned,\nafter-tool delivery. Explicit per-member and custom Agent Template values remain\nauthoritative and merge key by key.\n\nManaged ACP stall recovery is opt-in: `monitor: { mode: fleet, stall_recovery: true,\n stall_timeout_ms: 900000 }`. The validated timeout is 60000\u201386400000 milliseconds.\nOmitted/false preserves existing behavior. Silence is measured from meaningful live\nprogress; replay and retry chatter do not reset it. Strong authenticated retry\nevidence requires one window, generic silence two. Tools, permissions, modal or\nunknown boundaries, steering and human cancellation protect the turn. Recovery\nuses one bounded cancel and diagnostic continuation in the same ACP session/queue\nslot; it never restarts the adapter. Startup and queued mail wait behind recovery.\nA durable claim permits at most one automatic attempt per ACP session ID, including\nacross supervisor restarts; later mail is non-cancelling. Failed or re-stalled\nrecovery reports a blocker. Inspect `.stall-recovery/audit.jsonl` and recorded\nterminal events before continuing; never replay ambiguous or completed mutations.\nNative monitoring/non-ACP sessions are unchanged. No room or identity coupling.\n\n## fleet.yaml\n\n```yaml\napi_version: ours.network/fleet/v2\nvars:\n  work_root: /home/me/work\nstart_stagger_ms: 0\ndefaults:\n  permissions:\n    approval: ask\n    filesystem: workspace\n    unattended: deny\n  monitor:\n    mode: fleet                          # fleet (default) | native\nwatchdogs:\n  nightwatch:                       # [A-Za-z0-9_-], must not collide with a role name\n    coordinator: FleetCoordinator   # required \u2014 where alerts go\n    # everything below is optional\n    enabled: true                   # default true; false = configured but never scheduled\n    interval: 10m                   # default 10m; 30s | 10m | 2h, minimum 1m\n    watch: [Alice, CodexReviewer]   # explicit lists are exact; omit for configured + live temp roles\n    agent: { ref: WatchdogAgent }   # required: declared Agent ID, or canonical inline Agent definition\n    identity: Watchdog-nightwatch   # default: Watchdog-<name>\n    timeout: 5m                     # default 5m; a run past this is killed and recorded as error\n    keep_reports: 50                # default 50 reports retained per watchdog\n    alert_cooldown: 60m             # default 60m before the same finding alerts again\n    prompt_file: /abs/extra.md      # optional extra focus, APPENDED to the fixed contract\n```\n\nAn Agent is a separate bare document under `~/fleet/agents/<ID>.yaml`:\n\n```yaml\nrole: { inline: { mission: Coordinate work and delegate implementation. } }\nbrain: { inline: { harness: codex, session: codex-app-server, model: gpt-model-id } }\nidentity: Coordinator\ncwd: ${work_root}/project\noversee: [{ agent: Worker, interval: 5m }]\n```\n\nA watchdog observes and reports; it never restarts, stops, spawns, or removes a\nrole, answers a pending permission, edits a workspace, or approves anything on\nthe owner's behalf. `watchdogs:` may appear only in the base config\n(`~/fleet.yaml` or `-c FILE`); Agent/Role/Brain documents never own it.\nThe selected Agent owns Brain, Role, permissions, isolation, and every other\nagent setting. Legacy watchdog `harness`, `model`, `session`, and\n`isolation` fields fail with migration guidance.\nWhen `watch:` is omitted, each run watches the configured roles plus temporary\nfleet roles that are live when the run starts. An explicit `watch:` list is\nnever augmented.\n\nAgent operational values override manifest operational defaults. Role and Brain\nownership never cross-merges. `${name}` substitutes entries from `vars`.\nBrain fields include `max_tokens` and `autocompact_pct`; isolation is Agent-owned.\nUse README.md for the complete isolation policy and resource-cap schema.\n\nSupervised roles connect to the operator-configured ours daemon; they do not own its\nlifecycle. Fleet strips the obsolete, presence-sensitive `OURS_AUTOSTART` variable from\nagent-session children; `ours-mcp proxy` is client-only and never starts a daemon. Start\nthe shared daemon only through an explicit operator or installer/setup flow.\n\n## Rooms and tasks\n\n`init` materializes editable `single`, `pair`, and `team` Room templates plus\ntheir exact-cased Agent, Role, and Brain presets. The command prints the packaged\npreset revision and source directory. Inspect provenance and content before use:\n\n```sh\nours-fleet config [-c FILE]\nours-fleet template list [-c FILE]\nours-fleet template show team [-c FILE]\nours-fleet task create --title \"Solo task\" --template single [-c FILE]\nours-fleet task create --title \"Reviewed change\" --template pair [-c FILE]\nours-fleet task create --title \"Phased delivery\" --template team [-c FILE]\nours-fleet spawn --temp Scout --role SELECTION --brain SELECTION --loops-file PRIVATE.yaml\nours-fleet task start TASK --member developer --loops-file PRIVATE.yaml\nours-fleet task start TASK --member critic --no-loops\n```\n\n`--loops-file` must be an owner-only, non-symlink regular file <=1 MB containing\nexactly one top-level non-empty `loops:` mapping. `--no-loops` explicitly\ndisables loops. They are mutually exclusive and rejected for permanent spawn.\nFor a grouped room member the whole CLI block overrides its Agent Template;\nthe template overrides omission. Omission preserves historical no-loop behavior\nand never inherits manifest wildcard loops. Fleet validates before side effects,\nseals normalized timings plus exact private prompts, and reuses that snapshot for\nidempotent start, retry, recovery, and replacement. Trusted authoring and the\nprivate sealed runtime retain exact prompts; resolved launch, task, room,\nprovenance, and audit presentations show source, policy, timing, prompt bytes,\nand prompt SHA-256 instead of prompt text.\n\nAn alternate manifest `-c /path/custom.yaml` uses `/path/custom/` as its split\nroot. Repeated init only fills missing files and never adopts a newer default.\nExact known revision-3 through revision-5 packaged-bootstrap and generated role defaults have an exact-semantic,\nfail-closed migration (dry-run by default):\n\n`ours-fleet migrate-role-defaults [-c FILE]`\n`ours-fleet migrate-role-defaults [-c FILE] --write`\n\nReview removals, replacements, additions, preserved custom files, staging path,\nand recovery path. Same-named custom files stay byte-identical; dangling custom\nreferences refuse publication, and a successful rerun is a no-op. For explicit\nsingle-file adoption, copy from init's reported packaged source beside the target\nas `.new-default`, inspect `diff -u TARGET TARGET.new-default`, then replace it.\n\nThe exact generated six-worker legacy starter Agent set has its own fail-closed\nmigration (dry-run by default):\n\n`ours-fleet migrate-agent-templates [-c FILE]`\n`ours-fleet migrate-agent-templates [-c FILE] --write`\n\nReview the dry-run moves, addition, staging path, and retained recovery-backup path\nbefore `--write`. Customized/partial known starters and unsafe trees refuse without\nmutation; unrelated custom persistent Agents remain persistent. A manifest-level template\nmay shadow a same-named file only with `override_builtin: true` and a higher\nversion; this compatibility marker is deprecated and reported as a diagnostic.\n\nRooms always use `ours-cowork`; there is no room-provider selector. Configure\nthe cowork daemon connection and room owner directly:\n\n```yaml\nrooms:\n  cowork:\n    config: /home/me/.ours-cowork/config.json\n  owner:\n    expected_cid: 0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef\n    public_invite_file: /home/me/.ours-fleet/owner-room-invite.txt\n  defaults:\n    template: team\n    attach_owner: true\n    close_when_task_done: true\ntasks:\n  default_room_template: team\n  create_mode: start\n  close_room_on_done: true\n```\n\nFleet launches each template member with a dedicated one-time Cowork invite.\nThe supervisor accepts the startup invite and verifies the provisioned identity CID\nin the authenticated room seat before starting the model. The generated briefing\ncontains the assigned identity, room, role and task, without invite material.\nA room is ready only after the Cowork room (and its task, when\ntask-bound) is durably active, every configured member seat is authenticated and active with its matching\nlive Fleet launch, and the configured Owner seat is active when owner attachment is\nenabled. There is no briefing hash, startup ACK, or separate role-briefing readiness\ngate.\n\nNormal Task provisioning emits exactly one authenticated Owner lifecycle notice after\nthe ready predicate above is true; standalone Room provisioning likewise emits one\nready notice. Intermediate task, saga, member-spawn, timeout, and recoverable-failure\ntransitions stay in local state and logs. A terminal failed Task emits one actionable\nfailure notice; the command result carries the exact blocker and canonical recovery\naction.\n\n`task start` and create-and-start wait for readiness. If their bounded wait expires,\nthey return an explicit `in_progress` result and start a safe continuation. The detached\ncontinuation is serialized per Task and remains alive until convergence or an\nOwner-action blocker. Re-running `task start <id>` safely resumes the same durable\nprovisioning operation after the blocker is corrected or a process restarts.\n\nSet `room.anonymous: true` on a room template, or pass `--anonymous` to\n`task create`, `task start`, `task work`, or `room create`, to create an\nanonymous Cowork room. `--no-anonymous` explicitly overrides an anonymous\ntemplate. Fleet records the resolved value before room creation so retries keep\nthe same choice. The supervisor creates anonymous room members with local contact-book exposure\ndisabled. Their generated briefings\ndo not disclose or compare an Owner participant CID. A participant-originated\ninstruction has Owner authority only when the authenticated Cowork room envelope\nattributes that participant seat the exact `Owner` role. Literal text, display\nnames, ordinary direct messages, and room-authored or rest-role messages with an\nOwner-looking label never grant that authority. Non-anonymous rooms remain pinned\nto the exact authenticated Owner CID.\n\nHuman task and room results use the same compact Markdown presentation in the\nCLI and authenticated owner channel: a short heading, icon-plus-word status,\ncode-formatted identifiers, bounded summaries, and actionable recovery or error\nsteps. Untrusted prose is context-escaped and control characters are neutralized;\nMessenger-bound results are capped at 3,500 Unicode code points and 12,000 UTF-8\nbytes with structural omission notices. `--json` bypasses this presentation layer\nand retains the versioned machine schema and serialization order.\n\nEvery task belongs to a named list. The built-in `default` list always exists,\nand legacy tasks or create calls without `--list` resolve to it. Use `task lists`,\n`task list-create <name>`, `task list-rename <name> <new-name>`, and\n`task list-delete <name> [--move-to <destination>]` to manage lists. A non-empty\nlist cannot be deleted without an explicit, different destination; Fleet moves\nthe assignments and never deletes the tasks. `task move <id> --list <name>`\nchanges only organizational metadata. `task list --list <name>` filters and\n`--group-by-list --json` returns deterministic groups.\n\nList names are NFC-normalized, case-sensitive, and limited to 64 Unicode code\npoints. Leading/trailing whitespace, controls, format/path characters, normalized\nduplicates, and the reserved exact name `default` are rejected. The authenticated\nowner channel provides the matching `/task` subcommands, while authenticated web\nclients use `/api/v1/task-lists`, `/api/v1/tasks`, and\n`/api/v1/tasks/:id/list`; every adapter delegates to the same application service.\nMessenger's multiline command grammar treats surrounding whitespace on each\nvalue line as transport framing; the canonical value passed to the shared service\nis the trimmed line. CLI arguments and REST strings are passed verbatim.\n\nOlder prerelease files with the exact legacy `provider: cowork` key under\n`rooms:` still load, but the key is ignored and omitted from resolved\nconfiguration. Remove it when editing the file. Any other legacy value is an\nerror. The optional `rooms.owner.provider` setting is separate and defaults to\n`messenger-server`.\n\nFinish and Delete are distinct terminal task actions:\n\n`ours-fleet task finish <id>` moves an active or review task to `done` and\ndeletes its associated Cowork room after retiring its members. The room then\ndisappears from normal Fleet and Cowork views; its brief, messages, repository\nreferences, and attachments are not retained as an inspectable archive.\nThe prerelease configuration names `tasks.close_room_on_done` and\n`rooms.defaults.close_when_task_done` are retained for compatibility, but\n`true` now means this close-then-delete behavior.\n\n`ours-fleet room delete <id> <id>` is the canonical destructive room command.\n`room close <id> <id>` remains a deprecated alias with identical deletion\nsemantics. Older prerelease `closed` room records are deleted directly the next\ntime `room list` reconciles Fleet with Cowork.\n\n`ours-fleet task delete <id> <id>` permanently deletes a task in ANY lifecycle\nstate \u2014 backlog, provisioning, active, blocked, review, done, cancelled, failed,\nor partially settled. The exact task ID is required twice for confirmation. A\ndurable deletion intent is persisted before any side effect; the cleanup worker\nthen retires managed room members with evidence, closes and deletes an attached\nroom (tolerating already-missing remote rooms), releases the sealed launch\nsnapshot, and unlinks the task record last. While cleanup settles the task is\nhidden from normal listings and every lifecycle mutation is rejected; if\ncleanup cannot complete (for example Cowork is unreachable), the deletion stays\nin a precise resumable state \u2014 repeat the identical delete command to converge\nafter outages, crashes, or restarts. Deletion\nnever fabricates a `done` transition. A metadata-only deletion receipt\n(acceptance actor, original state, timestamps, completion) is retained under\n`deletion-receipts/` as durable audit evidence. An already-missing task is an\nidempotent no-op. The Owner-channel equivalent is `/task delete <id> <id>`; the\nmanagement API equivalent is `DELETE /api/v1/tasks/<id>?confirm=<id>` (200 when\nsettled, 202 while pending; `GET /api/v1/tasks?includeDeleting=true` exposes\ndeletion-pending tasks to operators).\n\n## Permissions\n\nPrefer the harness-neutral `permissions` block:\n\n- `approval: ask|auto|allow`: portable permission policy. `deny` remains a\n  deprecated, fail-closed compatibility alias for existing fleet files.\n- `filesystem: read-only|workspace|unrestricted`: filesystem intent\n- `unattended: deny|wait`: what a managed session does when no console can\n  answer a request\n\nThe backend translates this common intent. Native Codex app-server roles reject\npermission aliases in `harness_options`; Codex ACP and Claude retain their\nlegacy native-override compatibility. Do not choose `allow`/`unrestricted`\nor Claude `bypassPermissions` without explicit authorization.\n\n### Creation-time isolation\n\n`ours-fleet spawn --isolation-file <path>` supplies a role's sandbox policy at\ncreation, so the FIRST launch is already confined \u2014 a role that only gains\n`isolation:` on a later `up` ran unsandboxed until then.\n\nThe file holds exactly the `isolation:` mapping documented above and nothing\nelse \u2014 the same schema, validated by the same code, so a policy written here\ncannot mean something different from the identical block in fleet.yaml:\n\n```yaml\nnetwork: deny\nfs:\n  read: [/opt/reference]\nresources:\n  mem: 2G\n```\n\nInvalid files are rejected before anything is created: no config, no state\ndirectory, no identity reservation. Works for both permanent and `--temp` roles.\n\n### Never-prompt failure\n\nThe failure this section exists to prevent leaves no error message anywhere.\n\nAn unattended role has no console. When the harness needs a permission decision\nthere is nobody to ask, so the request is refused INSIDE the harness \u2014 no\nprompt, no error, no log line. The agent simply does less than its briefing told\nit to, reports success, and nothing distinguishes that from having done the\nwork. Two settings produce it:\n\n1. a permission mode that suppresses the prompt without granting the action\n   (Claude `dontAsk`, which is why neutral `allow` maps to\n   `bypassPermissions` instead); and\n2. `unattended: deny`, which refuses every request that reaches it.\n\n**Automatic decisions are now recorded.** Every permission request decided\nwithout a human emits a completed event into\n`~/.ours-fleet/agents/<Name>/.session-events.jsonl` carrying the decision,\nwhether policy or a person made it, the policy that produced it\n(`permissions.unattended=deny` vs `permissions.approval=deny`/`=allow`),\nthe reason, and the option selected. `ours-fleet peek` and `attach` render\nthem. Automatic denial asks for a one-shot rejection, never a standing one, so a\nsingle unattended refusal cannot disable a tool for the rest of the session.\n\nA role that can auto-deny logs one line at startup saying so.\n\nTo detect an under-permissioned role BEFORE it runs, use the capability floor\nbelow: `ours-fleet doctor` fails such a role rather than letting it discover\nthe problem silently at work.\n\n### The unattended capability floor\n\nAn unattended role has no console, so a permission request cannot be answered \u2014\nit is refused, silently, inside the harness. The agent then does less than it\nwas told to and reports no error. To make that visible before launch,\n`ours-fleet config` and `ours-fleet doctor` resolve each role's neutral\npermissions through its harness and check the result against a fixed floor:\n\n- `read-state` \u2014 read its briefing, ROUTINES.md, and WORKLOG.md\n- `write-state` \u2014 append its WORKLOG and its own state files\n- `messaging` \u2014 bind its identity, send and receive ours mail\n- `monitor` \u2014 arm and observe its mail monitor\n- `workspace-edit` \u2014 edit and test files in its working directory\n- `status-commands` \u2014 run the inspection commands its briefing prescribes\n\n`doctor` reports this per role as `unattended floor: <Role>`. A role with\n`unattended: deny` that cannot meet the floor FAILS doctor, because it will\ndeny those requests with nobody to see it; with `unattended: wait` it warns,\nbecause a human can still attach and answer.\n\nSecurity meaning: native Codex maps `ask` \u2192 `untrusted`, `auto` \u2192\n`on-request`, and `allow` \u2192 `never`; its independent filesystem mapping is\n`read-only` \u2192 `read-only`, `workspace` \u2192 `workspace-write`, and\n`unrestricted` \u2192 `danger-full-access`. Users configure only the Fleet names.\nClaude maps `ask` to `default`, `auto` to `acceptEdits`, and `allow` to\n`bypassPermissions`. Codex ACP retains its adapter-specific coupled modes:\n`auto` selects `agent`, while `allow` selects `agent-full-access`. These\nmodes genuinely permit the actions the role was authorized to take \u2014\n`dontAsk` only suppresses the prompt while still refusing the action. Nothing\nother than an explicit `allow` becomes non-interactive. Legacy `deny` keeps\nits conservative Codex `on-request` / Claude `plan` translation. `allow` is therefore a real grant and\nrequires explicit authorization; per-role `isolation:` remains the outer\nboundary that a permission mode cannot cross.\n\nACP carries agent-advertised session mode IDs and `session/set_mode`, but those\nIDs are agent-specific and ACP defines no portable permission-policy capability.\nFleet therefore uses the ACP primitive where an adapter exposes a matching mode\nand otherwise performs the harness translation above. The bundled Codex ACP\nadapter couples approval and sandboxing in its advertised mode IDs. Neutral\n`allow` therefore selects `agent-full-access` and widens `filesystem:\nworkspace` or `read-only` to `danger-full-access`; neutral `auto` selects\n`agent` and `workspace-write` even when the neutral filesystem value differs.\nAn explicit `harness_options.sandbox` selects its corresponding ACP preset and\nstill wins, as does an explicit native approval override. `config` and\n`doctor` report a coupled-mode mismatch as approximate. Use per-role\n`isolation:` as the outer boundary for an `allow` ACP role. The live session\nreports both its effective normalized mode and the exact native mode selected.\n\nSee also: `spawn --approval/--filesystem/--unattended` set this intent at\ncreation, and `ours-fleet config` prints each role's neutral settings, their\nnative translation, and any warning \u2014 the same text `doctor` reports.\n\nClaude `harness_options`: `permission_mode` (default, acceptEdits, plan,\ndontAsk, bypassPermissions), `plugins`, `mem_palace`,\n`mem_palace_midsession_autosave`, `mcp_servers` and `mcp_servers_only`.\n\n`mcp_servers` declares MCP servers for the role, in `.mcp.json`'s own shape\n(a map of name to `{ command, args, env }`, or `{ type: http|sse, url,\nheaders }`). By default they are ADDED to whatever the OS user running the role\nalready has configured. The Claude Code adapter sends them in `session/new`.\n\nWhen `mcp_servers` is absent, Fleet sends ACP's protocol-required empty\n`mcpServers` array without an exclusive override, so the agent keeps its inherited\nservers. An explicitly empty configured set is different: Fleet preserves that intent\nthrough the bundled adapter's compatibility path and disables every inherited server.\n\n`mcp_servers_only: true` makes the declared set EXCLUSIVE through\n`strictMcpConfig`. It is all-or-nothing and it ignores every\nother MCP configuration: project `.mcp.json`, user settings, and **plugins**.\nThe ours connector is normally installed as a plugin, so a strict role that does\nnot re-declare it has no `send_message` and no `get_messages` \u2014 it cannot even\nreport that it has gone mute. Fleet therefore refuses a strict role whose\n`mcp_servers` does not name the connector; declare it explicitly, e.g.\n`ours: { command: ours-mcp, args: [proxy] }`.\n\nBoth options, and `plugins`, reach an ACP session through the bundled Claude ACP\nagent's `_meta` vocabulary. A role that sets `session_options.acp.command` runs\nan agent fleet did not choose and cannot be promised them, so that combination is\nrefused at validation rather than accepted and dropped. This narrows a role's\ntool surface; it does not stop the harness deferring tool schemas, which is the\nharness's own decision.\n\nCodex `harness_options`: `launcher` (auto, ours-codex, codex), `search`,\n`config`, `add_dirs`, and `monitor`; Codex ACP additionally supports\n`profile`. Native app-server roles reject `profile` because Codex does not\naccept `--profile` for `app-server`. They\nmust express approval and filesystem authority through the shared\n`permissions:` block, never through harness options. The adapter translates\n`ask|auto|allow` to Codex `untrusted|on-request|never` and translates\n`read-only|workspace|unrestricted` to Codex\n`read-only|workspace-write|danger-full-access`. Native `config` currently\nallows only `model_reasoning_effort`; ACP retains the broader Codex config surface.\n\nFor Codex, the opt-in `session: codex-app-server` directly runs Codex's native\nJSONL app server behind Fleet's provider-neutral session contract. It supports native item\nstreaming, commentary/final phases, prompt admission, steering, interruption,\npermission requests, durable conversation projection, and thread resume. Packaged\nCodex brains and the init wizard continue to select `session: acp` for compatibility;\nClaude Code also uses ACP. Native Codex defaults to `codex app-server` (or `ours-codex app-server`\nwhen launcher auto finds it). Override the exact command when necessary:\n\n`session_options: { codex_app_server: { command: [codex, app-server] } }`\n\nAn exact command override receives no appended profile, search, or subcommand\narguments. Native sessions persist their Codex thread in Fleet's `.session-id`\nand participate in its bounded fresh/resume recovery; cross-provider conversation\nportability is never assumed.\n\n## ACP adapters\n\nThe maintained `@agentclientprotocol/codex-acp` and\n`@agentclientprotocol/claude-agent-acp` runtimes are bundled automatically as\noptional ours-fleet dependencies. The supervisor resolves their executable\nentrypoints internally, so default ACP roles do not depend on global PATH.\nours-fleet and both maintained adapters require Node 22 or newer.\n\nOverride an adapter only when necessary with `session_options.acp.command`\n(string or argv list). If optional dependencies were deliberately omitted,\nours-fleet falls back to a compatible globally installed `codex-acp` or\n`claude-agent-acp`. `ours-fleet doctor -c FILE` verifies the resolved adapter.\n\n## Boot-time daemon readiness\n\nLinux permanent-agent services wait for their configured daemon before launching\nFleet's runner. This uses the role's saved manifest path and environment, including\nhost profiles, gateway endpoints and expected daemon identity; no Docker container\nnames or default ports are assumed. The read-only probe requires verified startup\nreadiness and an available identity index. Unavailable or unauthorized daemons leave\nthe service waiting, with a diagnostic code in the journal. Each wait is bounded\nand systemd retries it until the daemon is ready; stopping the service cancels it.\nThis does not consume the agent crash budget or discard its session context.\nOnce the runner starts, its normal crash circuit breaker still applies.\nAfter upgrading Fleet, rerun init to refresh the generated service template.\nTemporary agents and macOS services retain their existing lifecycle behavior.\n\n## Reliable mail wake\n\n`monitor.mode` selects exactly one wake owner:\n\n- `fleet` (default): the ours-fleet supervisor consumes body-free daemon\n  events and advances its durable cursor only after delivery is accepted. ACP\n  uses live steering when supported and falls back to structured\n  `session/prompt`.\n- `native`: ours-fleet starts no supervisor monitor; the generated briefing\n  instructs Claude Code or Codex to arm its harness-native wake mechanism.\n\nSet `monitor.interrupt: true` in fleet mode to cancel active work before every\nconfigured wake. Set it to `after_tool` to preserve an active ACP tool (and any\npending permission), then steer the wake at the first tool-terminal boundary\nwithout cancellation. A hung boundary is bounded at 120 seconds and falls back\nto non-cancelling steering/queueing; adapters without authenticated tool events\nuse the same conservative fallback. Explicit human/control interrupts remain\nimmediate. The policy is content-blind because the supervisor cannot inspect\nencrypted message bodies. Message bodies are released only when the role calls\nthe ours `get_messages` tool.\n\nThe default is `false`. For a temporary role whose mission intentionally arrives\nafter its readiness announcement, set `mode: fleet` and `interrupt: true`\nexplicitly. The readiness announcement does not change the transport: the\nmission remains ordinary ours mail, fleet injects only the body-free wake, and\nthe role calls `get_messages` before acting. Every later configured wake uses\nthe same interruption policy.\n\nLegacy `monitor.enabled: true|false` remains accepted as an alias for\n`mode: fleet|native`; use `mode` in new configuration. Codex's separate\n`harness_options.monitor: true` is native-monitor consent, not monitor-owner\nselection.\nInspect `ours-fleet status Name`, `peek Name`, role logs, and\n`~/.ours-fleet/agents/Name/.monitor-status` when diagnosing delivery.\n\n## Trusted owner channel\n\nAny managed role may declare a separate ours identity which fleet \u2014 never the agent \u2014\ncreates when missing and binds:\n\n```yaml\nowner_channel:\n  identity: Coordinator Owner Channel\n  owners: [authenticated-owner-contact-cid]\n  agent: authenticated-managed-agent-cid\n  interrupt: false\n  progress_interval_ms: 30000\n  comments: true\n  attachments:\n    enabled: true\n    max_files_per_request: 4\n    max_file_bytes: 10485760\n    max_request_bytes: 20971520\n    retention_ms: 86400000\n```\n\nPermanent role identities are also reconciled before launch. Fleet creates a\nmissing role identity with local exposure and local auto-accept enabled. A\nmissing owner-channel identity uses the safer inverse policy: both are disabled.\nThe short provisioning lease is released before the agent or channel binds.\nTemporary role identities remain connector-owned because their creating lease\ndefines their cleanup lifetime.\n\nThis does not replace the role identity. Normal identity mail remains untrusted\npeer input: the agent reads it through `get_messages` and replies through\n`send_message`. Mail arriving on the dedicated channel from a CID in `owners`\nis injected as a direct `[fleet-owner]` prompt. Mail from the exact `agent`\nCID is forwarded as a new message to the latest authenticated owner conversation;\nits files may also be relayed through this channel. A reply reference selects the\nowner of that authenticated source wire instead of the latest conversation.\nEvery other CID is rejected and warned about without reflecting its body. Fleet sends\naccepted/queued/progress/interrupted/failure notices and routes the ACP turn's\nfinal assistant text back to the authenticated sender with its source wire ID.\nFor file replies of every kind \u2014 a response artifact, a proactive note, or an\nin-turn attachment \u2014 the agent calls ours `send_file` to the channel identity\nand may pair it with a reply-linked caption; fleet, not the agent, chooses the\nowner. That is the only delivery route an agent is given: a tool call either\ndelivers or reports an error, where a file written to disk does neither.\nOwner messages whose trimmed text starts with `/` are deterministic\nsupervisor commands and never enter the model: `/help` (alias `/commands`),\n`/status`, `/comments [status|on|off]`, `/interrupt`, `/clear`,\n`/compact`, `/model <model-id>`, `/restart`, `/force-restart`, `/ls`,\n`/peek`, `/worklog`, and\n`/version`. Unknown or malformed commands answer with the help text instead of\nbeing forwarded; plain messages reach the agent unchanged. `/clear`,\n`/compact`, and `/model` are forwarded only when the role's bundled ACP\nadapter executes them locally (claude-code: all three; codex: `/compact`\nonly) and are otherwise refused with a notice, so slash text never reaches the\nmodel as a prompt.\n\nThe supervisor advertises the same primary registry entries as recipient-scoped\nours typed commands. Their single arguments field is converted back to the text\nafter the slash command name and enters the same dispatcher; aliases stay\nslash-only. Typed handlers repeat the live authenticated Owner-CID check before\ndispatch and return a null protocol completion because the existing correlated\nowner-channel reply remains the result.\n\nWhile a request runs, the agent's live ACP commentary is relayed as messages\nprefixed with the single stable label `\uD83D\uDFE1 Live update:`, so an owner can see\nexactly which messages the setting controls. `owner_channel.comments`\n(default `true`, so existing channels keep their current behavior) is the\nRESTART BASELINE; `/comments on|off` changes only the running session and is\ndeliberately not persisted, so a restart always returns to the checked-in\nconfiguration. `/comments status` reports the live value, the baseline, and\nwhether the backend emits live comments at all. Suppressing live comments never\nsuppresses receipts, progress notices, or the final answer.\n\nOwner documents, images, and voice messages use the same authenticated sender\nand source-wire boundary. Fleet inspects body-free metadata first and rejects\ndisabled, over-count, or over-size requests before selective\nretrieval. Unauthorized CIDs are never retrieved or answered. Reply-linked text\nand files from the same sender become one ordered request; a file-only wake also\nstarts a turn. Retrieved bytes must match their structured size and SHA-256,\nwhile MIME values, extensions, file categories, and declared-versus-detected mismatches\nremain report-only metadata. Symlinks or non-regular paths fail closed. Sanitized copies live only in a mode-0700 request directory as\nmode-0600 files and are removed after completion or bounded stale retention.\n\nThe legacy `attachments.allowed_mime` key is accepted and ignored so existing\nconfigurations keep loading; it is omitted from resolved configuration and cannot\naffect admission.\n\nVoice prompts include a bounded transcript only when typed daemon metadata reports success.\nFailure or unavailability is explicit and preserves the private audio path as the\ninput for direct review. Run `ours config show --json` and inspect `sttConfigured` without\nrevealing provider credentials.\nA mode-0600 message claim journal stores only wire ID, persistent-history\nsequence, and claim time. Fleet journals the exact body-free oldest-first slice\nbefore calling `getMessages` with that slice length, rejects a returned set\nmismatch, and loads a crash-recovered body only through `getHistoryItem`.\nThe attachment crash journal contains only authenticated CID and wire routing\ndata; it never stores captions, filenames, paths, transcript text, or bytes.\nJournaled read files resume through `getFileInfo` and `fetchFile`. A claimed\nagent caption is loaded from history and rejoined before the group is admitted. Fleet\nresolves one authenticated owner route before retrieving bytes, admits every file\nbefore emitting the caption or any file, and sends every part to that same route.\nUnknown correlated routes remain queued without retrieval and receive one bounded\ncorrelated notice. Admission rejection consumes the whole group with one NACK;\nonce emission starts, a transport error becomes terminal uncertain delivery and\nthe group is never blind-retried. Bounded v2 source-wire routing state is migrated\nfrom v1 on read. Corrupt state disables attachment admission rather than weakening\nprovenance checks.\n\nThe channel identity must be unique and must not be a role identity. The bridge\npersists bounded wire IDs only, never message/reply plaintext, and requeues input\nbefore starting its turn for at-least-once crash recovery. It currently requires\nthe structured agent-session interface so correlated final replies retain their\ndelivery guarantee.\n\n### Live contact and owner administration\n\nThe supervisor which is already running the managed role remains the sole binder of\n`owner_channel.identity`. The CLI reaches that exact live `OwnerChannel`\nthrough the role's token-authenticated, mode-0600 Unix control socket for contact\ninspection and setup; it never starts another ours client and never force-binds:\n\nRapid supervised restart is serialized by a role-scoped single-binder lease.\nThe predecessor closes its authenticated control socket and MCP proxy before\nreleasing ownership. The replacement waits at most five seconds and retries the\ndaemon bind only when PID/start-marker metadata proves the holder was the same\nrole and owner-channel identity. Foreign, live, corrupt, or otherwise\nunverifiable ownership remains fail-closed; fleet never uses `force=true`.\n\nIf that matching predecessor misses the bound, its still-authenticated control\nroute may send one fixed, digest-deduplicated recovery notice through the latest\nauthenticated owner conversation (or the sole configured owner). Notice\nplaintext is never persisted. With no safe deterministic route fleet guesses no\nrecipient and leaves the actionable failure in the web console and role logs.\nThe remote recovery action is `/restart`; inspect repeated failures with\n`ours-fleet logs <Role>` or the web console.\n\n```sh\nours-fleet owner-channel contact list <Role>\nours-fleet owner-channel contact invite <Role> [--name <label>]\nours-fleet owner-channel contact add <Role> (--invite-file <path> | --invite-stdin) [--name <label>]\nours-fleet owner-channel owner list <Role>\nours-fleet owner-channel owner authorize <Role> <exact-64-hex-contact-cid>\nours-fleet owner-channel owner revoke <Role> <exact-64-hex-contact-cid>\n```\n\nContact establishment and owner authorization are separate security steps.\n`contact add` never authorizes: invite redemption is pending until the peer\nverifies it. Once `contact list` reports the established contact, authorize\nits exact immutable CID explicitly. Invite creation emits invite material only\non stdout; acceptance reads it from a file or stdin, not argv.\n\nConfigured `owners` remain the baseline. On legacy channels without `agent`,\nlive authorizations/revocations are an immediately effective, restart-persistent\noverlay. Managed-agent CID gating makes fleet configuration authoritative and\ndisables live owner mutation and direct control-socket sends. `owner list` labels\nbaseline versus dynamic entries and effective status. The atomic mode-0600 file\ncontains bounded CIDs and audit actions only. Corruption disables all effective\nowners and refuses mutation rather than resurrecting authority; revoking the\nlast effective owner is always refused.\n\nA missing/stopped role, role without `owner_channel`, unavailable\nMCP client, or a role entering shutdown returns an actionable error with no\nside effects. Management uses no network listener and never logs or persists\ninvite material.\n\nFor any non-final message\u2014progress, blocker, suggestion, or later proactive note\u2014\nthe managed agent calls ordinary ours `send_message` to the channel identity.\nFleet checks only that the authenticated sender CID exactly equals `agent`, then\nforwards the text as a new message. There is no task/request/update type, phase,\nreply correlation, or owner recipient argument. A sole owner is the safe fallback;\nwith multiple owners and no inbound route history the relay fails closed. Devices\nsharing one identity share its CID; separate owner identities hand off the route\nwhen either sends channel mail. The ACP final is separate: fleet extracts it from\nthe completed turn and deterministically replies to the initiating owner wire.\n\nThe bounded mode-0600 route state stores CIDs, wire IDs, timestamps, delivery state,\nand hashes but never message plaintext. Unauthorized attempts produce a bounded\nCID-only owner warning; attempted bodies are neither reflected nor persisted.\n\nFor a mobile owner, establish the contact first, wait for peer verification,\nauthorize its exact CID, and revoke that same CID when access ends. The bounded\nmode-0600 CID overlay survives supervisor restart and remains fail-closed on\ncorruption. Update bodies remain memory-only. After a crash/restart, unfinished\ndeferred owner input follows the existing at-least-once replay path; the restarted\nsupervisor remains the sole binder.\n\n## Stable config and YAML migration\n\n`ours-fleet config --json` emits schemaVersion 1 resolved plans. Environment\nvalues and mission/persona/bio bodies are withheld; environment keys are sorted\nand values are marked redacted. Additive fields may appear in schema 1, while a\nremoval or semantic reuse requires a new schema version.\n\nYAML parsing always rejects duplicate keys. The current default\n`--yaml-mode compat` warns with file/line/column for anchors, aliases, explicit\ntags, non-scalar keys, and multiple documents. Use `--yaml-mode strict` in CI\nnow; strict becomes the next-major default and compat is the temporary migration\nescape hatch.\n\n## Bounded worklogs, auth proxy, and model recovery\n\nWORKLOG rotation is enabled by default with\n`worklog: { max_kb: 1024, keep_tail_kb: 256, max_archives: 12 }`. Maps may\noverride individual values; `worklog: false` on a role or in defaults opts out.\nFleet rotates only at that role's launch/resume lifecycle boundary. Concurrent\nchanges defer rotation. The active file keeps a bounded UTF-8 tail and advances\nto a line boundary when a complete line fits. If one logical line alone exceeds\nthe budget, its newest suffix remains and the rotation manifest records the\nmid-line start and omitted byte count. The complete prior inode receives a\ncollision-safe UTC archive name, and\n`.worklog-rotation.json` records restart provenance. `max_archives` bounds\nrecent archives beside WORKLOG.md; older complete archives move to\n`WORKLOG.archives/` without deletion. All archives share the role's sensitive\nstate boundary. Fleet refuses a symlinked/non-regular live log or a symlinked\ncold-archive boundary before replacing the live path and best-effort removes a\nduplicate publication left by a detected failure while the original inode is\nstill available. The manifest records SHA-256 digests for the archive and live\nbytes observed when it is written. These checks address ordinary path hazards,\nnot intentional path mutation by a malicious concurrent process with the same\nUnix authority; that is outside the threat model and requires OS-level isolation.\n\nACP tool diffs are bounded before entering web conversation events. Existing\nsmall before/after diffs are unchanged. Oversized whole-file snapshots are\nreduced to the actual changed region plus path, operation, original byte counts,\ndigest, and omission metadata. Each retained side is a newest-content UTF-8 tail\nof at most 64 KiB, advanced to a line boundary when a complete line fits. An\noverlong single line keeps its newest suffix and explicitly records a mid-line\nstart. Paths retain at most a 4 KiB suffix with byte count, digest, and omitted\nprefix metadata; the complete normalized update is capped at 320 KiB. A large\nappend therefore retains current appended content, not the historical prefix.\nThe live web-console transcript includes only the current runner generation and\nexcludes adapter session/load replay. Replayed events remain durable with\nagent_replay provenance for diagnosis and recovery.\n\n`auth_proxy: { kind: anthropic, base_url, required, health_url }` is Claude-only\nand loopback-only. Fleet injects only ANTHROPIC_BASE_URL and doctor rejects\ncredential env keys. The privileged reference companion is\n`contrib/anthropic-auth-proxy.mjs`; deploy it separately as a dedicated account\nwith a 0600 token file and per-role listener access. Fleet never installs it or\nreads its credential.\n\n`model_chain` is an ordered authorization list and its first entry must equal\n`model`. Only sustained high-confidence entitlement/quota 429 evidence advances\none entry. Transient 429, overload, auth, policy, and unknown errors never\ndown-shift. Runtime state is atomic in .model-recovery.json; exhaustion is\nfail-closed and held down. Change the declared chain/model and restart to\nreconcile explicitly; no chain preserves detection-only behavior.\n";
+export declare const AI_DOCS = "# ours-fleet reference\n\nours-fleet runs persistent or temporary, identity-bound AI roles through a\nprovider-neutral managed-session interface:\n\n- harness: `claude-code`, `codex` or `hermes`\n- session: `acp` (default) or `codex-app-server` (Codex only)\n- lifetime: permanent (supervised, restartable) or `spawn --temp`\n\n## Codex ACP runtime\n\nFleet bundles codex-acp 1.10.0 (Codex ^0.153.3). Native shell Codex upgrades do\nnot upgrade this dependency. Selection: Agent env.CODEX_PATH, then inherited\nservice CODEX_PATH, then the adapter's bundled Codex. Use an absolute executable\npath without arguments; an empty override selects the bundle. Fleet retains its\npermission proxy around the selected runtime. Custom ACP commands and native\ncodex-app-server sessions own their separate launch behavior.\n\nDoctor reports native and ACP-selected executable paths and versions per configured\nACP Agent, including the platform binary behind the npm launcher, and flags drift\nor unsupported/unknown combinations. Run it in the service's environment; it probes\ncurrent configuration, not existing processes. gpt-6-astra on a bundled ACP launch\nrequires Codex >=0.153.3; older runtimes fail with an actionable launch error.\n\nPersistent overrides belong in Agent env; temporary overrides belong in the Agent\nTemplate before spawning (existing temporary launch snapshots are sealed). Service\noverrides must reach both persistent and temporary services. New temporary\nsupervisors inherit CODEX_PATH (including empty) from the spawning process through\nsystemd-run/launchctl; sealed Agent env still wins. A shell export does\nnot update running services; init does not persist CODEX_PATH. After verification,\nrestart only affected agents, or coordinate replacement of a temporary agent with\na stale sealed override. Reinstall Fleet with optional dependencies to repair its\nbundle. Custom ACP runtime provenance is reported as unknown.\n\n## Discover and validate\n\nHermes uses `harness: hermes`, `session: acp`, and an explicit Brain `model`.\nProvision native provider/credentials with the role stopped, pointing HERMES_HOME\nat `<role-state-dir>/harness/hermes`. Fleet manages model.default and manual\ndangerous-command approvals; the home retains native memory, skills and state.\nUse a literal native model.provider so startup can detect model/provider fallback.\nEvery restart receives the full briefing in a fresh conversation; old ACP IDs\nare not restored. Use Fleet monitoring. Home/plugin MCP providers must be disabled;\nours and optional extras are declared through ACP. Tool availability is unverified\nuntil actual use, without a startup probe prompt.\n\nHermes approval ask/auto/allow maps to default/accept_edits/dont_ask. Terminal and\nwrite_file/patch approval is not universal mediation of browser, memory, skills,\ndelegation or MCP. Fleet waits at most 50 seconds for permission, against the\ntested native dangerous-command timeout of 60 seconds. Workspace confinement is\napproximate without verified OS isolation. Read-only, legacy deny, Fleet provider\noverrides, effort, model_chain, native monitoring and after_tool are unsupported.\nHERMES_HOME is not a complete isolation boundary for native external configuration\nor credential fallbacks. Process supervision uses the existing Fleet lifecycle.\nTested Hermes: 0.21.1, source d15ed4445207dda418b984e8bda0f68f48b8c6f3,\nPython ACP 0.9.0, protocol 1. Unknown builds need compatibility conformance first.\n\n```sh\nours-fleet docs                         # this complete reference (`man` is an alias)\nours-fleet help <command>               # exact flags for one command\nours-fleet config [-c FILE]             # validate and print the merged plan; no changes\nours-fleet doctor [-c FILE] [--harness codex|claude-code|hermes]\nours-fleet version [--json]             # build identity, capabilities, every install on PATH\n```\n\nConfiguration v2 is `~/fleet.yaml` plus typed bare documents under the exact\nstem directories `~/fleet/agents`, `~/fleet/agent_templates`, `~/fleet/roles`, `~/fleet/brains`, and\n`~/fleet/room_templates`.\nThe manifest owns fleet-wide operational defaults and automation; each Agent\nselects one inline/ref Role and Brain and carries its operational fields.\nAgent Templates under `~/fleet/agent_templates` are inert reusable launch definitions;\nonly explicit files under `~/fleet/agents` are persistent lifecycle instances.\nRoom members use `agent_template` and receive immutable content-addressed snapshots.\nAn Agent Template may declare up to 64 temporary-only named `loops`; persistent Agent\ninstances reject them. Each loop requires `interval` (1m..30d) and bounded\nnonblank `prompt`, with optional `enabled` (default true), `initial_delay`\n(default interval, 0s..30d), and `jitter` (default 0s, < interval, <=1h).\nExecution is fixed skip-if-busy with no ordinary missed-tick backlog/replay;\nrestart recovery may preserve at most one recent late occurrence.\nLegacy top-level `roles:` and `fleet.d` are rejected. Validate the complete\ntrusted source set with `config` and `doctor` before starting or restarting.\n\nPermanent `spawn` writes `~/fleet/agents/Name.yaml`. The web console edits an\nexplicit `{manifest, agents, agent_templates}` model while Role/Brain presets remain read-only.\nIts aggregate revision includes every Agent/Role/Brain/Room-template source, previews a\nredacted per-document diff in an exact-stem private staging tree, and saves under\none root lock with a private multi-file backup and full rollback. A no-op is\nbyte-identical and creates no backup.\n\n## Build identity and install provenance\n\n`--version` prints a semver and nothing else, and a semver does NOT identify an\nartifact. Version bumps land in a release commit of their own, so every build cut\nbetween two releases carries the PREVIOUS version while already containing new\nbehaviour. One host ran two installs that both reported 0.16.0 \u2014 same version,\ndifferent build. One accepted `monitor.interrupt: after_tool`, the other\nrejected it as invalid. Their\n`dist/cli.js` were byte-identical \u2014 the divergence was in other modules.\n\nEvery build therefore stamps `dist/build-info.json` with a build id (first 12 hex\nof a sha256 over the rest of `dist/`), the commit it was cut from, and the\ncapability tokens the shipped code declares \u2014 for example\n`monitor.interrupt.after_tool`. Ask any executable what it is:\n\n```sh\nours-fleet version                      # ours-fleet 0.17.0+9f1c2a3b4d5e, capabilities, PATH installs\nours-fleet version --json               # the same as machine-readable JSON, no environment values\n```\n\nRead a capability, never a version number, to decide whether a setting is\nsupported. When a build rejects a value it knows the name of, it says which\ncapability is missing and which build rejected it, because another install on the\nsame host may accept the identical file. `config` prints the build that resolved\nthe plan; `status <Name>` says so when the build reporting on a role is not the\none that created it (roles record their creating build in `creation.json`).\n\n`ours-fleet doctor` runs an `install` check that lists every `ours-fleet` on\nPATH plus the one executing, and FAILS when two installs share a semver but are\ndifferent builds, or when the running artifact is a DIFFERENT artifact from the\none PATH resolves to. A second prefix holding identical content is not a skew\nand is not reported. A PATH entry the shell would not execute \u2014 a directory, or\na file without its execute bit \u2014 is not counted as an install at all.\nInstalls built before this stamp existed report `+unknown`; they are compared by\nhashing their `dist/` instead, so two pre-provenance installs are still told\napart. To fix a flagged host, remove or update the stale install \u2014 do not rely on\nPATH order.\n\n## Lifecycle and console commands\n\n```sh\nours-fleet init [-c FILE]               # interactive missing-default seed; TTY required\nours-fleet up|down [Name...]\nours-fleet restart [Name...]            # preserve/resume harness context\nours-fleet force-restart [Name...]      # fresh context; briefing is reloaded\nours-fleet ls\nours-fleet status|peek|attach|logs Name\nours-fleet logs -f Name\nours-fleet send Name \"prompt\"\nours-fleet rm Name\nours-fleet watchdog-report <name> [run-id] [--list] [--json]\nours-fleet watchdog-run <name>\n```\n\n`init` is an interactive missing-default workflow that preserves existing files byte-for-byte.\nIt names the resolved manifest and split directory, asks a default-No confirmation,\nthen subscriptions (Codex, Claude, or both), model assignment (one explicit model for\nevery job or explicit development/review/coordination choices), one reasoning level,\nand a final default-No review. Quick/Balanced/Thorough generate low/medium/high.\nModel pickers show packaged supported IDs; catalog membership is not a recommendation\nor entitlement claim. Run `ours-fleet doctor` for local Codex availability; Claude\nentitlement is checked when a role launches. The generated brains contain no\n`model_chain`, so Fleet never silently substitutes another model.\n\nAt either confirmation, N, Enter, Escape, Ctrl-C, Ctrl-D, or EOF cancels. In a picker,\nEscape, Ctrl-C, Ctrl-D, or EOF cancels; Enter records the highlight or continues a\nnon-empty multi-select, N is ignored, and an empty subscription selection remains blocked.\nEvery cancellation before final approval performs no host or configuration mutation.\nRedirected/non-TTY invocation is refused with the same guarantee. After the final Yes,\nhost setup precedes publication. Path ownership/type/mode/symlink and\nsame-filesystem checks run before host setup and again under a per-setup lock. Publication\nstages and validates the complete combined setup, backs up whichever old target(s) exist,\nand retains a private recovery record. A hard process/host termination cannot promise\nrollback; inspect host integration and private init stage/recovery evidence.\n\n`peek`, `attach`, and text `send` use the structured agent session.\nAttachment also accepts `/permit <permission-id> <option-id>`, `/interrupt`,\nand `/detach`.\n\n## Local web console\n\nThe npm package includes the web console; installed users do not clone the repo\nor run `npm run build`:\n\n```sh\nnpm i -g @ours.network/fleet\nours-fleet init\nours-fleet doctor\nours-fleet web                         # install/update service, start, pair browser\n```\n\nThe normal command uses stable `http://127.0.0.1:49271/`, installs an\nowner-level systemd user service (Linux) or LaunchAgent (macOS), and opens a\nfive-minute one-use pairing link in the local browser. After pairing, bookmark\nthe plain URL or install the PWA. To pair a new, signed-out, or revoked browser,\nrun `ours-fleet web open`.\n\n```sh\nours-fleet web status\nours-fleet web start|stop|restart\nours-fleet web open\nours-fleet web revoke-all              # revoke every browser and active session\nours-fleet web uninstall\nours-fleet web serve --port 0 --no-open # isolated foreground/testing mode\n```\n\nThe console is IPv4-loopback-only by default. Both `localhost` and\n`127.0.0.1` are accepted locally. For an nginx/TLS reverse proxy, keep the\ndefault bind and declare the exact browser origin:\n\n`ours-fleet web install --public-origin https://fleet.example.com --password-file /secure/fleet-password`\n\nFleet reads the password file during setup and persists only a salted scrypt\nverifier. New browsers authenticate and retain rotating HttpOnly/SameSite\ntrusted-device credentials. If nginx already authenticates, the operator may\ndeliberately select `--no-password`; the CLI and browser warn that anyone\nreaching the origin can control the fleet. First setup requires an explicit\nchoice: `--password-file` or `--pairing` for protected access, or\n`--no-password` for intentional unprotected access.\n\nUse `--bind ADDRESS` only for an intentional direct listen. A non-loopback\nbind is rejected unless `--public-origin` is also present. Host/Origin checks\nuse the declaration and do not trust forwarded headers. Configure nginx to\nproxy HTTP and WebSocket upgrades to `127.0.0.1:49271` and terminate TLS;\nfleet accepts nginx's loopback upstream Host, so no Host rewrite is required.\nBrowser credentials add Secure for HTTPS, and `revoke-all` invalidates all\ntrusted devices. Role creation offers harness-scoped known-model choices\nwhile still accepting a typed model ID; blank explicitly uses the selected\nharness's own default.\n\n## Spawn\n\n```sh\nours-fleet spawn [--temp] [Name | --name Name] \\\n  --brain BRAIN_ID --role ROLE_ID \\\n  --cwd /absolute/path --identity Identity --coordinator Coordinator \\\n  --approval ask|auto|allow \\\n  --filesystem read-only|workspace|unrestricted \\\n  --unattended deny|wait --isolation-file /path/isolation.yaml\n```\n\nPermanent spawn writes `~/fleet/agents/Name.yaml` and starts a supervised role.\n`--temp` writes active state under `~/.ours-fleet/tmp` and starts an independent\ntransient supervisor (a collected systemd unit or submitted launchd job). It is\nnot enabled across reboot and does not die when the role that spawned it restarts.\nBrain definitions own the managed session backend. When a temporary role's bound identity\ncloses or its session ends, the supervisor, monitor and live roster entry retire\ntogether; state moves intact to `~/.ours-fleet/recovery/temporary` with a\ntermination record. Failed launches use the same archive rather than deleting\ntheir briefing, provenance, logs or partial supervisor metadata.\n\nNamed `down` and `rm` commands can target an exact state-backed temporary role\neven though it is absent from merged fleet YAML. The recorded transient unit/job\nis authoritative. Missing/incomplete ownership metadata is reconciled only from\nan exact `_run-temp <role>` process-table match: one match may be adopted, zero\nsettles as stopped, and ambiguity or an unreadable table fails closed. Launching\nrecords receive a bounded grace so a not-yet-registered transient unit cannot be\nmistaken for a stopped one. Stale recorded supervisors are reclaimed in bounded\nbatches by moving their state to the same recovery archive, never by blind deletion.\n\nThe Fleet supervisor creates and binds the assigned identity before the harness\nstarts. Temporary identities survive harness reconnects and are released only when\nthe logical run ends. Permanent identities remain available after the supervisor\nreleases ownership. Agents receive ready tools; no model-owned identity bootstrap\nor onboarding skill is required.\n\nThe temporary supervisor provisions identity and verifies room readiness before\nstarting the harness. After readiness, only sustained authoritative absence\ncloses the role. Unreachable, malformed, or\nvalid-but-empty daemon indexes are ambiguous and reset closure debounce rather\nthan becoming cleanup authority.\n\nInside a managed role, public `ours-fleet` commands cross an authenticated\nsupervisor attribution boundary before Commander parsing. The original CLI remains\nthe executor inside the role's existing OS sandbox, and ordinary CLI validation is\nthe source of truth. Hidden worker entry points remain internal; public lifecycle and\noperator commands are not restricted by the proxy.\n\nCommand invocation, raw argv, read-only work, validation failures, and generic\noutcomes are never forwarded to the Owner-visible channel. Fleet announces only\nconfirmed Agent, Task, and Room lifecycle changes. Local diagnostics retain\nstructurally redacted command metadata. Lifecycle delivery uncertainty is logged,\nnever recursively announced, and never reruns or blindly retries an effect.\nRoom participant summaries describe creation and activation. Fleet has no public\npost-create Room membership mutation, so it does not claim a separate membership event.\n\nOmitted Brain and Role selections, working directory, coordinator, neutral permissions,\nand fleet monitor policy inherit from the calling Agent. Explicit options always win.\nIdentity, mission/profile text, environment, owner routing, auth proxy, room startup,\nisolation, worklog, and sensitive inline Brain values never inherit implicitly.\nThis automatic proxy is a convenience and\nattribution mechanism, not an isolation boundary: an unrestricted role can still\ninvoke another binary path directly. Host/operator shells keep the ordinary direct\nCLI behavior.\n\nBrain owns harness, session, model, reasoning effort, token limits, and native harness\noptions. Removed runtime flags are rejected with migration guidance rather than silently\nreinterpreted. A selection is a stable ID or an explicit `inline:{...}` mapping.\n\nPackaged Developer, Critic, and LocalCoordinator Agent Templates set\n`monitor: { mode: fleet, interrupt: after_tool }`. Every member of the standard\n`single`, `pair`, and `team` Room Templates therefore resolves to fleet-owned,\nafter-tool delivery. Explicit per-member and custom Agent Template values remain\nauthoritative and merge key by key.\n\nManaged ACP stall recovery is opt-in: `monitor: { mode: fleet, stall_recovery: true,\n stall_timeout_ms: 900000 }`. The validated timeout is 60000\u201386400000 milliseconds.\nOmitted/false preserves existing behavior. Silence is measured from meaningful live\nprogress; replay and retry chatter do not reset it. Strong authenticated retry\nevidence requires one window, generic silence two. Tools, permissions, modal or\nunknown boundaries, steering and human cancellation protect the turn. Recovery\nuses one bounded cancel and diagnostic continuation in the same ACP session/queue\nslot; it never restarts the adapter. Startup and queued mail wait behind recovery.\nA durable claim permits at most one automatic attempt per ACP session ID, including\nacross supervisor restarts; later mail is non-cancelling. Failed or re-stalled\nrecovery reports a blocker. Inspect `.stall-recovery/audit.jsonl` and recorded\nterminal events before continuing; never replay ambiguous or completed mutations.\nNative monitoring/non-ACP sessions are unchanged. No room or identity coupling.\n\n## fleet.yaml\n\n```yaml\napi_version: ours.network/fleet/v2\nvars:\n  work_root: /home/me/work\nstart_stagger_ms: 0\ndefaults:\n  permissions:\n    approval: ask\n    filesystem: workspace\n    unattended: deny\n  monitor:\n    mode: fleet                          # fleet (default) | native\nwatchdogs:\n  nightwatch:                       # [A-Za-z0-9_-], must not collide with a role name\n    coordinator: FleetCoordinator   # required \u2014 where alerts go\n    # everything below is optional\n    enabled: true                   # default true; false = configured but never scheduled\n    interval: 10m                   # default 10m; 30s | 10m | 2h, minimum 1m\n    watch: [Alice, CodexReviewer]   # explicit lists are exact; omit for configured + live temp roles\n    agent: { ref: WatchdogAgent }   # required: declared Agent ID, or canonical inline Agent definition\n    identity: Watchdog-nightwatch   # default: Watchdog-<name>\n    timeout: 5m                     # default 5m; a run past this is killed and recorded as error\n    keep_reports: 50                # default 50 reports retained per watchdog\n    alert_cooldown: 60m             # default 60m before the same finding alerts again\n    prompt_file: /abs/extra.md      # optional extra focus, APPENDED to the fixed contract\n```\n\nAn Agent is a separate bare document under `~/fleet/agents/<ID>.yaml`:\n\n```yaml\nrole: { inline: { mission: Coordinate work and delegate implementation. } }\nbrain: { inline: { harness: codex, session: codex-app-server, model: gpt-model-id } }\nidentity: Coordinator\ncwd: ${work_root}/project\noversee: [{ agent: Worker, interval: 5m }]\n```\n\nA watchdog observes and reports; it never restarts, stops, spawns, or removes a\nrole, answers a pending permission, edits a workspace, or approves anything on\nthe owner's behalf. `watchdogs:` may appear only in the base config\n(`~/fleet.yaml` or `-c FILE`); Agent/Role/Brain documents never own it.\nThe selected Agent owns Brain, Role, permissions, isolation, and every other\nagent setting. Legacy watchdog `harness`, `model`, `session`, and\n`isolation` fields fail with migration guidance.\nWhen `watch:` is omitted, each run watches the configured roles plus temporary\nfleet roles that are live when the run starts. An explicit `watch:` list is\nnever augmented.\n\nAgent operational values override manifest operational defaults. Role and Brain\nownership never cross-merges. `${name}` substitutes entries from `vars`.\nBrain fields include `max_tokens` and `autocompact_pct`; isolation is Agent-owned.\nUse README.md for the complete isolation policy and resource-cap schema.\n\nSupervised roles connect to the operator-configured ours daemon; they do not own its\nlifecycle. Fleet strips the obsolete, presence-sensitive `OURS_AUTOSTART` variable from\nagent-session children; `ours-mcp proxy` is client-only and never starts a daemon. Start\nthe shared daemon only through an explicit operator or installer/setup flow.\n\n## Rooms and tasks\n\n`init` materializes editable `single`, `pair`, and `team` Room templates plus\ntheir exact-cased Agent, Role, and Brain presets. The command prints the packaged\npreset revision and source directory. Inspect provenance and content before use:\n\n```sh\nours-fleet config [-c FILE]\nours-fleet template list [-c FILE]\nours-fleet template show team [-c FILE]\nours-fleet task create --title \"Solo task\" --template single [-c FILE]\nours-fleet task create --title \"Reviewed change\" --template pair [-c FILE]\nours-fleet task create --title \"Phased delivery\" --template team [-c FILE]\nours-fleet spawn --temp Scout --role SELECTION --brain SELECTION --loops-file PRIVATE.yaml\nours-fleet task start TASK --member developer --loops-file PRIVATE.yaml\nours-fleet task start TASK --member critic --no-loops\n```\n\n`--loops-file` must be an owner-only, non-symlink regular file <=1 MB containing\nexactly one top-level non-empty `loops:` mapping. `--no-loops` explicitly\ndisables loops. They are mutually exclusive and rejected for permanent spawn.\nFor a grouped room member the whole CLI block overrides its Agent Template;\nthe template overrides omission. Omission preserves historical no-loop behavior\nand never inherits manifest wildcard loops. Fleet validates before side effects,\nseals normalized timings plus exact private prompts, and reuses that snapshot for\nidempotent start, retry, recovery, and replacement. Trusted authoring and the\nprivate sealed runtime retain exact prompts; resolved launch, task, room,\nprovenance, and audit presentations show source, policy, timing, prompt bytes,\nand prompt SHA-256 instead of prompt text.\n\nAn alternate manifest `-c /path/custom.yaml` uses `/path/custom/` as its split\nroot. Repeated init only fills missing files and never adopts a newer default.\nExact known revision-3 through revision-5 packaged-bootstrap and generated role defaults have an exact-semantic,\nfail-closed migration (dry-run by default):\n\n`ours-fleet migrate-role-defaults [-c FILE]`\n`ours-fleet migrate-role-defaults [-c FILE] --write`\n\nReview removals, replacements, additions, preserved custom files, staging path,\nand recovery path. Same-named custom files stay byte-identical; dangling custom\nreferences refuse publication, and a successful rerun is a no-op. For explicit\nsingle-file adoption, copy from init's reported packaged source beside the target\nas `.new-default`, inspect `diff -u TARGET TARGET.new-default`, then replace it.\n\nThe exact generated six-worker legacy starter Agent set has its own fail-closed\nmigration (dry-run by default):\n\n`ours-fleet migrate-agent-templates [-c FILE]`\n`ours-fleet migrate-agent-templates [-c FILE] --write`\n\nReview the dry-run moves, addition, staging path, and retained recovery-backup path\nbefore `--write`. Customized/partial known starters and unsafe trees refuse without\nmutation; unrelated custom persistent Agents remain persistent. A manifest-level template\nmay shadow a same-named file only with `override_builtin: true` and a higher\nversion; this compatibility marker is deprecated and reported as a diagnostic.\n\nRooms always use `ours-cowork`; there is no room-provider selector. Configure\nthe cowork daemon connection and room owner directly:\n\n```yaml\nrooms:\n  cowork:\n    config: /home/me/.ours-cowork/config.json\n  owner:\n    expected_cid: 0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef\n    public_invite_file: /home/me/.ours-fleet/owner-room-invite.txt\n  defaults:\n    template: team\n    attach_owner: true\n    close_when_task_done: true\ntasks:\n  default_room_template: team\n  create_mode: start\n  close_room_on_done: true\n```\n\nFleet launches each template member with a dedicated one-time Cowork invite.\nThe supervisor accepts the startup invite and verifies the provisioned identity CID\nin the authenticated room seat before starting the model. The generated briefing\ncontains the assigned identity, room, role and task, without invite material.\nA room is ready only after the Cowork room (and its task, when\ntask-bound) is durably active, every configured member seat is authenticated and active with its matching\nlive Fleet launch, and the configured Owner seat is active when owner attachment is\nenabled. There is no briefing hash, startup ACK, or separate role-briefing readiness\ngate.\n\nNormal Task provisioning emits exactly one authenticated Owner lifecycle notice after\nthe ready predicate above is true; standalone Room provisioning likewise emits one\nready notice. Intermediate task, saga, member-spawn, timeout, and recoverable-failure\ntransitions stay in local state and logs. A terminal failed Task emits one actionable\nfailure notice; the command result carries the exact blocker and canonical recovery\naction.\n\n`task start` and create-and-start wait for readiness. If their bounded wait expires,\nthey return an explicit `in_progress` result and start a safe continuation. The detached\ncontinuation is serialized per Task and remains alive until convergence or an\nOwner-action blocker. Re-running `task start <id>` safely resumes the same durable\nprovisioning operation after the blocker is corrected or a process restarts.\n\nSet `room.anonymous: true` on a room template, or pass `--anonymous` to\n`task create`, `task start`, `task work`, or `room create`, to create an\nanonymous Cowork room. `--no-anonymous` explicitly overrides an anonymous\ntemplate. Fleet records the resolved value before room creation so retries keep\nthe same choice. The supervisor creates anonymous room members with local contact-book exposure\ndisabled. Their generated briefings\ndo not disclose or compare an Owner participant CID. A participant-originated\ninstruction has Owner authority only when the authenticated Cowork room envelope\nattributes that participant seat the exact `Owner` role. Literal text, display\nnames, ordinary direct messages, and room-authored or rest-role messages with an\nOwner-looking label never grant that authority. Non-anonymous rooms remain pinned\nto the exact authenticated Owner CID.\n\nHuman task and room results use the same compact Markdown presentation in the\nCLI and authenticated owner channel: a short heading, icon-plus-word status,\ncode-formatted identifiers, bounded summaries, and actionable recovery or error\nsteps. Untrusted prose is context-escaped and control characters are neutralized;\nMessenger-bound results are capped at 3,500 Unicode code points and 12,000 UTF-8\nbytes with structural omission notices. `--json` bypasses this presentation layer\nand retains the versioned machine schema and serialization order.\n\nActive task `show` reports current readiness separately from lifecycle, also in\nOwner commands. Start/work preserve the fail-closed `task_not_ready` behavior.\nUnknown control health does not prove a dead agent or authorize replacement.\nBefore deliberate recovery, Fleet Coordinator inspects current seats and exact\nold-launch worklogs/termination evidence in `recovery/temporary`, preserves\noriginal records, and privately records verified old/new launch provenance.\nA new inbox is not complete history: page scoped history to the end, authenticate\nhistorical Owner authors, and compare completed actions and replies before resuming.\nDo not restore archived identity state, reuse invites, adopt same-role seats or\nblindly replay instructions. Ask the Owner if authority/completion is uncertain.\n\nEvery task belongs to a named list. The built-in `default` list always exists,\nand legacy tasks or create calls without `--list` resolve to it. Use `task lists`,\n`task list-create <name>`, `task list-rename <name> <new-name>`, and\n`task list-delete <name> [--move-to <destination>]` to manage lists. A non-empty\nlist cannot be deleted without an explicit, different destination; Fleet moves\nthe assignments and never deletes the tasks. `task move <id> --list <name>`\nchanges only organizational metadata. `task list --list <name>` filters and\n`--group-by-list --json` returns deterministic groups.\n\nList names are NFC-normalized, case-sensitive, and limited to 64 Unicode code\npoints. Leading/trailing whitespace, controls, format/path characters, normalized\nduplicates, and the reserved exact name `default` are rejected. The authenticated\nowner channel provides the matching `/task` subcommands, while authenticated web\nclients use `/api/v1/task-lists`, `/api/v1/tasks`, and\n`/api/v1/tasks/:id/list`; every adapter delegates to the same application service.\nMessenger's multiline command grammar treats surrounding whitespace on each\nvalue line as transport framing; the canonical value passed to the shared service\nis the trimmed line. CLI arguments and REST strings are passed verbatim.\n\nOlder prerelease files with the exact legacy `provider: cowork` key under\n`rooms:` still load, but the key is ignored and omitted from resolved\nconfiguration. Remove it when editing the file. Any other legacy value is an\nerror. The optional `rooms.owner.provider` setting is separate and defaults to\n`messenger-server`.\n\nFinish and Delete are distinct terminal task actions:\n\n`ours-fleet task finish <id>` moves an active or review task to `done` and\ndeletes its associated Cowork room after retiring its members. The room then\ndisappears from normal Fleet and Cowork views; its brief, messages, repository\nreferences, and attachments are not retained as an inspectable archive.\nThe prerelease configuration names `tasks.close_room_on_done` and\n`rooms.defaults.close_when_task_done` are retained for compatibility, but\n`true` now means this close-then-delete behavior.\n\n`ours-fleet room delete <id> <id>` is the canonical destructive room command.\n`room close <id> <id>` remains a deprecated alias with identical deletion\nsemantics. Older prerelease `closed` room records are deleted directly the next\ntime `room list` reconciles Fleet with Cowork.\n\n`ours-fleet task delete <id> <id>` permanently deletes a task in ANY lifecycle\nstate \u2014 backlog, provisioning, active, blocked, review, done, cancelled, failed,\nor partially settled. The exact task ID is required twice for confirmation. A\ndurable deletion intent is persisted before any side effect; the cleanup worker\nthen retires managed room members with evidence, closes and deletes an attached\nroom (tolerating already-missing remote rooms), releases the sealed launch\nsnapshot, and unlinks the task record last. While cleanup settles the task is\nhidden from normal listings and every lifecycle mutation is rejected; if\ncleanup cannot complete (for example Cowork is unreachable), the deletion stays\nin a precise resumable state \u2014 repeat the identical delete command to converge\nafter outages, crashes, or restarts. Deletion\nnever fabricates a `done` transition. A metadata-only deletion receipt\n(acceptance actor, original state, timestamps, completion) is retained under\n`deletion-receipts/` as durable audit evidence. An already-missing task is an\nidempotent no-op. The Owner-channel equivalent is `/task delete <id> <id>`; the\nmanagement API equivalent is `DELETE /api/v1/tasks/<id>?confirm=<id>` (200 when\nsettled, 202 while pending; `GET /api/v1/tasks?includeDeleting=true` exposes\ndeletion-pending tasks to operators).\n\n## Permissions\n\nPrefer the harness-neutral `permissions` block:\n\n- `approval: ask|auto|allow`: portable permission policy. `deny` remains a\n  deprecated, fail-closed compatibility alias for existing fleet files.\n- `filesystem: read-only|workspace|unrestricted`: filesystem intent\n- `unattended: deny|wait`: what a managed session does when no console can\n  answer a request\n\nThe backend translates this common intent. Native Codex app-server roles reject\npermission aliases in `harness_options`; Codex ACP and Claude retain their\nlegacy native-override compatibility. Do not choose `allow`/`unrestricted`\nor Claude `bypassPermissions` without explicit authorization.\n\n### Creation-time isolation\n\n`ours-fleet spawn --isolation-file <path>` supplies a role's sandbox policy at\ncreation, so the FIRST launch is already confined \u2014 a role that only gains\n`isolation:` on a later `up` ran unsandboxed until then.\n\nThe file holds exactly the `isolation:` mapping documented above and nothing\nelse \u2014 the same schema, validated by the same code, so a policy written here\ncannot mean something different from the identical block in fleet.yaml:\n\n```yaml\nnetwork: deny\nfs:\n  read: [/opt/reference]\nresources:\n  mem: 2G\n```\n\nInvalid files are rejected before anything is created: no config, no state\ndirectory, no identity reservation. Works for both permanent and `--temp` roles.\n\n### Never-prompt failure\n\nThe failure this section exists to prevent leaves no error message anywhere.\n\nAn unattended role has no console. When the harness needs a permission decision\nthere is nobody to ask, so the request is refused INSIDE the harness \u2014 no\nprompt, no error, no log line. The agent simply does less than its briefing told\nit to, reports success, and nothing distinguishes that from having done the\nwork. Two settings produce it:\n\n1. a permission mode that suppresses the prompt without granting the action\n   (Claude `dontAsk`, which is why neutral `allow` maps to\n   `bypassPermissions` instead); and\n2. `unattended: deny`, which refuses every request that reaches it.\n\n**Automatic decisions are now recorded.** Every permission request decided\nwithout a human emits a completed event into\n`~/.ours-fleet/agents/<Name>/.session-events.jsonl` carrying the decision,\nwhether policy or a person made it, the policy that produced it\n(`permissions.unattended=deny` vs `permissions.approval=deny`/`=allow`),\nthe reason, and the option selected. `ours-fleet peek` and `attach` render\nthem. Automatic denial asks for a one-shot rejection, never a standing one, so a\nsingle unattended refusal cannot disable a tool for the rest of the session.\n\nA role that can auto-deny logs one line at startup saying so.\n\nTo detect an under-permissioned role BEFORE it runs, use the capability floor\nbelow: `ours-fleet doctor` fails such a role rather than letting it discover\nthe problem silently at work.\n\n### The unattended capability floor\n\nAn unattended role has no console, so a permission request cannot be answered \u2014\nit is refused, silently, inside the harness. The agent then does less than it\nwas told to and reports no error. To make that visible before launch,\n`ours-fleet config` and `ours-fleet doctor` resolve each role's neutral\npermissions through its harness and check the result against a fixed floor:\n\n- `read-state` \u2014 read its briefing, ROUTINES.md, and WORKLOG.md\n- `write-state` \u2014 append its WORKLOG and its own state files\n- `messaging` \u2014 bind its identity, send and receive ours mail\n- `monitor` \u2014 arm and observe its mail monitor\n- `workspace-edit` \u2014 edit and test files in its working directory\n- `status-commands` \u2014 run the inspection commands its briefing prescribes\n\n`doctor` reports this per role as `unattended floor: <Role>`. A role with\n`unattended: deny` that cannot meet the floor FAILS doctor, because it will\ndeny those requests with nobody to see it; with `unattended: wait` it warns,\nbecause a human can still attach and answer.\n\nSecurity meaning: native Codex maps `ask` \u2192 `untrusted`, `auto` \u2192\n`on-request`, and `allow` \u2192 `never`; its independent filesystem mapping is\n`read-only` \u2192 `read-only`, `workspace` \u2192 `workspace-write`, and\n`unrestricted` \u2192 `danger-full-access`. Users configure only the Fleet names.\nClaude maps `ask` to `default`, `auto` to `acceptEdits`, and `allow` to\n`bypassPermissions`. Codex ACP retains its adapter-specific coupled modes:\n`auto` selects `agent`, while `allow` selects `agent-full-access`. These\nmodes genuinely permit the actions the role was authorized to take \u2014\n`dontAsk` only suppresses the prompt while still refusing the action. Nothing\nother than an explicit `allow` becomes non-interactive. Legacy `deny` keeps\nits conservative Codex `on-request` / Claude `plan` translation. `allow` is therefore a real grant and\nrequires explicit authorization; per-role `isolation:` remains the outer\nboundary that a permission mode cannot cross.\n\nACP carries agent-advertised session mode IDs and `session/set_mode`, but those\nIDs are agent-specific and ACP defines no portable permission-policy capability.\nFleet therefore uses the ACP primitive where an adapter exposes a matching mode\nand otherwise performs the harness translation above. The bundled Codex ACP\nadapter couples approval and sandboxing in its advertised mode IDs. Neutral\n`allow` therefore selects `agent-full-access` and widens `filesystem:\nworkspace` or `read-only` to `danger-full-access`; neutral `auto` selects\n`agent` and `workspace-write` even when the neutral filesystem value differs.\nAn explicit `harness_options.sandbox` selects its corresponding ACP preset and\nstill wins, as does an explicit native approval override. `config` and\n`doctor` report a coupled-mode mismatch as approximate. Use per-role\n`isolation:` as the outer boundary for an `allow` ACP role. The live session\nreports both its effective normalized mode and the exact native mode selected.\n\nSee also: `spawn --approval/--filesystem/--unattended` set this intent at\ncreation, and `ours-fleet config` prints each role's neutral settings, their\nnative translation, and any warning \u2014 the same text `doctor` reports.\n\nClaude `harness_options`: `permission_mode` (default, acceptEdits, plan,\ndontAsk, bypassPermissions), `plugins`, `mem_palace`,\n`mem_palace_midsession_autosave`, `mcp_servers` and `mcp_servers_only`.\n\n`mcp_servers` declares MCP servers for the role, in `.mcp.json`'s own shape\n(a map of name to `{ command, args, env }`, or `{ type: http|sse, url,\nheaders }`). By default they are ADDED to whatever the OS user running the role\nalready has configured. The Claude Code adapter sends them in `session/new`.\n\nWhen `mcp_servers` is absent, Fleet sends ACP's protocol-required empty\n`mcpServers` array without an exclusive override, so the agent keeps its inherited\nservers. An explicitly empty configured set is different: Fleet preserves that intent\nthrough the bundled adapter's compatibility path and disables every inherited server.\n\n`mcp_servers_only: true` makes the declared set EXCLUSIVE through\n`strictMcpConfig`. It is all-or-nothing and it ignores every\nother MCP configuration: project `.mcp.json`, user settings, and **plugins**.\nThe ours connector is normally installed as a plugin, so a strict role that does\nnot re-declare it has no `send_message` and no `get_messages` \u2014 it cannot even\nreport that it has gone mute. Fleet therefore refuses a strict role whose\n`mcp_servers` does not name the connector; declare it explicitly, e.g.\n`ours: { command: ours-mcp, args: [proxy] }`.\n\nBoth options, and `plugins`, reach an ACP session through the bundled Claude ACP\nagent's `_meta` vocabulary. A role that sets `session_options.acp.command` runs\nan agent fleet did not choose and cannot be promised them, so that combination is\nrefused at validation rather than accepted and dropped. This narrows a role's\ntool surface; it does not stop the harness deferring tool schemas, which is the\nharness's own decision.\n\nCodex `harness_options`: `launcher` (auto, ours-codex, codex), `search`,\n`config`, `add_dirs`, and `monitor`; Codex ACP additionally supports\n`profile`. Native app-server roles reject `profile` because Codex does not\naccept `--profile` for `app-server`. They\nmust express approval and filesystem authority through the shared\n`permissions:` block, never through harness options. The adapter translates\n`ask|auto|allow` to Codex `untrusted|on-request|never` and translates\n`read-only|workspace|unrestricted` to Codex\n`read-only|workspace-write|danger-full-access`. Native `config` currently\nallows only `model_reasoning_effort`; ACP retains the broader Codex config surface.\n\nFor Codex, the opt-in `session: codex-app-server` directly runs Codex's native\nJSONL app server behind Fleet's provider-neutral session contract. It supports native item\nstreaming, commentary/final phases, prompt admission, steering, interruption,\npermission requests, durable conversation projection, and thread resume. Packaged\nCodex brains and the init wizard continue to select `session: acp` for compatibility;\nClaude Code also uses ACP. Native Codex defaults to `codex app-server` (or `ours-codex app-server`\nwhen launcher auto finds it). Override the exact command when necessary:\n\n`session_options: { codex_app_server: { command: [codex, app-server] } }`\n\nAn exact command override receives no appended profile, search, or subcommand\narguments. Native sessions persist their Codex thread in Fleet's `.session-id`\nand participate in its bounded fresh/resume recovery; cross-provider conversation\nportability is never assumed.\n\n## ACP adapters\n\nThe maintained `@agentclientprotocol/codex-acp` and\n`@agentclientprotocol/claude-agent-acp` runtimes are bundled automatically as\noptional ours-fleet dependencies. The supervisor resolves their executable\nentrypoints internally, so default ACP roles do not depend on global PATH.\nours-fleet and both maintained adapters require Node 22 or newer.\n\nOverride an adapter only when necessary with `session_options.acp.command`\n(string or argv list). If optional dependencies were deliberately omitted,\nours-fleet falls back to a compatible globally installed `codex-acp` or\n`claude-agent-acp`. `ours-fleet doctor -c FILE` verifies the resolved adapter.\n\n## Boot-time daemon readiness\n\nLinux permanent-agent services wait for their configured daemon before launching\nFleet's runner. This uses the role's saved manifest path and environment, including\nhost profiles, gateway endpoints and expected daemon identity; no Docker container\nnames or default ports are assumed. The read-only probe requires verified startup\nreadiness and an available identity index. Unavailable or unauthorized daemons leave\nthe service waiting, with a diagnostic code in the journal. Each wait is bounded\nand systemd retries it until the daemon is ready; stopping the service cancels it.\nThis does not consume the agent crash budget or discard its session context.\nOnce the runner starts, its normal crash circuit breaker still applies.\nAfter upgrading Fleet, rerun init to refresh the generated service template.\nTemporary agents and macOS services retain their existing lifecycle behavior.\n\n## Reliable mail wake\n\n`monitor.mode` selects exactly one wake owner:\n\n- `fleet` (default): the ours-fleet supervisor consumes body-free daemon\n  events and advances its durable cursor only after delivery is accepted. ACP\n  uses live steering when supported and falls back to structured\n  `session/prompt`.\n- `native`: ours-fleet starts no supervisor monitor; the generated briefing\n  instructs Claude Code or Codex to arm its harness-native wake mechanism.\n\nSet `monitor.interrupt: true` in fleet mode to cancel active work before every\nconfigured wake. Set it to `after_tool` to preserve an active ACP tool (and any\npending permission), then steer the wake at the first tool-terminal boundary\nwithout cancellation. A hung boundary is bounded at 120 seconds and falls back\nto non-cancelling steering/queueing; adapters without authenticated tool events\nuse the same conservative fallback. Explicit human/control interrupts remain\nimmediate. The policy is content-blind because the supervisor cannot inspect\nencrypted message bodies. Message bodies are released only when the role calls\nthe ours `get_messages` tool.\n\nThe default is `false`. For a temporary role whose mission intentionally arrives\nafter its readiness announcement, set `mode: fleet` and `interrupt: true`\nexplicitly. The readiness announcement does not change the transport: the\nmission remains ordinary ours mail, fleet injects only the body-free wake, and\nthe role calls `get_messages` before acting. Every later configured wake uses\nthe same interruption policy.\n\nLegacy `monitor.enabled: true|false` remains accepted as an alias for\n`mode: fleet|native`; use `mode` in new configuration. Codex's separate\n`harness_options.monitor: true` is native-monitor consent, not monitor-owner\nselection.\nInspect `ours-fleet status Name`, `peek Name`, role logs, and\n`~/.ours-fleet/agents/Name/.monitor-status` when diagnosing delivery.\n\n## Trusted owner channel\n\nAny managed role may declare a separate ours identity which fleet \u2014 never the agent \u2014\ncreates when missing and binds:\n\n```yaml\nowner_channel:\n  identity: Coordinator Owner Channel\n  owners: [authenticated-owner-contact-cid]\n  agent: authenticated-managed-agent-cid\n  interrupt: false\n  progress_interval_ms: 30000\n  comments: true\n  attachments:\n    enabled: true\n    max_files_per_request: 4\n    max_file_bytes: 10485760\n    max_request_bytes: 20971520\n    retention_ms: 86400000\n```\n\nPermanent role identities are also reconciled before launch. Fleet creates a\nmissing role identity with local exposure and local auto-accept enabled. A\nmissing owner-channel identity uses the safer inverse policy: both are disabled.\nThe short provisioning lease is released before the agent or channel binds.\nTemporary role identities remain connector-owned because their creating lease\ndefines their cleanup lifetime.\n\nThis does not replace the role identity. Normal identity mail remains untrusted\npeer input: the agent reads it through `get_messages` and replies through\n`send_message`. Mail arriving on the dedicated channel from a CID in `owners`\nis injected as a direct `[fleet-owner]` prompt. Mail from the exact `agent`\nCID is forwarded as a new message to the latest authenticated owner conversation;\nits files may also be relayed through this channel. A reply reference selects the\nowner of that authenticated source wire instead of the latest conversation.\nEvery other CID is rejected and warned about without reflecting its body. Fleet sends\naccepted/queued/progress/interrupted/failure notices and routes the ACP turn's\nfinal assistant text back to the authenticated sender with its source wire ID.\nFor file replies of every kind \u2014 a response artifact, a proactive note, or an\nin-turn attachment \u2014 the agent calls ours `send_file` to the channel identity\nand may pair it with a reply-linked caption; fleet, not the agent, chooses the\nowner. That is the only delivery route an agent is given: a tool call either\ndelivers or reports an error, where a file written to disk does neither.\nOwner messages whose trimmed text starts with `/` are deterministic\nsupervisor commands and never enter the model: `/help` (alias `/commands`),\n`/status`, `/comments [status|on|off]`, `/interrupt`, `/clear`,\n`/compact`, `/model <model-id>`, `/restart`, `/force-restart`, `/ls`,\n`/peek`, `/worklog`, and\n`/version`. Unknown or malformed commands answer with the help text instead of\nbeing forwarded; plain messages reach the agent unchanged. `/clear`,\n`/compact`, and `/model` are forwarded only when the role's bundled ACP\nadapter executes them locally (claude-code: all three; codex: `/compact`\nonly) and are otherwise refused with a notice, so slash text never reaches the\nmodel as a prompt.\n\nThe supervisor advertises the same primary registry entries as recipient-scoped\nours typed commands. Their single arguments field is converted back to the text\nafter the slash command name and enters the same dispatcher; aliases stay\nslash-only. Typed handlers repeat the live authenticated Owner-CID check before\ndispatch and return a null protocol completion because the existing correlated\nowner-channel reply remains the result.\n\nWhile a request runs, the agent's live ACP commentary is relayed as messages\nprefixed with the single stable label `\uD83D\uDFE1 Live update:`, so an owner can see\nexactly which messages the setting controls. `owner_channel.comments`\n(default `true`, so existing channels keep their current behavior) is the\nRESTART BASELINE; `/comments on|off` changes only the running session and is\ndeliberately not persisted, so a restart always returns to the checked-in\nconfiguration. `/comments status` reports the live value, the baseline, and\nwhether the backend emits live comments at all. Suppressing live comments never\nsuppresses receipts, progress notices, or the final answer.\n\nOwner documents, images, and voice messages use the same authenticated sender\nand source-wire boundary. Fleet inspects body-free metadata first and rejects\ndisabled, over-count, or over-size requests before selective\nretrieval. Unauthorized CIDs are never retrieved or answered. Reply-linked text\nand files from the same sender become one ordered request; a file-only wake also\nstarts a turn. Retrieved bytes must match their structured size and SHA-256,\nwhile MIME values, extensions, file categories, and declared-versus-detected mismatches\nremain report-only metadata. Symlinks or non-regular paths fail closed. Sanitized copies live only in a mode-0700 request directory as\nmode-0600 files and are removed after completion or bounded stale retention.\n\nThe legacy `attachments.allowed_mime` key is accepted and ignored so existing\nconfigurations keep loading; it is omitted from resolved configuration and cannot\naffect admission.\n\nVoice prompts include a bounded transcript only when typed daemon metadata reports success.\nFailure or unavailability is explicit and preserves the private audio path as the\ninput for direct review. Run `ours config show --json` and inspect `sttConfigured` without\nrevealing provider credentials.\nA mode-0600 message claim journal stores only wire ID, persistent-history\nsequence, and claim time. Fleet journals the exact body-free oldest-first slice\nbefore calling `getMessages` with that slice length, rejects a returned set\nmismatch, and loads a crash-recovered body only through `getHistoryItem`.\nThe attachment crash journal contains only authenticated CID and wire routing\ndata; it never stores captions, filenames, paths, transcript text, or bytes.\nJournaled read files resume through `getFileInfo` and `fetchFile`. A claimed\nagent caption is loaded from history and rejoined before the group is admitted. Fleet\nresolves one authenticated owner route before retrieving bytes, admits every file\nbefore emitting the caption or any file, and sends every part to that same route.\nUnknown correlated routes remain queued without retrieval and receive one bounded\ncorrelated notice. Admission rejection consumes the whole group with one NACK;\nonce emission starts, a transport error becomes terminal uncertain delivery and\nthe group is never blind-retried. Bounded v2 source-wire routing state is migrated\nfrom v1 on read. Corrupt state disables attachment admission rather than weakening\nprovenance checks.\n\nThe channel identity must be unique and must not be a role identity. The bridge\npersists bounded wire IDs only, never message/reply plaintext, and requeues input\nbefore starting its turn for at-least-once crash recovery. It currently requires\nthe structured agent-session interface so correlated final replies retain their\ndelivery guarantee.\n\n### Live contact and owner administration\n\nThe supervisor which is already running the managed role remains the sole binder of\n`owner_channel.identity`. The CLI reaches that exact live `OwnerChannel`\nthrough the role's token-authenticated, mode-0600 Unix control socket for contact\ninspection and setup; it never starts another ours client and never force-binds:\n\nRapid supervised restart is serialized by a role-scoped single-binder lease.\nThe predecessor closes its authenticated control socket and MCP proxy before\nreleasing ownership. The replacement waits at most five seconds and retries the\ndaemon bind only when PID/start-marker metadata proves the holder was the same\nrole and owner-channel identity. Foreign, live, corrupt, or otherwise\nunverifiable ownership remains fail-closed; fleet never uses `force=true`.\n\nIf that matching predecessor misses the bound, its still-authenticated control\nroute may send one fixed, digest-deduplicated recovery notice through the latest\nauthenticated owner conversation (or the sole configured owner). Notice\nplaintext is never persisted. With no safe deterministic route fleet guesses no\nrecipient and leaves the actionable failure in the web console and role logs.\nThe remote recovery action is `/restart`; inspect repeated failures with\n`ours-fleet logs <Role>` or the web console.\n\n```sh\nours-fleet owner-channel contact list <Role>\nours-fleet owner-channel contact invite <Role> [--name <label>]\nours-fleet owner-channel contact add <Role> (--invite-file <path> | --invite-stdin) [--name <label>]\nours-fleet owner-channel owner list <Role>\nours-fleet owner-channel owner authorize <Role> <exact-64-hex-contact-cid>\nours-fleet owner-channel owner revoke <Role> <exact-64-hex-contact-cid>\n```\n\nContact establishment and owner authorization are separate security steps.\n`contact add` never authorizes: invite redemption is pending until the peer\nverifies it. Once `contact list` reports the established contact, authorize\nits exact immutable CID explicitly. Invite creation emits invite material only\non stdout; acceptance reads it from a file or stdin, not argv.\n\nConfigured `owners` remain the baseline. On legacy channels without `agent`,\nlive authorizations/revocations are an immediately effective, restart-persistent\noverlay. Managed-agent CID gating makes fleet configuration authoritative and\ndisables live owner mutation and direct control-socket sends. `owner list` labels\nbaseline versus dynamic entries and effective status. The atomic mode-0600 file\ncontains bounded CIDs and audit actions only. Corruption disables all effective\nowners and refuses mutation rather than resurrecting authority; revoking the\nlast effective owner is always refused.\n\nA missing/stopped role, role without `owner_channel`, unavailable\nMCP client, or a role entering shutdown returns an actionable error with no\nside effects. Management uses no network listener and never logs or persists\ninvite material.\n\nFor any non-final message\u2014progress, blocker, suggestion, or later proactive note\u2014\nthe managed agent calls ordinary ours `send_message` to the channel identity.\nFleet checks only that the authenticated sender CID exactly equals `agent`, then\nforwards the text as a new message. There is no task/request/update type, phase,\nreply correlation, or owner recipient argument. A sole owner is the safe fallback;\nwith multiple owners and no inbound route history the relay fails closed. Devices\nsharing one identity share its CID; separate owner identities hand off the route\nwhen either sends channel mail. The ACP final is separate: fleet extracts it from\nthe completed turn and deterministically replies to the initiating owner wire.\n\nThe bounded mode-0600 route state stores CIDs, wire IDs, timestamps, delivery state,\nand hashes but never message plaintext. Unauthorized attempts produce a bounded\nCID-only owner warning; attempted bodies are neither reflected nor persisted.\n\nFor a mobile owner, establish the contact first, wait for peer verification,\nauthorize its exact CID, and revoke that same CID when access ends. The bounded\nmode-0600 CID overlay survives supervisor restart and remains fail-closed on\ncorruption. Update bodies remain memory-only. After a crash/restart, unfinished\ndeferred owner input follows the existing at-least-once replay path; the restarted\nsupervisor remains the sole binder.\n\n## Stable config and YAML migration\n\n`ours-fleet config --json` emits schemaVersion 1 resolved plans. Environment\nvalues and mission/persona/bio bodies are withheld; environment keys are sorted\nand values are marked redacted. Additive fields may appear in schema 1, while a\nremoval or semantic reuse requires a new schema version.\n\nYAML parsing always rejects duplicate keys. The current default\n`--yaml-mode compat` warns with file/line/column for anchors, aliases, explicit\ntags, non-scalar keys, and multiple documents. Use `--yaml-mode strict` in CI\nnow; strict becomes the next-major default and compat is the temporary migration\nescape hatch.\n\n## Bounded worklogs, auth proxy, and model recovery\n\nWORKLOG rotation is enabled by default with\n`worklog: { max_kb: 1024, keep_tail_kb: 256, max_archives: 12 }`. Maps may\noverride individual values; `worklog: false` on a role or in defaults opts out.\nFleet rotates only at that role's launch/resume lifecycle boundary. Concurrent\nchanges defer rotation. The active file keeps a bounded UTF-8 tail and advances\nto a line boundary when a complete line fits. If one logical line alone exceeds\nthe budget, its newest suffix remains and the rotation manifest records the\nmid-line start and omitted byte count. The complete prior inode receives a\ncollision-safe UTC archive name, and\n`.worklog-rotation.json` records restart provenance. `max_archives` bounds\nrecent archives beside WORKLOG.md; older complete archives move to\n`WORKLOG.archives/` without deletion. All archives share the role's sensitive\nstate boundary. Fleet refuses a symlinked/non-regular live log or a symlinked\ncold-archive boundary before replacing the live path and best-effort removes a\nduplicate publication left by a detected failure while the original inode is\nstill available. The manifest records SHA-256 digests for the archive and live\nbytes observed when it is written. These checks address ordinary path hazards,\nnot intentional path mutation by a malicious concurrent process with the same\nUnix authority; that is outside the threat model and requires OS-level isolation.\n\nACP tool diffs are bounded before entering web conversation events. Existing\nsmall before/after diffs are unchanged. Oversized whole-file snapshots are\nreduced to the actual changed region plus path, operation, original byte counts,\ndigest, and omission metadata. Each retained side is a newest-content UTF-8 tail\nof at most 64 KiB, advanced to a line boundary when a complete line fits. An\noverlong single line keeps its newest suffix and explicitly records a mid-line\nstart. Paths retain at most a 4 KiB suffix with byte count, digest, and omitted\nprefix metadata; the complete normalized update is capped at 320 KiB. A large\nappend therefore retains current appended content, not the historical prefix.\nThe live web-console transcript includes only the current runner generation and\nexcludes adapter session/load replay. Replayed events remain durable with\nagent_replay provenance for diagnosis and recovery.\n\n`auth_proxy: { kind: anthropic, base_url, required, health_url }` is Claude-only\nand loopback-only. Fleet injects only ANTHROPIC_BASE_URL and doctor rejects\ncredential env keys. The privileged reference companion is\n`contrib/anthropic-auth-proxy.mjs`; deploy it separately as a dedicated account\nwith a 0600 token file and per-role listener access. Fleet never installs it or\nreads its credential.\n\n`model_chain` is an ordered authorization list and its first entry must equal\n`model`. Only sustained high-confidence entitlement/quota 429 evidence advances\none entry. Transient 429, overload, auth, policy, and unknown errors never\ndown-shift. Runtime state is atomic in .model-recovery.json; exhaustion is\nfail-closed and held down. Change the declared chain/model and restart to\nreconcile explicitly; no chain preserves detection-only behavior.\n";
 /**
  * What every shipped spawn-skill variant must say, and must not say.
  *

package/dist/docs.js

@@ -492,6 +492,17 @@ Messenger-bound results are capped at 3,500 Unicode code points and 12,000 UTF-8
 bytes with structural omission notices. \`--json\` bypasses this presentation layer
 and retains the versioned machine schema and serialization order.
 
+Active task \`show\` reports current readiness separately from lifecycle, also in
+Owner commands. Start/work preserve the fail-closed \`task_not_ready\` behavior.
+Unknown control health does not prove a dead agent or authorize replacement.
+Before deliberate recovery, Fleet Coordinator inspects current seats and exact
+old-launch worklogs/termination evidence in \`recovery/temporary\`, preserves
+original records, and privately records verified old/new launch provenance.
+A new inbox is not complete history: page scoped history to the end, authenticate
+historical Owner authors, and compare completed actions and replies before resuming.
+Do not restore archived identity state, reuse invites, adopt same-role seats or
+blindly replay instructions. Ask the Owner if authority/completion is uncertain.
+
 Every task belongs to a named list. The built-in \`default\` list always exists,
 and legacy tasks or create calls without \`--list\` resolve to it. Use \`task lists\`,
 \`task list-create <name>\`, \`task list-rename <name> <new-name>\`, and

package/dist/harness/codex-app-server-proxy.d.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+type JsonObject = Record<string, unknown>;
 interface TerminalRecoveryOptions {
     sendToCodex(line: string): void;
     emitToClient(line: string): void;
@@ -39,6 +40,8 @@ export declare class CodexTerminalRecovery {
     private finishTurn;
 }
 /** Transform one app-server NDJSON request; malformed input passes through. */
-export declare function rewriteCodexAppServerRequest(line: string, approval: string, expectedSandbox: string, disableInheritedMcp?: boolean): string;
+export declare function rewriteCodexAppServerRequest(line: string, approval: string, expectedSandbox: string, disableInheritedMcp?: boolean, managedOursTools?: JsonObject): string;
+/** ACP only carries transport fields; read policy from Fleet's complete config. */
+export declare function managedCodexToolPolicy(env: NodeJS.ProcessEnv): JsonObject | undefined;
 export declare function runCodexAppServerProxy(): void;
 export {};

package/dist/harness/codex-app-server-proxy.js

@@ -300,9 +300,9 @@ function sandboxMode(policy) {
  * Fleet keeps the preset's sandbox policy, but restores the independently
  * configured approval policy on the request Codex actually executes.
  */
-function rewriteMessage(value, approval, expectedSandbox, disableInheritedMcp) {
+function rewriteMessage(value, approval, expectedSandbox, disableInheritedMcp, managedOursTools) {
     if (Array.isArray(value))
-        return value.map(candidate => rewriteMessage(candidate, approval, expectedSandbox, disableInheritedMcp));
+        return value.map(candidate => rewriteMessage(candidate, approval, expectedSandbox, disableInheritedMcp, managedOursTools));
     if (!isObject(value) || !isObject(value.params))
         return value;
     if (value.method === 'turn/start') {
@@ -318,17 +318,52 @@ function rewriteMessage(value, approval, expectedSandbox, disableInheritedMcp) {
             params: { ...value.params, config: { ...config, mcp_servers: {} } },
         };
     }
+    if (managedOursTools
+        && (value.method === 'thread/start' || value.method === 'thread/resume')) {
+        const config = isObject(value.params.config) ? value.params.config : {};
+        const servers = isObject(config.mcp_servers) ? config.mcp_servers : {};
+        const ours = servers.ours;
+        // Policy cannot create or re-enable a connector that ACP did not inject.
+        if (!isObject(ours) || ours.enabled === false)
+            return value;
+        const tools = isObject(ours.tools) ? { ...ours.tools } : {};
+        for (const [name, policy] of Object.entries(managedOursTools)) {
+            if (isObject(policy))
+                tools[name] = {
+                    ...(isObject(tools[name]) ? tools[name] : {}), ...policy,
+                };
+        }
+        return { ...value, params: { ...value.params, config: { ...config,
+                    mcp_servers: { ...servers, ours: { ...ours, tools } },
+                } } };
+    }
     return value;
 }
 /** Transform one app-server NDJSON request; malformed input passes through. */
-export function rewriteCodexAppServerRequest(line, approval, expectedSandbox, disableInheritedMcp = false) {
+export function rewriteCodexAppServerRequest(line, approval, expectedSandbox, disableInheritedMcp = false, managedOursTools) {
     try {
-        return JSON.stringify(rewriteMessage(JSON.parse(line), approval, expectedSandbox, disableInheritedMcp));
+        return JSON.stringify(rewriteMessage(JSON.parse(line), approval, expectedSandbox, disableInheritedMcp, managedOursTools));
     }
     catch {
         return line;
     }
 }
+/** ACP only carries transport fields; read policy from Fleet's complete config. */
+export function managedCodexToolPolicy(env) {
+    if (env.FLEET_OURS_MANAGED !== '1')
+        return undefined;
+    try {
+        const config = JSON.parse(env.CODEX_CONFIG ?? '{}');
+        const servers = isObject(config) ? config.mcp_servers : undefined;
+        const ours = isObject(servers) ? servers.ours : undefined;
+        return isObject(ours) && ours.enabled !== false && isObject(ours.tools)
+            ? ours.tools : undefined;
+    }
+    catch {
+        // Invalid config never grants tool approval. ACP owns config diagnostics.
+        return undefined;
+    }
+}
 function requiredChoice(name, allowed) {
     const value = process.env[name];
     if (value && allowed.has(value))
@@ -355,6 +390,7 @@ export function runCodexAppServerProxy() {
     const approval = requiredChoice(APPROVAL_ENV, APPROVAL_POLICIES);
     const expectedSandbox = requiredChoice(SANDBOX_ENV, SANDBOX_MODES);
     const disableInheritedMcp = process.env[DISABLE_INHERITED_MCP_ENV] === '1';
+    const managedOursTools = managedCodexToolPolicy(process.env);
     const launch = realCodexLaunch();
     const env = { ...process.env };
     delete env.CODEX_PATH;
@@ -450,7 +486,7 @@ export function runCodexAppServerProxy() {
     input.on('line', line => {
         if (finished)
             return;
-        const rewritten = rewriteCodexAppServerRequest(line, approval, expectedSandbox, disableInheritedMcp);
+        const rewritten = rewriteCodexAppServerRequest(line, approval, expectedSandbox, disableInheritedMcp, managedOursTools);
         recovery.observeClientLine(rewritten);
         writeToChild(rewritten);
     });

package/dist/init-wizard.js

@@ -7,7 +7,7 @@ import { packagedPresetRoot } from './preset-bootstrap.js';
 import { listTemplates } from './rooms-tasks/templates.js';
 const WORK_KINDS = ['development', 'review', 'coordination'];
 const ROLE_WORK = {
-    Developer: 'development', Critic: 'review',
+    Developer: 'development', Engineer: 'development', Critic: 'review',
     LocalCoordinator: 'coordination', Coordinator: 'coordination', FleetCoordinator: 'coordination',
 };
 const REASONING_EFFORT = {
@@ -170,6 +170,7 @@ export function formatSetupSummary(answers, configuration) {
         '  One-agent work: one Developer',
         '  Reviewed pair: Developer + independent Critic',
         '  Team: LocalCoordinator + Developer + Critic',
+        '  Gated engineering: Engineer (gate pipeline) + independent Critic',
         '  FleetCoordinator: coordination model',
         '',
         'After the final Yes, Fleet performs host service setup before publishing the complete configuration.',
@@ -228,7 +229,7 @@ export function generateSetup(answers) {
         if (tuples.size !== 1)
             throw new Error('one-model assignment requires the same exact model for development, review, and coordination');
     }
-    for (const role of ['Coordinator', 'LocalCoordinator', 'Developer', 'Critic']) {
+    for (const role of ['Coordinator', 'LocalCoordinator', 'Developer', 'Engineer', 'Critic']) {
         files.set(`roles/${role}.yaml`, preset(`roles/${role}.yaml`));
         if (role === 'Coordinator')
             continue;
@@ -243,7 +244,7 @@ export function generateSetup(answers) {
     }
     files.set('agents/FleetCoordinator.yaml', preset('agents/FleetCoordinator.yaml')
         .replace('brain: { ref: claude-default }', 'brain: { ref: coordination }'));
-    for (const name of ['single', 'pair', 'team'])
+    for (const name of ['single', 'pair', 'team', 'engineering'])
         files.set(`room_templates/${name}.yaml`, preset(`room_templates/${name}.yaml`));
     return { files, answers };
 }
@@ -401,8 +402,8 @@ function validateStaged(stageManifest) {
     const config = loadConfig(stageManifest, { yamlMode: 'strict' });
     const templates = listTemplates(config.roomTemplates ?? {});
     const names = new Set(templates.map(template => template.name));
-    if (!['pair', 'single', 'team'].every(name => names.has(name)))
-        throw new Error('generated setup did not resolve the default single, pair, and team experiences');
+    if (!['pair', 'single', 'team', 'engineering'].every(name => names.has(name)))
+        throw new Error('generated setup did not resolve the default single, pair, team, and engineering experiences');
     for (const template of templates)
         for (const member of template.members)
             if (!config.agentTemplates?.[member.agent_template])

package/dist/owner-channel/channel.js

@@ -1398,6 +1398,7 @@ export class OwnerChannel {
                     await this.fleetOps.provisionTask(task.task_id);
                 return outcome;
             }),
+            observeTaskReadiness: taskId => new TaskRoomApplicationService(this.options.configPath).observeTaskReadiness(taskId),
             taskProvisioningOutcome: taskId => new TaskRoomApplicationService(this.options.configPath).taskProvisioningOutcome(taskId),
             listTasks: filter => new TaskRoomApplicationService(this.options.configPath).listTasks(filter),
             groupedTasks: filter => new TaskRoomApplicationService(this.options.configPath).groupedTasks(filter),

package/dist/owner-channel/commands.d.ts

@@ -1,3 +1,4 @@
+import type { TaskReadinessIssue } from '../rooms-tasks/live-readiness.js';
 import type { InterruptOutcome, SessionEvent, SessionSnapshot } from '../session/types.js';
 import type { RoomOrchestrationRecord, TaskOutcome, TaskRecord, TaskTerminalIntent, TaskListRecord } from '../rooms-tasks/types.js';
 import { type OwnerCommentsState } from './notices.js';
@@ -58,6 +59,9 @@ export interface OwnerCommandContext {
     terminalTask(taskId: string, kind: TaskTerminalIntent['kind'], outcome?: TaskOutcome): Promise<void>;
     createTask(input: Omit<CreateTaskRequest, 'actor'>): Promise<TaskRecord>;
     startTask(taskId: string): Promise<TaskProvisioningOutcome | TaskRecord>;
+    observeTaskReadiness?(taskId: string): Promise<{
+        state: 'ready';
+    } | TaskReadinessIssue>;
     taskProvisioningOutcome?(taskId: string): TaskProvisioningOutcome;
     listTasks(filter?: {
         state?: TaskState | TaskState[];

package/dist/owner-channel/commands.js

@@ -306,6 +306,7 @@ export const ownerCommands = [
             const trailingLines = argLines.slice(1).join('\n').trim() || undefined;
             const showTask = async (id) => {
                 const { task: t } = ctx.getTask(id);
+                const readiness = t.state === 'active' ? await ctx.observeTaskReadiness?.(id) : undefined;
                 await ctx.reply(renderMarkdownResult({
                     icon: '📋', title: 'Task details',
                     fields: [
@@ -313,6 +314,8 @@ export const ownerCommands = [
                         { label: 'Title', value: t.title },
                         { label: 'Status', value: taskStatus(t.state), kind: 'markdown' },
                         { label: 'List', value: t.list_name ?? 'default', kind: 'code' },
+                        ...(readiness ? [{ label: 'Readiness', value: readiness.state },
+                            ...('reason' in readiness ? [{ label: 'Reason', value: readiness.reason }] : [])] : []),
                         ...(t.blocked ? [{ label: 'Blocked', value: t.blocked.reason }] : []),
                         ...(t.template ? [{ label: 'Template', value: `${t.template.name}@${t.template.version}`, kind: 'code' }] : []),
                         ...(t.room_id ? [{ label: 'Room', value: t.room_id, kind: 'code' }] : []),

package/dist/preset-migration.js

@@ -69,8 +69,11 @@ const V5_GENERATED_ROLE_DEFAULT_FINGERPRINTS = Object.freeze({
 });
 const CURRENT_ROLE_DEFAULTS = new Set([
     'roles/Coordinator.yaml', 'roles/LocalCoordinator.yaml', 'roles/Developer.yaml', 'roles/Critic.yaml',
+    'roles/Engineer.yaml',
     'agent_templates/LocalCoordinator.yaml', 'agent_templates/Developer.yaml', 'agent_templates/Critic.yaml',
+    'agent_templates/Engineer.yaml',
     'room_templates/single.yaml', 'room_templates/pair.yaml', 'room_templates/team.yaml',
+    'room_templates/engineering.yaml',
     'agents/FleetCoordinator.yaml',
 ]);
 export const legacyStarterMigrationManifest = Object.freeze({
@@ -258,6 +261,18 @@ export function migratePackagedRoleDefaults(configuration, options = {}, hooks =
                 unlinkSync(target);
             copyFileSync(join(source, relative), target, constants.COPYFILE_EXCL);
             chmodSync(target, 0o600);
+            // New Engineer seats use the existing Developer's selected brain. This
+            // preserves wizard/custom provider choices without copying permissions.
+            if (relative === 'agent_templates/Engineer.yaml' && classified.additions.includes(path)) {
+                const developer = join(root, 'agent_templates/Developer.yaml');
+                if (existsSync(developer)) {
+                    const value = parseFleetDocument(developer, readFileSync(developer, 'utf8'), 'strict').value;
+                    if (value.brain !== undefined && JSON.stringify(value.brain) !== JSON.stringify({ ref: 'claude-default' })) {
+                        const bytes = readFileSync(target, 'utf8').replace('brain: { ref: claude-default }', () => `brain: ${JSON.stringify(value.brain)}`);
+                        writeFileSync(target, bytes, { mode: 0o600 });
+                    }
+                }
+            }
             fsyncPath(target);
         }
         for (const kind of ['roles', 'agent_templates', 'room_templates', 'agents'])

package/dist/rooms-tasks/cli.js

@@ -520,10 +520,10 @@ function taskRoomService(configuration) {
 function allTemplates(cfg) {
     return cfg.roomTemplates ?? {};
 }
-function coworkFor(cfg) {
+function coworkFor(cfg, options) {
     if (!cfg.rooms)
         throw new ConfigError('rooms: configuration is required before creating or querying rooms');
-    return createCoworkAdapter({ configPath: cfg.rooms.cowork?.config });
+    return createCoworkAdapter({ configPath: cfg.rooms.cowork?.config, ...options });
 }
 function resolveRoomTemplate(cfg, name) {
     if (!name)
@@ -832,16 +832,18 @@ export function registerTaskCommands(parent, cOpt) {
             dieTaskRoom(e);
         }
     });
-    taskCmd.command('show <id>')
+    cOpt(taskCmd.command('show <id>'))
         .description('show task details')
         .option('--json', 'JSON output')
         .action(async (id, opts) => {
         try {
-            const service = taskRoomService();
+            const service = taskRoomService(opts.configuration);
             const { task: t, orchestration: room } = service.getTask(id);
+            const readiness = t.state === 'active' ? await service.observeTaskReadiness(id) : undefined;
             if (opts.json) {
                 console.log(JSON.stringify({
                     schema_version: 1, task: t, orchestration: room ?? null,
+                    ...(readiness ? { readiness } : {}),
                 }, null, 2));
                 return;
             }
@@ -851,6 +853,8 @@ export function registerTaskCommands(parent, cOpt) {
                     { label: 'ID', value: t.task_id, kind: 'code' },
                     { label: 'Title', value: t.title },
                     { label: 'Status', value: taskStatus(t.state), kind: 'markdown' },
+                    ...(readiness ? [{ label: 'Readiness', value: readiness.state },
+                        ...('reason' in readiness ? [{ label: 'Reason', value: readiness.reason }] : [])] : []),
                     ...(t.blocked ? [{ label: 'Blocked', value: t.blocked.reason }] : []),
                     ...(t.template ? [{ label: 'Template', value: `${t.template.name}@${t.template.version}`, kind: 'code' }] : []),
                     ...(t.room_id ? [{ label: 'Room', value: t.room_id, kind: 'code' }] : []),

package/dist/rooms-tasks/live-readiness.js

@@ -13,7 +13,8 @@ export async function taskLiveReadiness(task, room, cowork, deps = {}) {
         return degraded('room_record_mismatch');
     const expected = room.template_snapshot?.members.reduce((n, member) => n + member.count, 0);
     if (expected === undefined || room.member_seats.length !== expected
-        || new Set(room.member_seats.map(seat => seat.role_name)).size !== expected)
+        || new Set(room.member_seats.map(seat => seat.role_name)).size !== expected
+        || new Set(room.member_seats.map(seat => seat.identity_cid)).size !== expected)
         return degraded('member_roster_mismatch');
     let remote;
     try {
@@ -25,11 +26,11 @@ export async function taskLiveReadiness(task, room, cowork, deps = {}) {
     if (!remote || remote.room_id !== room.room_id || remote.identity_cid !== room.room_identity_cid
         || remote.state !== 'active')
         return degraded('room_identity_or_state_mismatch');
-    if (room.owner_seat_cid && !remote.seats.some(seat => seat.identity_cid === room.owner_seat_cid && seat.seat_state === 'active'))
+    if (room.owner_seat_cid && remote.seats.filter(seat => seat.identity_cid === room.owner_seat_cid && seat.seat_state === 'active').length !== 1)
         return degraded('owner_seat_missing');
     for (const seat of room.member_seats) {
         const member = seat.role_name;
-        if (seat.seat_state !== 'active' || !seat.identity_cid || !seat.invite_id
+        if (!/^[A-Za-z0-9_-]+$/.test(member) || seat.seat_state !== 'active' || !seat.identity_cid || !seat.invite_id
             || seat.launch?.state !== 'launched' || !seat.launch.launch_id || seat.retirement)
             return degraded('member_record_incomplete', member);
         const matches = remote.seats.filter(item => item.display_name === member && item.seat_state !== 'removed');
@@ -59,7 +60,7 @@ export async function taskLiveReadiness(task, room, cowork, deps = {}) {
             return unknown('supervisor_probe_unavailable', member);
         }
         try {
-            const response = await (deps.control ?? controlRequest)(dir, { command: 'status' }, 2_000);
+            const response = await (deps.control ?? controlRequest)(dir, { command: 'status', controller: false }, 2_000);
             if (!response.ok)
                 return unknown('control_unavailable', member);
             const status = response.result;
@@ -67,9 +68,17 @@ export async function taskLiveReadiness(task, room, cowork, deps = {}) {
                 return degraded('agent_not_ready', member);
             if (status?.alive !== true || !['idle', 'running', 'awaiting_permission'].includes(status.readiness ?? ''))
                 return unknown('agent_readiness_unknown', member);
+            const after = (deps.supervisor ?? readTempSupervisor)(dir);
+            if (!after || after.role !== member || after.launchId !== seat.launch.launch_id)
+                return degraded('supervisor_launch_changed', member);
         }
         catch {
             return unknown('control_unavailable', member);
         }
     }
+    const memberCids = new Set(room.member_seats.map(seat => seat.identity_cid));
+    const memberRoles = new Set(room.member_seats.map(seat => seat.cowork_role));
+    if (remote.seats.some(seat => seat.seat_state === 'active' && memberRoles.has(seat.role)
+        && !memberCids.has(seat.identity_cid) && seat.identity_cid !== room.owner_seat_cid))
+        return degraded('untracked_member_seats');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/fleet",
-  "version": "1.2.0-nightly.17",
+  "version": "1.2.0-nightly.19",
   "description": "Harness-agnostic fleet of persistent, identity-bound AI agents. Declarative fleet.yaml, managed native/ACP sessions, supervision, and ours.network messaging.",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",

package/presets/fleet/agent_templates/Engineer.yaml

@@ -0,0 +1,5 @@
+role: { ref: Engineer }
+brain: { ref: claude-default }
+coordinator: FleetCoordinator
+permissions: { approval: ask, filesystem: workspace, unattended: deny }
+monitor: { mode: fleet, interrupt: after_tool }

package/presets/fleet/roles/Engineer.yaml

@@ -0,0 +1,40 @@
+mission: Own implementation and task execution for the assigned goal through the engineering gate pipeline, with maintainable code and tests.
+persona: |
+  Make the smallest coherent change that satisfies the task. Preserve unrelated work, validate
+  observable behavior in proportion to risk, and report deviations. Do not waive failing tests,
+  publish, deploy, or mutate Fleet lifecycle without authority.
+
+  Work every non-trivial task through the engineering gate pipeline, in order: tighten scope and
+  record a numbered Definition of Done before any code; pressure-test the design against
+  over-engineering and prefer the simplest solution that works; write the spec down before
+  implementing; implement test-first — write the failing test, watch it fail for the right
+  reason, then make it pass; run a code review; run a security pass sized to the real attack
+  surface; update the documentation the change touches; and verify every Definition of Done item
+  with evidence before calling anything done. Report each gate's outcome in the assigned Cowork
+  room as it closes. If a gate-pipeline skill is installed in this session, invoke it at task
+  start and follow its gates; if none is installed, say so in the room and walk the same gates by
+  hand — never skip a gate silently. Trivial one-line fixes, typos, and purely mechanical
+  refactors are exempt from the full pipeline; claim the exemption out loud when using it.
+
+  Task state, progress, checkpoints, findings, review verdicts, completion, handoffs, and ordinary
+  errors are routine task communication: report them only in the assigned Cowork room. When a
+  LocalCoordinator is present, read and follow its instructions directly in the room and keep all
+  replies and evidence in that same room; it does not become a separate reporting channel. Fleet
+  Coordinator ownership of lifecycle operations does not make it the routine task-communication sink.
+
+  Distinguish infrastructure or orchestration failure from ordinary task difficulty, review
+  disagreement, asynchronous delay, implementation defects, normal review findings, test failures
+  under active diagnosis, or incomplete work. Send a direct message only for a confirmed blocker or
+  infrastructure or orchestration problem that prevents safe progress or room communication and
+  requires Fleet-level action. Report it once
+  to the configured Fleet Coordinator with authenticated sender, available task/room context,
+  observed state, bounded safe attempts, and the canonical next action. Never include invites or
+  invite fingerprints, keys, tokens, unrelated messages, or private workspace content. Retry only
+  transient blocker-report transport at most once after backoff. Never retry the failed identity,
+  room, or lifecycle operation after an identity/CID mismatch, consumed/invalid invite, permission
+  failure, or lost lifecycle state. Avoid busy-polling,
+  continue independent safe work, or declare BLOCKED/resting. Report peer nonresponse only 10 minutes
+  after a direct room attempt unless the room contract defines another window; honor any later
+  absolute ETA from the peer's timestamp or stated start time. Leave recover,
+  block/unblock, review/finish, deletion, replacement, and respawn decisions to Fleet Coordinator.
+bio: Gate-pipeline implementation specialist; engage to deliver a bounded change with gate-by-gate verification evidence.

package/presets/fleet/room_templates/engineering.yaml

@@ -0,0 +1,19 @@
+version: 1
+description: "Engineering pair: Engineer works the gate pipeline and Critic independently reviews"
+room: { quiet_membership: false, anonymous: false }
+contract: |
+  Engineer owns implementation and verification evidence, and works through the engineering gate
+  pipeline: scope and a numbered Definition of Done before code, an over-engineering check, spec
+  before implementation, test-first implementation, review, a security pass sized to the change,
+  documentation, and evidence-backed verification of every Definition of Done item — reporting
+  each gate's outcome in this room. The seat label Engineer marks the gated pipeline; a plain
+  Developer seat is never the gated one.
+  Critic independently challenges assumptions, may audit against the same gates, and withholds
+  sign-off on material failures.
+  Both keep routine state, findings, verdicts, completion, handoffs, and ordinary errors in this room.
+  Direct Fleet Coordinator contact is reserved for a confirmed blocker or infrastructure or orchestration
+  problem that prevents safe progress or room communication and requires Fleet-level action.
+  Completion requires Engineer evidence and Critic sign-off.
+members:
+  - { slot: developer, role: Engineer, count: 1, agent_template: Engineer }
+  - { slot: critic, role: Critic, count: 1, agent_template: Critic }