@dougbots/avenor-core 0.16.1 → 0.18.0

package/dist/index.d.ts

@@ -145,6 +145,7 @@ interface WorkflowControllerCreateParams {
   max_inflight: number;
 }
 interface MessageSendParams {
+  expected_sentinel_file?: string;
   to_run_id: string;
   message_id: string;
   generation: string;
@@ -207,6 +208,12 @@ interface MessagePeer {
 interface MessagePeersResult {
   peers: MessagePeer[];
   generation?: string;
+  /**
+   * Set when the listing read only part of the peer set. The peers beside it
+   * are the ones that were read, so a partial list is never read as a
+   * complete one.
+   */
+  peers_error?: string;
 }
 interface MessagePreflightResult {
   protocol: number;
@@ -311,7 +318,6 @@ declare class Client {
   events(options?: SubscribeOptions): AsyncIterableIterator<Event>;
   history(options: HistoryOptions): Promise<HistoryResult>;
   status(runtimeId?: string): Promise<Record<string, unknown>>;
-  result(runtimeId?: string): Promise<Record<string, unknown>>;
   list(): Promise<Array<Record<string, unknown>>>;
   spawn(params: SpawnParams): Promise<SpawnResult>;
   shutdown(mode: string): Promise<void>;
@@ -350,7 +356,9 @@ declare class Client {
   messagePreflight(): Promise<MessagePreflightResult>;
   resume(params: ResumeParams): Promise<ResumeResult>;
   sessionRename(sessionId: string, name: string): Promise<SessionRenameResult>;
-  sessionLast(runtimeId: string): Promise<SessionLastResult>;
+  sessionLast(runtimeId: string, expectedSentinelFile?: string): Promise<SessionLastResult>;
+  /** The complete terminal reply for a runtime, with the sentinel that turn currently owns. */
+  result(runtimeId: string): Promise<Record<string, unknown>>;
   sessionLastSet(runtimeId: string, finalOutput: string, stopReason: string, truncated: boolean): Promise<void>;
   workflowCancel(workflowId: string, actor: string, reason: string): Promise<Record<string, unknown>>;
   isClosed(): boolean;
@@ -517,7 +525,12 @@ interface RunSnapshot {
 }
 declare function createRunSnapshot(limits?: Partial<RunReducerLimits>): RunSnapshot;
 declare function reduceRunSnapshot(current: RunSnapshot, input: unknown, limits?: Partial<RunReducerLimits>): RunSnapshot;
-type RunSnapshotSeed = Partial<Omit<RunSnapshot, '_seen_seq_by_scope' | '_recent_legacy_keys' | '_last_semantic_fingerprint' | '_last_source_event'>>;
+/**
+ * A snapshot as the inspect surface and an observer publish it: the reducer's
+ * dedupe bookkeeping stays internal to `RunReducer`.
+ */
+type RunSnapshotView = Omit<RunSnapshot, '_seen_seq_by_scope' | '_recent_legacy_keys' | '_last_semantic_fingerprint' | '_last_source_event'>;
+type RunSnapshotSeed = Partial<RunSnapshotView>;
 declare class RunReducer {
   private state;
   constructor(limits?: Partial<RunReducerLimits>, initial?: RunSnapshotSeed);
@@ -619,20 +632,46 @@ declare class Supervisor {
   registerResumed(run: RunInfo): void;
   /** The one place a run's ID and label are registered, for spawn and for resume. */
   private register;
-  /** Match a stored run by its broker runtime ID. */
+  /** The stored runs that carry a broker runtime ID. */
+  getRunsByRuntimeId(runtimeId: string): RunInfo[];
+  /**
+   * Match a stored run by its broker runtime ID, returning the entry only
+   * when exactly one run carries the id. Several registered turns can share
+   * a runtime (a warm resume, or a restart that re-minted one while the
+   * pre-restart entry stays registered); the current turn is identified by
+   * the sentinel the runtime holds, so a shared id is disambiguated with
+   * getRunByRuntimeTurn rather than by whichever entry was inserted last.
+   */
   getRunByRuntimeId(runtimeId: string): RunInfo | undefined;
+  /**
+   * Return the entry for (runtimeId, sentinelPath) only when exactly one
+   * stored run carries both. A sentinel no entry carries, or one carried by
+   * several entries, is claimed by no turn.
+   */
+  getRunByRuntimeTurn(runtimeId: string, sentinelPath: string): RunInfo | undefined;
   /**
    * The live singleton when it owns supervisorId, null otherwise. Single
    * source of truth for the ownership check, so callers cannot observe
    * isCurrentInstance true while currentInstance is null.
    */
+  /**
+   * Build an instance that owns socketPath without spawning a supervisor
+   * process, and adopt it as the live singleton. `start` is the production
+   * writer of both; this exists so a test can drive the in-process plane
+   * without forging private state, and hands back the previous singleton so
+   * the caller can restore it.
+   */
+  static adoptTestInstance(binaryPath: string, socketPath: string): {
+    supervisor: Supervisor;
+    restore: () => void;
+  };
   static getInstance(supervisorId: string): Supervisor | null;
   static isCurrentInstance(supervisorId: string): boolean;
   static currentInstance(): Supervisor | null;
   /** Iterate stored runs without exposing the internal map. */
   forEachRun(callback: (info: RunInfo) => void): void;
   getClient(): Client;
-  spawn(params: SpawnParams, runId?: `${string}-${string}-${string}-${string}-${string}`, metadata?: SpawnMetadata): Promise<RunInfo>;
+  spawn(params: SpawnParams, runId?: string, metadata?: SpawnMetadata): Promise<RunInfo>;
   close(options?: {
     skipShutdown?: boolean;
   }): Promise<void>;
@@ -743,6 +782,7 @@ interface StatusResult {
   latest_seq?: number;
   final_output?: string;
   final_output_truncated?: boolean;
+  runtime_output_available?: boolean;
 }
 declare const statusTool: (args: StatusToolArgs) => Promise<StatusResult | StatusListResult>;
 //#endregion
@@ -762,6 +802,11 @@ interface EventsToolResult {
     [key: string]: unknown;
   }>;
 }
+/**
+ * Stream the parsed records of one NDJSON event log. Malformed lines are
+ * dropped; an unreadable log rejects, so a caller that cannot read the log
+ * never sees a silent empty tail.
+ */
 declare const eventsTool: (args: EventsToolArgs) => Promise<EventsToolResult>;
 //#endregion
 //#region src/tools/inspect.d.ts
@@ -775,7 +820,7 @@ interface InspectResult {
   run_id: string;
   label: string;
   status: StatusResult;
-  snapshot: Omit<RunSnapshot, '_seen_seq_by_scope' | '_recent_legacy_keys' | '_last_semantic_fingerprint' | '_last_source_event'>;
+  snapshot: RunSnapshotView;
   transcript: RunSnapshot['transcript'];
   tools: RunSnapshot['tools'];
   live_tools: RunSnapshot['live_tools'];
@@ -961,9 +1006,9 @@ interface MessageProvider {
   surface(): MessageSurface;
   role(): string;
   resolve(ref: string): Promise<Resolution>;
-  state(runId: string): Promise<RunFacts>;
-  tell(targetRunId: string, message: string): Promise<ProviderResult>;
-  ask(targetRunId: string, message: string, timeoutMs?: number, signal?: AbortSignal): Promise<ProviderResult>;
+  state(runId: string, publicRunId?: string): Promise<RunFacts>;
+  tell(targetRunId: string, message: string, publicRunId?: string): Promise<ProviderResult>;
+  ask(targetRunId: string, message: string, timeoutMs?: number, signal?: AbortSignal, publicRunId?: string): Promise<ProviderResult>;
   reply(inboundAskId: string, message: string, askerRunId: string): Promise<ProviderResult>;
   withdraw(messageId: string): Promise<ProviderResult>;
   controlReply?(target: string, payload: unknown): Promise<ProviderResult>;
@@ -978,7 +1023,7 @@ interface MessageProvider {
     sessionId?: string;
     name: string;
   }): Promise<ProviderResult>;
-  last(runId: string): Promise<ProviderResult>;
+  last(runId: string, publicRunId?: string): Promise<ProviderResult>;
   peers(): Promise<PeersProviderResult>;
   /** Host surfaces that own a turn loop publish their own finished turn. */
   recordLastTurn?(text: string, stopReason: string, truncated: boolean): Promise<void>;
@@ -1092,6 +1137,7 @@ interface MessageClient {
     generation: string;
     body: string;
     no_reply?: boolean;
+    expected_sentinel_file?: string;
   }): Promise<MessageSendResult>;
   messageWait(params: {
     message_id: string;
@@ -1121,7 +1167,7 @@ interface MessageClient {
     on_event?: string;
   }): Promise<ResumeResult>;
   sessionRename(sessionId: string, name: string): Promise<SessionRenameResult>;
-  sessionLast(runtimeId: string): Promise<SessionLastResult>;
+  sessionLast(runtimeId: string, expectedSentinelFile?: string): Promise<SessionLastResult>;
   sessionLastSet(runtimeId: string, finalOutput: string, stopReason: string, truncated: boolean): Promise<void>;
   status(runtimeId?: string): Promise<Record<string, unknown>>;
 }
@@ -1166,7 +1212,10 @@ declare function installAskClaims(provider: MessageProvider, claims: AskClaims,
 /**
  * Build the bound host provider: one supervisor, one generation, one control
  * client. It never reads an ambient singleton or retargets, and it never
- * preflights per call.
+ * preflights per call. Listing-backed lookups fail fast: an incomplete
+ * listing refuses every resolution and state read, even for a peer the
+ * partial set contains, so a wire `peers_error` resolves the same way the Go
+ * providers do. Self and public-ID resolution bypass the listing.
  */
 declare function createHostMessageProvider(options: HostProviderOptions): MessageProvider;
 interface ChildProviderOptions {
@@ -1181,17 +1230,24 @@ interface ChildProviderOptions {
 /**
  * Build a child provider over the surface's inherited broker. A child never
  * learns a public run id, and it cannot read a sentinel, so it is never
- * resumable from here: the supervisor owns a resume.
+ * resumable from here: the supervisor owns a resume. Listing-backed lookups
+ * fail fast: an incomplete listing refuses every resolution and state read,
+ * even for a peer the partial set contains, so a wire `peers_error` resolves
+ * the same way the Go providers do. Self resolution bypasses the listing.
  */
 declare function createChildMessageProvider(options: ChildProviderOptions): MessageProvider;
 //#endregion
 //#region src/tools/peers.d.ts
 interface PeersToolArgs extends PeersInput {}
 type PeersResult = PeersRouterResult;
-/** The one avenor_peers handler; it resolves and reads through the bound provider. */
-declare function peersTool(args: PeersToolArgs, provider: MessageProvider): Promise<PeersResult>;
+/** The one avenor_peers handler; it resolves and reads through the bound provider.
+ *
+ * Admission belongs to the shared router for every surface, so the argument is
+ * the untyped JSON a tool call carries and `executePeers` validates it first —
+ * the same shape `messageTool` takes. */
+declare function peersTool(args: unknown, provider: MessageProvider): Promise<PeersResult>;
 /** Bind the peers handler to one provider. */
-declare function createPeersTool(provider: MessageProvider): (args: PeersToolArgs) => Promise<PeersResult>;
+declare function createPeersTool(provider: MessageProvider): (args: unknown) => Promise<PeersResult>;
 //#endregion
 //#region src/tools/kill.d.ts
 interface KillToolArgs {
@@ -1318,4 +1374,4 @@ type WorkflowCancelResult = Record<string, unknown>;
 declare function createWorkflowCancelTool(getSupervisorClient: GetSupervisorClient): (args: WorkflowCancelArgs) => Promise<WorkflowCancelResult>;
 declare const workflowCancelTool: (args: WorkflowCancelArgs) => Promise<WorkflowCancelResult>;
 //#endregion
-export { type AskClaims, type BrokerReceiveArgs, type BrokerReceiveResult, type ChildBroker, type Client, ClosedSocketError, DEFAULT_RUN_REDUCER_LIMITS, type Event, type ExecutionIdentity, ForeignPeerError, type HistoryOptions, type HistoryResult, type InboundAsk, type InspectResult, type KillResult, type KillToolArgs, MAX_FINAL_OUTPUT_RUNES, MAX_WAIT_MS, MESSAGE_OUTCOMES, type MessageCallerKind, type MessageClient, type MessageInput, type MessageOutcome, type MessageProvider, type MessageSurface, type NormalizedRunEvent, type ObserveRunOptions, type OwnerAttachOptions, OwnerAuthError, OwnerRecordMissingError, type PeerRecord, type PeersInput, type PeersProviderResult, type PeersResult, type PeersRouterResult, type PeersToolArgs, type PendingAsk, type ProviderResult, type Resolution, type ResultResult, type ResultToolArgs, RpcError, type RunChunkRole, type RunFacts, type RunIdentity, type RunInfo, type RunObserver, type RunObserverClient, type RunPermissionOption, type RunPermissionSummary, RunReducer, type RunReducerLimits, type RunSnapshot, type RunSnapshotSeed, type RunToolState, type RunToolSummary, type RunTranscriptEntry, SUPERVISOR_RUN_ID, type SpawnMetadata, type SpawnParams, type SpawnResult, type SpawnSelectionInput, type SpawnToolArgs, type SpawnToolResult, StaleOwnerRecordError, type StatusListResult, type StatusResult, type StatusToolArgs, type StatusView, type SubscribeOptions, Supervisor, type SupervisorClientOptions, type SupervisorOptions, THINKING_LEVELS, type ThinkingLevel, type ThinkingOutcome, ToolError, type WorkflowCancelArgs, type WorkflowCancelResult, type WorkflowCompleteParams, type WorkflowCompleteResult, type WorkflowCompleteToolArgs, type WorkflowControllerCreateParams, type WorkflowControllerStatusResult, type WorkflowControllerStatusToolArgs, type WorkflowEventsResult, type WorkflowEventsToolArgs, type WorkflowGateOperation, type WorkflowGateParams, type WorkflowGateResult, type WorkflowGateToolArgs, type WorkflowHeartbeatParams, type WorkflowInspectResult, type WorkflowInspectToolArgs, type WorkflowReadyResult, type WorkflowReadyToolArgs, type WorkflowStatusResult, type WorkflowStatusToolArgs, type WorkflowWaitResult, type WorkflowWaitToolArgs, answerPermissionTool, assertMessageInput, assertPeersInput, attachOwner, boundFinalOutput, brokerReceiveTool, createChildMessageProvider, createHostMessageProvider, createMessageTool, createPeersTool, createRunSnapshot, createWorkflowCancelTool, createWorkflowCompleteTool, createWorkflowControllerStatusTool, createWorkflowEventsTool, createWorkflowGateTool, createWorkflowInspectTool, createWorkflowReadyTool, createWorkflowStatusTool, createWorkflowWaitTool, dial, evaluateThinkingPolicy, eventsTool, executeMessage, executePeers, extractEventText, extractReplyMessage, extractTurnText, findAvenorBinary, getInstallDir, getSupervisorClient, getVersion, inspectTool, installAskClaims, installerBinaryPath, isClosedSocketError, isGenerationMismatchError, isThinkingLevel, killTool, messageTool, newMsgID, normalizeAskTimeoutMs, normalizeRunEvent, normalizeTurnStopReason, observeRun, peersDetails, peersTool, quote, quoteList, reduceRunSnapshot, renderAskFailure, renderLast, renderOutcome, renderPeerList, repair, resultOutput, resultTool, sanitize, shutdownTool, socketsRoot, spawnTool, statusTool, validateSpawnSelection, validateThinking, validateThinkingForBackend, validateThinkingForBackendResume, workflowCancelTool, workflowCompleteTool, workflowControllerStatusTool, workflowEventsTool, workflowGateTool, workflowInspectTool, workflowReadyTool, workflowStatusTool, workflowWaitTool };
+export { type AskClaims, type BrokerReceiveArgs, type BrokerReceiveResult, type ChildBroker, type Client, ClosedSocketError, DEFAULT_RUN_REDUCER_LIMITS, type Event, type ExecutionIdentity, ForeignPeerError, type HistoryOptions, type HistoryResult, type InboundAsk, type InspectResult, type KillResult, type KillToolArgs, MAX_FINAL_OUTPUT_RUNES, MAX_WAIT_MS, MESSAGE_OUTCOMES, type MessageCallerKind, type MessageClient, type MessageInput, type MessageOutcome, type MessageProvider, type MessageSurface, type NormalizedRunEvent, type ObserveRunOptions, type OwnerAttachOptions, OwnerAuthError, OwnerRecordMissingError, type PeerRecord, type PeersInput, type PeersProviderResult, type PeersResult, type PeersRouterResult, type PeersToolArgs, type PendingAsk, type ProviderResult, type Resolution, type ResultResult, type ResultToolArgs, RpcError, type RunChunkRole, type RunFacts, type RunIdentity, type RunInfo, type RunObserver, type RunObserverClient, type RunPermissionOption, type RunPermissionSummary, RunReducer, type RunReducerLimits, type RunSnapshot, type RunSnapshotSeed, type RunSnapshotView, type RunToolState, type RunToolSummary, type RunTranscriptEntry, SUPERVISOR_RUN_ID, type SpawnMetadata, type SpawnParams, type SpawnResult, type SpawnSelectionInput, type SpawnToolArgs, type SpawnToolResult, StaleOwnerRecordError, type StatusListResult, type StatusResult, type StatusToolArgs, type StatusView, type SubscribeOptions, Supervisor, type SupervisorClientOptions, type SupervisorOptions, THINKING_LEVELS, type ThinkingLevel, type ThinkingOutcome, ToolError, type WorkflowCancelArgs, type WorkflowCancelResult, type WorkflowCompleteParams, type WorkflowCompleteResult, type WorkflowCompleteToolArgs, type WorkflowControllerCreateParams, type WorkflowControllerStatusResult, type WorkflowControllerStatusToolArgs, type WorkflowEventsResult, type WorkflowEventsToolArgs, type WorkflowGateOperation, type WorkflowGateParams, type WorkflowGateResult, type WorkflowGateToolArgs, type WorkflowHeartbeatParams, type WorkflowInspectResult, type WorkflowInspectToolArgs, type WorkflowReadyResult, type WorkflowReadyToolArgs, type WorkflowStatusResult, type WorkflowStatusToolArgs, type WorkflowWaitResult, type WorkflowWaitToolArgs, answerPermissionTool, assertMessageInput, assertPeersInput, attachOwner, boundFinalOutput, brokerReceiveTool, createChildMessageProvider, createHostMessageProvider, createMessageTool, createPeersTool, createRunSnapshot, createWorkflowCancelTool, createWorkflowCompleteTool, createWorkflowControllerStatusTool, createWorkflowEventsTool, createWorkflowGateTool, createWorkflowInspectTool, createWorkflowReadyTool, createWorkflowStatusTool, createWorkflowWaitTool, dial, evaluateThinkingPolicy, eventsTool, executeMessage, executePeers, extractEventText, extractReplyMessage, extractTurnText, findAvenorBinary, getInstallDir, getSupervisorClient, getVersion, inspectTool, installAskClaims, installerBinaryPath, isClosedSocketError, isGenerationMismatchError, isThinkingLevel, killTool, messageTool, newMsgID, normalizeAskTimeoutMs, normalizeRunEvent, normalizeTurnStopReason, observeRun, peersDetails, peersTool, quote, quoteList, reduceRunSnapshot, renderAskFailure, renderLast, renderOutcome, renderPeerList, repair, resultOutput, resultTool, sanitize, shutdownTool, socketsRoot, spawnTool, statusTool, validateSpawnSelection, validateThinking, validateThinkingForBackend, validateThinkingForBackendResume, workflowCancelTool, workflowCompleteTool, workflowControllerStatusTool, workflowEventsTool, workflowGateTool, workflowInspectTool, workflowReadyTool, workflowStatusTool, workflowWaitTool };

package/dist/index.js

@@ -368,10 +368,6 @@ var Client = class {
 		const params = runtimeId ? { runtime_id: runtimeId } : void 0;
 		return this.call("status", params);
 	}
-	async result(runtimeId) {
-		const params = runtimeId ? { runtime_id: runtimeId } : void 0;
-		return this.call("result", params);
-	}
 	async list() {
 		return this.call("list");
 	}
@@ -504,7 +500,7 @@ var Client = class {
 		});
 	}
 	async messageSend(params) {
-		return this.call("message_send", params);
+		return this.call(params.expected_sentinel_file ? "message_send_turn" : "message_send", params);
 	}
 	async messageWait(params) {
 		const requested = params.timeout_ms !== void 0 && params.timeout_ms > 0 ? params.timeout_ms : MESSAGE_MAX_WAIT_MS;
@@ -535,8 +531,15 @@ var Client = class {
 			name
 		});
 	}
-	async sessionLast(runtimeId) {
-		return this.call("session_last", { runtime_id: runtimeId });
+	async sessionLast(runtimeId, expectedSentinelFile) {
+		return this.call(expectedSentinelFile ? "session_last_turn" : "session_last", {
+			runtime_id: runtimeId,
+			...expectedSentinelFile ? { expected_sentinel_file: expectedSentinelFile } : {}
+		});
+	}
+	/** The complete terminal reply for a runtime, with the sentinel that turn currently owns. */
+	async result(runtimeId) {
+		return this.call("result", { runtime_id: runtimeId });
 	}
 	async sessionLastSet(runtimeId, finalOutput, stopReason, truncated) {
 		await this.call("session_last_set", {
@@ -2149,16 +2152,56 @@ var Supervisor = class Supervisor {
 		this.runs.set(run.runId, run);
 		this.aliases.set(run.label, run);
 	}
-	/** Match a stored run by its broker runtime ID. */
+	/** The stored runs that carry a broker runtime ID. */
+	getRunsByRuntimeId(runtimeId) {
+		if (!runtimeId) return [];
+		return [...this.runs.values()].filter((info) => info.runtimeId === runtimeId);
+	}
+	/**
+	* Match a stored run by its broker runtime ID, returning the entry only
+	* when exactly one run carries the id. Several registered turns can share
+	* a runtime (a warm resume, or a restart that re-minted one while the
+	* pre-restart entry stays registered); the current turn is identified by
+	* the sentinel the runtime holds, so a shared id is disambiguated with
+	* getRunByRuntimeTurn rather than by whichever entry was inserted last.
+	*/
 	getRunByRuntimeId(runtimeId) {
-		if (!runtimeId) return void 0;
-		for (const runInfo of this.runs.values()) if (runInfo.runtimeId === runtimeId) return runInfo;
+		const matches = this.getRunsByRuntimeId(runtimeId);
+		return matches.length === 1 ? matches[0] : void 0;
+	}
+	/**
+	* Return the entry for (runtimeId, sentinelPath) only when exactly one
+	* stored run carries both. A sentinel no entry carries, or one carried by
+	* several entries, is claimed by no turn.
+	*/
+	getRunByRuntimeTurn(runtimeId, sentinelPath) {
+		if (!runtimeId || !sentinelPath) return void 0;
+		const matches = this.getRunsByRuntimeId(runtimeId).filter((info) => info.sentinelPath === sentinelPath);
+		return matches.length === 1 ? matches[0] : void 0;
 	}
 	/**
 	* The live singleton when it owns supervisorId, null otherwise. Single
 	* source of truth for the ownership check, so callers cannot observe
 	* isCurrentInstance true while currentInstance is null.
 	*/
+	/**
+	* Build an instance that owns socketPath without spawning a supervisor
+	* process, and adopt it as the live singleton. `start` is the production
+	* writer of both; this exists so a test can drive the in-process plane
+	* without forging private state, and hands back the previous singleton so
+	* the caller can restore it.
+	*/
+	static adoptTestInstance(binaryPath, socketPath) {
+		const previous = Supervisor.instance;
+		const supervisor = new Supervisor(binaryPath, socketPath);
+		Supervisor.instance = supervisor;
+		return {
+			supervisor,
+			restore: () => {
+				Supervisor.instance = previous;
+			}
+		};
+	}
 	static getInstance(supervisorId) {
 		if (Supervisor.instance === null) return null;
 		if (Supervisor.instance.supervisorId === supervisorId) return Supervisor.instance;
@@ -2637,7 +2680,7 @@ var thinking_policy_umpire_default = {
 						{
 							"op": "condIn",
 							"condition": "backend",
-							"values": ["claude", "claude-channel"]
+							"values": ["claude"]
 						},
 						{
 							"op": "condEq",
@@ -2657,7 +2700,7 @@ var thinking_policy_umpire_default = {
 						}
 					]
 				},
-				"reason": "claude and claude-channel support low through max only on a new session"
+				"reason": "claude supports low through max only on a new session"
 			}]
 		}
 	}]
@@ -2781,6 +2824,55 @@ function validateThinkingForBackendResume(backend, value) {
 	throw new Error(`backend ${JSON.stringify(backend)} does not support parameter "thinking"`);
 }
 //#endregion
+//#region src/tools/sentinel-status.ts
+/**
+* Sentinel statuses that settle the provider session itself, so the recorded
+* session id is a loadable transcript. TIMEOUT and KILLED are supervisor-imposed
+* terminations (time budget, cancellation) where an automatic continuation would
+* surprise. Matches the Go `readSentinelSession`.
+*/
+const RESUMABLE_SENTINEL_STATUSES = new Set([
+	"DONE",
+	"FAILED",
+	"BLOCKED"
+]);
+/**
+* The terminal sentinel statuses the provider's state fallback answers from,
+* matching the Go `terminalStatusFromRunInfo` set: a run that settled before
+* a supervisor restart keeps its outcome discoverable by run id.
+*/
+const TERMINAL_SENTINEL_STATUSES = new Set([
+	"DONE",
+	"FAILED",
+	"BLOCKED",
+	"TIMEOUT",
+	"KILLED"
+]);
+/**
+* The result word a sentinel status settles on. Both the status surface and the
+* message provider's state fallback answer from this one mapping, so the same
+* sentinel file cannot classify differently between them. BLOCKED reads as
+* failed: it names why the run stopped, not a result of its own.
+*/
+function sentinelStatusToResult(sentinelStatus) {
+	switch (sentinelStatus) {
+		case "DONE": return "done";
+		case "FAILED": return "failed";
+		case "TIMEOUT": return "timeout";
+		case "KILLED": return "killed";
+		case "BLOCKED": return "failed";
+		default: return "running";
+	}
+}
+/**
+* Whether a terminal sentinel leaves a session worth resuming. Mirrors the only
+* hit Go's `runFactsFromStatus` reaches for a registry entry: a non-empty
+* session id. The sentinel word never decides this.
+*/
+function resumableFromSession(sessionId) {
+	return typeof sessionId === "string" && sessionId !== "";
+}
+//#endregion
 //#region src/tools/run-resolution.ts
 /** Resolve a local public run ID before considering a label alias. */
 function findLocalRunByReference(sup, reference) {
@@ -2821,16 +2913,6 @@ async function sentinelExists(filePath) {
 function rawStatusPhase(source) {
 	return stringField(source ?? {}, "phase") || stringField(source ?? {}, "status") || "running";
 }
-function sentinelStatusToResult(sentinelStatus) {
-	switch (sentinelStatus) {
-		case "DONE": return "done";
-		case "FAILED": return "failed";
-		case "TIMEOUT": return "timeout";
-		case "KILLED": return "killed";
-		case "BLOCKED": return "failed";
-		default: return "running";
-	}
-}
 function translateStatus(rawPhase, sentinelData) {
 	const sentinelStatus = sentinelData?._status;
 	const phase = rawPhase.toLowerCase();
@@ -2933,16 +3015,19 @@ function shapeStatusResult(result, view = "full") {
 	};
 }
 async function buildRunStatus(runInfo, liveStatus) {
-	if (liveStatus) retainLiveIdentity(runInfo, liveStatus);
+	const liveSentinel = stringField(liveStatus ?? {}, "sentinel_file");
+	const belongsToRun = !liveSentinel || liveSentinel === runInfo.sentinelPath;
+	if (liveStatus && belongsToRun) retainLiveIdentity(runInfo, liveStatus);
 	let sentinel = null;
 	if (await sentinelExists(runInfo.sentinelPath)) sentinel = await parseSentinel(runInfo.sentinelPath);
-	const translated = translateStatus(rawStatusPhase(liveStatus), sentinel);
-	return buildBaseStatus(liveStatus ?? {}, {
+	const source = belongsToRun ? liveStatus : null;
+	const translated = belongsToRun && liveStatus ? translateStatus(rawStatusPhase(source), sentinel) : sentinel ? sentinelStatusToResult(sentinel._status) : translateStatus(rawStatusPhase(source), null);
+	const result = buildBaseStatus(source ?? {}, {
 		run_id: runInfo.runId,
 		label: runInfo.label,
 		prefer_fallback_run_id: true,
 		runtime_id: runInfo.runtimeId,
-		session_id: sentinel?.SESSION ?? liveStatus?.session_id ?? runInfo.sessionId,
+		session_id: sentinel?.SESSION ?? source?.session_id ?? runInfo.sessionId,
 		stop_reason: sentinel?.STOP_REASON,
 		identity: {
 			roster_file: runInfo.rosterFile,
@@ -2956,6 +3041,10 @@ async function buildRunStatus(runInfo, liveStatus) {
 			effective_backend: runInfo.effectiveBackend
 		}
 	}, translated);
+	result.label = runInfo.label;
+	if (!belongsToRun || !result.event_path) result.event_path = runInfo.eventLogPath;
+	if (!belongsToRun || !liveStatus) result.runtime_output_available = false;
+	return result;
 }
 async function queryLiveStatus(client, runtimeId) {
 	if (!runtimeId) return null;
@@ -3112,27 +3201,41 @@ function matchesFilters(record, args) {
 	if (args.after_seq !== void 0 && seq !== void 0 && seq <= args.after_seq) return false;
 	return true;
 }
-async function readNdjsonEvents(filePath, args) {
+/**
+* Stream the parsed records of one NDJSON event log. Malformed lines are
+* dropped; an unreadable log rejects, so a caller that cannot read the log
+* never sees a silent empty tail.
+*/
+async function* readNdjsonRecords(filePath) {
 	const stream = fs.createReadStream(filePath, { encoding: "utf-8" });
 	const rl = readline.createInterface({
 		input: stream,
 		crlfDelay: Infinity
 	});
-	const events = [];
 	try {
 		for await (const line of rl) {
 			if (!line.trim()) continue;
+			let parsed;
 			try {
-				const record = asRecord(JSON.parse(line));
-				if (!record || !matchesFilters(record, args)) continue;
-				events.push(clipEvent(record));
-				if (events.length > args.limit) events.splice(0, events.length - args.limit);
-			} catch {}
+				parsed = JSON.parse(line);
+			} catch {
+				continue;
+			}
+			const record = asRecord(parsed);
+			if (record) yield record;
 		}
 	} finally {
 		rl.close();
 		stream.close();
 	}
+}
+async function readNdjsonEvents(filePath, args) {
+	const events = [];
+	for await (const record of readNdjsonRecords(filePath)) {
+		if (!matchesFilters(record, args)) continue;
+		events.push(clipEvent(record));
+		if (events.length > args.limit) events.splice(0, events.length - args.limit);
+	}
 	return events;
 }
 async function resolveRun(args, getSupervisorClient) {
@@ -3221,7 +3324,7 @@ async function executeEventsTool(args, getSupervisorClient) {
 		} catch (error) {
 			failures.push(contextualError(`read event log ${resolved.eventLogPath}`, error));
 		}
-		if (resolved.runtimeId) try {
+		if (resolved.runtimeId && !resolved.runInfo) try {
 			const history = await resolved.client.history({
 				runtime_id: resolved.runtimeId,
 				limit,
@@ -3333,23 +3436,31 @@ function sleep(ms, signal) {
 		signal?.addEventListener("abort", onAbort, { once: true });
 	});
 }
-async function fullOutput(runtimeId, supervisorId) {
-	if (supervisorId) {
-		const { client, isSingleton } = await getSupervisorClient(supervisorId);
-		try {
-			const result = await client.result(runtimeId);
-			return typeof result.final_output === "string" ? result.final_output : void 0;
-		} finally {
-			if (!isSingleton) client.close();
-		}
+async function outputFromEvents(filePath) {
+	let output;
+	for await (const record of readNdjsonRecords(filePath)) try {
+		const event = normalizeRunEvent(record);
+		if (event?.event === "session.end" && event.final_output !== void 0) output = event.final_output;
+	} catch {}
+	return output;
+}
+async function realResult(supervisorId, runtimeId) {
+	const { client, isSingleton } = await getSupervisorClient(supervisorId);
+	try {
+		return await client.result(runtimeId);
+	} finally {
+		if (!isSingleton) client.close();
 	}
-	const result = await (await Supervisor.get()).getClient().result(runtimeId);
-	return typeof result.final_output === "string" ? result.final_output : void 0;
+}
+async function realSentinelPath(supervisorId, runId) {
+	const { sup, supervisorId: resolvedId } = await getSupervisorClient(supervisorId);
+	return (sup ? sup.getRunByReference(runId) : void 0)?.sentinelPath ?? findExternalRun(resolvedId, runId)?.sentinelPath;
 }
 const defaultDeps = {
 	status: statusTool,
 	inspect: inspectTool,
-	fullOutput,
+	result: realResult,
+	sentinelPath: realSentinelPath,
 	sleep,
 	now: Date.now,
 	pollIntervalMs: DEFAULT_POLL_INTERVAL_MS
@@ -3388,14 +3499,25 @@ async function executeResultTool(args, deps) {
 		if (TERMINAL_STATUSES$1.has(status.status)) {
 			let exactOutputRetrieved = false;
 			try {
-				const output = await deps.fullOutput?.(status.runtime_id, args.supervisorId);
+				let output = status.event_path ? await outputFromEvents(status.event_path).catch(() => void 0) : void 0;
 				if (output !== void 0) {
 					status.final_output = output;
 					status.final_output_truncated = false;
 					exactOutputRetrieved = true;
 				}
 			} catch {}
-			if (status.final_output === void 0) try {
+			if (!exactOutputRetrieved && status.runtime_output_available !== false && status.runtime_id) try {
+				const result = await deps.result(args.supervisorId, status.runtime_id);
+				const output = typeof result.final_output === "string" ? result.final_output : void 0;
+				const sentinel = await deps.sentinelPath(args.supervisorId, status.run_id);
+				const matchesTurn = sentinel === void 0 ? true : sentinel !== "" && typeof result.sentinel_file === "string" && result.sentinel_file === sentinel;
+				if (output !== void 0 && matchesTurn) {
+					status.final_output = output;
+					status.final_output_truncated = false;
+					exactOutputRetrieved = true;
+				}
+			} catch {}
+			if (!exactOutputRetrieved && status.final_output === void 0 && status.runtime_output_available !== false) try {
 				const inspected = await deps.inspect({
 					runId: args.runId,
 					supervisorId: args.supervisorId
@@ -5223,7 +5345,7 @@ var message_route_conformance_default = {
 			"expect": {
 				"code": "unsupported_action",
 				"facts": {},
-				"message": "action \"control_reply\" is only available on the claude-channel backend"
+				"message": "action \"control_reply\" is retained in the contract but no surface can deliver one"
 			}
 		},
 		{
@@ -5242,7 +5364,7 @@ var message_route_conformance_default = {
 			"expect": {
 				"code": "unsupported_action",
 				"facts": {},
-				"message": "action \"control_reply\" is only available on the claude-channel backend"
+				"message": "action \"control_reply\" is retained in the contract but no surface can deliver one"
 			}
 		},
 		{
@@ -5261,7 +5383,7 @@ var message_route_conformance_default = {
 			"expect": {
 				"code": "unsupported_action",
 				"facts": {},
-				"message": "action \"control_reply\" is only available on the claude-channel backend"
+				"message": "action \"control_reply\" is retained in the contract but no surface can deliver one"
 			}
 		},
 		{
@@ -5280,7 +5402,7 @@ var message_route_conformance_default = {
 			"expect": {
 				"code": "unsupported_action",
 				"facts": {},
-				"message": "action \"control_reply\" is only available on the claude-channel backend"
+				"message": "action \"control_reply\" is retained in the contract but no surface can deliver one"
 			}
 		},
 		{
@@ -5299,7 +5421,7 @@ var message_route_conformance_default = {
 			"expect": {
 				"code": "unsupported_action",
 				"facts": {},
-				"message": "action \"control_reply\" is only available on the claude-channel backend"
+				"message": "action \"control_reply\" is retained in the contract but no surface can deliver one"
 			}
 		},
 		{
@@ -5318,7 +5440,7 @@ var message_route_conformance_default = {
 			"expect": {
 				"code": "unsupported_action",
 				"facts": {},
-				"message": "action \"control_reply\" is only available on the claude-channel backend"
+				"message": "action \"control_reply\" is retained in the contract but no surface can deliver one"
 			}
 		},
 		{
@@ -8274,6 +8396,41 @@ function renderAskFailure(messageId, target, outcome = "possibly-pending") {
 function normalizeAskTimeoutMs(timeoutMs) {
 	return timeoutMs !== void 0 && Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : void 0;
 }
+/** Render a value the way Go's `%q` verb does (`strconv.Quote`). */
+function goQuote(value) {
+	let out = "\"";
+	for (const character of value) out += goEscapedRune(character);
+	return `${out}"`;
+}
+const GO_PRINTABLE = /[\p{L}\p{M}\p{N}\p{P}\p{S}]/u;
+/**
+* One rune in `strconv.Quote` form: short escapes for a quote, a backslash, a
+* bell and the whitespace controls; `\xNN` for the remaining ASCII escapes;
+* `\uNNNN` and `\UNNNNNNNN` for a non-printable rune; the rune itself when it
+* is printable. Printable is Go's `strconv.IsPrint` — ASCII space through `~`,
+* and elsewhere the categories L, M, N, P and S. V8's Unicode tables can be
+* newer than Go's, so a rune assigned since Go's tables were generated renders
+* escaped here where Go writes it verbatim; that direction only fails to match
+* a sentence, never invents one.
+*/
+function goEscapedRune(character) {
+	const code = character.codePointAt(0) ?? 0;
+	switch (character) {
+		case "\"": return "\\\"";
+		case "\\": return "\\\\";
+		case "\x07": return "\\a";
+		case "\b": return "\\b";
+		case "\f": return "\\f";
+		case "\n": return "\\n";
+		case "\r": return "\\r";
+		case "	": return "\\t";
+		case "\v": return "\\v";
+	}
+	if (code < 128 ? code >= 32 && code !== 127 : GO_PRINTABLE.test(character)) return character;
+	if (code < 128) return `\\x${code.toString(16).padStart(2, "0")}`;
+	if (code < 65536) return `\\u${code.toString(16).padStart(4, "0")}`;
+	return `\\U${code.toString(16).padStart(8, "0")}`;
+}
 //#endregion
 //#region ../../schemas/message.input.json
 var message_input_default = {
@@ -8409,11 +8566,11 @@ var message_input_default = {
 			"properties": {
 				"action": {
 					"const": "control_reply",
-					"description": "Answer a claude-channel control request; registered only on the claude-channel backend."
+					"description": "Retained in the contract for the retired claude-channel backend's reply path; no surface can deliver one."
 				},
 				"target": {
 					"type": "string",
-					"description": "Opaque claude-channel control message id, passed through unchanged."
+					"description": "Opaque control message id, passed through unchanged."
 				},
 				"payload": {
 					"type": "object",
@@ -8452,7 +8609,7 @@ var message_route_umpire_default = {
 		},
 		"controlReplySupported": {
 			"type": "boolean",
-			"description": "The surface can deliver a claude-channel control reply (the sidecar only)."
+			"description": "Retained in the contract; no surface can deliver a control reply now that the claude-channel sidecar is retired."
 		}
 	},
 	fields: {
@@ -8509,7 +8666,7 @@ var message_route_umpire_default = {
 					"condition": "controlReplySupported"
 				}]
 			},
-			"reason": "action \"control_reply\" is only available on the claude-channel backend"
+			"reason": "action \"control_reply\" is retained in the contract but no surface can deliver one"
 		},
 		{
 			"type": "fairWhen",
@@ -8953,7 +9110,7 @@ async function tell(provider, input, resolution) {
 	const label = resolutionLabel(resolution, input.target ?? "");
 	let result;
 	try {
-		result = await provider.tell(resolution.runId, input.message ?? "");
+		result = await provider.tell(resolution.runId, input.message ?? "", resolution.publicRunId);
 	} catch (err) {
 		throw asToolError(err);
 	}
@@ -8971,7 +9128,7 @@ async function ask(provider, input, resolution, signal) {
 	const label = resolutionLabel(resolution, input.target ?? "");
 	let result;
 	try {
-		result = await provider.ask(resolution.runId, input.message ?? "", input.timeout_ms, signal);
+		result = await provider.ask(resolution.runId, input.message ?? "", input.timeout_ms, signal, resolution.publicRunId);
 	} catch (err) {
 		throw asToolError(err);
 	}
@@ -9088,9 +9245,10 @@ async function executeMessage(provider, input, options) {
 	conditions.targetMatch = resolution.match;
 	const denial = permissionDenial(action, conditions);
 	if (denial) throw denial;
+	if (action === "resume" && typed.idempotency_key) return resume(provider, typed, resolution);
 	let facts;
 	try {
-		facts = await provider.state(resolution.runId);
+		facts = await provider.state(resolution.runId, resolution.publicRunId);
 	} catch (err) {
 		throw refused(err);
 	}
@@ -9168,7 +9326,7 @@ async function executePeers(provider, input) {
 	const resolution = await resolveTarget(provider, typed.target ?? "");
 	let last;
 	try {
-		last = await provider.last(resolution.runId);
+		last = await provider.last(resolution.runId, resolution.publicRunId);
 	} catch (err) {
 		throw asToolError(err);
 	}
@@ -9302,19 +9460,6 @@ function createMessageTool(provider) {
 	return (args, options) => messageTool(args, provider, options);
 }
 //#endregion
-//#region src/tools/sentinel-status.ts
-/**
-* Sentinel statuses that settle the provider session itself, so the recorded
-* session id is a loadable transcript. TIMEOUT and KILLED are supervisor-imposed
-* terminations (time budget, cancellation) where an automatic continuation would
-* surprise. Matches the Go `readSentinelSession`.
-*/
-const RESUMABLE_SENTINEL_STATUSES = new Set([
-	"DONE",
-	"FAILED",
-	"BLOCKED"
-]);
-//#endregion
 //#region src/tools/message-provider.ts
 const SUPERVISOR_RUN_ID = "supervisor";
 const TERMINAL_STATUSES = new Set([
@@ -9354,6 +9499,16 @@ function isGenerationMismatchError(error) {
 	}
 	return error instanceof Error && /generation mismatch/i.test(error.message);
 }
+/**
+* Matches Go's `statusReportsNoRuntime`: true only for the supervisor's absence
+* answer for this exact runtime, so a refusal or a transport failure stays the
+* caller's error. The sentence is rendered with `goQuote` because the
+* supervisor formats the id with Go's `%q`.
+*/
+function statusReportsNoRuntime(error, runId) {
+	if (!(error instanceof RpcError) || error.code !== -32e3) return false;
+	return rpcText(error) === `runtime ${goQuote(runId)} not found`;
+}
 /** Reject an abort exactly the way fetch does, so the ask cleanup path runs. */
 function raceAbort(promise, signal) {
 	if (!signal) return promise;
@@ -9425,15 +9580,42 @@ function translateRunFacts(rawStatus, rawPhase) {
 		live: !TERMINAL_STATUSES.has(status)
 	};
 }
-async function sentinelResumable(filePath) {
-	if (!filePath) return false;
+/**
+* Classify one broker peer row into the facts the router gates on. The Go
+* providers share this translation through `messaging.PeerRunFacts`: a peer row
+* carries no session and no sentinel, so the run is never resumable from here —
+* the supervisor that spawned it owns a resume.
+*/
+function peerFacts(peer) {
+	const translation = translateRunFacts(peer?.status ?? "", "");
+	return {
+		live: translation.live,
+		resumable: false,
+		status: translation.status
+	};
+}
+/** Read one sentinel file's status word, or undefined when the file is unreadable. */
+async function readSentinelStatus(filePath) {
 	try {
-		const status = ((await fs.promises.readFile(filePath, "utf-8")).trim().split("\n")[0] ?? "").trim().toUpperCase();
-		return RESUMABLE_SENTINEL_STATUSES.has(status);
+		return ((await fs.promises.readFile(filePath, "utf-8")).trim().split("\n")[0] ?? "").trim().toUpperCase();
 	} catch {
-		return false;
+		return;
 	}
 }
+/**
+* Read one sentinel file's terminal result word, or undefined when the file is
+* unreadable or holds a status that is not terminal. The mapping is the status
+* surface's, so both classify a sentinel the same way.
+*/
+async function terminalSentinelStatus(filePath) {
+	const status = await readSentinelStatus(filePath);
+	if (!status || !TERMINAL_SENTINEL_STATUSES.has(status)) return void 0;
+	return sentinelStatusToResult(status);
+}
+async function sentinelResumable(filePath) {
+	const status = await readSentinelStatus(filePath);
+	return status !== void 0 && RESUMABLE_SENTINEL_STATUSES.has(status);
+}
 function peerRecords(peers) {
 	return (peers.peers ?? []).map((peer) => {
 		const session = peer.session;
@@ -9480,13 +9662,20 @@ function installAskClaims(provider, claims, pendingAsks, pollGeneration) {
 /**
 * Build the bound host provider: one supervisor, one generation, one control
 * client. It never reads an ambient singleton or retargets, and it never
-* preflights per call.
+* preflights per call. Listing-backed lookups fail fast: an incomplete
+* listing refuses every resolution and state read, even for a peer the
+* partial set contains, so a wire `peers_error` resolves the same way the Go
+* providers do. Self and public-ID resolution bypass the listing.
 */
 function createHostMessageProvider(options) {
 	const { surface, supervisorId, generation, client, pendingAsks, pollGeneration } = options;
 	const claims = /* @__PURE__ */ new Map();
 	async function listedPeers() {
-		return peerRecords(await client.messagePeers({ generation }));
+		const result = await client.messagePeers({ generation });
+		return {
+			peers: peerRecords(result),
+			detail: result.peers_error || void 0
+		};
 	}
 	async function retractAsk(messageId) {
 		try {
@@ -9496,10 +9685,33 @@ function createHostMessageProvider(options) {
 			});
 		} catch {}
 	}
-	function publicRunIdFor(runId) {
-		const local = Supervisor.getInstance(supervisorId)?.getRunByRuntimeId(runId);
-		if (local?.runId) return local.runId;
-		return listExternalRuns(supervisorId).find((info) => info.runtimeId === runId)?.runId;
+	async function publicRunIdFor(runId) {
+		const instance = Supervisor.getInstance(supervisorId);
+		if (instance && instance.getRunsByRuntimeId(runId).length > 0) {
+			const unique = instance.getRunByRuntimeId(runId);
+			if (unique) return unique.runId;
+			const status = await client.status(runId);
+			const match = typeof status.sentinel_file === "string" ? instance.getRunByRuntimeTurn(runId, status.sentinel_file) : void 0;
+			if (!match) throw new Error(`turn identity unavailable for ${runId}`);
+			return match.runId;
+		}
+		const matches = listExternalRuns(supervisorId).filter((info) => info.runtimeId === runId);
+		if (matches.length <= 1) return matches[0]?.runId;
+		const status = await client.status(runId);
+		const match = matches.find((info) => info.sentinelPath === status.sentinel_file);
+		if (!match) throw new Error(`turn identity unavailable for ${runId}`);
+		return match.runId;
+	}
+	function publicRunInfo(publicRunId) {
+		if (!publicRunId) return void 0;
+		const instance = Supervisor.getInstance(supervisorId);
+		return instance ? instance.getRunById(publicRunId) : findExternalRunById(supervisorId, publicRunId);
+	}
+	function expectedSentinel(publicRunId) {
+		if (!publicRunId) return void 0;
+		const info = publicRunInfo(publicRunId);
+		if (!info?.sentinelPath) throw new Error(`turn identity unavailable for ${publicRunId}`);
+		return info.sentinelPath;
 	}
 	function unique(info) {
 		return {
@@ -9509,6 +9721,18 @@ function createHostMessageProvider(options) {
 			match: "unique"
 		};
 	}
+	async function peerRunState(runId) {
+		let listed;
+		try {
+			listed = await listedPeers();
+		} catch (error) {
+			if (isGenerationMismatchError(error)) throw error;
+			return;
+		}
+		if (listed.detail) return void 0;
+		const peer = listed.peers.find((entry) => entry.run_id === runId);
+		return peer ? peerFacts(peer) : void 0;
+	}
 	const provider = {
 		caller: () => ({
 			kind: "owner",
@@ -9533,18 +9757,19 @@ function createHostMessageProvider(options) {
 				const external = findExternalRunById(supervisorId, ref);
 				if (external?.runtimeId) return unique(external);
 			}
-			const peers = await listedPeers();
+			const { peers, detail } = await listedPeers();
+			if (detail) throw new Error(`the peer listing is incomplete: ${detail}`);
 			const exact = peers.find((peer) => peer.run_id === ref);
 			if (exact) return {
 				runId: exact.run_id,
-				publicRunId: publicRunIdFor(exact.run_id),
+				publicRunId: await publicRunIdFor(exact.run_id),
 				label: firstNonEmpty(exact.label, exact.run_id),
 				match: "unique"
 			};
 			const candidates = peers.filter((peer) => peer.label === ref).map((peer) => peer.run_id);
 			if (candidates.length === 1) return {
 				runId: candidates[0],
-				publicRunId: publicRunIdFor(candidates[0]),
+				publicRunId: await publicRunIdFor(candidates[0]),
 				label: ref,
 				match: "unique"
 			};
@@ -9558,18 +9783,38 @@ function createHostMessageProvider(options) {
 				match: "none"
 			};
 		},
-		async state(runId) {
+		async state(runId, publicRunId) {
 			if (runId === "supervisor") {
-				const translation = translateRunFacts((await listedPeers()).find((entry) => entry.run_id === "supervisor")?.status ?? "", "");
-				return {
-					live: translation.live,
-					resumable: false,
-					status: translation.status
-				};
+				const { peers, detail } = await listedPeers();
+				if (detail) throw new Error(`the peer listing is incomplete: ${detail}`);
+				return peerFacts(peers.find((entry) => entry.run_id === SUPERVISOR_RUN_ID));
 			}
-			const status = await client.status(runId);
+			let status;
+			try {
+				status = await client.status(runId);
+			} catch (error) {
+				if (!statusReportsNoRuntime(error, runId)) throw error;
+				const registered = Supervisor.getInstance(supervisorId)?.getRunById(runId) ?? findExternalRunById(supervisorId, runId);
+				if (registered) {
+					const terminal = await terminalSentinelStatus(registered.sentinelPath);
+					if (terminal) return {
+						live: false,
+						resumable: resumableFromSession(registered.sessionId),
+						status: terminal
+					};
+				}
+				const listed = await peerRunState(runId);
+				if (listed) return listed;
+				throw error;
+			}
+			const info = publicRunInfo(publicRunId);
+			if (info && typeof status.sentinel_file === "string" && status.sentinel_file !== info.sentinelPath) return {
+				live: false,
+				resumable: false,
+				status: await terminalSentinelStatus(info.sentinelPath) ?? "unknown"
+			};
 			const translation = translateRunFacts(typeof status.status === "string" ? status.status : "", typeof status.phase === "string" ? status.phase : "");
-			let resumable = typeof status.session_id === "string" && status.session_id !== "";
+			let resumable = resumableFromSession(status.session_id);
 			if (!resumable && typeof status.sentinel_file === "string") resumable = await sentinelResumable(status.sentinel_file);
 			return {
 				live: translation.live,
@@ -9577,7 +9822,8 @@ function createHostMessageProvider(options) {
 				status: translation.status
 			};
 		},
-		async tell(targetRunId, message) {
+		async tell(targetRunId, message, publicRunId) {
+			const expected = expectedSentinel(publicRunId);
 			const messageId = newMsgID();
 			const body = JSON.stringify({
 				from: SUPERVISOR_RUN_ID,
@@ -9593,7 +9839,8 @@ function createHostMessageProvider(options) {
 					message_id: messageId,
 					generation,
 					body,
-					no_reply: true
+					no_reply: true,
+					...expected ? { expected_sentinel_file: expected } : {}
 				});
 			} catch (error) {
 				const outcome = controlOutcome(error);
@@ -9608,7 +9855,8 @@ function createHostMessageProvider(options) {
 				messageId: firstNonEmpty(result.message_id, messageId)
 			};
 		},
-		async ask(targetRunId, message, timeoutMs, signal) {
+		async ask(targetRunId, message, timeoutMs, signal, publicRunId) {
+			const expected = expectedSentinel(publicRunId);
 			const messageId = newMsgID();
 			const body = JSON.stringify({
 				id: messageId,
@@ -9625,7 +9873,8 @@ function createHostMessageProvider(options) {
 					to_run_id: targetRunId,
 					message_id: messageId,
 					generation,
-					body
+					body,
+					...expected ? { expected_sentinel_file: expected } : {}
 				});
 			} catch (error) {
 				const outcome = controlOutcome(error);
@@ -9754,10 +10003,20 @@ function createHostMessageProvider(options) {
 				previousLabel: renamed.previous_label
 			};
 		},
-		async last(runId) {
+		async last(runId, publicRunId) {
+			const expected = expectedSentinel(publicRunId);
+			if (expected) {
+				let status;
+				try {
+					status = await client.status(runId);
+				} catch (error) {
+					throw authorityError(error);
+				}
+				if (typeof status.sentinel_file === "string" && status.sentinel_file !== expected) throw authorityError(new RpcError(-32e3, `turn no longer current for runtime ${runId}`, { code: "invalid-request" }));
+			}
 			let last;
 			try {
-				last = await client.sessionLast(runId);
+				last = await client.sessionLast(runId, expected);
 			} catch (error) {
 				throw authorityError(error);
 			}
@@ -9771,7 +10030,11 @@ function createHostMessageProvider(options) {
 			};
 		},
 		async peers() {
-			return { peers: await listedPeers() };
+			const { peers, detail } = await listedPeers();
+			return {
+				peers,
+				detail
+			};
 		},
 		async recordLastTurn(text, stopReason, truncated) {
 			await client.sessionLastSet(SUPERVISOR_RUN_ID, text, stopReason, truncated);
@@ -9842,13 +10105,20 @@ function renderReply(reply) {
 /**
 * Build a child provider over the surface's inherited broker. A child never
 * learns a public run id, and it cannot read a sentinel, so it is never
-* resumable from here: the supervisor owns a resume.
+* resumable from here: the supervisor owns a resume. Listing-backed lookups
+* fail fast: an incomplete listing refuses every resolution and state read,
+* even for a peer the partial set contains, so a wire `peers_error` resolves
+* the same way the Go providers do. Self resolution bypasses the listing.
 */
 function createChildMessageProvider(options) {
 	const { surface, runId, broker, pendingAsks, pollGeneration } = options;
 	const claims = /* @__PURE__ */ new Map();
 	async function listedPeers() {
-		return (await broker.peers()).peers;
+		const result = await broker.peers();
+		return {
+			peers: result.peers,
+			detail: result.detail
+		};
 	}
 	const provider = {
 		caller: () => ({
@@ -9867,7 +10137,8 @@ function createChildMessageProvider(options) {
 				label: ref,
 				match: "unique"
 			};
-			const peers = await listedPeers();
+			const { peers, detail } = await listedPeers();
+			if (detail) throw new Error(`the peer listing is incomplete: ${detail}`);
 			const exact = peers.find((peer) => peer.run_id === ref);
 			if (exact) return {
 				runId: exact.run_id,
@@ -9891,14 +10162,11 @@ function createChildMessageProvider(options) {
 			};
 		},
 		async state(targetRunId) {
-			const peer = (await listedPeers()).find((entry) => entry.run_id === targetRunId);
+			const { peers, detail } = await listedPeers();
+			if (detail) throw new Error(`the peer listing is incomplete: ${detail}`);
+			const peer = peers.find((entry) => entry.run_id === targetRunId);
 			if (!peer) throw new Error(`run ${targetRunId} is not visible`);
-			const translation = translateRunFacts(peer.status ?? "", "");
-			return {
-				live: translation.live,
-				resumable: false,
-				status: translation.status
-			};
+			return peerFacts(peer);
 		},
 		tell: (targetRunId, message) => broker.tell(targetRunId, message, newMsgID()),
 		ask: (targetRunId, message, timeoutMs, signal) => broker.ask(targetRunId, message, newMsgID(), timeoutMs, signal),
@@ -9920,7 +10188,11 @@ function createChildMessageProvider(options) {
 }
 //#endregion
 //#region src/tools/peers.ts
-/** The one avenor_peers handler; it resolves and reads through the bound provider. */
+/** The one avenor_peers handler; it resolves and reads through the bound provider.
+*
+* Admission belongs to the shared router for every surface, so the argument is
+* the untyped JSON a tool call carries and `executePeers` validates it first —
+* the same shape `messageTool` takes. */
 async function peersTool(args, provider) {
 	return executePeers(provider, args);
 }

package/dist/postinstall.d.ts

@@ -4,6 +4,6 @@ import { n as getVersion, r as installerBinaryPath, t as getInstallDir } from ".
 declare function platformMapping(platform: string, arch: string): string | null;
 declare function verifyChecksum(buffer: Buffer, expectedHash: string): boolean;
 declare function parseChecksums(content: string, assetName: string): string | null;
-declare function postinstall(fetchFn?: typeof globalThis.fetch, platform?: string, arch?: string): Promise<void>;
+declare function postinstall(fetchFn?: (url: string) => Promise<Response>, platform?: string, arch?: string): Promise<void>;
 //#endregion
 export { getInstallDir, getVersion, installerBinaryPath, parseChecksums, platformMapping, postinstall, verifyChecksum };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dougbots/avenor-core",
-  "version": "0.16.1",
+  "version": "0.18.0",
   "type": "module",
   "repository": {
     "type": "git",
@@ -23,6 +23,7 @@
   },
   "scripts": {
     "build": "tsdown",
+    "typecheck": "tsc --noEmit",
     "test": "bun test",
     "test:e2e": "AVENOR_REAL_INTEGRATION=1 bun test",
     "dev": "tsdown --watch",