agl 40.5.1 → 40.6.0

package/dist_ts/functions.workerprocessproof.js

@@ -112,16 +112,40 @@ const processOwnsLoopbackConnection = async (connectionArg, pidArg) => {
     const matches = table.split('\n').slice(1).map(line => line.trim().split(/\s+/u)).filter(fields => (fields[1] === endpoint(connectionArg.remotePort) && fields[2] === endpoint(connectionArg.localPort) && fields[3] === '01'));
     return matches.length === 1 && await processOwnsInode(pidArg, matches[0][9]);
 };
-export const verifyWorkerBridge = async (connectionArg, bridgePidArg, commandArg, parentArg) => {
+/**
+ * The bridge process `bridgePidArg`, proved to hold the caller's end of the direct loopback connection and to run the
+ * approved command, whatever its parent. The command is the one recorded when the launch was prepared: an upgrade
+ * installs AGL under another path, and a command whose files are gone is refused as such.
+ */
+export const readWorkerBridge = async (connectionArg, bridgePidArg, commandArg) => {
+    for (const file of [commandArg.executable, commandArg.entry]) {
+        let resolved;
+        try {
+            resolved = await plugins.fs.promises.realpath(file);
+        }
+        catch (errorArg) {
+            if (isWorkerCallerProofRefusal(errorArg))
+                throw new WorkerCallerProofError('The approved bridge command no longer exists.');
+            throw errorArg;
+        }
+        if (resolved !== file)
+            throw new WorkerCallerProofError('The approved bridge command no longer exists.');
+    }
     if (!await processOwnsLoopbackConnection(connectionArg, bridgePidArg)) {
         throw new WorkerCallerProofError('Worker transport ownership could not be proved.');
     }
     const bridge = await readWorkerProcessSnapshot(bridgePidArg);
     const entry = await plugins.fs.promises.realpath(bridge.arguments[1] ?? '');
-    if (bridge.parentPid !== parentArg.pid || bridge.executable !== commandArg.executable
-        || entry !== commandArg.entry || !plugins.util.isDeepStrictEqual(bridge.arguments.slice(2), commandArg.arguments)) {
+    if (bridge.executable !== commandArg.executable || entry !== commandArg.entry
+        || !plugins.util.isDeepStrictEqual(bridge.arguments.slice(2), commandArg.arguments)) {
         throw new WorkerCallerProofError('Worker bridge does not match the approved launch.');
     }
+    return bridge;
+};
+export const verifyWorkerBridge = async (connectionArg, bridgePidArg, commandArg, parentArg) => {
+    const bridge = await readWorkerBridge(connectionArg, bridgePidArg, commandArg);
+    if (bridge.parentPid !== parentArg.pid)
+        throw new WorkerCallerProofError('Worker bridge does not match the approved launch.');
     if (!workerSnapshotsEqual(parentArg, await readWorkerProcessSnapshot(parentArg.pid))
         || !workerSnapshotsEqual(bridge, await readWorkerProcessSnapshot(bridge.pid))) {
         throw new WorkerCallerProofError('Worker transport or process incarnation could not be proved.');
@@ -189,4 +213,4 @@ export const proveConnectionProcessAncestry = async (connectionArg, pidArg, maxi
     }
     return chain;
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"functions.workerprocessproof.js","sourceRoot":"","sources":["../../ts/functions.workerprocessproof.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"functions.workerprocessproof.js","sourceRoot":"","sources":["../../ts/functions.workerprocessproof.ts"],"names":[],"mappings":"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"}

package/dist_ts_interfaces/workercallers.d.ts

@@ -4,6 +4,8 @@ export declare const workerCallerLaunchGenerationEnvironmentVariable = "AGL_MCP_
 export interface IFleetWorkerCallerLaunchBase {
     launchId: string;
     projectId: string;
+    /** The fleet worker the launch identifies, `${projectId}:${name}`: a worker holds one current launch. */
+    workerId: string;
 }
 /**
  * The Codex app-server connection that created the worker's thread: a controller connection profile, or the fleet's
@@ -28,12 +30,18 @@ export interface IFleetClaudeProcess {
     pid: number;
     startTicks: string;
 }
-export type TFleetWorkerCallerBinding = IFleetWorkerCallerLaunchBase & {
+export type TFleetWorkerCallerBinding = Omit<IFleetWorkerCallerLaunchBase, 'workerId'> & {
     nativeSessionId: string;
     expectedBindingRevision: number;
-} & ({
+} & (
+/**
+ * A Claude launch binds to its background job and to the job's current process; a job whose process already exited
+ * binds without one, and the next process of the same job proves itself when its bridge enrolls.
+ */
+{
     harnessId: 'claude';
-    claudeProcess: IFleetClaudeProcess;
+    claudeJobId: string;
+    claudeProcess?: IFleetClaudeProcess;
 } | {
     harnessId: 'codex';
 });
@@ -58,11 +66,42 @@ export interface IFleetWorkerCallerHooks {
         ticketSessionId: string;
     }>;
     getWorkerCallerStatus(launchId: string): IWorkerCallerReadiness;
-    revokeWorkerCaller(request: {
+    /**
+     * Revokes one launch, or the current launch of a worker, also one the controller kept from before a restart. Every
+     * reason but `generation_change` revokes it for good: its kept binding is deleted with it.
+     */
+    revokeWorkerCaller(request: ({
         launchId: string;
+    } | {
+        workerId: string;
+    }) & {
         reason: 'failure' | 'stop' | 'replacement' | 'generation_change' | 'cancelled';
     }): Promise<void>;
 }
+/** The background job a Claude worker's launch is bound to, as the controller asks the fleet about it. */
+export interface IWorkerClaudeJobRequest {
+    workerId: string;
+    projectId: string;
+    nativeSessionId: string;
+    jobId: string;
+}
+/**
+ * What a fresh Claude inventory shows of that job: `running` in one process, `settled` without a process, `ended` for
+ * this worker (the worker is gone or archived, continues in another session, or the session continues as another job),
+ * or `unproven` when the registry or the inventory could not be read or did not list the session once.
+ */
+export type TWorkerClaudeJobObservation = {
+    state: 'running';
+    process: IFleetClaudeProcess;
+} | {
+    state: 'settled';
+} | {
+    state: 'ended';
+    reason: string;
+} | {
+    state: 'unproven';
+    reason: string;
+};
 export interface IWorkerCallerSubject {
     kind: 'worker_launch';
     launchId: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agl",
-  "version": "40.5.1",
+  "version": "40.6.0",
   "controllerUpgradeManagementVersion": 2,
   "private": false,
   "description": "Agent Gateway Layer for OpenCode, FlexHarness, and Codex sessions",

package/readme.md

@@ -328,6 +328,8 @@ agl proxy run codex --model <catalog-model> -- exec 'Explain this repository'
 agl proxy run claude --                       # Claude Code on Claude accounts
 agl proxy run claude --provider openai --model <catalog-model> --
 agl proxy run opencode --model <catalog-model> -- run 'Explain this repository'
+agl proxy confined run -- docker run --rm --user "$(id -u):$(id -g)" -i <image> claude -p   # Claude Code in a container
+agl proxy confined end <run id>
 ```
 
 Every client -- `codex`, `claude`, `opencode`, or a name of your own -- has one credential. The proxy keeps it
@@ -434,7 +436,8 @@ pool and keeps its credential. `agl proxy run claude` uses Claude accounts unles
 ChatGPT models behind Claude Code; `run codex` and `run opencode` use ChatGPT accounts.
 
 The listener binds only `127.0.0.1` and requires the exact host and port, no browser Origin, and
-`Authorization: Bearer <credential>` (or `x-api-key`).
+`Authorization: Bearer <credential>` (or `x-api-key`). Claude Code in a container reaches the proxy through a second
+listener, a Unix socket that serves confined runs alone (see [Confined containers](#confined-containers)).
 
 - A ChatGPT pool serves `/openai/v1/responses` and `/openai/v1/models` (the pooled Codex catalog in Codex's
   own shape when Codex names its `client_version`), and `/anthropic/v1/messages` and `/anthropic/v1/models`
@@ -701,6 +704,65 @@ proxy's binding with it, and the sessions it served move at their next request.
 pool, 16 requests in flight per session, 256 per client credential, 512 in all, 32 MiB per request and 8 MiB
 per inspected response event (or non-streaming JSON response).
 
+#### Confined containers
+
+`agl proxy confined run` runs Claude Code in a Docker container that reaches AGL through one route only: the proxy's
+confined listener, a Unix socket alone in a directory of its own (`agl-proxy-confined/proxy.sock` beside the proxy's
+control socket; `agl proxy status` names it). The listener serves the Claude pool's three endpoints Claude Code uses --
+`GET /anthropic/v1/models`, `POST /anthropic/v1/messages` and `POST /anthropic/v1/messages/count_tokens` -- exactly as
+the loopback listener serves a Claude client, and refuses every other path, method and pool with 404 before anything is
+read or routed; nothing else of AGL is reachable through it. It accepts confined runs' credentials alone: a request
+without a credential, with one the proxy does not know, or with a credential of the loopback listener (any client's or
+lease's) is refused with 401, and a confined run's credential is refused on the loopback listener alike.
+
+```sh
+agl proxy confined run -- docker run --rm --user "$(id -u):$(id -g)" -i <image> \
+  claude -p --model claude-opus-5-5 --output-format json < prompt.txt
+agl proxy status                  # names the confined listener and lists the runs by id
+agl proxy confined end <run id>   # ends a run's credential at once
+```
+
+Before the container starts, the command asks the proxy for the run's credential: one for this run alone, a lease of
+the Claude pool (the Claude accounts first, then the Anthropic API keys) whose sessions are those of the client
+`confined`, so its requests are placed, moved and counted (token usage under `confined`) like any other Claude
+client's. Right after `docker run` it adds the listener's directory as a read-only mount at `/run/agl-proxy` and what
+Claude Code inside needs to reach it, each variable passed by name so the credential appears on no command line:
+
+- `ANTHROPIC_UNIX_SOCKET=/run/agl-proxy/proxy.sock`: Claude Code sends its API requests through the socket, as plain
+  HTTP, so no relay runs in the container (Claude Code's own setting, which `claude ssh` uses; verified with Claude Code
+  2.1.288, the release of AGL's Agent SDK);
+- `ANTHROPIC_BASE_URL=http://localhost/anthropic`: the path Claude Code puts on its requests; the host is not used;
+- `ANTHROPIC_AUTH_TOKEN`: the run's credential;
+- `CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY=1` and `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1`, as `agl proxy run
+  claude` sets them.
+
+It prints the run's id on standard error (`AGL proxy confined run <id>: …`), passes its standard input and output
+through, and exits with the container's status. The container never receives an account token, the control socket or
+any other part of the AGL home: the mount holds the socket alone, and the variables that would give Claude Code another
+login or route (`CLAUDE_CODE_OAUTH_TOKEN`, `ANTHROPIC_API_KEY`, …) are removed from the environment `docker` runs with,
+so a `-e NAME` of one of them passes nothing. What the launcher names itself after `docker run` is its own: it must not
+set the variables above. The command takes `docker run` and `docker container run` only, with the image and its
+command after the options.
+
+The socket and its directory are the proxy user's alone (0600 and 0700), so the container's processes connect as that
+user: `--user` with its uid and gid under a Docker daemon that runs as root, or the container's own root under rootless
+Docker, which maps it to that user; another uid, or a container whose user namespace maps it elsewhere, cannot connect.
+Root in a container of a rootful daemon connects as well while it keeps Docker's default capabilities, since
+`CAP_DAC_OVERRIDE` passes the socket's mode (with `--cap-drop ALL` it is refused): the mode keeps the host's other users
+out, and only the containers a run started have the mount at all. The directory, not the socket file, is mounted, so a
+proxy restart, which replaces the socket, does not cut the container off.
+
+The credential lives as long as the command. When the container exits the command ends it, and the proxy refuses it
+from then on and forgets it. Like a lease it survives a restart of the proxy, which keeps only its SHA-256 digest and
+serves it again at once while the command takes it back. `agl proxy confined end <run id>` ends it at once: requests in
+flight end, the next one is refused, and the command stops the container (`docker run` passes its SIGTERM on) and exits
+with the reason; it does the same when the proxy does not hand the credential back after a restart.
+
+Downgrade: an earlier proxy refuses to start while its store keeps a confined run's credential, which its check of the
+kept leases does not know. Let every confined run end before downgrading; if an earlier proxy's start already failed,
+start this release once with no confined run going and wait out the 60-second reclaim window, which ends the kept
+credential, then downgrade.
+
 ## Native Codex Harness
 
 Choose **New → Chat session** and pick the Codex harness to use Codex inside AGL. Native threads support text and reasoning streaming, tool activity, the Codex model and reasoning-effort catalog, command and file approvals, ordinary user-input questions, interruption, history pagination, rename, archive, and deletion. AGL Ask/Yolo controls apply to the exact pending native approval request; approvals never outlive its server request.
@@ -1737,11 +1799,12 @@ superseded origins refuse preparation.
 - Revoke on failure, stop, replacement, cancellation or controller-generation change.
   Revocation fences new admissions immediately, removes credentials, and waits for already
   admitted ticket requests. Native-ID uniqueness and binding revision checks fence races.
-  Controller restart invalidates every old handle; existing native workers remain
-  unidentified until fleet performs an authorized controlled resume/relaunch with a fresh
-  overlay. Hooks do not automatically terminate or adopt outside sessions. Revoked launch IDs
-  stay recorded so they are never prepared again; the oldest give way once 65,536 launches
-  are recorded.
+  Controller restart invalidates every credential. A Claude launch's binding to its job
+  outlives it (below); a Codex launch does not, and its worker is bound again at its next
+  steer. Every reason but a controller-generation change revokes a launch for good and
+  deletes its kept binding. Hooks do not automatically terminate or adopt outside sessions.
+  Revoked launch IDs stay recorded so they are never prepared again; the oldest give way
+  once 65,536 launches are recorded.
 
 Fleet workers use these hooks themselves, so a worker's MCP ticket writes are admitted as
 that worker, not as the driver or anonymously:
@@ -1753,16 +1816,40 @@ that worker, not as the driver or anonymously:
   the worker id), passed as `--mcp-config <file> -- <prompt>`. Claude Code saves that path and reads it
   again at every wake, so the fleet rewrites it before each one; the launch ID and
   generation reach only the `agl` MCP server's environment, never the Claude process's.
-  Once the agents listing shows the job's process, the fleet binds the launch to it. A start,
-  wake or relaunch that fails at any step revokes its launch. Stop revokes the launch and archive removes the overlay. A start fails closed before Claude
-  runs when the Configuration master has no `agl` MCP server.
+  Once the agents listing shows the job's process, the fleet binds the launch to the job and
+  that process; a job that already settled after a quick turn is bound without a process. A
+  start, wake or relaunch that fails at any step revokes its launch. Stop revokes the launch
+  and archive also removes the overlay. A start fails closed before Claude runs when the
+  Configuration master has no `agl` MCP server.
 - Fleet Codex workers prepare the launch on the fleet's own connection before
   `thread/start` and bind it before the first `turn/start`. Before steering a thread whose
   launch is unbound, from an earlier connection or from before a controller restart, the
   fleet loads the thread and binds a fresh launch; a refusal fails the steer undispatched.
-- Launches live in memory. After a controller restart a Claude worker stays unidentified
-  until its next fleet start, steer or resume, and a Codex worker is bound again at its next
-  steer.
+- A Claude launch belongs to its background job, not to one process. Claude Code retires an
+  idle job's process and starts a new one for the same job when someone writes to it in
+  Claude Code; that process reads the same overlay. The controller keeps each Claude
+  launch's binding in its store (`agl_worker_caller_bindings`, one record per worker:
+  digests of the launch ID and generation, the job and session IDs, the binding revision, the
+  proved process's PID, start and snapshot digest, and the approved bridge command; never a
+  credential). When a bridge enrolls under another process than the bound one, or after a
+  controller restart, the fleet reads a fresh Claude inventory (one read at a time) and the
+  launch is bound to the bridge's process only when the inventory lists the worker's session,
+  once, as the same background job in exactly that process, the process runs the approved
+  Claude Code executable, and the bridge is its direct child running the recorded command
+  over its own connection. A launch a restarted controller restores is proved the same way
+  before its first write, also when its process still runs. Every other process stays
+  unverified, and a refused bridge is not proved again at every call: for the life of that
+  process image, or for five seconds when the job showed no process yet, the inventory could
+  not be read, or the inventory still named another process for the job (Claude Code may just
+  have replaced it).
+  When the inventory shows the worker's session as another job, or the fleet no longer binds
+  the worker to it (archived, moved to another session), the launch is revoked for good.
+  An upgrade moves every bridge in place onto the new build (`process.execve`: the same PID and
+  start, a new image from the new install's path), and the image it became is proved afresh:
+  its command is the one recorded with the launch or the one the restarted controller resolves
+  itself from its configured `agl` MCP entry, never one the bridge names, and a new command is
+  kept with the binding's next revision. Each reason an enrollment stays unverified is written once to the controller log,
+  naming the worker and its session, never the launch ID or a credential.
 
 The bridge exchanges credentials only through the private controller endpoint after Linux
 direct-loopback socket-inode ownership, approved executable/argv and current native
@@ -2860,6 +2947,8 @@ Backend isolation is mandatory. Proxy mode binds the controller to all interface
 - Permission auto-accept is an explicit server policy, never an assumption based on an open browser.
 - Questions are never auto-answered.
 - Unknown, malformed, concurrent, or unverifiable lifecycle state fails closed.
+- The inference proxy's confined listener is a Unix socket of the proxy's user alone; it accepts only confined runs'
+  credentials and serves them only the Claude pool's three Claude Code endpoints.
 
 The global **auto-accept permissions (yolo)** setting replies once to pending permissions across registered projects and writes those replies to the audit log. Each conversation also has a run-local Ask/Yolo switch. For an active managed OpenCode root, that switch covers its currently active direct children under the same exact family authority. For an active managed Flex root, it covers admitted descendants through their exact active parent-run authority chain; a relationship alone grants nothing. Terminal children are never auto-accepted. Disabling either policy seals new automatic replies and drains already admitted replies before returning. Neither mode creates persistent broad provider grants.
 
@@ -2910,7 +2999,7 @@ A run that fails keeps its evidence before its root goes: when a test of the fil
 The suite guards, end to end: opening every harness's conversation across page reloads without a harness child being replaced, recovering the Flex child after `SIGKILL` within 15 seconds, rejoining the shared Codex daemon on its own after that daemon restarts (the conversation opens and answers again within one rejoin backoff step, without **Reconnect**), starting the controller again (as the same and as the next build) with a browser resource attached to a Codex, Flex and OpenCode chat, listing a project's resources right after a browser is attached to each new chat and after a restart, the Flex model list carrying the account's current catalog, a Flex conversation answering, and opening and answering again after a restart, in a project whose id begins with `-` or `_` (the file creates projects until one does), and an `agl mcp` bridge answering tool calls from the same process after the controller moves to the next build. It is the test step of `gitzone release` (`release.preflight` in `.smartconfig.json`) and takes about eight minutes.
 
 
-Host prerequisites: Linux, Chrome (`google-chrome`, `chromium` or `chromium-browser`), `openssl`, `ss` (iproute2, to name the process behind a refused connection) and `codex` 0.156.0 or newer on `PATH`. Set `AGL_E2E_PACKAGE_ROOT` to another installed and built checkout, for example an earlier release, to run a scenario against it and prove it fails there:
+Host prerequisites: Linux, Chrome (`google-chrome`, `chromium` or `chromium-browser`), `openssl`, `ss` (iproute2, to name the process behind a refused connection) and `codex` 0.156.0 or newer on `PATH`. `e2e.proxyconfined` also runs a Docker container (a daemon this user may use and the `ubuntu:24.04` image already on the host, which the case never pulls) and skips with the missing prerequisite named without them. Set `AGL_E2E_PACKAGE_ROOT` to another installed and built checkout, for example an earlier release, to run a scenario against it and prove it fails there:
 
 ```sh
 AGL_E2E_PACKAGE_ROOT=/path/to/agl-32.15.1 pnpm exec tsrepo test test/e2e/e2e.conversations.node.ts --verbose --timeout 900

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: 'agl',
-  version: '40.5.1',
+  version: '40.6.0',
   description: 'Agent Gateway Layer for OpenCode, FlexHarness, and Codex sessions'
 }

package/ts/classes.aglhome.ts

@@ -64,6 +64,11 @@ export interface IAGLHomePaths {
   proxy: string;
   /** The running proxy's private control socket. */
   proxySocket: string;
+  /**
+   * The proxy's confined listener: a Unix socket alone in a private directory of its own, which a confined run mounts
+   * into its container, so the container sees nothing else of AGL. Only confined credentials are accepted on it.
+   */
+  proxyConfinedSocket: string;
   /** The credentials the proxy keeps in files, one per client with delivery `file` (OpenCode's `{file:...}`). */
   proxyCredentials: string;
   /** The credential command a harness routed through the proxy runs; the proxy writes it whenever it starts. */
@@ -211,6 +216,7 @@ export const resolveAGLHomePaths = (
     claudeOnChatGpt: path.join(root, 'claude-gateway'),
     proxy: path.join(root, 'proxy'),
     proxySocket: path.join(sockets, 'agl-proxy.sock'),
+    proxyConfinedSocket: path.join(sockets, 'agl-proxy-confined', 'proxy.sock'),
     proxyCredentials: path.join(root, 'proxy', 'credentials'),
     proxyCredentialHelper: path.join(root, 'proxy', 'credential-helper'),
     migration: path.join(root, 'migration'),

package/ts/classes.authstore.ts

@@ -3,6 +3,7 @@ import { DriverModel } from './driver/classes.driverstore.js';
 import { DirectReportModel } from './driver/classes.directreportstore.js';
 import { SessionFeedAcknowledgementModel } from './classes.sessionfeedacknowledgements.js';
 import { HarnessReleaseModel } from './classes.harnessreleases.js';
+import { WorkerCallerBindingModel } from './classes.workercallerbindings.js';
 import { FleetTicketEffectModel } from './fleet/classes.ticketeffects.js';
 import { ControllerCodexOriginMigrationModel } from '../ts_migration/v29_codexorigins.js';
 import { ControllerCodexConnectionStore } from './classes.codexconnectionstore.js';
@@ -781,6 +782,7 @@ const setAuthStoreModelManager = (
   plugins.nosqldb.setDefaultManagerForDoc(managerArg, SessionFeedAcknowledgementModel);
   plugins.nosqldb.setDefaultManagerForDoc(managerArg, FleetTicketEffectModel);
   plugins.nosqldb.setDefaultManagerForDoc(managerArg, HarnessReleaseModel);
+  plugins.nosqldb.setDefaultManagerForDoc(managerArg, WorkerCallerBindingModel);
   plugins.nosqldb.setDefaultManagerForDoc(managerArg, TicketModel);
   plugins.nosqldb.setDefaultManagerForDoc(managerArg, TicketBoardModel);
   plugins.nosqldb.setDefaultManagerForDoc(managerArg, TicketCommentModel);
@@ -1054,6 +1056,8 @@ export class SmartDataAuthStore implements IAuthStore, IAuthStoreSessionIdentity
       await FleetTicketEffectModel.exact.prepare();
       await HarnessReleaseModel.init();
       await HarnessReleaseModel.exact.prepare();
+      await WorkerCallerBindingModel.init();
+      await WorkerCallerBindingModel.exact.prepare();
       await TicketModel.init();
       await TicketBoardModel.init();
       await TicketCommentModel.init();

package/ts/classes.controller.ts

@@ -5,6 +5,7 @@ import { FleetDispatchError } from './fleet/interfaces.workers.js';
 import type { TFleetWorkerAction, TFleetWorkerRequest } from '../ts_interfaces/fleetworkers.js';
 import { ControllerBrowserOperationAuthority } from './classes.browseroperationauthority.js';
 import { ControllerWorkerCallers, type IWorkerCodexCallerOrigin } from './classes.workercallers.js';
+import { WorkerCallerBindingStore } from './classes.workercallerbindings.js';
 import { FleetWorkerLaunches } from './fleet/classes.workerlaunches.js';
 import { workerCallerEnrollmentToolName } from './classes.mcpworkercaller.js';
 import { readWorkerProcessSnapshot, readWorkerUnixSocketOwner, workerSnapshotsEqual, isWorkerCallerProofRefusal, type IWorkerCallerConnection } from './functions.workerprocessproof.js';
@@ -10555,7 +10556,12 @@ export class OpenCodeController {
         readMaster: async () => {
           const resource = await configurationAuthority.getResource();
           return (await configurationAuthority.getMaster({ resourceId: resource.resourceId })).master;
-        }, captureCodexOrigin: launch => this.captureWorkerCodexOrigin(launch) });
+        }, captureCodexOrigin: launch => this.captureWorkerCodexOrigin(launch),
+        // Claude launches keep their bindings, so a fleet worker's bridge proves itself again after this restart and
+        // after Claude Code continued its job in another process; the fleet reads the job's inventory for that proof.
+        bindings: new WorkerCallerBindingStore(),
+        observeClaudeJob: async (request) => this.fleetWorkers
+          ? await this.fleetWorkers.observeCallerJob(request) : { state: 'unproven', reason: 'the fleet is not running yet' } });
       this.workerCallers = workerCallers;
       const mcpControllerHost = new ControllerMcpHost({
         controllerPort: runtimeConfig.controllerPort,
@@ -12955,6 +12961,9 @@ export class OpenCodeController {
       }
     };
 
+    // Fleet jobs prepare, bind and revoke worker launches through the caller hooks: admit none and let the running
+    // ones settle before the hooks go, so a stop or archive meets the fleet's own refusal, never missing hooks.
+    await stopPart(async () => { await this.fleetWorkers?.closeAdmission(); });
     await stopPart(async () => {
       await this.workerCallers?.close();
       this.workerCallers = undefined;