immune-brain 5.1.0 → 5.1.2

package/plugins/immune-brain/runtime/assurance/delivery_workspace.ts

@@ -54,8 +54,11 @@ function isolatedGitEnv(extra: Record<string, string> = {}): NodeJS.ProcessEnv {
 	};
 }
 
+// `maintenance.auto=false`: fetch otherwise starts `maintenance run --auto`,
+// which newer Git detaches; the detached child still owns
+// objects/maintenance.lock after fetch returns and mutates the sealed .git.
 function git(cwd: string, args: string[], extra: Record<string, string> = {}): string {
-	return execFileSync("git", args, {
+	return execFileSync("git", ["-c", "maintenance.auto=false", ...args], {
 		cwd,
 		encoding: "utf8",
 		stdio: ["ignore", "pipe", "pipe"],

package/plugins/immune-brain/runtime/assurance/review_mediation.ts

@@ -0,0 +1,107 @@
+// Host-neutral Review submission mediation (ADR 0017).
+//
+// Both host adapters resolve the verdict source before the shared submit path:
+// the Parent's relayed bytes when provided, or the host-observed reviewer
+// receipt when the verdict is omitted. The Parent keeps exclusive trigger
+// authority; only the transcription step is optional. The coordinator itself
+// stays single-verdict-input and never knows where the bytes came from.
+
+import { createHash } from "node:crypto";
+import type { AssuranceCoordinator, AssuranceSubmitReviewResult, HostContext } from "./coordinator";
+
+export function extractVerdictJson(input: unknown): Record<string, unknown> | null {
+	if (typeof input === "string") {
+		// Agent transport prefixes a status line to the strict JSON verdict.
+		const first = input.indexOf("{");
+		const last = input.lastIndexOf("}");
+		const cleaned = first >= 0 && last >= first ? input.slice(first, last + 1) : "";
+		if (!cleaned) return null;
+		try { return JSON.parse(cleaned) as Record<string, unknown>; } catch { return null; }
+	}
+	if (typeof input === "object" && input !== null && !Array.isArray(input)) return input as Record<string, unknown>;
+	return null;
+}
+
+function verdictFingerprint(raw: Record<string, unknown>): string {
+	return JSON.stringify({
+		contract: raw.contract ?? null,
+		role: raw.role ?? null,
+		task_id: raw.task_id ?? null,
+		snapshot_digest: raw.snapshot_digest ?? null,
+		decision: raw.decision ?? null,
+		approval: raw.approval ?? null,
+		findings: raw.findings ?? null,
+	});
+}
+
+/** sha256 over the reviewer's own result bytes, bound into the review attestation. */
+export function digestOfReviewerBytes(bytes: string): string {
+	return `sha256:${createHash("sha256").update(bytes).digest("hex")}`;
+}
+
+/** The host-observation shape both adapters supply; mirrors ClaudeReviewHost's. */
+export type ReviewObservation =
+	| { ok: true; receipt: { actorId: string; result: string } }
+	| { ok: false; release: boolean; reason: string };
+
+const RELEASED_REVIEW_RECOVERY =
+	"Call advance_assurance to obtain a new Review reservation, then dispatch one fresh reviewer with the returned envelope unchanged";
+const RETAINED_REVIEW_RECOVERY =
+	"Wait for the dispatched reviewer to finish, then call submit_review again with its verdict; do not dispatch or continue another reviewer";
+const MISMATCH_REVIEW_RECOVERY =
+	"Resubmit without a verdict to apply the observed reviewer receipt, or resubmit the reviewer's verdict exactly as the reviewer returned it";
+
+function withReviewRecovery(
+	result: AssuranceSubmitReviewResult,
+	recovery_action: string,
+): AssuranceSubmitReviewResult {
+	if (result.state !== "blocked" || result.code === "verdict_invalid") return result;
+	return { ...result, recovery_action };
+}
+
+export async function submitMediatedReview(
+	coordinator: AssuranceCoordinator,
+	ctx: HostContext,
+	taskId: string,
+	verdictInput: unknown,
+	inspect: () => ReviewObservation,
+): Promise<AssuranceSubmitReviewResult> {
+	// Preserve uncertain authority settlement before inspecting a released receipt.
+	if (coordinator.active(taskId)?.state === "settlement_unknown") {
+		return coordinator.submitReview(taskId, ctx, verdictInput);
+	}
+	const observed = inspect();
+	if (!observed.ok) {
+		if (observed.release) return withReviewRecovery(coordinator.abandonReview(taskId, observed.reason), RELEASED_REVIEW_RECOVERY);
+		return { state: "blocked", reason: observed.reason, recovery_action: RETAINED_REVIEW_RECOVERY };
+	}
+	const receiptBytes = observed.receipt.result;
+	const options = {
+		receiptRecoveryAction: RETAINED_REVIEW_RECOVERY,
+		reviewer_verdict_sha256: digestOfReviewerBytes(receiptBytes),
+		validateReceipt: () => {
+			const current = inspect();
+			if (!current.ok) return current.reason;
+			return current.receipt.actorId === observed.receipt.actorId && current.receipt.result === receiptBytes
+				? null : "reviewer receipt changed during submission";
+		},
+	};
+	if (verdictInput === undefined) {
+		// ADR 0017: the host-observed reviewer bytes are the submission.
+		if (!coordinator.isReviewVerdictValid(taskId, receiptBytes)) {
+			return withReviewRecovery(coordinator.abandonReview(taskId, "reviewer receipt is not a valid verdict"), RELEASED_REVIEW_RECOVERY);
+		}
+		return coordinator.submitReview(taskId, ctx, receiptBytes, options);
+	}
+	const parentValid = coordinator.isReviewVerdictValid(taskId, verdictInput);
+	if (!parentValid) return coordinator.submitReview(taskId, ctx, verdictInput);
+	if (!coordinator.isReviewVerdictValid(taskId, receiptBytes)) {
+		return withReviewRecovery(coordinator.abandonReview(taskId, "reviewer receipt is not a valid verdict"), RELEASED_REVIEW_RECOVERY);
+	}
+	const parentJson = extractVerdictJson(verdictInput);
+	const receiptJson = extractVerdictJson(receiptBytes);
+	if (!parentJson || !receiptJson || verdictFingerprint(parentJson) !== verdictFingerprint(receiptJson)) {
+		return { state: "blocked", reason: "parent verdict does not match reviewer receipt", recovery_action: MISMATCH_REVIEW_RECOVERY };
+	}
+	return coordinator.submitReview(taskId, ctx, verdictInput, options);
+}

package/plugins/immune-brain/runtime/assurance/verdict_authority.ts

@@ -272,6 +272,8 @@ export interface VerdictApplicationInput {
  verdict: AssuranceVerdict;
  invocation: InvocationToken;
  actorId: string;
+ /** ADR 0017: sha256 over the reviewer's own result bytes, bound only on review attestations. */
+ reviewer_verdict_sha256?: string;
  hooks?: { beforeCommit?: () => Promise<void>; onCommit?: () => void; afterCommit?: () => Promise<void> };
 }
 export interface VerdictAuthority {
@@ -310,6 +312,7 @@ export function createVerdictAuthority(options: {
     diff_hash: snapshot.diff_hash, actor_id: actorId, summary: verdict.approval!.summary,
     ...(snapshot.role === "review" && snapshot.review_revision ? { review_revision: snapshot.review_revision } : {}),
     ...(snapshot.role === "review" && advisories.length ? { advisory_findings: advisories } : {}),
+    ...(snapshot.role === "review" && input.reviewer_verdict_sha256 ? { reviewer_verdict_sha256: input.reviewer_verdict_sha256 } : {}),
    } : undefined;
    const op = verdict.decision === "rework" ? "request_rework" : "record_approval";
    const payload = approval ? { approval } : { findings };

package/plugins/immune-brain/runtime/claude/interaction.ts

@@ -6,6 +6,7 @@ export const PRIVILEGED_OPERATIONS = [
 	"approve_breaking_intent_revision",
 	"stop",
 	"start_unattended_batch",
+	"retire_stale_batch",
 ] as const;
 
 export type PrivilegedOperation = (typeof PRIVILEGED_OPERATIONS)[number];
@@ -87,14 +88,28 @@ export interface NativeConfirmationInput {
 			max_parallel: number;
 			parallel_groups: string[][];
 			serialized: Array<{ task_id: string; overlaps_with: string[] }>;
+			final_verification?: string[];
+			/** ADR 0018: the gate offers the opt-in delegation of in-envelope Lane Intent revisions. */
+			offer_revision_delegation?: boolean;
 		};
 	};
+	/** Present only for a batch disposition: the record the user is asked to retire. */
+	batchDisposition?: {
+		batch_id: string;
+		batch_state: string;
+		batch_branch: string;
+		plan_digest: string;
+		recorded_commits: number;
+		children: Array<{ task_id: string; slice_id: string; state: string; commit: string | null; lane_branch: string | null }>;
+	};
 	signal?: AbortSignal;
 }
 
 export interface NativeConfirmationResult {
 	decision: NativeDecision;
 	requestId: string;
+	/** ADR 0018: true only when the user ticked the delegation in a lane batch gate. */
+	delegateRevisions?: boolean;
 }
 
 export type NativeConfirmationPort = (input: NativeConfirmationInput) => Promise<NativeConfirmationResult>;

package/plugins/immune-brain/runtime/claude/kernel_ports.ts

@@ -55,9 +55,13 @@ import {
 	startBatch,
 	type BatchRunnerKernelPort,
 	type BatchRunReport,
+	type BatchTrackerPort,
 } from "../unattended/batch_runner";
 import { createBatchKernelPort } from "../unattended/batch_kernel_port";
-import type { LaneOffer } from "../unattended/batch_lanes";
+import type { LaneRevisionRequest } from "../unattended/batch_delegation";
+import { createBatchTrackerPort, laneRuntimeContractRefusal, type LaneInstructionRequest, type LaneOffer } from "../unattended/batch_lanes";
+import { retireStaleBatch } from "../unattended/batch_disposition";
+import type { BatchLaneRunReport } from "../unattended/batch_state";
 import {
 	createBatchAuthorityRegistry,
 } from "../kernel/batch_authority";
@@ -107,42 +111,11 @@ function readTaskIntentForRecord(root: string, taskId: string) {
 	return readTaskIntent(root, taskId, currentPath);
 }
 
-function extractVerdictJson(input: unknown): Record<string, unknown> | null {
-	if (typeof input === "string") {
-		const cleaned = input.split("\n").map((line) => line.trim()).filter((line) => line.startsWith("{") && line.endsWith("}")).join("");
-		if (!cleaned) return null;
-		try { return JSON.parse(cleaned) as Record<string, unknown>; } catch { return null; }
-	}
-	if (typeof input === "object" && input !== null && !Array.isArray(input)) return input as Record<string, unknown>;
-	return null;
-}
-
-function verdictFingerprint(raw: Record<string, unknown>): string {
-	return JSON.stringify({
-		contract: raw.contract ?? null,
-		role: raw.role ?? null,
-		task_id: raw.task_id ?? null,
-		snapshot_digest: raw.snapshot_digest ?? null,
-		decision: raw.decision ?? null,
-		approval: raw.approval ?? null,
-		findings: raw.findings ?? null,
-	});
-}
-
-const RELEASED_REVIEW_RECOVERY =
-	"Call advance_assurance to obtain a new Review reservation, then dispatch one fresh reviewer with the returned envelope unchanged";
-const RETAINED_REVIEW_RECOVERY =
-	"Wait for the dispatched reviewer to finish, then call submit_review again with its verdict; do not dispatch or continue another reviewer";
-const MISMATCH_REVIEW_RECOVERY =
-	"Resubmit the reviewer's verdict exactly as the reviewer returned it";
-
-function withReviewRecovery(
-	result: AssuranceSubmitReviewResult,
-	recovery_action: string,
-): AssuranceSubmitReviewResult {
-	if (result.state !== "blocked" || result.code === "verdict_invalid") return result;
-	return { ...result, recovery_action };
-}
+import {
+	extractVerdictJson,
+	submitMediatedReview,
+} from "../assurance/review_mediation";
+export { extractVerdictJson };
 
 export async function submitClaudeReview(
 	host: ClaudeReviewHost,
@@ -151,24 +124,8 @@ export async function submitClaudeReview(
 	taskId: string,
 	verdictInput: unknown,
 ): Promise<AssuranceSubmitReviewResult> {
-	if (verdictInput === undefined) throw new Error("verdict is required");
-	const observed = host.inspectReviewForTask(taskId);
-	if (!observed.ok) {
-		if (observed.release) return withReviewRecovery(coordinator.abandonReview(taskId, observed.reason), RELEASED_REVIEW_RECOVERY);
-		return { state: "blocked", reason: observed.reason, recovery_action: RETAINED_REVIEW_RECOVERY };
-	}
-	const parentValid = coordinator.isReviewVerdictValid(taskId, verdictInput);
-	if (!parentValid) return coordinator.submitReview(taskId, ctx, verdictInput);
-	const receiptValid = coordinator.isReviewVerdictValid(taskId, observed.receipt.result);
-	if (!receiptValid) {
-		return withReviewRecovery(coordinator.abandonReview(taskId, "reviewer receipt is not a valid verdict"), RELEASED_REVIEW_RECOVERY);
-	}
-	const parentJson = extractVerdictJson(verdictInput)!;
-	const receiptJson = extractVerdictJson(observed.receipt.result)!;
-	if (verdictFingerprint(parentJson) !== verdictFingerprint(receiptJson)) {
-		return { state: "blocked", reason: "parent verdict does not match reviewer receipt", recovery_action: MISMATCH_REVIEW_RECOVERY };
-	}
-	return coordinator.submitReview(taskId, ctx, verdictInput);
+	// ADR 0017: an omitted verdict applies the hook-observed reviewer receipt.
+	return submitMediatedReview(coordinator, ctx, taskId, verdictInput, () => host.inspectReviewForTask(taskId));
 }
 
 /**
@@ -276,6 +233,7 @@ export interface ClaudeRuntimeOptions {
 	requestConfirmation?: NativeConfirmationPort;
 	batchKernel?: Partial<BatchRunnerKernelPort>;
 	batchGit?: BatchRunnerGitPort;
+	batchTracker?: BatchTrackerPort;
 	readInitiative?: InitiativeObservationReader;
 }
 
@@ -285,6 +243,7 @@ export interface ClaudeRuntimeOptions {
  */
 type ClaudeBatchStartResult =
 	| { state: "started"; batch_id: string; report: BatchRunReport }
+	| { state: "retired"; batch_id: string; report: BatchRunReport | BatchLaneRunReport }
 	| { state: "rejected"; reason: string; recovery_action: string }
 	| { state: "cancelled"; reason: string; recovery_action: string }
 	| { state: "blocked"; reason: string; recovery_action: string };
@@ -312,6 +271,7 @@ export class ClaudeRuntime {
 	private app: ReturnType<typeof createCanaryApplication> | null = null;
 	private readonly batchKernel?: Partial<BatchRunnerKernelPort>;
 	private readonly batchGit?: BatchRunnerGitPort;
+	private readonly batchTracker?: BatchTrackerPort;
 	private readonly readInitiative?: InitiativeObservationReader;
 
 	constructor(options: ClaudeRuntimeOptions) {
@@ -321,6 +281,7 @@ export class ClaudeRuntime {
 		this.requestConfirmation = options.requestConfirmation;
 		this.batchKernel = options.batchKernel;
 		this.batchGit = options.batchGit;
+		this.batchTracker = options.batchTracker;
 		this.readInitiative = options.readInitiative;
 		this.host = options.host ?? new ClaudeReviewHost(new FileHookEventLog());
 		this.coordinator = new AssuranceCoordinator({
@@ -785,7 +746,7 @@ export class ClaudeRuntime {
 	async startUnattendedBatch(
 		initiativeSlug: string,
 		meta: ToolMeta,
-		options: { reuseOnly?: boolean; max_parallel?: number; lane_offers?: LaneOffer[] } = {},
+		options: { reuseOnly?: boolean; max_parallel?: number; lane_offers?: LaneOffer[]; final_verification?: string[]; lane_instruction?: LaneInstructionRequest; lane_revision?: LaneRevisionRequest } = {},
 	): Promise<ClaudeBatchStartResult> {
 		throwIfCancelled(meta.signal);
 		const reuseOnly = options.reuseOnly === true;
@@ -823,6 +784,12 @@ export class ClaudeRuntime {
 		const budget = preflight.projection.budget;
 		const planDigest = preflight.projection.plan_digest;
 		const recoveryChildren = preflight.projection.recovery_children;
+		// A new lane batch whose Lane runtime cannot read the coordinator's Kernel
+		// contracts is refused before the gate opens; a match adds nothing.
+		if (options.max_parallel !== undefined && !isResuming) {
+			const contractRefusal = laneRuntimeContractRefusal(this.cwd);
+			if (contractRefusal) return batchReason("batch_run_rejected", contractRefusal);
+		}
 		// 5. Literal-user gate plus the shared reuse decision, the post-gate
 		// claim/drift cascade, and the Batch Authorization binding. The Host supplies
 		// only its gate, its confirmation reference, and its binding nonce.
@@ -847,7 +814,7 @@ export class ClaudeRuntime {
 					};
 				// The gate settles only on the literal user's answer or the caller's
 				// cancellation signal.
-				let confirmationResult: { decision: NativeDecision; requestId: string };
+				let confirmationResult: { decision: NativeDecision; requestId: string; delegateRevisions?: boolean };
 				try {
 					confirmationResult = await this.requestConfirmation!({
 						operation: "start_unattended_batch",
@@ -874,6 +841,8 @@ export class ClaudeRuntime {
 											max_parallel: options.max_parallel,
 											parallel_groups: facts.parallel_groups,
 											serialized: facts.scope_conflicts,
+											...(options.final_verification ? { final_verification: options.final_verification } : {}),
+											offer_revision_delegation: true,
 										},
 									}
 								: {}),
@@ -918,7 +887,11 @@ export class ClaudeRuntime {
 					return { kind: "host_rejection", value: batchReason("confirmation_cancelled") };
 				if (confirmationResult.decision !== "accept")
 					return { kind: "host_rejection", value: batchReason("confirmation_no_decision") };
-				return { kind: "confirmed", request_id: confirmationResult.requestId };
+				return {
+					kind: "confirmed",
+					request_id: confirmationResult.requestId,
+					...(options.max_parallel !== undefined && confirmationResult.delegateRevisions ? { delegate_revisions: true } : {}),
+				};
 			},
 			// A reused authorization keeps this invocation's Kernel binding without a new
 			// literal-user act, so its confirmation reference names the resumed batch
@@ -981,7 +954,16 @@ export class ClaudeRuntime {
 			now,
 			kernel: kernelPort,
 			git: this.batchGit,
-			...(options.max_parallel !== undefined ? { max_parallel: options.max_parallel } : {}),
+			...(options.max_parallel !== undefined
+				? {
+						max_parallel: options.max_parallel,
+						tracker: this.batchTracker ?? createBatchTrackerPort(this.cwd, initiativeSlug),
+						...(options.final_verification ? { final_verification: options.final_verification } : {}),
+						...(options.lane_instruction ? { lane_instruction: options.lane_instruction } : {}),
+						...(options.lane_revision ? { lane_revision: options.lane_revision } : {}),
+						...(authorization.revision_delegation !== undefined ? { revision_delegation: authorization.revision_delegation } : {}),
+					}
+				: {}),
 			...(options.lane_offers !== undefined ? { lane_offers: options.lane_offers } : {}),
 		});
 
@@ -994,6 +976,85 @@ export class ClaudeRuntime {
 			report,
 		};
 	}
+
+	/**
+	 * The batch disposition. One explicit literal-user decision retires a record
+	 * the plan moved past: the terminal superseded state and its report preserve
+	 * every child state, recorded commit and the batch branch, and no child is
+	 * re-enrolled, handed off, or credited with delivery it never had.
+	 */
+	async retireStaleBatch(initiativeSlug: string, meta: ToolMeta): Promise<ClaudeBatchStartResult> {
+		throwIfCancelled(meta.signal);
+		const probe = probeHost(this.env, process.platform, this.hostVersion);
+		if (!probe.ok) throw new NativeAuthorityError("unsupported_host", probe.reason);
+		// The disposition always opens a gate, so it needs a confirmation port.
+		if (!this.requestConfirmation)
+			throw new NativeAuthorityError("interaction_not_opened", batchReason("confirmation_port_unavailable").reason);
+		const outcome = await retireStaleBatch<ClaudeBatchStartResult>({
+			root: this.cwd,
+			initiative_slug: initiativeSlug,
+			now: new Date().toISOString(),
+			gate: async (facts) => {
+				let confirmationResult: { decision: NativeDecision; requestId: string; delegateRevisions?: boolean };
+				try {
+					confirmationResult = await this.requestConfirmation!({
+						operation: "retire_stale_batch",
+						initiativeSlug,
+						toolCallId: meta.toolCallId,
+						batchDisposition: {
+							batch_id: facts.batch_id,
+							batch_state: facts.batch_state,
+							batch_branch: facts.branch,
+							plan_digest: facts.plan_digest,
+							recorded_commits: facts.recorded_commits.length,
+							children: facts.children.map((child) => ({
+								task_id: child.task_id,
+								slice_id: child.slice_id,
+								state: child.state,
+								commit: child.commit,
+								lane_branch: child.lane_branch,
+							})),
+						},
+						signal: meta.signal,
+					});
+				} catch (err) {
+					if (meta.signal?.aborted)
+						return { kind: "host_rejection", value: batchReason("confirmation_cancelled") };
+					if (err instanceof NativeAuthorityError) {
+						if (err.reasonCode === "unsupported_host") throw err;
+						if (err.reasonCode === "user_cancelled") {
+							return {
+								kind: "host_rejection",
+								value: { state: "cancelled", reason: err.message, recovery_action: err.recoveryAction },
+							};
+						}
+						return {
+							kind: "host_rejection",
+							value: { state: "rejected", reason: err.message, recovery_action: err.recoveryAction },
+						};
+					}
+					return {
+						kind: "host_rejection",
+						value: batchReason("confirmation_failed", err instanceof Error ? err.message : String(err)),
+						};
+				}
+				if (confirmationResult.decision === "cancel" && meta.signal?.aborted)
+					return { kind: "host_rejection", value: batchReason("confirmation_cancelled") };
+				if (meta.signal?.aborted)
+					return { kind: "host_rejection", value: batchReason("cancelled_before_execution") };
+				if (confirmationResult.decision === "decline")
+					return { kind: "host_rejection", value: batchReason("confirmation_declined") };
+				if (confirmationResult.decision === "cancel")
+					return { kind: "host_rejection", value: batchReason("confirmation_cancelled") };
+				if (confirmationResult.decision !== "accept")
+					return { kind: "host_rejection", value: batchReason("confirmation_no_decision") };
+				return { kind: "confirmed", request_id: confirmationResult.requestId };
+			},
+		});
+		if (outcome.outcome === "host_rejection") return outcome.value;
+		if (outcome.outcome === "rejected") return outcome.rejection;
+		return { state: "retired", batch_id: outcome.batch_id, report: outcome.report };
+	}
 }
 
 export interface ToolMeta {

package/plugins/immune-brain/runtime/claude/lane_guard.ts

@@ -0,0 +1,33 @@
+// Claude Code hook decisions that are not Review observation. PreToolUse guard for batch Lanes: an Edit, Write, MultiEdit or
+// NotebookEdit whose target resolves outside the Lane is denied before it
+// runs, the same rule the Pi extension applies to `edit`/`write`. Bash is not
+// intercepted. Outside a Lane the hook answers nothing and the tool runs as
+// configured.
+import { laneWriteRefusal } from "../unattended/lane_workspace";
+import { activeTaskNotice } from "../assurance/active_task_notice";
+
+const FILE_TOOLS = new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+
+/** The hook's stdout for one PreToolUse payload, or null to stay silent. */
+export function laneGuardHookOutput(payload: Record<string, unknown>): string | null {
+	if (payload.hook_event_name !== "PreToolUse" || !FILE_TOOLS.has(String(payload.tool_name))) return null;
+	const input = (payload.tool_input ?? {}) as { file_path?: unknown; notebook_path?: unknown };
+	const cwd = typeof payload.cwd === "string" && payload.cwd ? payload.cwd : process.cwd();
+	const refusal = laneWriteRefusal(cwd, input.file_path ?? input.notebook_path);
+	if (!refusal) return null;
+	return JSON.stringify({
+		hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "deny", permissionDecisionReason: refusal },
+	});
+}
+
+/**
+ * UserPromptSubmit: when the workspace has an active Managed task, add the
+ * advisory notice as context. It never resumes the task.
+ */
+export async function activeTaskHookOutput(payload: Record<string, unknown>): Promise<string | null> {
+	if (payload.hook_event_name !== "UserPromptSubmit") return null;
+	const cwd = typeof payload.cwd === "string" && payload.cwd ? payload.cwd : process.cwd();
+	const notice = await activeTaskNotice(cwd);
+	if (!notice) return null;
+	return JSON.stringify({ hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: notice } });
+}