pi-crew 0.11.55 → 0.11.57

package/src/extension/team-tool/respond.ts

@@ -8,12 +8,13 @@ import { withRunLockSync } from "../../state/coordination/locks.ts";
 import { appendMailboxMessage, readMailbox, updateMailboxMessageReply } from "../../state/coordination/mailbox.ts";
 import { appendEventAsync } from "../../state/event-log/event-log.ts";
 import { loadRunManifestById, saveRunManifest, saveRunTasks, updateRunStatus } from "../../state/stores/state-store.ts";
-import type { TeamTaskState } from "../../state/types.ts";
+import type { TeamRunManifest, TeamTaskState } from "../../state/types.ts";
 import { logInternalError } from "../../utils/internal-error.ts";
 import { locateRunCwd } from "../team-tool.ts";
 import type { PiTeamsToolResult } from "../tool-result.ts";
 import { result, type TeamContext } from "./context.ts";
 import { paramRequired } from "./param-error.ts";
+import { deliverResponseRow, type RespondDeliveryRow } from "./respond-delivery.ts";
 import { RUN_NOT_FOUND_HINT } from "./run-not-found.ts";
 
 /** WP-2/R2 (ADR-0 item 8/security P1-4): fence the injected ask answer as
@@ -47,6 +48,27 @@ function requeueWaitingTask(tasks: TeamTaskState[], taskId: string, message: str
 	});
 }
 
+/** Lock-section product for handleRespond: either an early error result, or
+ *  the full post-lock context. HƯỚNG A (2026-11-01): ALIVE-park response rows
+ *  are STAGED inside the run lock (atomically with the exactly-one-dispatch
+ *  scan) but DELIVERED after it releases — deliverResponseRow's broker RPC
+ *  window must never sit under withRunLockSync (the broker handler takes its
+ *  own run lock via withRunLockBusyRetry; an in-lock RPC window would
+ *  livelock cross-process). */
+type LockedRespondOutcome =
+	| { ok: false; early: PiTeamsToolResult }
+	| {
+			ok: true;
+			manifest: TeamRunManifest;
+			targetTaskIds: string[];
+			answeredIds: string[];
+			requeuedIds: string[];
+			noopIds: string[];
+			mailboxIds: string[];
+			pendingDeliveries: RespondDeliveryRow[];
+			message: string;
+	  };
+
 /**
  * Handle `respond` action: answer a waiting (parked) task's question.
  *
@@ -54,25 +76,33 @@ function requeueWaitingTask(tasks: TeamTaskState[], taskId: string, message: str
  * liveness discrimination replaces the old blanket re-queue of ALL waiting
  * tasks.
  * - ALIVE (heartbeat last-beat within the 60s gradient-stale window, or a
- *   live in-memory session handle) → append a mailbox `kind:"response"`
+ *   live in-memory session handle) → stage a mailbox `kind:"response"`
  *   entry carrying the task's `waiting.questionId` (from leader, to the task)
  *   and LEAVE `task.waiting` in place: the parked `ask` tool polls the task
  *   mailbox stream, picks the response up and flips waiting→running via its
- *   own terminal report.
+ *   own terminal report. HƯỚNG A: the staged row is delivered AFTER the run
+ *   lock releases via deliverResponseRow (broker-first CR path → a
+ *   BROKER-SIGNED row that verifies in the worker even when this responder
+ *   is not the dispatch process; local signed append fallback = hướng C).
  * - DEAD → re-queue the task AND inject the fenced answer into the next
  *   dispatch prompt (pendingSteers cross-attempt channel). No questionId-
  *   tagged mailbox response is written.
  * - EXACTLY-ONE-DISPATCH GUARD: a response for a given questionId dispatches
  *   via mailbox-write OR requeue+inject — never both — and is idempotent per
- *   questionId. The branch is atomic under the run lock (check + write inside
- *   one withRunLockSync + fresh-reload critical section); the requeue path
- *   clears `waiting` so a second respond finds no waiting task (no-op).
+ *   questionId. The branch decision is atomic under the run lock (check +
+ *   staging inside one withRunLockSync + fresh-reload critical section); the
+ *   requeue path clears `waiting` so a second respond finds no waiting task
+ *   (no-op), and the out-of-lock row write is exactly-once via the durable
+ *   requestId = questionId idempotency key (broker append AND local fallback
+ *   both dedupe on it — a concurrent second respond that missed the in-lock
+ *   scan reuses the first row instead of duplicating it).
  * - Legacy waiting parks without `task.waiting` (pre-v2 records) keep the old
  *   mailbox + re-queue resume behavior — there is no parked tool to pick a
- *   questionId-tagged response up.
+ *   questionId-tagged response up (no questionId → no broker contract row;
+ *   the legacy append stays inline/local, verbatim).
  * - `ask.answered` is emitted on both discrimination paths.
  */
-export function handleRespond(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
+export async function handleRespond(params: TeamToolParamsValue, ctx: TeamContext): Promise<PiTeamsToolResult> {
 	if (!params.runId)
 		return result(
 			paramRequired("respond", "runId", "{ action: 'respond', runId: 'team_...', message: '...' }"),
@@ -95,20 +125,27 @@ export function handleRespond(params: TeamToolParamsValue, ctx: TeamContext): Pi
 	const loaded = loadRunManifestById(runCwd, params.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
 	if (!loaded) return result(`Run '${params.runId}' not found.${RUN_NOT_FOUND_HINT}`, { action: "respond", status: "error" }, true);
 
-	return withRunLockSync(loaded.manifest, () => {
+	const locked = withRunLockSync(loaded.manifest, (): LockedRespondOutcome => {
 		const fresh = loadRunManifestById(loaded.manifest.cwd, params.runId!); // NOTE: inside withRunLockSync - consistent read
-		if (!fresh) return result(`Run '${params.runId}' not found.${RUN_NOT_FOUND_HINT}`, { action: "respond", status: "error" }, true);
+		if (!fresh)
+			return {
+				ok: false,
+				early: result(`Run '${params.runId}' not found.${RUN_NOT_FOUND_HINT}`, { action: "respond", status: "error" }, true),
+			};
 		const foreignRun = typeof fresh.manifest.ownerSessionId === "string" && fresh.manifest.ownerSessionId !== ctx.sessionId;
 		if (foreignRun && !params.force)
-			return result(
-				`Run ${fresh.manifest.runId} belongs to another session. Use force: true to override.`,
-				{
-					action: "respond",
-					status: "error",
-					runId: fresh.manifest.runId,
-				},
-				true,
-			);
+			return {
+				ok: false,
+				early: result(
+					`Run ${fresh.manifest.runId} belongs to another session. Use force: true to override.`,
+					{
+						action: "respond",
+						status: "error",
+						runId: fresh.manifest.runId,
+					},
+					true,
+				),
+			};
 
 		const taskId = params.taskId;
 		const message = params.message ?? "";
@@ -184,19 +221,22 @@ export function handleRespond(params: TeamToolParamsValue, ctx: TeamContext): Pi
 			const existing = taskId ? fresh.tasks.find((t) => t.id === taskId) : undefined;
 			const hint =
 				" Use api operation=follow-up-agent for continuation prompts or api operation=steer-agent to interrupt active work.";
-			return result(
-				(taskId
-					? existing
-						? `Task '${taskId}' is ${existing.status}, not waiting.`
-						: `Task '${taskId}' not found.`
-					: `No waiting tasks in run ${fresh.manifest.runId}.`) + hint,
-				{
-					action: "respond",
-					status: "error",
-					runId: fresh.manifest.runId,
-				},
-				true,
-			);
+			return {
+				ok: false,
+				early: result(
+					(taskId
+						? existing
+							? `Task '${taskId}' is ${existing.status}, not waiting.`
+							: `Task '${taskId}' not found.`
+						: `No waiting tasks in run ${fresh.manifest.runId}.`) + hint,
+					{
+						action: "respond",
+						status: "error",
+						runId: fresh.manifest.runId,
+					},
+					true,
+				),
+			};
 		}
 
 		const mailboxIds: string[] = [];
@@ -206,6 +246,12 @@ export function handleRespond(params: TeamToolParamsValue, ctx: TeamContext): Pi
 		const requeuedIds: string[] = [];
 		/** Exactly-once no-ops: a mailbox response already exists for the questionId. */
 		const noopIds: string[] = [];
+		/** HƯỚNG A (2026-11-01): ALIVE-park response rows staged IN-LOCK (atomic
+		 *  with the exactly-one-dispatch scan above) for post-lock delivery via
+		 *  deliverResponseRow — broker-first CR path / local signed fallback. The
+		 *  durable requestId = questionId key keeps the out-of-lock write
+		 *  exactly-once. */
+		const pendingDeliveries: RespondDeliveryRow[] = [];
 		const answeredEvents: Array<{ taskId: string; questionId: string; delivery: "mailbox" | "requeue" }> = [];
 		/** G5 (deep-review 2026-10-01): DEAD parks — the questionId-tagged response
 		 *  can never be picked up (the parked poller is gone); recorded with the
@@ -256,7 +302,16 @@ export function handleRespond(params: TeamToolParamsValue, ctx: TeamContext): Pi
 				// ALIVE: deliver via the task mailbox stream the parked ask tool
 				// polls (≤500ms). The park stays — the tool's terminal report
 				// flips waiting→running; root-side status must NOT change here.
-				const mailbox = appendMailboxMessage(fresh.manifest, {
+				// HƯỚNG A (2026-11-01): the row is no longer appended inline. It is
+				// staged here — inside the run lock, atomically with the
+				// exactly-one-dispatch scan — and delivered AFTER the lock releases
+				// via deliverResponseRow (broker-first CR path → a BROKER-SIGNED row
+				// that verifies in the worker even when this responder is not the
+				// dispatch process; local signed append fallback = hướng C behavior).
+				// Holding withRunLockSync across the RPC window would livelock
+				// against the broker handler's own run lock (withRunLockBusyRetry);
+				// exactly-once moves to the durable requestId = questionId key.
+				pendingDeliveries.push({
 					direction: "inbox",
 					from: "leader",
 					to: task.id,
@@ -266,12 +321,12 @@ export function handleRespond(params: TeamToolParamsValue, ctx: TeamContext): Pi
 					priority: "normal",
 					deliveryMode: "next_turn",
 					questionId,
+					requestId: questionId,
 					data: { action: "respond", kind: "response", questionId },
 					replyTo: params.replyTo,
 					replyFrom: params.replyFrom,
 					replyDeadline: params.replyDeadline,
 				});
-				mailboxIds.push(mailbox.id);
 				answeredIds.push(task.id);
 				answeredEvents.push({ taskId: task.id, questionId, delivery: "mailbox" });
 				continue;
@@ -410,21 +465,51 @@ export function handleRespond(params: TeamToolParamsValue, ctx: TeamContext): Pi
 			}
 		}
 
-		const summaryParts: string[] = [];
-		if (answeredIds.length > 0) summaryParts.push(`answered via mailbox (worker alive): ${answeredIds.join(", ")}`);
-		if (requeuedIds.length > 0) summaryParts.push(`requeued with injected answer (worker dead): ${requeuedIds.join(", ")}`);
-		if (noopIds.length > 0) summaryParts.push(`already answered, no-op: ${noopIds.join(", ")}`);
-		return result(
-			`Responded to ${targetTasks.length} waiting task(s). ${summaryParts.join("; ")}. Message: ${message || "(no message)"}`,
-			{
-				action: "respond",
-				status: "ok",
-				runId: fresh.manifest.runId,
-				resumedIds: requeuedIds,
-				mailboxIds,
-				intent: `responding to ${targetTasks.map((t) => t.id).join(", ")} in ${fresh.manifest.runId}`,
-				data: { answeredIds, noopIds },
-			},
-		);
+		// HƯỚNG A (2026-11-01): ALIVE rows are staged, not appended — the lock
+		// section returns the context and delivery happens after the release
+		// (see deliverResponseRow). task.resumed events above snapshot
+		// `mailboxIds` at fire time (in-lock), so their data lists the legacy
+		// inline ids only — informational field, the ALIVE ids land in the tool
+		// result below.
+		return {
+			ok: true,
+			manifest,
+			targetTaskIds: targetTasks.map((t) => t.id),
+			answeredIds,
+			requeuedIds,
+			noopIds,
+			mailboxIds,
+			pendingDeliveries,
+			message,
+		};
 	});
+	if (!locked.ok) return locked.early;
+	// Deliver the staged ALIVE rows OUTSIDE the run lock — broker-first CR
+	// path (broker-SIGNED row, verifies in the worker regardless of who the
+	// responder process is) with the local signed idempotent append as
+	// fallback (hướng C). deliverResponseRow never throws on broker failure;
+	// a local append failure propagates exactly like the pre-hướng-A inline
+	// append did.
+	for (const row of locked.pendingDeliveries) {
+		const delivered = await deliverResponseRow(locked.manifest, row);
+		locked.mailboxIds.push(delivered.messageId);
+	}
+	const summaryParts: string[] = [];
+	if (locked.answeredIds.length > 0) summaryParts.push(`answered via mailbox (worker alive): ${locked.answeredIds.join(", ")}`);
+	if (locked.requeuedIds.length > 0) summaryParts.push(`requeued with injected answer (worker dead): ${locked.requeuedIds.join(", ")}`);
+	if (locked.noopIds.length > 0) summaryParts.push(`already answered, no-op: ${locked.noopIds.join(", ")}`);
+	return result(
+		`Responded to ${locked.targetTaskIds.length} waiting task(s). ${summaryParts.join("; ")}. Message: ${
+			locked.message || "(no message)"
+		}`,
+		{
+			action: "respond",
+			status: "ok",
+			runId: locked.manifest.runId,
+			resumedIds: locked.requeuedIds,
+			mailboxIds: locked.mailboxIds,
+			intent: `responding to ${locked.targetTaskIds.join(", ")} in ${locked.manifest.runId}`,
+			data: { answeredIds: locked.answeredIds, noopIds: locked.noopIds },
+		},
+	);
 }

package/src/extension/team-tool.ts

@@ -11,7 +11,7 @@ import type { executeTeamRun as _executeTeamRunFn } from "../runtime/team-runner
 import type { TeamToolParamsValue } from "../schema/team-tool-schema.ts";
 import { TEAM_TERMINAL_TASK_STATUSES } from "../state/contracts.ts";
 import { withRunLock } from "../state/coordination/locks.ts";
-import { replayPendingMailboxMessages, signSteeringEntry } from "../state/coordination/mailbox.ts";
+import { getMailboxVerifyKeyPublic, replayPendingMailboxMessages, signSteeringEntry } from "../state/coordination/mailbox.ts";
 import { isTaskClaimExpired } from "../state/coordination/task-claims.ts";
 import { appendEventAsync, appendEventFireAndForget } from "../state/event-log/event-log.ts";
 import { ACTIVE_RUN_STALE_MS, activeRunEntries, registerActiveRun, unregisterActiveRun } from "../state/stores/active-run-registry.ts";
@@ -1069,6 +1069,27 @@ function clampSteerBody(message: string): string {
 	return `${message.slice(0, TEAM_STEER_MAX_MESSAGE_LENGTH - TEAM_STEER_TRUNCATION_MARKER.length)}${TEAM_STEER_TRUNCATION_MARKER}`;
 }
 
+/** HƯỚNG A follow-up (probe19): token-less steer.force client — single
+ *  NDJSON frame to the run's broker (stamped socket preferred, derivation
+ *  fallback). The broker (detached runner host) performs the trusted write
+ *  pair. Mirrors respond-delivery's force tier; LAZY imports keep the
+ *  extension registration cold-start free of the broker-client graph. */
+async function attemptSteerForceViaBroker(manifest: TeamRunManifest, taskId: string, message: string): Promise<void> {
+	const { brokerRoundTrip } = await import("./team-tool/respond-delivery.ts"); // LAZY: broker-client graph out of extension registration cold-start
+	const { getBrokerSocketPath } = await import("../utils/socket-path.ts"); // LAZY: same — keep cold-start lean
+	const stamped = manifest.brokerSocketPath;
+	const socketPath = typeof stamped === "string" && stamped.length > 0 ? stamped : getBrokerSocketPath(manifest.sessionId ?? "");
+	let sent = false;
+	await brokerRoundTrip(socketPath, () => {
+		if (sent) return undefined; // force ack received — exchange done
+		sent = true;
+		return {
+			method: "steer.force",
+			params: { runId: manifest.runId, taskId, body: message },
+		};
+	});
+}
+
 export function handleSteer(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
 	const { runId, taskId } = params;
 	const rawMessage = params.message;
@@ -1125,6 +1146,25 @@ export function handleSteer(params: TeamToolParamsValue, ctx: TeamContext): PiTe
 	} catch {
 		// Best-effort: file write failure doesn't block the steer from pending array
 	}
+	// HƯỚNG A follow-up (probe19, 2026-11-01): a RESTARTED/foreign session's
+	// steering-file row is signed with a key the live worker does NOT hold
+	// (its verify set = dispatcher + spawner) — pollSteering drops it, so the
+	// fs row is dead for this incarnation and pendingSteers only delivers at
+	// the NEXT spawn. When we are not the trusted signer, ALSO route the
+	// message through the run's broker via token-less steer.force: the
+	// broker-host (detached runner) signs with a key every worker trusts and
+	// appends mailbox row + steering line itself. Fire-and-forget (handleSteer
+	// is sync); the steer.broker_force audit event is the success trace.
+	if (loaded.manifest.dispatcherVerifyKey !== getMailboxVerifyKeyPublic()) {
+		void attemptSteerForceViaBroker(loaded.manifest, taskId, message).catch((error) =>
+			logInternalError(
+				"steer.force-delivery-fallback",
+				error instanceof Error ? error : new Error(String(error)),
+				`runId=${runId} taskId=${taskId}`,
+				"warn",
+			),
+		);
+	}
 	// H1 (2026-08-10): handleSteer is a SYNC function — fire-and-forget async.
 	void appendEventAsync(loaded.manifest.eventsPath, {
 		type: "task.steer_queued",

package/src/runtime/async-runner.ts

@@ -5,6 +5,7 @@ import * as path from "node:path";
 import { pathToFileURL } from "node:url";
 import { backgroundRunnerEnvAllowlist } from "../config/env-allowlist-registry.ts";
 import { getCrewEnv } from "../config/env-vars.ts";
+import { ensureCoordinationPublicVerifyKey } from "../state/coordination/mailbox.ts";
 import { appendEventAsync } from "../state/event-log/event-log.ts";
 import type { TeamRunManifest } from "../state/types.ts";
 import { sanitizeEnvSecrets } from "../utils/env-filter.ts";
@@ -416,7 +417,15 @@ export async function spawnBackgroundTeamRun(manifest: TeamRunManifest): Promise
 				}
 			}
 			if (socketPath && Object.keys(tasks).length > 0) {
-				line = buildBrokerStdinLine(manifest.runId, socketPath, tasks);
+				// HƯỚNG A (ADR Option 3): thread THIS (spawning/dispatcher) process's
+				// PUBLIC coordination verify key over the start-options pipe so a
+				// broker constructed inside the runner binds the DISPATCHER's key for
+				// respond.append challenge-response auth. Derived in THIS heap at
+				// spawn time — deliberately NOT read from manifest.dispatcherVerifyKey
+				// (the manifest file is unauthenticated/worker-writable: a w1a NO-GO
+				// for auth bindings). The spawner IS the effective dispatcher (it will
+				// author future respond rows for this run). PUBLIC material only.
+				line = buildBrokerStdinLine(manifest.runId, socketPath, tasks, ensureCoordinationPublicVerifyKey());
 				child.stdin?.write(line);
 			} else {
 				child.stdin?.write("\n");

package/src/runtime/background-runner.ts

@@ -45,6 +45,8 @@ import { writeAsyncStartMarker } from "./async-marker.ts";
 // F4: broker creds handshake helpers live in broker/stdin-handshake.ts
 // (pure module — background-runner runs await main() at module scope, so
 // importing THIS file from tests would boot the runner).
+import { setActiveDispatcherVerifyKey } from "./broker/dispatcher-key-registry.ts";
+import type { RunnerHostedBrokerHandle } from "./broker/runner-broker.ts";
 import { parseStdinBrokerPayload, readStdinFirstLine } from "./broker/stdin-handshake.ts";
 import { terminateActiveChildPiProcesses } from "./child-pi/child-pi.ts";
 import { directTeamAndWorkflowFromRun } from "./direct-run.ts";
@@ -321,7 +323,7 @@ function setupUnhandledRejectionGuard(
  * and error handlers. This ensures consistent cleanup regardless of how
  * the process exits (normal flow, unhandled rejection, or main() exception).
  */
-function runCleanup(
+async function runCleanup(
 	stopInterruptGuard: () => void,
 	stopParentGuard: () => void,
 	stopHeartbeat: () => void,
@@ -329,7 +331,7 @@ function runCleanup(
 	watchdogTimer: NodeJS.Timeout,
 	exitDueToRejection: boolean,
 	eventsPath?: string,
-): void {
+): Promise<void> {
 	console.log(`[background-runner] runCleanup, exitDueToRejection=${exitDueToRejection}`);
 	stopInterruptGuard();
 	stopParentGuard();
@@ -350,6 +352,19 @@ function runCleanup(
 		console.log(`[background-runner] runCleanup: terminateActiveChildPiProcesses error: ${errorMessage(error)}`);
 	}
 	console.log(`[background-runner] runCleanup: killed ${killed} child processes`);
+	// FINDING D: stop the runner-hosted broker AFTER the children (they may
+	// still flush final frames) — ownership-gated unlink of its socket. Never
+	// re-throws: cleanup must keep going.
+	if (activeRunnerBroker) {
+		const brokerToStop = activeRunnerBroker;
+		activeRunnerBroker = undefined;
+		try {
+			await brokerToStop.stop();
+			console.log("[background-runner] runCleanup: runner-hosted broker stopped");
+		} catch (error) {
+			console.log(`[background-runner] runCleanup: broker stop error: ${errorMessage(error)}`);
+		}
+	}
 	// FIX Issue #5: Unregister this worker from the orphan registry on exit.
 	// Previously this was only cleaned up on the next session_start cleanup cycle,
 	// causing unnecessary delay in removing stale registrations.
@@ -381,6 +396,9 @@ function runCleanup(
 // Module-level flag: set by unhandled rejection guard and main() catch.
 // Used by the module-level catch to signal that finally should call process.exit(1).
 let exitDueToRejection = false;
+/** FINDING D: the runner-hosted broker for THIS run (undefined = legacy
+ *  dispatcher-socket path / hosting failed). Stopped in runCleanup(). */
+let activeRunnerBroker: RunnerHostedBrokerHandle | undefined;
 
 export interface ExecuteBackgroundRunOptions {
 	/**
@@ -810,20 +828,78 @@ async function main(): Promise<void> {
 			const { setActiveBrokerIssuer } = await import("./broker/broker-issuer.ts");
 			// LAZY: pi-args pulls the model registry chain.
 			const { resolveCrewMaxDepth } = await import("./model/pi-args.ts");
-			// Static issuer scoped to THIS run, serving PRE-MINTED per-task COMPOUND
-			// tokens — wait.* rejects bare-runId tokens (ADR-0 item 6), so the v1
-			// single-token shortcut left every park forbidden. Unknown taskIds
-			// (dynamic workflows planned in-runner) get NO creds — follow-up:
-			// broker-side mint RPC. Depth-cap parity with the parent-side
-			// issueForChild gate (lifecycle-handlers.ts:1130-1136).
-			setActiveBrokerIssuer(async (rid, taskId, childDepth) => {
-				if (rid !== payload.runId) return undefined;
-				if (childDepth !== undefined && childDepth >= resolveCrewMaxDepth(undefined)) return undefined;
-				if (!taskId) return undefined;
-				const token = payload.tasks[taskId];
-				if (!token) return undefined;
-				return { socketPath: payload.socketPath, token };
-			});
+			// HƯỚNG A (ADR Option 3): bind the dispatcher's PUBLIC verify key from
+			// the same start-options payload (heap → pipe → heap). A broker
+			// constructed in THIS process (lifecycle-handlers.ts construct site)
+			// then binds the DISPATCHER's key for respond.append CR auth instead
+			// of this runner's own keypair. Absent (older spawner) = no binding —
+			// the construct site falls back to its own key (sync-path semantics).
+			// The registry is a pure module (static import, stdin-handshake
+			// discipline — no lazy boundary needed).
+			if (payload.dispatcherVerifyKey !== undefined) {
+				setActiveDispatcherVerifyKey(payload.dispatcherVerifyKey);
+				debugLog(`[broker] dispatcher verify key bound from start options (run ${runId})`);
+			}
+			// FINDING D (2026-11-01, probes 8/9): payload.socketPath is the
+			// DISPATCHER's broker — a `pi -p` dispatcher exits seconds after
+			// async dispatch and session_shutdown unlinks that socket while the
+			// run lives on (every later worker broker op hit ENOENT). Host the
+			// run's broker HERE instead: the runner outlives the whole run, mints
+			// its own per-task tokens, and stamps ITS socket on the manifest so
+			// cross-process responders (respond-delivery RPC / respond.force)
+			// reach a listener that exists for the run's full lifetime. Soft-fail:
+			// when hosting fails (disabled / bind error), keep the legacy payload
+			// issuer + dispatcher socket below — exact pre-Finding-D behavior,
+			// correct while the dispatcher still lives.
+			let hostedBroker: RunnerHostedBrokerHandle | undefined;
+			try {
+				const { startRunnerHostedBroker } = await import("./broker/runner-broker.ts"); // LAZY: broker module has process-level side effects at load
+				hostedBroker = await startRunnerHostedBroker({
+					runId,
+					cwd,
+					dispatcherVerifyKey: payload.dispatcherVerifyKey,
+					resolveMaxDepth: () => resolveCrewMaxDepth(undefined),
+				});
+			} catch (error) {
+				logInternalError("background-runner.runner-broker-boot", error, `runId=${runId}`, "warn");
+			}
+			if (hostedBroker) {
+				activeRunnerBroker = hostedBroker;
+				setActiveBrokerIssuer(hostedBroker.issueForChild);
+				debugLog(`[broker] runner-hosted broker listening (${hostedBroker.socketPath})`);
+			} else {
+				// Legacy path: static issuer scoped to THIS run, serving PRE-MINTED
+				// per-task COMPOUND tokens — wait.* rejects bare-runId tokens
+				// (ADR-0 item 6). Unknown taskIds get NO creds — follow-up:
+				// broker-side mint RPC. Depth-cap parity with the parent-side
+				// issueForChild gate (lifecycle-handlers.ts:1130-1136).
+				setActiveBrokerIssuer(async (rid, taskId, childDepth) => {
+					if (rid !== payload.runId) return undefined;
+					if (childDepth !== undefined && childDepth >= resolveCrewMaxDepth(undefined)) return undefined;
+					if (!taskId) return undefined;
+					const token = payload.tasks[taskId];
+					if (!token) return undefined;
+					return { socketPath: payload.socketPath, token };
+				});
+			}
+			// HƯỚNG A + FINDING D: persist the run's ACTUAL broker socket path onto
+			// the manifest so cross-process responders can find it — the
+			// runner-hosted socket when hosting succeeded, else the dispatcher's
+			// (pre-Finding-D semantics; derivation from manifest.sessionId was
+			// never correct in async topology — probe8: derived 7e4df036 vs actual
+			// 9529a08a). Best-effort: a stamp failure never blocks the run
+			// (responders fall back to derivation, then to the local signed
+			// append — hướng C).
+			const stampPath = hostedBroker?.socketPath ?? payload.socketPath;
+			try {
+				const loaded = loadRunManifestById(cwd, runId);
+				if (loaded && loaded.manifest.brokerSocketPath !== stampPath) {
+					await saveRunManifestAsync({ ...loaded.manifest, brokerSocketPath: stampPath });
+					debugLog(`[broker] manifest.brokerSocketPath stamped (${stampPath})`);
+				}
+			} catch (error) {
+				logInternalError("background-runner.broker-socket-stamp", error, `runId=${runId}`, "warn");
+			}
 			debugLog(
 				`[broker] stdin handshake accepted for run ${runId} (${Object.keys(payload.tasks).length} task tokens, socket ${payload.socketPath})`,
 			);
@@ -1073,7 +1149,7 @@ async function main(): Promise<void> {
 		// FIX Issue #1: Wrap runCleanup in try/catch to ensure process.exit(1)
 		// is called even if runCleanup throws unexpectedly.
 		try {
-			runCleanup(
+			await runCleanup(
 				stopInterruptGuard,
 				stopParentGuard,
 				stopHeartbeat,