@superjackfruitlabs/salaam 0.0.1 → 0.0.3

package/dist/src/service.js

@@ -1,9 +1,15 @@
 import { createServer } from 'node:http';
 import { mkdirSync, chmodSync, existsSync, unlinkSync, realpathSync, statSync } from 'node:fs';
 import { join, resolve } from 'node:path';
+import { providerRoute } from './provider-config.js';
 import { TaskContext } from './task-context.js';
+import { ContextAdmission } from './context-admission.js';
+import { SLASH_COMMANDS } from './tui-commands.js';
 import { TaskWork } from './task-work.js';
 import { TaskBudget } from './task-budget.js';
+import { AgentPodWorkDecisions } from './agentpod-work-decisions.js';
+import { AgentPodWork } from './agentpod-work.js';
+import { agentpodWorkAdmission } from './agentpod-work-protocol.js';
 import { TaskVerification } from './task-verification.js';
 import { TaskCheckpoints } from './task-checkpoints.js';
 import { TaskDriver } from './task-driver.js';
@@ -14,7 +20,7 @@ import { Store } from './store.js';
 import { acquireStateLock } from './state-lock.js';
 import { Artifacts } from './artifacts.js';
 import { Supervisor } from './supervisor.js';
-import { canonical, integer, object, ServiceError, string } from './protocol.js';
+import { canonical, digest, integer, object, ServiceError, string } from './protocol.js';
 import { readJson } from './transport.js';
 import { Dispatcher } from './dispatcher.js';
 import { ManagedWork } from './managed.js';
@@ -24,7 +30,43 @@ import { engineRequest } from './execution-boundary.js';
 import { DockerCodingExecutor } from './coding-executor.js';
 import { Workspaces } from './workspaces.js';
 import { CodingWork } from './coding.js';
+import { AgentProfiles } from './agent-profiles.js';
+import { RepositorySnapshots } from './repository-snapshots.js';
+import { TeamWork } from './team-work.js';
+import { WorkerWorkspaces } from './worker-workspaces.js';
+import { ExternalWork } from './external-work.js';
+import { DockerHarnessBackend } from './harness-backend.js';
+import { A2AInbound } from './a2a-inbound.js';
+import { AgentPodAuthority, readAgentPodPins } from './agentpod-authority.js';
+import { ToolkitResources } from './toolkit-resources.js';
+import { cancelToolkitCalls, recoverToolkitCalls } from './toolkit-calls.js';
+import { ToolkitOwners } from './toolkit-owners.js';
+import { ToolkitResolutions, resolvedToolkitCallSql } from './toolkit-resolutions.js';
+import { A2ABackend, ExternalBackends } from './a2a-backend.js';
+import { VERSION } from './config.js';
+import { TurnCancellations } from './turn-cancellations.js';
+import { McpAdmission } from './mcp-admission.js';
+import { McpWork } from './mcp-work.js';
+import { ToolkitWork } from './toolkit-work.js';
+import { permissionPolicy, configurePermissions } from './autonomy.js';
+import { LocalCoding } from './local-coding.js';
+import { localDiff } from './local-diff.js';
+import { reviewUndo, applyUndo, reconcileUndo } from './local-undo.js';
+import { forkPiSession } from './pi-sessions.js';
+import { StationWork } from './station-work.js';
+import { readToolkitConfig } from './toolkit-config.js';
 export class SalaamService {
+    agentpod;
+    agentpodWork;
+    toolkitResources;
+    toolkitOwners;
+    toolkitResolutions;
+    mcp;
+    toolkit;
+    station;
+    cancellations;
+    external;
+    a2aInbound;
     stateDir;
     socket;
     bridgeSocket;
@@ -43,8 +85,13 @@ export class SalaamService {
     dispatcher;
     managed;
     children;
+    agents;
+    repositories;
+    team;
+    workerWorkspaces;
     workspaces;
     coding;
+    localCoding;
     codingSocket;
     closed;
     resolveClosed;
@@ -52,14 +99,44 @@ export class SalaamService {
     bridgeServer;
     release;
     stopping = false;
+    shutdownFailure;
     handlers = new Set();
+    revocationStops = new Set();
+    authorityTimer;
+    hostManifestDigest;
+    agentpodWorkProgression;
     constructor(options) {
+        this.agentpodWorkProgression = options.agentpodWorkProgression === true;
+        if (this.agentpodWorkProgression && (!options.stationConfig || !options.agentpodConfig))
+            throw Error('Strict work requires reviewed AgentPod protected station configuration');
+        this.hostManifestDigest = options.hostManifestDigest ?? null;
         if (process.platform === 'win32')
             throw new Error('Windows transport is not implemented');
         this.stateDir = resolve(options.stateDir);
+        if (options.managedMcp && !options.agentpodConfig)
+            throw Error('Managed MCP requires reviewed AgentPod authority pins');
+        if ((options.managedToolkit || options.managedToolkitConfig) && !options.agentpodConfig)
+            throw Error('Native Toolkit requires reviewed AgentPod authority pins');
+        if (options.stationConfig && !options.agentpodConfig)
+            throw Error('Station execution requires reviewed AgentPod authority');
+        if (options.managedToolkit && options.managedToolkitConfig)
+            throw Error('Use one reviewed native Toolkit assignment');
+        if (options.agentpodConfig &&
+            (options.codingRoot ||
+                options.codingBackend ||
+                options.codingSocket ||
+                options.effectConnector ||
+                options.externalBackend ||
+                options.harnessConfig ||
+                options.a2aConfig ||
+                options.a2aListenConfig))
+            throw new Error('AgentPod authority profile does not enable station writes, fixture effects or external runtimes');
         this.codingSocket = options.codingSocket ? resolve(options.codingSocket) : null;
         mkdirSync(this.stateDir, { recursive: true, mode: 0o700 });
         this.stateDir = realpathSync(this.stateDir);
+        const mcpAdmission = options.managedMcp
+            ? new McpAdmission(options.managedMcp.config, readAgentPodPins(resolve(options.agentpodConfig), this.stateDir), options.managedMcp.profile_digest)
+            : undefined;
         this.socket = join(this.stateDir, 'operator.sock');
         this.bridgeSocket = join(this.stateDir, 'bridge.sock');
         if (Buffer.byteLength(this.bridgeSocket) > 100)
@@ -70,8 +147,16 @@ export class SalaamService {
             try {
                 this.artifacts = new Artifacts(join(this.stateDir, 'artifacts'), this.store);
                 this.tasks = new TaskContext(this.store, this.artifacts);
+                this.tasks.admitted = new ContextAdmission(this.store);
                 this.taskWork = new TaskWork(this.store, this.tasks);
                 this.taskBudget = new TaskBudget(this.store, this.taskWork);
+                if (options.admitModelRequest) {
+                    const taskAdmission = this.store.taskModelAdmission;
+                    this.store.taskModelAdmission = (session, attempt, input, output) => {
+                        taskAdmission(session, attempt, input, output);
+                        options.admitModelRequest(session, attempt, input, output);
+                    };
+                }
                 this.workspaces = new Workspaces(this.store, this.artifacts, options.codingRoot);
                 if (options.codingSocket && !options.codingRoot)
                     throw new Error('Command execution requires an explicit --coding-root');
@@ -79,6 +164,23 @@ export class SalaamService {
                     (options.codingSocket
                         ? new DockerCodingExecutor(engineRequest(options.codingSocket))
                         : undefined);
+                if (options.harnessConfig &&
+                    (options.externalBackend ||
+                        !(executor instanceof DockerCodingExecutor) ||
+                        !options.codingSocket ||
+                        !options.codingRoot))
+                    throw Error('Harness configuration requires the real configured Docker executor and an exclusive backend');
+                if (options.a2aConfig && (options.externalBackend || !options.codingRoot || !executor))
+                    throw Error('A2A configuration requires an owned coding root/executor and an exclusive backend');
+                const externalBackend = options.externalBackend ??
+                    new ExternalBackends([
+                        ...(options.harnessConfig
+                            ? [
+                                new DockerHarnessBackend(resolve(options.harnessConfig), join(resolve(options.codingRoot), 'external'), options.codingSocket, executor),
+                            ]
+                            : []),
+                        ...(options.a2aConfig ? [new A2ABackend(resolve(options.a2aConfig))] : []),
+                    ]);
                 this.coding = new CodingWork(this.store, this.workspaces, this.artifacts, executor, (id, error) => this.supervisor.failControl(id, error));
                 this.taskVerification = new TaskVerification(this.store, this.taskWork, this.taskBudget, this.workspaces, this.coding, this.artifacts);
                 this.taskCheckpoints = new TaskCheckpoints(this.store, this.taskWork, this.taskVerification, this.workspaces, this.artifacts);
@@ -89,22 +191,61 @@ export class SalaamService {
                     effectsEnabled: !!options.effectConnector,
                 });
                 this.supervisor.tasks = this.tasks;
+                this.taskWork.providerCheck = (limits, session) => this.supervisor.assertTaskProviderSupported(limits, session ? this.store.localOutputCap(session) : undefined);
                 this.supervisor.coding = this.coding;
                 this.managed = new ManagedWork(this.store, {
                     connector: options.effectConnector,
                     approvalTtlMs: options.approvalTtlMs,
-                    assertActive: (id, epoch, attempt) => this.supervisor.assertActive(id, epoch, attempt),
+                    assertActive: (id, epoch, attempt) => this.external?.owns(id)
+                        ? this.external.assertActive(id, epoch, attempt)
+                        : this.supervisor.assertActive(id, epoch, attempt),
                     reply: (id, epoch, request, confirmed) => this.supervisor.replyUI(id, epoch, request, confirmed),
-                    failed: (id, error) => this.supervisor.failControl(id, error),
+                    failed: (id, error) => this.external?.owns(id)
+                        ? this.external.failControl(id, error)
+                        : this.supervisor.failControl(id, error),
                 });
                 this.supervisor.managed = this.managed;
-                this.children = new ChildWork(this.store, this.artifacts, this.supervisor);
+                this.localCoding = new LocalCoding(this.store, this.managed, (id, epoch, attempt) => this.supervisor.assertActive(id, epoch, attempt));
+                this.supervisor.localCoding = this.localCoding;
+                this.agents = new AgentProfiles(this.store, this.supervisor.route, async (route, session) => {
+                    const prepared = await this.supervisor.prepareProviderRoute(route);
+                    const task = this.taskWork.forSession(session);
+                    if (task)
+                        this.supervisor.assertTaskProviderSupported(task.limits, prepared.output_cap);
+                    return { route: prepared.route, output_cap: prepared.output_cap };
+                });
+                this.store.workerBoundary.profiles = this.agents;
+                this.agents.validateFrame = (session) => {
+                    this.tasks.frame(session, 'x'.repeat(32));
+                };
+                this.repositories = new RepositorySnapshots(this.store, this.artifacts, this.workspaces);
+                this.supervisor.repositories = this.repositories;
+                this.children = new ChildWork(this.store, this.artifacts, this.supervisor, this.repositories);
                 this.supervisor.children = this.children;
+                this.workerWorkspaces = new WorkerWorkspaces(this.store, this.workspaces, this.repositories, this.artifacts, this.coding, this.children);
+                this.children.workspaces = this.workerWorkspaces;
+                this.agents.assertExecution = () => {
+                    this.workerWorkspaces.execution();
+                };
+                this.store.workerBoundary.assertIsolation = (binding) => this.workerWorkspaces.assert(binding);
+                this.taskWork.assertStepReview = (task, step) => this.workerWorkspaces.assertStepReview(task, step);
+                this.team = new TeamWork(this.store, this.taskWork, this.taskBudget, this.children, this.agents);
+                this.supervisor.team = this.team;
+                this.external = new ExternalWork(this.store, this.artifacts, this.children, this.taskBudget, this.managed, this.workspaces, externalBackend, options.admitModelRequest);
+                this.children.external = this.external;
+                const guardSubmission = this.store.guardTaskSubmission;
+                this.store.guardTaskSubmission = (session, step) => {
+                    const child = this.children.owned(session);
+                    if (child && this.store.workerBoundary.view(child.id).binding.external)
+                        throw new ServiceError('external_worker_owned', 'Use the owning team assignment and an explicit continuation');
+                    guardSubmission(session, step);
+                };
                 this.dispatcher = new Dispatcher(this.store, this.supervisor);
                 this.taskDriver = new TaskDriver(this.store, this.taskWork, this.taskBudget, this.taskVerification, this.supervisor, this.children, this.coding);
                 this.jobs = new JobWork(this.store, this.taskWork, this.taskDriver, this.taskVerification, this.managed);
                 this.recurring = new RecurringWork(this.jobs);
                 this.inbox = new OperatorInbox(this.store, (error) => {
+                    this.external.failAll(error);
                     for (const session of this.store.sessions())
                         this.supervisor.failControl(session.id, error);
                 });
@@ -113,6 +254,102 @@ export class SalaamService {
                     if (error)
                         throw new ServiceError('host_control_unavailable', error, 503);
                 };
+                if (options.agentpodConfig)
+                    this.agentpod = new AgentPodAuthority(this.store, this.stateDir, resolve(options.agentpodConfig), (attempt) => {
+                        this.managed.cancelInTransaction(attempt, 'agentpod-revocation', 'agentpod-node');
+                        this.mcp?.cancelInTransaction(attempt, 'agentpod-revocation');
+                        this.station?.cancelInTransaction(attempt);
+                        cancelToolkitCalls(this.store, this.managed, attempt, this.toolkitResources);
+                    }, (session) => (this.mcp?.stopped(session) ?? true) &&
+                        this.toolkitResources.stopped(session) &&
+                        (this.station?.stopped(session) ?? true));
+                this.toolkitResources = new ToolkitResources(this.store, this.agentpod);
+                this.toolkitOwners = new ToolkitOwners(this.store, this.toolkitResources, this.socket);
+                this.toolkitResolutions = new ToolkitResolutions(this.store, this.managed, this.toolkitResources, this.toolkitOwners);
+                this.store.nativeResourceCheck = (session) => {
+                    this.toolkitResources.assertSession(session);
+                    this.station?.assertResources(session);
+                };
+                if (options.managedToolkit || options.managedToolkitConfig) {
+                    if (!this.agentpod)
+                        throw new Error('Native Toolkit requires AgentPod execution authority');
+                    this.toolkit = new ToolkitWork(this.store, this.managed, this.agentpod, this.toolkitResources, this.toolkitOwners, options.managedToolkit ??
+                        readToolkitConfig(options.managedToolkitConfig.config, options.managedToolkitConfig.configuration_digest, this.agentpod.pins.workspace), {
+                        configurationCheck: () => {
+                            if (options.managedToolkitConfig)
+                                readToolkitConfig(options.managedToolkitConfig.config, options.managedToolkitConfig.configuration_digest, this.agentpod.pins.workspace);
+                        },
+                        assertActive: (session, epoch, attempt) => this.supervisor.assertActive(session, epoch, attempt),
+                        failed: (session, error) => this.supervisor.failControl(session, error),
+                    });
+                    this.supervisor.toolkit = this.toolkit;
+                }
+                this.taskDriver.awaitingAuthorityRenewal = (session) => this.agentpod?.awaitingRenewal(session) ?? false;
+                if (options.stationConfig) {
+                    if (!this.agentpod)
+                        throw Error('Station execution requires AgentPod authority');
+                    this.station = new StationWork(this.store, this.managed, this.artifacts, this.agentpod, options.stationConfig, this.stateDir, {
+                        assertActive: (session, epoch, attempt) => this.supervisor.assertActive(session, epoch, attempt),
+                        failed: (session, error) => this.supervisor.failControl(session, error),
+                    });
+                    this.supervisor.station = this.station;
+                    this.taskVerification.installStation(this.station);
+                    this.agentpodWork = new AgentPodWork(this.store, this.agentpod, this.taskWork, this.taskVerification);
+                    const cancelOwned = this.store.cancelChildren;
+                    this.store.cancelChildren = (attempt) => {
+                        cancelOwned?.(attempt);
+                        this.station.cancelInTransaction(attempt);
+                    };
+                }
+                if (options.managedMcp) {
+                    this.mcp = new McpWork(this.store, this.managed, this.artifacts, {
+                        admission: mcpAdmission,
+                        current: (session) => this.agentpod.binding(session),
+                        assertActive: (session, epoch, attempt) => this.supervisor.assertActive(session, epoch, attempt),
+                        failed: (session, error) => this.supervisor.failControl(session, error),
+                    });
+                    this.supervisor.mcp = this.mcp;
+                }
+                this.cancellations = new TurnCancellations(this.store, this.managed, (id) => this.supervisor.attemptActive(id), async (attempt) => {
+                    this.managed.abortCancelled(attempt);
+                    this.mcp?.abortAttempt(attempt);
+                    this.toolkit?.abortAttempt(attempt);
+                    const stopped = await Promise.allSettled([
+                        this.station?.abortAttempt(attempt),
+                        this.toolkitResources.stopAttempt(attempt),
+                        (async () => {
+                            this.coding.cancelAttempt(attempt);
+                            const owned = this.children.owned(this.store.attempt(attempt).session_id);
+                            if (owned && this.store.workerBoundary.view(owned.id).binding.external)
+                                await this.external.cancel(owned);
+                            else {
+                                await this.children.cancelOwned(attempt);
+                                await this.supervisor.cancelAttempt(attempt);
+                            }
+                        })(),
+                    ]);
+                    const failures = stopped.filter((r) => r.status === 'rejected');
+                    if (failures.length)
+                        throw new AggregateError(failures.map((r) => r.reason), 'Turn resource stop is unconfirmed');
+                });
+                this.cancellations.cancelAdditional = (attempt) => {
+                    this.mcp?.cancelInTransaction(attempt);
+                    this.station?.cancelInTransaction(attempt);
+                    cancelToolkitCalls(this.store, this.managed, attempt, this.toolkitResources);
+                };
+                this.cancellations.additionalResources = (session, attempt) => [
+                    ...(this.station?.unconfirmed(session, attempt) ?? []),
+                    ...(this.mcp && !this.mcp.stopped(session) ? ['managed-mcp:' + session] : []),
+                    ...(this.store.db
+                        .prepare("SELECT 1 FROM toolkit_resources r JOIN toolkit_calls c ON c.resource_id=r.id WHERE c.attempt_id=? AND c.cancel_requested=1 AND r.state!='stopped' LIMIT 1")
+                        .get(attempt)
+                        ? ['managed-toolkit:' + session]
+                        : []),
+                    ...this.store.db
+                        .prepare(`SELECT id FROM toolkit_calls c WHERE attempt_id=? AND state IN ('delivered','dispatching','outcome_unknown') AND NOT ${resolvedToolkitCallSql('c')}`)
+                        .all(attempt)
+                        .map((row) => 'toolkit-call:' + row.id),
+                ];
             }
             catch (error) {
                 this.store.close();
@@ -164,25 +401,54 @@ export class SalaamService {
                 (service.coding.executor?.profileDigest !== options.expectedExecution.profile_digest ||
                     service.coding.executor?.engineId !== options.expectedExecution.engine_id))
                 throw new Error('Host executor does not match reviewed manifest');
+            await service.supervisor.providerAuth();
+            await service.external.backend?.prepare?.();
+            await service.toolkitResources.recover();
+            await service.station?.initialize();
+            recoverToolkitCalls(service.store, service.managed);
             await service.supervisor.recover();
+            service.cancellations.recover();
+            await service.external.recover();
             service.store.recoverWork();
             service.taskWork.recover();
             service.tasks.recover();
             service.workspaces.recover();
             service.coding.recover();
             service.children.recover();
+            service.workerWorkspaces.recover();
             service.managed.recover();
+            service.mcp?.recover();
             await service.managed.reconcileAll();
             service.taskCheckpoints.recover();
             await service.jobs.recover();
             await service.recurring.recover();
             service.inbox.reconcile();
+            if (options.a2aListenConfig) {
+                service.a2aInbound = new A2AInbound(service, resolve(options.a2aListenConfig));
+                await service.a2aInbound.listen();
+            }
             await service.listen(service.bridgeServer, service.bridgeSocket);
             await service.listen(service.operator, service.socket);
             service.taskDriver.start();
             service.jobs.start();
             service.recurring.start();
             service.inbox.start();
+            service.authorityTimer = setInterval(() => {
+                try {
+                    for (const binding of service.agentpod?.expired() ?? []) {
+                        const status = service.agentpod.revoke(binding, 'expired:' + binding.hub_session_id, 'AgentPod authority lease expired');
+                        service.scheduleRevocationStop(service.store.execution.revocation(status.session_id));
+                    }
+                }
+                catch (error) {
+                    for (const session of service.store.sessions())
+                        if (service.store.db
+                            .prepare('SELECT 1 FROM agentpod_admissions WHERE session_id=?')
+                            .get(session.id))
+                            service.supervisor.failControl(session.id, error);
+                }
+            }, 250);
+            service.authorityTimer.unref();
             return service;
         }
         catch (error) {
@@ -190,6 +456,40 @@ export class SalaamService {
             throw error;
         }
     }
+    scheduleRevocationStop(receipt) {
+        const cleanup = this.stopRevoked(receipt).finally(() => this.revocationStops.delete(cleanup));
+        this.revocationStops.add(cleanup);
+    }
+    async stopRevoked(receipt) {
+        const jobs = receipt.attempt_ids.map(async (attempt) => {
+            this.managed.abortCancelled(attempt);
+            this.mcp?.abortAttempt(attempt);
+            this.toolkit?.abortAttempt(attempt);
+            await this.station?.abortAttempt(attempt);
+        });
+        for (const session of receipt.session_ids) {
+            jobs.push(this.toolkitResources.stopSession(session));
+            if (this.mcp)
+                jobs.push(this.mcp.stopSession(session));
+            if (this.toolkit)
+                jobs.push(this.toolkit.stopSession(session));
+            if (this.station)
+                jobs.push(this.station.stopSession(session));
+            jobs.push(Promise.resolve().then(() => this.supervisor.stopSession(session)));
+            jobs.push(Promise.resolve().then(async () => {
+                const child = this.children.owned(session);
+                if (child && this.store.workerBoundary.view(child.id).binding.external)
+                    await this.external.cancel(child);
+            }));
+            jobs.push(Promise.resolve().then(() => {
+                for (const run of this.store.db
+                    .prepare("SELECT id FROM command_runs WHERE session_id=? AND state NOT IN ('succeeded','failed','cancelled','timed_out','output_limited','interrupted')")
+                    .all(session))
+                    this.coding.cancel(session, String(run.id), 'session-revocation:' + run.id, () => { });
+            }));
+        }
+        await Promise.allSettled(jobs);
+    }
     async listen(server, path) {
         // The exclusive state lock is held before removing a stale socket.
         if (existsSync(path))
@@ -213,6 +513,54 @@ export class SalaamService {
                 throw new ServiceError('stopping', 'Service is stopping', 503);
             const url = new URL(req.url ?? '/', 'http://local');
             const parts = url.pathname.split('/').filter(Boolean);
+            if (!bridge && req.method === 'POST' && req.url === '/managed-toolkit/v1/verify') {
+                this.send(res, 200, await this.toolkitOwners.verify(req));
+                return;
+            }
+            if (!bridge && req.method === 'POST' && req.url === '/managed-toolkit/v1/control') {
+                this.send(res, 200, await this.toolkitOwners.control(req));
+                return;
+            }
+            if (!bridge &&
+                req.method === 'GET' &&
+                parts[0] === 'v1' &&
+                parts[1] === 'a2a' &&
+                parts[2] === 'grants' &&
+                parts[3] &&
+                parts.length === 4) {
+                this.send(res, 200, A2AInbound.binding(this, parts[3]));
+                return;
+            }
+            if (!bridge && parts[0] === 'v1' && parts[1] === 'harnesses') {
+                if (req.method === 'GET' && parts.length === 2) {
+                    this.send(res, 200, this.external.runtimes());
+                    return;
+                }
+                if (parts[2]) {
+                    const raw = this.store.db
+                        .prepare('SELECT * FROM child_tasks WHERE id=?')
+                        .get(parts[2]);
+                    if (!raw || !this.store.workerBoundary.view(raw.id).binding.external)
+                        throw new ServiceError('not_found', 'External worker not found', 404);
+                    if (req.method === 'GET' && parts.length === 3) {
+                        this.send(res, 200, {
+                            child: this.children.inspect(raw.parent_session, raw.id),
+                            execution: this.external.view(raw.id),
+                        });
+                        return;
+                    }
+                    if (req.method === 'POST' && parts.length === 4 && parts[3] === 'reconcile') {
+                        const body = object(await readJson(req));
+                        const result = await this.external.reconcile(raw, string(body.request_id, 'request_id', 128), string(body.run_id, 'run_id', 128), () => this.store.authorizeControl(raw.parent_session, {
+                            client_id: string(body.client_id, 'client_id', 128),
+                            token: string(body.token, 'token', 128),
+                        }));
+                        this.send(res, 200, result);
+                        return;
+                    }
+                }
+                throw new ServiceError('not_found', 'External worker route not found', 404);
+            }
             if (bridge) {
                 if (req.method !== 'POST' || parts.length !== 3 || parts[0] !== 'worker')
                     throw new ServiceError('not_found', 'Bridge route not found', 404);
@@ -221,6 +569,199 @@ export class SalaamService {
                 this.send(res, 200, value);
                 return;
             }
+            if (parts[0] === 'v1' &&
+                parts[1] === 'agentpod' &&
+                parts.length === 3 &&
+                req.method === 'POST') {
+                if (!this.agentpod)
+                    throw new ServiceError('authority_disabled', 'AgentPod authority requires reviewed --agentpod-config pins');
+                const body = object(await readJson(req));
+                if (parts[2] === 'attach') {
+                    const attached = this.agentpod.authenticate(string(body.admission_id, 'admission_id', 128), string(body.token, 'token', 128));
+                    this.send(res, 200, {
+                        ...attached,
+                        ...(this.agentpodWorkProgression &&
+                            this.agentpodWork &&
+                            attached.binding.run.source === 'superpipeline'
+                            ? { work_control: { version: 1, owner: 'superpipeline' } }
+                            : {}),
+                        ...(this.mcp ? { managed_mcp: this.mcp.status(attached.session_id).assignment } : {}),
+                    });
+                    return;
+                }
+                if (parts[2] === 'status') {
+                    this.send(res, 200, this.agentpod.inspect(body.binding));
+                    return;
+                }
+                if (parts[2] === 'work-capability') {
+                    if (Object.keys(body).length)
+                        throw new ServiceError('invalid_work_payload', 'Empty capability request required');
+                    this.send(res, 200, {
+                        version: 1,
+                        enabled: !!this.agentpodWork && this.agentpodWorkProgression,
+                    });
+                    return;
+                }
+                if (parts[2] === 'work-status' || parts[2] === 'work-progress') {
+                    if (!this.agentpodWork || !this.agentpodWorkProgression)
+                        throw new ServiceError('work_disabled', 'Strict progression is not enabled');
+                    if (parts[2] === 'work-status') {
+                        if (Object.keys(body).join(',') !== 'binding')
+                            throw new ServiceError('invalid_work_payload', 'Closed status request required');
+                        this.send(res, 200, await this.agentpodWork.status(body.binding, this.taskDriver));
+                    }
+                    else {
+                        if (Object.keys(body).sort().join(',') !==
+                            'binding,compact,max_steps,request_id,work_request_id' ||
+                            body.compact !== false)
+                            throw new ServiceError('invalid_work_payload', 'Closed bounded progression request required');
+                        this.send(res, 200, this.agentpodWork.progress(body.binding, string(body.request_id, 'request_id', 128), string(body.work_request_id, 'work_request_id', 128), integer(body.max_steps, 'max_steps'), this.taskDriver));
+                    }
+                    return;
+                }
+                if (parts[2] === 'work-abandon') {
+                    if (!this.agentpodWork || !this.agentpodWorkProgression)
+                        throw new ServiceError('work_disabled', 'Strict work historical success retirement is not enabled');
+                    if (Object.keys(body).sort().join(',') !==
+                        'binding,producer_terminal_digest,request_id,work_request_id')
+                        throw new ServiceError('invalid_work_payload', 'Closed explicit failure request required');
+                    this.send(res, 200, this.agentpodWork.abandon(body.binding, string(body.request_id, 'request_id', 128), string(body.work_request_id, 'work_request_id', 128), string(body.producer_terminal_digest, 'producer_terminal_digest', 64)));
+                    return;
+                }
+                if (parts[2] === 'work-fail') {
+                    if (!this.agentpodWork || !this.agentpodWorkProgression)
+                        throw new ServiceError('work_disabled', 'Strict work failure retirement is not enabled');
+                    if (Object.keys(body).sort().join(',') !==
+                        'binding,producer_terminal_digest,request_id,work_request_id')
+                        throw new ServiceError('invalid_work_payload', 'Closed explicit failure request required');
+                    this.send(res, 200, this.agentpodWork.fail(body.binding, string(body.request_id, 'request_id', 128), string(body.work_request_id, 'work_request_id', 128), string(body.producer_terminal_digest, 'producer_terminal_digest', 64), this.taskDriver));
+                    return;
+                }
+                if (parts[2] === 'work-expire') {
+                    if (!this.agentpodWork || !this.agentpodWorkProgression)
+                        throw new ServiceError('work_disabled', 'Strict work expiry is not enabled');
+                    if (Object.keys(body).sort().join(',') !==
+                        'binding,decision_request_id,producer_terminal_digest,request_id,work_request_id')
+                        throw new ServiceError('invalid_work_payload', 'Closed explicit expiry request required');
+                    this.send(res, 200, this.agentpodWork.expire(body.binding, string(body.request_id, 'request_id', 128), string(body.work_request_id, 'work_request_id', 128), string(body.decision_request_id, 'decision_request_id', 128), string(body.producer_terminal_digest, 'producer_terminal_digest', 64), this.taskDriver));
+                    return;
+                }
+                if (parts[2] === 'work-settle') {
+                    if (!this.agentpodWork || !this.agentpodWorkProgression)
+                        throw new ServiceError('work_disabled', 'Strict work settlement is not enabled');
+                    if (Object.keys(body).sort().join(',') !==
+                        'binding,producer_terminal_digest,request_id,work_request_id')
+                        throw new ServiceError('invalid_work_payload', 'Closed explicit settlement request required');
+                    this.send(res, 200, this.agentpodWork.settle(body.binding, string(body.request_id, 'request_id', 128), string(body.work_request_id, 'work_request_id', 128), string(body.producer_terminal_digest, 'producer_terminal_digest', 64), this.taskDriver));
+                    return;
+                }
+                if (parts[2] === 'work-trace') {
+                    if (!this.agentpodWork)
+                        throw new ServiceError('work_disabled', 'Strict work is not enabled');
+                    if (Object.keys(body).sort().join(',') !== 'binding,schema_version,traceparent' ||
+                        body.schema_version !== 'salaam-work-trace/v1')
+                        throw new ServiceError('invalid_trace_context', 'Closed versioned trace context required');
+                    this.send(res, 200, this.agentpodWork.trace(body.binding, body.traceparent));
+                    return;
+                }
+                if (parts[2] === 'work-evidence-artifacts') {
+                    if (!this.agentpodWork)
+                        throw new ServiceError('work_disabled', 'Strict work is not enabled');
+                    if (Object.keys(body).sort().join(',') !== 'artifact_ids,binding,schema_version' ||
+                        body.schema_version !== 'salaam-execution-artifacts/v1')
+                        throw new ServiceError('unsupported_evidence_version', 'Closed versioned artifact selection required');
+                    this.send(res, 200, this.agentpodWork.evidenceArtifacts(body.binding, body.artifact_ids));
+                    return;
+                }
+                if (parts[2] === 'work-evidence') {
+                    if (!this.agentpodWork)
+                        throw new ServiceError('work_disabled', 'Strict work is not enabled');
+                    if (Object.keys(body).sort().join(',') !== 'binding,schema_version' ||
+                        body.schema_version !== 'salaam-execution-evidence/v1')
+                        throw new ServiceError('unsupported_evidence_version', 'Explicit supported evidence version required');
+                    this.send(res, 200, this.agentpodWork.evidence(body.binding));
+                    return;
+                }
+                if (parts[2] === 'work-completion') {
+                    if (!this.agentpodWork)
+                        throw new ServiceError('verification_unavailable', 'Reviewed protected station backend required');
+                    if (Object.keys(body).join(',') !== 'binding')
+                        throw new ServiceError('invalid_work_payload', 'Closed completion request required');
+                    this.send(res, 200, await this.agentpodWork.completion(body.binding));
+                    return;
+                }
+                if (parts[2] === 'work-decisions' || parts[2] === 'work-decision') {
+                    if (!this.agentpodWork)
+                        throw new ServiceError('verification_unavailable', 'Reviewed protected station backend required');
+                    const answering = parts[2] === 'work-decision';
+                    if (Object.keys(body).sort().join(',') !== (answering ? 'answer,binding' : 'binding'))
+                        throw new ServiceError('invalid_work_decision', 'Closed decision payload required');
+                    const decisions = new AgentPodWorkDecisions(this.agentpodWork, this.managed);
+                    this.send(res, 200, answering ? decisions.answer(body.binding, body.answer) : decisions.list(body.binding));
+                    return;
+                }
+                if (parts[2] === 'work-admit') {
+                    // This is the private owner socket, never the worker bridge. The native
+                    // node authenticates its Hub reservation; board/card/stage are that
+                    // trusted producer's assertion. Runtime pins and byte digests are local.
+                    if (!this.agentpodWork)
+                        throw new ServiceError('verification_unavailable', 'Reviewed protected station work backend required');
+                    if (Object.keys(body).sort().join(',') !== 'admission,input,plan')
+                        throw new ServiceError('invalid_work_payload', 'Closed work payload required');
+                    const admission = agentpodWorkAdmission(body.admission), input = object(body.input);
+                    if (Object.keys(input).sort().join(',') !== 'incoming_handoff,instructions,references' ||
+                        typeof input.instructions !== 'string' ||
+                        input.instructions.length < 1 ||
+                        input.instructions.length > 65536 ||
+                        !Array.isArray(input.references) ||
+                        input.references.length > 64 ||
+                        input.references.some((v) => typeof v !== 'string' || v.length < 1 || v.length > 4096) ||
+                        (input.incoming_handoff !== null &&
+                            (typeof input.incoming_handoff !== 'string' || input.incoming_handoff.length > 65536)))
+                        throw new ServiceError('invalid_work_payload', 'Closed work input required');
+                    if (canonical(this.taskWork.parse(body.plan)) !== canonical(body.plan))
+                        throw new ServiceError('invalid_work_payload', 'Fully expanded canonical task plan required');
+                    const owner = this.agentpod.inspect(admission.binding);
+                    this.send(res, 200, this.agentpodWork.admit(owner.session_id, admission, {
+                        board_id: admission.work.board_id,
+                        card_id: admission.work.card_id,
+                        stage_key: admission.work.stage_key,
+                    }, input, body.plan));
+                    return;
+                }
+                if (parts[2] === 'mcp-assign') {
+                    if (!this.mcp)
+                        throw new ServiceError('mcp_disabled', 'No reviewed managed MCP host profile', 403);
+                    const current = this.agentpod.inspect(body.binding);
+                    const old = this.mcp.status(current.session_id).assignment;
+                    const assigned = this.mcp.assign(current.session_id, body.assignment);
+                    if (old && old.assignment_digest !== assigned.assignment_digest) {
+                        this.supervisor.failControl(current.session_id, new Error('MCP assignment changed; restart required'));
+                        await Promise.all([
+                            this.supervisor.stopSession(current.session_id),
+                            this.mcp.stopSession(current.session_id),
+                        ]);
+                    }
+                    this.send(res, 200, await this.mcp.ready(current.session_id));
+                    return;
+                }
+                const request = string(body.request_id, 'request_id', 128);
+                if (parts[2] === 'admit') {
+                    this.send(res, 200, this.agentpod.admit(body.binding, request));
+                    return;
+                }
+                if (parts[2] === 'renew') {
+                    this.send(res, 200, this.agentpod.renew(body.binding, request, integer(body.lease_sequence, 'lease_sequence')));
+                    return;
+                }
+                if (parts[2] === 'revoke') {
+                    const status = this.agentpod.revoke(body.binding, request, string(body.reason, 'reason', 1024));
+                    this.scheduleRevocationStop(this.store.execution.revocation(status.session_id));
+                    this.send(res, 202, status);
+                    return;
+                }
+                throw new ServiceError('not_found', 'Unknown AgentPod authority method', 404);
+            }
             if (parts[0] === 'v1' &&
                 parts[1] === 'job-occurrences' &&
                 parts.length === 3 &&
@@ -332,12 +873,100 @@ export class SalaamService {
                 }
                 throw new ServiceError('not_found', 'Job route not found', 404);
             }
+            if (parts[0] === 'v1' &&
+                parts[1] === 'integrations' &&
+                parts[2] &&
+                parts.length === 4 &&
+                parts[3] === 'resolve' &&
+                req.method === 'POST') {
+                const body = object(await readJson(req)), controller = {
+                    client_id: string(body.client_id, 'client_id', 128),
+                    token: string(body.token, 'token', 128),
+                }, parent = this.workerWorkspaces.owner(parts[2]);
+                this.send(res, 200, this.workerWorkspaces.resolve(parts[2], string(body.request_id, 'request_id', 128), integer(body.workspace_revision, 'workspace_revision'), string(body.workspace_digest, 'workspace_digest', 128), () => this.store.authorizeControl(parent, controller)));
+                return;
+            }
+            if (parts[0] === 'v1' &&
+                parts[1] === 'integrations' &&
+                parts[2] &&
+                parts.length === 3 &&
+                req.method === 'GET') {
+                this.send(res, 200, this.workerWorkspaces.inspect(parts[2]));
+                return;
+            }
+            if (parts[0] === 'v1' && parts[1] === 'workers' && parts[2] && parts.length === 4) {
+                const child = this.store.db
+                    .prepare('SELECT parent_session FROM child_tasks WHERE id=?')
+                    .get(parts[2]);
+                if (!child)
+                    throw new ServiceError('not_found', 'Worker not found', 404);
+                const parent = String(child.parent_session);
+                if (parts[3] === 'proposal' && req.method === 'GET') {
+                    this.send(res, 200, this.workerWorkspaces.proposal(parent, parts[2], integer(Number(url.searchParams.get('offset') ?? '0'), 'offset')));
+                    return;
+                }
+                if (parts[3] === 'integrate' && req.method === 'POST') {
+                    const body = object(await readJson(req)), controller = {
+                        client_id: string(body.client_id, 'client_id', 128),
+                        token: string(body.token, 'token', 128),
+                    };
+                    this.send(res, 200, this.workerWorkspaces.integrate(parent, parts[2], string(body.request_id, 'request_id', 128), integer(body.workspace_revision, 'workspace_revision'), string(body.workspace_digest, 'workspace_digest', 128), string(body.patch_digest, 'patch_digest', 128), () => this.store.authorizeControl(parent, controller)));
+                    return;
+                }
+            }
             if (parts[0] === 'v1' && parts[1] === 'tasks') {
+                if (parts[2] && parts[3] === 'team') {
+                    const task = this.taskWork.get(parts[2]);
+                    if (req.method === 'GET' && parts.length === 4) {
+                        this.send(res, 200, this.team.view(task.id));
+                        return;
+                    }
+                    if (req.method === 'POST') {
+                        const body = object(await readJson(req));
+                        const request = string(body.request_id, 'request_id', 128);
+                        const controller = {
+                            client_id: string(body.client_id, 'client_id', 128),
+                            token: string(body.token, 'token', 128),
+                        };
+                        const authorize = () => this.store.authorizeControl(task.session_id, controller);
+                        let result;
+                        if (parts.length === 5 && parts[4] === 'assign') {
+                            if (body.runtime !== undefined && body.requests !== undefined)
+                                throw new ServiceError('worker_budget_scope', 'Use invocations for an external runtime; requests always means model requests', 400);
+                            result = this.team.assign(task.id, string(body.step_id, 'step_id', 128), string(body.profile_id, 'profile_id', 128), integer(body.runtime === undefined ? body.requests : body.invocations, body.runtime === undefined ? 'requests' : 'invocations'), request, integer(body.expected_revision, 'expected_revision'), controller, body.runtime === undefined ? undefined : string(body.runtime, 'runtime', 128));
+                        }
+                        else if (parts.length === 5 && parts[4] === 'send') {
+                            result = this.team.send(task.id, 'operator', string(body.recipient, 'recipient', 128), string(body.text, 'text', 4096), request, authorize);
+                        }
+                        else if (parts.length === 6 && parts[4]) {
+                            const assignment = this.team.get(parts[4]);
+                            if (assignment.task_id !== task.id)
+                                throw new ServiceError('team_message_scope', 'Assignment belongs to another task');
+                            if (parts[5] === 'run')
+                                result = this.team.run(assignment.id, request, integer(body.expected_revision, 'expected_revision'), integer(body.generation, 'generation'), body.instruction == null ? null : string(body.instruction, 'instruction', 4096), body.continues_attempt_id == null
+                                    ? null
+                                    : string(body.continues_attempt_id, 'continues_attempt_id', 128), controller);
+                            else if (parts[5] === 'reject')
+                                result = this.team.reject(assignment.id, request, integer(body.expected_revision, 'expected_revision'), integer(body.generation, 'generation'), string(body.reason, 'reason', 4096), controller);
+                            else if (parts[5] === 'receive')
+                                result = this.team.receive(assignment.id, request, authorize);
+                            else if (parts[5] === 'ack')
+                                result = this.team.acknowledge(assignment.id, string(body.message_id, 'message_id', 128), request, authorize);
+                            else
+                                throw new ServiceError('not_found', 'Team action not found', 404);
+                        }
+                        else
+                            throw new ServiceError('not_found', 'Team route not found', 404);
+                        this.send(res, 200, result);
+                        return;
+                    }
+                    throw new ServiceError('not_found', 'Team route not found', 404);
+                }
                 if (req.method === 'GET' && parts.length === 2) {
                     const session = string(url.searchParams.get('session_id'), 'session_id', 128);
                     this.store.session(session);
                     const current = this.taskWork.forSession(session);
-                    this.send(res, 200, current ? this.taskDriver.view(current.id) : null);
+                    this.send(res, 200, current ? await this.taskDriver.viewAsync(current.id) : null);
                     return;
                 }
                 const taskId = parts[2];
@@ -352,7 +981,7 @@ export class SalaamService {
                     return;
                 }
                 if (req.method === 'GET' && taskId && parts.length === 3) {
-                    this.send(res, 200, this.taskDriver.view(taskId));
+                    this.send(res, 200, await this.taskDriver.viewAsync(taskId));
                     return;
                 }
                 if (req.method === 'GET' && taskId && parts.length === 4 && parts[3] === 'history') {
@@ -369,7 +998,7 @@ export class SalaamService {
                     const expected = integer(body.expected_revision, 'expected_revision');
                     if (parts.length === 2) {
                         const task = this.taskWork.create(string(body.session_id, 'session_id', 128), request, expected, body.plan, controller);
-                        this.send(res, 201, this.taskDriver.view(task.id));
+                        this.send(res, 201, await this.taskDriver.viewAsync(task.id));
                         return;
                     }
                     if (taskId &&
@@ -381,13 +1010,13 @@ export class SalaamService {
                             result = this.taskVerification.start(taskId, string(body.check_key, 'check_key', 64), body.step_id == null ? null : string(body.step_id, 'step_id', 128), request, expected, authorize);
                         else if (parts[3] === 'finish') {
                             const exception = body.exception == null ? null : object(body.exception);
-                            this.taskVerification.finish(taskId, request, expected, exception
+                            await this.taskVerification.finishAsync(taskId, request, expected, exception
                                 ? {
                                     reason: string(exception.reason, 'reason', 4096),
                                     evidence_artifact: string(exception.evidence_artifact, 'evidence_artifact', 128),
                                 }
                                 : null, authorize);
-                            result = this.taskDriver.view(taskId);
+                            result = await this.taskDriver.viewAsync(taskId);
                         }
                         else if (parts[3] === 'checkpoint')
                             result = this.taskCheckpoints.capture(taskId, request, expected, authorize);
@@ -397,18 +1026,18 @@ export class SalaamService {
                             if (body.compact !== undefined && typeof body.compact !== 'boolean')
                                 throw new ServiceError('invalid_field', 'compact must be boolean', 400);
                             this.taskDriver.configure(taskId, request, expected, integer(body.max_steps, 'max_steps'), body.compact === true, controller);
-                            result = this.taskDriver.view(taskId);
+                            result = await this.taskDriver.viewAsync(taskId);
                         }
                         else {
                             await this.taskDriver.cancel(taskId, request, expected, controller);
-                            result = this.taskDriver.view(taskId);
+                            result = await this.taskDriver.viewAsync(taskId);
                         }
                         this.send(res, 200, result);
                         return;
                     }
                     if (taskId && parts.length === 4 && parts[3] === 'revise') {
                         this.send(res, 200, (this.taskWork.revise(taskId, request, expected, body.plan, controller),
-                            this.taskDriver.view(taskId)));
+                            await this.taskDriver.viewAsync(taskId)));
                         return;
                     }
                     if (taskId && parts.length === 6 && parts[3] === 'steps' && parts[4]) {
@@ -420,16 +1049,59 @@ export class SalaamService {
                         }
                         if (parts[5] === 'complete') {
                             this.send(res, 200, (this.taskWork.complete(taskId, parts[4], request, expected, string(body.review, 'review', 4096), controller),
-                                this.taskDriver.view(taskId)));
+                                await this.taskDriver.viewAsync(taskId)));
                             return;
                         }
                     }
                 }
             }
+            if (url.pathname === '/v1/command-inventory' && req.method === 'GET') {
+                this.send(res, 200, {
+                    version: 1,
+                    surface: 'salaam-tui',
+                    commands: SLASH_COMMANDS,
+                    automatic_discovery: false,
+                });
+                return;
+            }
             if (url.pathname === '/v1/health' && req.method === 'GET') {
                 const sessions = this.store.sessions().map((x) => this.supervisor.inspect(x.id));
                 this.send(res, 200, {
+                    pid: process.pid,
+                    host_manifest_digest: this.hostManifestDigest,
+                    host_supervisor_connected: this.hostManifestDigest ? process.connected === true : null,
+                    runtime_node: realpathSync(process.execPath),
+                    service_version: VERSION,
+                    context_admission: { version: 1, automatic_discovery: false, child_inheritance: false },
+                    agentpod_config: this.agentpod?.configPath ?? null,
+                    agentpod_pins_digest: this.agentpod ? digest(this.agentpod.pins) : null,
+                    managed_mcp: this.mcp
+                        ? { profile_digest: this.mcp.options.admission.profileDigest }
+                        : null,
+                    managed_toolkit: this.toolkit
+                        ? { configuration_digest: this.toolkit.configurationDigest }
+                        : null,
+                    strict_work: this.agentpodWorkProgression && this.agentpodWork ? { version: 1 } : null,
+                    station_execution: this.station
+                        ? { configuration_digest: this.station.configurationDigest }
+                        : null,
                     service: 'healthy',
+                    a2a: {
+                        inbound_enabled: !!this.a2aInbound,
+                        listener: this.a2aInbound?.server.address() ?? null,
+                        wire_version: '1.0',
+                        remote_execution: 'unobserved',
+                        inbound_authority: 'one-use-native-analysis-assignment',
+                    },
+                    external_workers: {
+                        control: this.external.status(),
+                        runtimes: this.external.runtimes(),
+                        opaque_budget: 'explicit-invocations-only',
+                        unknown_model_usage: true,
+                        uncertain_stops: Number(this.store.db
+                            .prepare("SELECT count(*) AS n FROM external_runs WHERE stopped=0 AND state='unknown'")
+                            .get().n),
+                    },
                     job_execution: {
                         durable_jobs: true,
                         one_shot_triggers: !!this.coding.executor,
@@ -441,16 +1113,24 @@ export class SalaamService {
                         control_error: this.jobs.controlError,
                     },
                     task_execution: {
-                        durable_tasks: true,
+                        durable_tasks: this.supervisor.providerCapabilities().durable_tasks,
                         explicit_steps: true,
                         automatic_progression: 'operator-bounded-opt-in',
                         verified_completion: !!this.coding.executor,
                         verification_supported: true,
                         task_budgets: true,
+                        task_token_budgets: this.supervisor.providerCapabilities().output_token_cap,
                         checkpoints: true,
                         deterministic_compaction: 'operator-bounded-idle-only',
                     },
+                    local_workspace: {
+                        inspection: true,
+                        session_routes: true,
+                        coding: true,
+                        reasoning: true,
+                    },
                     provider_route: this.supervisor.route,
+                    provider_capabilities: this.supervisor.providerCapabilities(),
                     effect_connector: this.managed.options.connector?.id ?? null,
                     coding_root: this.workspaces.root ?? null,
                     coding_socket: this.codingSocket,
@@ -491,6 +1171,8 @@ export class SalaamService {
                 return;
             }
             if (url.pathname === '/v1/sessions' && req.method === 'POST') {
+                if (this.agentpod)
+                    throw new ServiceError('admission_required', 'This daemon requires a trusted AgentPod admission; unbound session creation is disabled');
                 const body = object(await readJson(req));
                 const cwd = realpathSync(string(body.cwd, 'cwd'));
                 if (!statSync(cwd).isDirectory())
@@ -499,7 +1181,59 @@ export class SalaamService {
                     throw new ServiceError('invalid_field', 'coding must be a boolean', 400);
                 if (body.coding && !this.workspaces.root)
                     throw new ServiceError('coding_disabled', 'Start with an explicit --coding-root');
-                const session = this.store.create(cwd, string(body.request_id, 'request_id', 128), body.coding === true);
+                if (body.local_coding !== undefined &&
+                    (typeof body.local_coding !== 'boolean' || !body.local_workspace))
+                    throw new ServiceError('invalid_field', 'local_coding requires a local workspace');
+                if (body.local_workspace !== undefined && typeof body.local_workspace !== 'boolean')
+                    throw new ServiceError('invalid_field', 'local_workspace must be a boolean', 400);
+                if (body.local_workspace && body.coding)
+                    throw new ServiceError('invalid_field', 'Choose local inspection or an owned coding workspace', 400);
+                if (body.route !== undefined && !body.local_workspace)
+                    throw new ServiceError('invalid_field', 'Session route selection requires a local workspace', 400);
+                const selected = body.route === undefined
+                    ? this.supervisor.route
+                    : (() => {
+                        const input = object(body.route);
+                        return providerRoute(string(input.provider, 'provider'), input.model === undefined ? undefined : string(input.model, 'model'), input.max_tokens === undefined
+                            ? undefined
+                            : integer(input.max_tokens, 'max_tokens'), undefined, undefined, input.reasoning);
+                    })();
+                if (body.local_workspace) {
+                    const saved = this.store.cachedRequest('local-operator', string(body.request_id, 'request_id', 128), {
+                        kind: 'create',
+                        cwd,
+                        local: {
+                            workspace: true,
+                            route: selected,
+                            ...(body.local_coding ? { coding: true } : {}),
+                        },
+                    });
+                    if (saved) {
+                        this.send(res, 201, saved);
+                        return;
+                    }
+                    if (this.mcp || this.toolkit || this.station)
+                        throw new ServiceError('admission_required', 'Local inspection cannot be combined with managed host capabilities');
+                }
+                const preparedLocal = body.local_workspace
+                    ? await this.supervisor.prepareProviderRoute(selected).catch(() => {
+                        throw new ServiceError('provider_auth_required', `Provider authentication or routing configuration is unavailable. Configure ${selected.provider} with sal auth login ${selected.provider} or sal auth set ${selected.provider}, then retry.`, 400);
+                    })
+                    : undefined;
+                if (preparedLocal?.output_cap === false &&
+                    body.route !== undefined &&
+                    object(body.route).max_tokens !== undefined)
+                    throw new ServiceError('provider_output_cap_unavailable', 'This authentication route cannot enforce an output token cap; omit max_tokens for an interactive session.', 400);
+                const local = body.local_workspace
+                    ? {
+                        workspace: true,
+                        coding: body.local_coding === true,
+                        requestedRoute: selected,
+                        route: preparedLocal.route,
+                        outputCap: preparedLocal.output_cap,
+                    }
+                    : undefined;
+                const session = this.store.create(cwd, string(body.request_id, 'request_id', 128), body.coding === true, local);
                 if (body.coding)
                     this.workspaces.import(session.id, cwd);
                 if (this.store.session(session.id).state === 'stopped')
@@ -524,6 +1258,152 @@ export class SalaamService {
             }
             if (parts[0] === 'v1' && parts[1] === 'sessions' && parts[2]) {
                 const id = parts[2];
+                if (parts.length === 4 && parts[3] === 'permissions') {
+                    if (req.method === 'GET') {
+                        this.send(res, 200, {
+                            policy: permissionPolicy(this.store, id),
+                            configurable: this.store.localWorkspace(id),
+                            coding: this.store.localCoding(id),
+                            command_auto_approval: false,
+                        });
+                        return;
+                    }
+                    if (req.method === 'POST') {
+                        const body = object(await readJson(req));
+                        this.send(res, 200, configurePermissions(this.store, id, string(body.request_id, 'request_id', 128), integer(body.expected_revision, 'expected_revision'), body.policy, {
+                            client_id: string(body.client_id, 'client_id', 128),
+                            token: string(body.token, 'token', 128),
+                        }));
+                        return;
+                    }
+                }
+                if (parts.length === 4 && parts[3] === 'local-diff' && req.method === 'GET') {
+                    if (!this.store.localWorkspace(id))
+                        throw new ServiceError('local_denied', 'Local workspace required');
+                    this.send(res, 200, { text: await localDiff(this.store.session(id).cwd) });
+                    return;
+                }
+                if (parts.length === 4 && parts[3] === 'steer' && req.method === 'POST') {
+                    const body = object(await readJson(req));
+                    this.send(res, 200, await this.supervisor.steer(id, string(body.request_id, 'request_id', 128), string(body.text, 'text', 65536), {
+                        client_id: string(body.client_id, 'client_id', 128),
+                        token: string(body.token, 'token', 128),
+                    }));
+                    return;
+                }
+                if (parts.length === 4 && parts[3] === 'undo-reconcile' && req.method === 'POST') {
+                    const body = object(await readJson(req));
+                    this.send(res, 200, reconcileUndo(this.store, id, {
+                        client_id: string(body.client_id, 'client_id', 128),
+                        token: string(body.token, 'token', 128),
+                    }, () => this.supervisor.assertIdle(id)));
+                    return;
+                }
+                if (parts.length === 4 && parts[3] === 'undo') {
+                    if (req.method === 'GET') {
+                        this.send(res, 200, reviewUndo(this.store, id));
+                        return;
+                    }
+                    if (req.method === 'POST') {
+                        const body = object(await readJson(req));
+                        this.send(res, 200, applyUndo(this.store, id, string(body.request_id, 'request_id', 128), string(body.review_digest, 'review_digest', 128), {
+                            client_id: string(body.client_id, 'client_id', 128),
+                            token: string(body.token, 'token', 128),
+                        }, () => {
+                            this.supervisor.assertIdle(id);
+                            if (this.store.db
+                                .prepare("SELECT 1 FROM attempts WHERE session_id=? AND state IN ('accepted','dispatching','running')")
+                                .get(id))
+                                throw new ServiceError('session_busy', 'Wait for queued work before undo');
+                        }));
+                        return;
+                    }
+                }
+                if (parts.length === 4 && parts[3] === 'fork' && req.method === 'POST') {
+                    if (this.agentpod)
+                        throw new ServiceError('admission_required', 'Managed station sessions cannot be forked locally');
+                    const body = object(await readJson(req));
+                    const session = this.store.forkLocal(id, string(body.request_id, 'request_id', 128), integer(body.expected_revision, 'expected_revision'), {
+                        client_id: string(body.client_id, 'client_id', 128),
+                        token: string(body.token, 'token', 128),
+                    }, (source, target) => {
+                        this.supervisor.assertIdle(id);
+                        const dir = join(this.stateDir, 'workers', target, 'sessions');
+                        mkdirSync(dir, { recursive: true, mode: 0o700 });
+                        return forkPiSession(source.pi_session_file, source.cwd, dir, target);
+                    });
+                    this.send(res, 201, session);
+                    return;
+                }
+                if (parts.length === 4 && parts[3] === 'name') {
+                    if (req.method === 'GET') {
+                        this.send(res, 200, { name: this.store.sessionName(id) ?? null });
+                        return;
+                    }
+                    if (req.method === 'POST') {
+                        const body = object(await readJson(req));
+                        this.send(res, 200, this.store.nameSession(id, string(body.request_id, 'request_id', 128), string(body.name, 'name', 120), {
+                            client_id: string(body.client_id, 'client_id', 128),
+                            token: string(body.token, 'token', 128),
+                        }));
+                        return;
+                    }
+                }
+                if (parts.length === 4 && parts[3] === 'revocation' && req.method === 'GET') {
+                    this.send(res, 200, this.store.execution.revocation(id));
+                    return;
+                }
+                if (parts.length === 4 && parts[3] === 'revoke' && req.method === 'POST') {
+                    const body = object(await readJson(req));
+                    const request = string(body.request_id, 'request_id', 128);
+                    const receipt = this.store.execution.revoke(id, request, integer(body.expected_revision, 'expected_revision'), string(body.reason, 'reason', 1024), {
+                        client_id: string(body.client_id, 'client_id', 128),
+                        token: string(body.token, 'token', 128),
+                    }, (attempt) => {
+                        this.managed.cancelInTransaction(attempt, request, 'session-revocation');
+                        this.mcp?.cancelInTransaction(attempt, 'session-revocation');
+                        this.station?.cancelInTransaction(attempt);
+                    });
+                    // The receipt commits before any asynchronous process/executor cleanup.
+                    // Cleanup failure never restores authority or implies a confirmed stop.
+                    this.scheduleRevocationStop(receipt);
+                    this.send(res, 202, receipt);
+                    return;
+                }
+                if (parts[3] === 'agents') {
+                    if (req.method === 'GET') {
+                        const profile = url.searchParams.get('profile');
+                        this.send(res, 200, profile
+                            ? {
+                                ...this.agents.inspect(id, profile),
+                                digest: digest(this.agents.inspect(id, profile)),
+                            }
+                            : this.agents.list(id).map((p) => ({ ...p, digest: digest(p) })));
+                        return;
+                    }
+                    const body = object(await readJson(req));
+                    const controller = {
+                        client_id: string(body.client_id, 'client_id', 128),
+                        token: string(body.token, 'token', 128),
+                    };
+                    const request = string(body.request_id, 'request_id', 128);
+                    if (parts[4] === 'admit') {
+                        const facts = body.fact_ids === undefined
+                            ? []
+                            : Array.isArray(body.fact_ids)
+                                ? body.fact_ids.map((x) => string(x, 'fact_id', 128))
+                                : (() => {
+                                    throw new ServiceError('invalid_field', 'fact_ids must be an array');
+                                })();
+                        this.send(res, 201, await this.agents.admit(id, request, string(body.profile_id, 'profile_id', 128), string(body.expected_digest, 'expected_digest', 64), facts, controller));
+                        return;
+                    }
+                    if (parts[4] === 'revoke') {
+                        this.send(res, 200, this.agents.revoke(id, string(body.grant_id, 'grant_id', 128), request, controller));
+                        return;
+                    }
+                    throw new ServiceError('not_found', 'Agent operation not found', 404);
+                }
                 if (parts[3] === 'activity' && req.method === 'GET') {
                     this.store.session(id);
                     const rows = this.store.db
@@ -594,6 +1474,31 @@ export class SalaamService {
                         }
                     }
                 }
+                if (parts[3] === 'context') {
+                    const contexts = this.tasks.admitted;
+                    if (parts.length === 4 && req.method === 'GET') {
+                        this.send(res, 200, contexts.inspect(id));
+                        return;
+                    }
+                    if (req.method === 'POST' && (parts[4] === 'plan' || parts[4] === 'admit')) {
+                        const body = object(await readJson(req));
+                        const authorize = () => {
+                            this.store.authorizeControl(id, {
+                                client_id: string(body.client_id, 'client_id', 128),
+                                token: string(body.token, 'token', 128),
+                            });
+                            this.supervisor.assertIdle(id);
+                        };
+                        if (parts[4] === 'plan') {
+                            authorize();
+                            this.send(res, 200, contexts.plan(id, body.selection));
+                        }
+                        else {
+                            this.send(res, 200, contexts.admit(id, string(body.request_id, 'request_id', 128), integer(body.expected_revision, 'expected_revision'), string(body.digest, 'digest', 128), body.selection, authorize));
+                        }
+                        return;
+                    }
+                }
                 if (parts[3] === 'task' && req.method === 'GET') {
                     this.send(res, 200, this.tasks.state(id));
                     return;
@@ -645,6 +1550,20 @@ export class SalaamService {
                     return;
                 }
             }
+            if (parts[0] === 'v1' && parts[1] === 'toolkit' && parts[2] === 'calls' && parts[3]) {
+                const id = parts[3];
+                if (parts.length === 4 && req.method === 'GET') {
+                    this.send(res, 200, this.toolkitResolutions.inspect(id));
+                    return;
+                }
+                if (parts.length === 5 && parts[4] === 'resolution' && req.method === 'POST') {
+                    const body = object(await readJson(req)), outcome = string(body.outcome, 'outcome');
+                    if (outcome !== 'succeeded' && outcome !== 'failed_definite')
+                        throw new ServiceError('invalid_field', 'Invalid resolution outcome', 400);
+                    this.send(res, 200, await this.toolkitResolutions.resolveRead(id, string(body.request_id, 'request_id', 128), integer(body.expected_revision, 'expected_revision'), string(body.context_digest, 'context_digest', 128), outcome, string(body.evidence, 'evidence', 4096)));
+                    return;
+                }
+            }
             if (parts[0] === 'v1' && parts[1] === 'operations' && parts[2]) {
                 const id = parts[2];
                 if (parts.length === 3 && req.method === 'GET') {
@@ -669,10 +1588,23 @@ export class SalaamService {
                     const outcome = string(body.outcome, 'outcome');
                     if (outcome !== 'succeeded' && outcome !== 'failed_definite')
                         throw new ServiceError('invalid_field', 'Invalid resolution outcome', 400);
-                    this.send(res, 200, this.managed.resolve(id, string(body.request_id, 'request_id', 128), integer(body.expected_revision, 'expected_revision'), string(body.operation_digest, 'operation_digest', 128), outcome, string(body.evidence, 'evidence', 4096)));
+                    this.send(res, 200, await (this.toolkitResolutions.owns(id)
+                        ? this.toolkitResolutions.resolveOperation.bind(this.toolkitResolutions)
+                        : this.managed.resolve.bind(this.managed))(id, string(body.request_id, 'request_id', 128), integer(body.expected_revision, 'expected_revision'), string(body.operation_digest, 'operation_digest', 128), outcome, string(body.evidence, 'evidence', 4096)));
                     return;
                 }
             }
+            if (parts[0] === 'v1' &&
+                parts[1] === 'station' &&
+                parts[2] === 'calls' &&
+                parts[3] &&
+                parts.length === 4 &&
+                req.method === 'GET') {
+                if (!this.station)
+                    throw new ServiceError('station_disabled', 'Station execution is unavailable');
+                this.send(res, 200, this.station.view(parts[3]));
+                return;
+            }
             if (parts[0] === 'v1' &&
                 parts[1] === 'attempts' &&
                 parts[2] &&
@@ -693,10 +1625,10 @@ export class SalaamService {
                     token: string(body.token, 'token', 128),
                 });
                 this.coding.cancelAttempt(attempt);
-                void this.children
-                    .cancelOwned(attempt)
-                    .then(() => this.supervisor.cancelAttempt(attempt))
-                    .catch((error) => this.supervisor.failControl(this.store.attempt(attempt).session_id, error));
+                const owned = this.children.owned(this.store.attempt(attempt).session_id);
+                void (owned && this.store.workerBoundary.view(owned.id).binding.external
+                    ? this.external.cancel(owned)
+                    : this.children.cancelOwned(attempt).then(() => this.supervisor.cancelAttempt(attempt))).catch((error) => this.supervisor.failControl(this.store.attempt(attempt).session_id, error));
                 this.send(res, 202, receipt);
                 return;
             }
@@ -746,11 +1678,34 @@ export class SalaamService {
                         ...this.supervisor.inspect(id),
                         job: this.jobs.forSession(id) ? this.jobs.view(this.jobs.forSession(id).id) : null,
                         work_task: this.taskWork.forSession(id)
-                            ? this.taskDriver.view(this.taskWork.forSession(id).id)
+                            ? await this.taskDriver.viewAsync(this.taskWork.forSession(id).id)
                             : null,
                     });
                     return;
                 }
+                if (parts[3] === 'tool-metadata' && req.method === 'GET') {
+                    this.send(res, 200, this.store.toolMetadata(id, string(url.searchParams.get('call_id'), 'call_id', 512)));
+                    return;
+                }
+                if (parts[3] === 'cancellations') {
+                    if (req.method === 'GET') {
+                        const request = url.searchParams.get('request_id');
+                        this.send(res, 200, request
+                            ? this.cancellations.get(id, string(request, 'request_id', 128))
+                            : this.cancellations.list(id));
+                        return;
+                    }
+                    if (req.method === 'POST') {
+                        const body = object(await readJson(req));
+                        this.send(res, 202, this.cancellations.begin(id, string(body.request_id, 'request_id', 128), body.target_request_id == null
+                            ? null
+                            : string(body.target_request_id, 'target_request_id', 128), {
+                            client_id: string(body.client_id, 'client_id', 128),
+                            token: string(body.token, 'token', 128),
+                        }));
+                        return;
+                    }
+                }
                 if (parts[3] === 'control' && req.method === 'POST') {
                     const body = object(await readJson(req));
                     const action = string(body.action, 'action');
@@ -765,9 +1720,10 @@ export class SalaamService {
                         client_id: string(body.client_id, 'client_id', 128),
                         token: string(body.token, 'token', 128),
                     });
+                    this.store.execution.assert(id);
                     const session = this.supervisor.inspect(id);
                     if (session.provider_route &&
-                        canonical(session.provider_route) !== canonical(this.supervisor.route))
+                        canonical(session.provider_route) !== canonical(this.supervisor.routeFor(id)))
                         throw new ServiceError('provider_route_changed', 'Restart the service with this session’s original provider route, or create a new session');
                     if (session.state !== 'ready' && session.state !== 'starting')
                         void this.supervisor.start(id).catch(() => { });
@@ -893,49 +1849,63 @@ export class SalaamService {
     async close() {
         if (this.stopping) {
             await this.closed;
+            if (this.shutdownFailure)
+                throw this.shutdownFailure;
             return;
         }
         this.stopping = true;
-        this.inbox.close();
-        this.recurring.close();
-        this.jobs.close();
-        await this.taskDriver.close();
-        this.dispatcher.pause();
-        this.managed.pause();
-        this.children.pause();
+        this.toolkitResolutions.stop();
+        clearInterval(this.authorityTimer);
         const errors = [];
-        try {
-            await this.coding.close();
+        const attempt = async (cleanup) => {
             try {
-                await this.children.close();
-                await this.supervisor.close();
+                await cleanup();
             }
             catch (error) {
                 errors.push(error);
             }
-            await this.dispatcher.drain();
-            await this.managed.close();
-            await Promise.all([this.operator, this.bridgeServer].map((server) => new Promise((resolve) => {
-                if (!server.listening) {
-                    resolve();
-                    return;
-                }
-                server.close(() => resolve());
-                server.closeAllConnections();
-            })));
-            await Promise.all(this.handlers);
-            try {
-                this.store.close();
-            }
-            catch (error) {
-                errors.push(error);
+        };
+        await attempt(() => this.inbox.close());
+        await attempt(() => this.recurring.close());
+        await attempt(() => this.jobs.close());
+        await attempt(() => this.taskDriver.close());
+        this.taskVerification.station?.stop();
+        await attempt(() => this.dispatcher.pause());
+        await attempt(() => this.managed.pause());
+        await attempt(() => this.children.pause());
+        await attempt(() => this.a2aInbound?.close());
+        await Promise.all([...this.revocationStops].map((stop) => attempt(() => stop)));
+        await attempt(() => this.external.close());
+        await attempt(() => this.localCoding.close());
+        await attempt(() => this.coding.close());
+        await attempt(() => this.mcp?.close());
+        await attempt(() => this.toolkit?.close());
+        await attempt(() => this.station?.close());
+        await attempt(() => this.taskVerification.station?.drain());
+        await attempt(() => this.toolkitResources.close());
+        await attempt(() => this.toolkitResolutions.close());
+        await attempt(() => this.children.close());
+        await attempt(() => this.supervisor.close());
+        await attempt(() => this.dispatcher.drain());
+        await attempt(() => this.managed.close());
+        await attempt(() => Promise.all([this.operator, this.bridgeServer].map((server) => new Promise((resolve, reject) => {
+            if (!server.listening) {
+                resolve();
+                return;
             }
-        }
-        finally {
-            this.release();
-            this.resolveClosed();
-        }
+            server.close((error) => (error ? reject(error) : resolve()));
+            server.closeAllConnections();
+        }))));
+        await Promise.all([...this.handlers].map((handler) => attempt(() => handler)));
+        await attempt(() => this.store.close());
+        // A replacement must not mistake an empty resource map for proof that this
+        // process stopped all of its workers. OS death releases a retained lock.
+        if (!errors.length)
+            await attempt(() => this.release());
         if (errors.length)
-            throw new AggregateError(errors, 'Service shutdown could not persist all final states');
+            this.shutdownFailure = new AggregateError(errors, 'Service shutdown could not confirm all resources and final states; state ownership retained until process exit');
+        this.resolveClosed();
+        if (this.shutdownFailure)
+            throw this.shutdownFailure;
     }
 }