@gajae-code/coding-agent 0.12.6 → 0.12.8

package/src/task/index.ts

@@ -53,9 +53,6 @@ import {
 	RepositoryBindingError,
 	resolveTaskRepositoryBinding,
 } from "../gjc-runtime/repository-binding";
-import { reconcileReviewSourceDelivery } from "../gjc-runtime/ultragoal-review-source";
-import { classifyUltragoalReviewDelivery, validateUltragoalReviewDispatch } from "../gjc-runtime/ultragoal-runtime";
-
 import { initializeLocalRoot, type LocalProtocolOptions, resolveLocalUrlToPath } from "../internal-urls";
 import { ArtifactManager } from "../session/artifacts";
 import { generateCommitMessage } from "../utils/commit-message-generator";
@@ -91,6 +88,18 @@ import {
 	type WorktreeBaseline,
 } from "./worktree";
 
+interface DuplicateIdentity {
+	role: string;
+	ownerId?: string;
+	parentSession: string | null;
+	repository: { root: string; relativeSubdir: string | null };
+}
+
+interface DuplicateDisposition {
+	action: "warned" | "superseded";
+	predecessorIds: string[];
+}
+
 interface TaskResumeDescriptor {
 	toolCallId: string;
 	params: TaskParams;
@@ -99,6 +108,11 @@ interface TaskResumeDescriptor {
 	durableOutputAllowed?: boolean;
 	forkContextSeed?: ForkContextSeed;
 	agentSource: AgentDefinition["source"];
+	repositoryBinding: RepositoryBinding;
+	duplicateIdentity: DuplicateIdentity;
+	duplicatePolicy: "warn" | "supersede";
+	initialDisposition?: DuplicateDisposition;
+	lastAdmissionFailure?: string;
 }
 
 function isTaskResumeDescriptor(value: unknown): value is TaskResumeDescriptor {
@@ -188,18 +202,12 @@ async function resolveTaskItemsWithRepositoryBindings(
 	for (const task of tasks) {
 		try {
 			const binding = await resolveTaskRepositoryBinding(cwd, task.repositoryBinding);
-			if (binding.relativeSubdir) {
-				assertPathUnderRepositoryBinding(binding, ".");
-			}
-			resolved.push({
-				...task,
-				repositoryBinding: binding,
-			});
+			if (binding.relativeSubdir) assertPathUnderRepositoryBinding(binding, ".");
+			resolved.push({ ...task, repositoryBinding: binding });
 		} catch (error) {
 			const id = task.id?.trim() ? task.id : "(missing-id)";
-			if (error instanceof RepositoryBindingError) {
+			if (error instanceof RepositoryBindingError)
 				return { tasks: [], error: `Task "${id}" repository binding rejected: ${error.message}` };
-			}
 			return {
 				tasks: [],
 				error: `Task "${id}" repository binding rejected: ${error instanceof Error ? error.message : String(error)}`,
@@ -209,6 +217,31 @@ async function resolveTaskItemsWithRepositoryBindings(
 	return { tasks: resolved };
 }
 
+function duplicateIdentityForTask(
+	task: TaskItem,
+	role: string,
+	ownerId: string | undefined,
+	parentSession: string | null,
+): DuplicateIdentity {
+	const binding = task.repositoryBinding as RepositoryBinding;
+	return {
+		role: role.trim(),
+		ownerId,
+		parentSession,
+		repository: { root: binding.commonDir ?? binding.worktreeRoot, relativeSubdir: binding.relativeSubdir ?? null },
+	};
+}
+
+function duplicateIdentityKey(identity: DuplicateIdentity): string {
+	return JSON.stringify([
+		identity.role,
+		identity.ownerId ?? null,
+		identity.parentSession,
+		identity.repository.root,
+		identity.repository.relativeSubdir,
+	]);
+}
+
 function repositoryBindingFromTask(task: TaskItem): RepositoryBinding | undefined {
 	return task.repositoryBinding ? publicRepositoryBinding(task.repositoryBinding as RepositoryBinding) : undefined;
 }
@@ -859,7 +892,13 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 		}
 
 		const startedJobs: Array<{ jobId: string; taskId: string }> = [];
-		const failedSchedules: string[] = [];
+		const failedSchedules: Array<{
+			task: TaskItem & { id: string };
+			taskIndex: number;
+			message: string;
+			signalSkip: boolean;
+			duplicateDisposition?: DuplicateDisposition;
+		}> = [];
 		let completedJobs = 0;
 		let failedJobs = 0;
 
@@ -886,21 +925,105 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 		};
 
 		const maxConcurrency = this.session.settings.get("task.maxConcurrency");
+		const ownerId = this.session.getAgentId?.() ?? undefined;
+		const parentSession = this.session.getSessionFile();
+		const admitDuplicateLaunch = (
+			subagentId: string,
+			task: TaskItem,
+			policy: "warn" | "supersede",
+			selfSubagentId?: string,
+		): { ok: boolean; disposition?: DuplicateDisposition; error?: string; identity: DuplicateIdentity } => {
+			const identity = duplicateIdentityForTask(task, params.agent, ownerId, parentSession);
+			const key = duplicateIdentityKey(identity);
+			const predecessors = (manager.getSubagentRecords?.({ ownerId }) ?? [])
+				.filter(record => {
+					if (record.subagentId === selfSubagentId || record.subagentId === subagentId) return false;
+					if (record.status !== "running" && record.status !== "paused" && record.status !== "queued")
+						return false;
+					return record.duplicateIdentity === key;
+				})
+				.sort(
+					(a, b) =>
+						(b.currentJobId ? (manager.getJob(b.currentJobId)?.startTime ?? 0) : 0) -
+							(a.currentJobId ? (manager.getJob(a.currentJobId)?.startTime ?? 0) : 0) ||
+						a.subagentId.localeCompare(b.subagentId),
+				);
+			if (predecessors.length === 0) return { ok: true, identity };
+			if (policy === "warn")
+				return {
+					ok: true,
+					identity,
+					disposition: { action: "warned", predecessorIds: predecessors.map(record => record.subagentId) },
+				};
+			for (const predecessor of predecessors)
+				if (!manager.cancelSubagent(predecessor.subagentId, { ownerId }))
+					return { ok: false, identity, error: "duplicate_supersede_failed" };
+			return {
+				ok: true,
+				identity,
+				disposition: { action: "superseded", predecessorIds: predecessors.map(record => record.subagentId) },
+			};
+		};
 		let resumeRunner: ResumeRunner | undefined;
 		if (typeof manager.setResumeRunner === "function") {
 			resumeRunner = (_subagentId, message, resumeDescriptor) => {
 				const descriptor = isTaskResumeDescriptor(resumeDescriptor?.data) ? resumeDescriptor.data : undefined;
 				if (!descriptor) return undefined;
+				const admission = (() => {
+					const identity = descriptor.duplicateIdentity;
+					const key = duplicateIdentityKey(identity);
+					const predecessors = manager
+						.getSubagentRecords({ ownerId })
+						.filter(record => {
+							if (
+								record.subagentId === descriptor.task.id ||
+								!["running", "paused", "queued"].includes(record.status)
+							)
+								return false;
+							return record.duplicateIdentity === key;
+						})
+						.sort(
+							(a, b) =>
+								(b.currentJobId ? (manager.getJob(b.currentJobId)?.startTime ?? 0) : 0) -
+									(a.currentJobId ? (manager.getJob(a.currentJobId)?.startTime ?? 0) : 0) ||
+								a.subagentId.localeCompare(b.subagentId),
+						);
+					if (predecessors.length === 0) return { ok: true, identity };
+					if (descriptor.duplicatePolicy === "warn")
+						return {
+							ok: true,
+							identity,
+							disposition: { action: "warned", predecessorIds: predecessors.map(record => record.subagentId) },
+						};
+					for (const predecessor of predecessors)
+						if (!manager.cancelSubagent(predecessor.subagentId, { ownerId }))
+							return { ok: false, identity, error: "duplicate_supersede_failed" };
+					return {
+						ok: true,
+						identity,
+						disposition: { action: "superseded", predecessorIds: predecessors.map(record => record.subagentId) },
+					};
+				})();
+				if (!admission.ok) {
+					descriptor.lastAdmissionFailure = admission.error;
+					return undefined;
+				}
+				if (!descriptor) return undefined;
 				const forkSeeds = descriptor.forkContextSeed
 					? new Map([[descriptor.task.id, descriptor.forkContextSeed]])
 					: undefined;
+				const resumedTask = {
+					...descriptor.task,
+					repositoryBinding: descriptor.repositoryBinding,
+					duplicate_policy: descriptor.duplicatePolicy,
+				};
 				return manager.register(
 					"task",
 					descriptor.task.id,
 					async ({ signal: runSignal }) => {
 						const result = await this.#executeSync(
 							descriptor.toolCallId,
-							{ ...descriptor.params, tasks: [descriptor.task] },
+							{ ...descriptor.params, tasks: [resumedTask] },
 							runSignal,
 							undefined,
 							[descriptor.task.id],
@@ -921,7 +1044,22 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 							},
 						);
 						const finalText = result.content.find(part => part.type === "text")?.text ?? "(no output)";
-						const singleResult = result.details?.results[0];
+						const rawSingleResult = result.details?.results[0];
+						const singleResult = rawSingleResult
+							? {
+									...rawSingleResult,
+									duplicateDisposition: (() => {
+										const initial = descriptor.initialDisposition;
+										const current = admission.disposition;
+										if (!initial) return current;
+										if (!current) return initial;
+										return {
+											action: current.action,
+											predecessorIds: [...new Set([...initial.predecessorIds, ...current.predecessorIds])],
+										};
+									})(),
+								}
+							: rawSingleResult;
 						return subagentRunOutcomeFromSingleResult(finalText, singleResult);
 					},
 					{
@@ -932,6 +1070,9 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 								id: descriptor.task.id,
 								agent: descriptor.params.agent,
 								agentSource: descriptor.agentSource,
+								duplicateIdentity: duplicateIdentityKey(descriptor.duplicateIdentity),
+								duplicateDisposition: (admission.disposition?.action ??
+									descriptor.initialDisposition?.action) as DuplicateDisposition["action"] | undefined,
 								description: descriptor.task.description,
 								assignment: descriptor.task.assignment.trim(),
 							},
@@ -968,7 +1109,12 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 		for (let i = 0; i < taskItems.length; i++) {
 			const taskItem = taskItems[i];
 			if (signal?.aborted) {
-				failedSchedules.push(`${taskItem.id}: cancelled before scheduling`);
+				failedSchedules.push({
+					task: taskItem as TaskItem & { id: string },
+					taskIndex: i,
+					message: "cancelled before scheduling",
+					signalSkip: true,
+				});
 				const progress = progressByTaskId.get(taskItem.id);
 				if (progress) {
 					progress.status = "aborted";
@@ -981,13 +1127,25 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 			if (signal?.aborted) {
 				for (let skippedIndex = i; skippedIndex < taskItems.length; skippedIndex++) {
 					const skippedTask = taskItems[skippedIndex]!;
-					failedSchedules.push(`${skippedTask.id}: cancelled before scheduling`);
+					failedSchedules.push({
+						task: skippedTask as TaskItem & { id: string },
+						taskIndex: skippedIndex,
+						message: "cancelled before scheduling",
+						signalSkip: true,
+					});
 					const skippedProgress = progressByTaskId.get(skippedTask.id);
 					if (skippedProgress) skippedProgress.status = "aborted";
 				}
 				break;
 			}
-			if (frozenForkSeed) frozenForkSeeds.set(uniqueId, frozenForkSeed);
+			if (frozenForkSeed) {
+				frozenForkSeeds.set(uniqueId, frozenForkSeed);
+				// The async callback may execute through a compatibility path that retains
+				// the caller's task id instead of the allocated artifact id. Preserve the
+				// same immutable seed under both identities so detached execution never
+				// rebuilds context after dispatch.
+				frozenForkSeeds.set(taskItem.id, frozenForkSeed);
+			}
 			const singleParams: TaskParams = { ...params, tasks: [taskItem] };
 			const label = uniqueId;
 			try {
@@ -997,6 +1155,17 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 				const subtaskSessionFile = managedPersistence
 					? null
 					: path.join(batchArtifactsDir ?? externalTaskSessionsDir!, `${uniqueId}.jsonl`);
+				const admission = admitDuplicateLaunch(uniqueId, taskItem, taskItem.duplicate_policy ?? "warn");
+				if (!admission.ok) {
+					failedSchedules.push({
+						task: taskItem as TaskItem & { id: string },
+						taskIndex: i,
+						message: admission.error ?? "duplicate_supersede_failed",
+						signalSkip: false,
+						duplicateDisposition: admission.disposition,
+					});
+					continue;
+				}
 				const jobId = manager.register(
 					"task",
 					label,
@@ -1036,7 +1205,13 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 								},
 							);
 							const finalText = result.content.find(part => part.type === "text")?.text ?? "(no output)";
-							const singleResult = result.details?.results[0];
+							const rawSingleResult = result.details?.results[0];
+							const singleResult = rawSingleResult
+								? {
+										...rawSingleResult,
+										duplicateDisposition: rawSingleResult.duplicateDisposition ?? admission.disposition,
+									}
+								: rawSingleResult;
 							if (progress) {
 								progress.status = singleResult?.paused
 									? "paused"
@@ -1119,6 +1294,8 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 								id: uniqueId,
 								agent: params.agent,
 								agentSource: fallbackAgentSource,
+								duplicateIdentity: duplicateIdentityKey(admission.identity),
+								duplicateDisposition: admission.disposition?.action,
 								description: taskItem.description,
 								assignment: taskItem.assignment.trim(),
 							},
@@ -1145,6 +1322,10 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 								durableOutputAllowed: Boolean(batchArtifactsDir),
 								forkContextSeed: frozenForkSeed,
 								agentSource: fallbackAgentSource,
+								repositoryBinding: taskItem.repositoryBinding as RepositoryBinding,
+								duplicateIdentity: admission.identity,
+								duplicatePolicy: taskItem.duplicate_policy ?? "warn",
+								initialDisposition: admission.disposition,
 							} satisfies TaskResumeDescriptor,
 						},
 						resumeRunner,
@@ -1155,10 +1336,13 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 						subagentId: uniqueId,
 						ownerId: this.session.getAgentId?.() ?? undefined,
 						currentJobId: jobId,
+						currentJobGeneration: manager.getJob(jobId)?.generation,
 						historicalJobIds: [],
 						status: manager.getJob(jobId)?.status ?? "running",
 						sessionFile: null,
 						resumable: true,
+						duplicateIdentity: duplicateIdentityKey(admission.identity),
+						duplicateDisposition: admission.disposition?.action,
 					});
 				}
 			} catch (error) {
@@ -1168,7 +1352,12 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 						: error instanceof Error
 							? error.message
 							: String(error);
-				failedSchedules.push(`${taskItem.id}: ${message}`);
+				failedSchedules.push({
+					task: taskItem as TaskItem & { id: string },
+					taskIndex: i,
+					message,
+					signalSkip: false,
+				});
 				const progress = progressByTaskId.get(taskItem.id);
 				if (progress) {
 					progress.status = "failed";
@@ -1181,11 +1370,36 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 			failedJobs += failedSchedules.length;
 		}
 
+		const scheduleFailureReceipts = failedSchedules
+			.slice()
+			.sort((a, b) => a.taskIndex - b.taskIndex)
+			.map((entry, index) =>
+				buildTaskReceipt({
+					index,
+					id: entry.task.id,
+					agent: params.agent,
+					agentSource: fallbackAgentSource,
+					task: renderTaskAssignment(entry.task.assignment, simpleMode),
+					assignment: entry.task.assignment,
+					description: entry.task.description,
+					status: "failed",
+					exitCode: 1,
+					aborted: entry.signalSkip ? true : undefined,
+					abortReason: entry.signalSkip ? "Cancelled before start" : undefined,
+					truncated: false,
+					durationMs: 0,
+					tokens: 0,
+					output: "",
+					stderr: entry.message,
+					error: entry.message,
+					duplicateDisposition: entry.duplicateDisposition,
+				} as SingleResult),
+			);
 		if (startedJobs.length === 0) {
-			const failureText = `Failed to start background task jobs: ${failedSchedules.join("; ")}`;
+			const failureText = `Failed to start background task jobs: ${failedSchedules.map(entry => `${entry.task.id}: ${entry.message}`).join("; ")}`;
 			return {
 				content: [{ type: "text", text: failureText }],
-				details: { projectAgentsDir: null, results: [], totalDurationMs: 0 },
+				details: { projectAgentsDir: null, results: scheduleFailureReceipts, totalDurationMs: 0 },
 			};
 		}
 
@@ -1233,7 +1447,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 			],
 			details: {
 				projectAgentsDir: null,
-				results: [],
+				results: scheduleFailureReceipts,
 				totalDurationMs: 0,
 				progress: getProgressSnapshot(),
 				async: { state: asyncState, jobId: startedJobs[0].jobId, type: "task" },
@@ -1705,27 +1919,6 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 				if (taskRepositoryBinding.relativeSubdir) {
 					assertPathUnderRepositoryBinding(taskRepositoryBinding, ".");
 				}
-				if (task.reviewSource) {
-					await validateUltragoalReviewDispatch({
-						cwd: this.session.cwd,
-						dispatchId: task.reviewSource.dispatchId,
-						cohortId: task.reviewSource.cohortId,
-						taskId: task.id,
-						lane: task.reviewSource.lane,
-						snapshotId: task.reviewSource.snapshotId,
-						generation: task.reviewSource.generation,
-						repositoryBindingDigest: task.reviewSource.repositoryBindingDigest,
-						stateRevision: task.reviewSource.stateRevision,
-						rerunCommand: task.reviewSource.rerunCommand,
-						taskSourceTaskId: task.reviewSource.taskId,
-						createdAt: task.reviewSource.createdAt,
-					});
-				}
-				if (isIsolated && task.reviewSource) {
-					throw new Error(
-						"source-aware review tasks cannot use generic task isolation; dispatch them against the coordinator-owned source snapshot",
-					);
-				}
 				if (!isIsolated) {
 					await assertExecutionRootMatchesRepositoryBinding(this.session.cwd, taskRepositoryBinding);
 					const result = await runSubprocess({
@@ -1780,32 +1973,11 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 						parentTelemetry: this.session.getTelemetry?.(),
 						forkContextSeed,
 					});
-					const reviewSourceDisposition = task.reviewSource
-						? await reconcileReviewSourceDelivery({
-								cwd: this.session.cwd,
-								repositoryBinding: taskRepositoryBinding,
-								reviewSource: task.reviewSource,
-							})
-						: undefined;
-					const reviewSource =
-						task.reviewSource && reviewSourceDisposition
-							? {
-									...task.reviewSource,
-									...reviewSourceDisposition,
-									...(await classifyUltragoalReviewDelivery({
-										cwd: this.session.cwd,
-										cohortId: task.reviewSource.cohortId,
-										dispatchId: task.reviewSource.dispatchId,
-										observedDisposition: reviewSourceDisposition.disposition,
-									})),
-								}
-							: undefined;
 					return {
 						...result,
 						...(forkContext ? { forkContext } : {}),
 						forkContextAdvisory,
 						repositoryBinding: publicRepositoryBinding(taskRepositoryBinding),
-						...(reviewSource ? { reviewSource } : {}),
 					};
 				}
 

package/src/task/receipt.ts

@@ -43,6 +43,7 @@ export interface TaskResultReceipt {
 	retryFailure?: { attempt: number; errorSummary: string };
 	setupFailure?: { summary: string };
 	errorSummary?: string;
+	duplicateDisposition?: SingleResult["duplicateDisposition"];
 	abortSummary?: string;
 	preview: string;
 	previewTruncated: boolean;
@@ -67,9 +68,6 @@ export interface TaskResultReceipt {
 	forkContextAdvisory?: SingleResult["forkContextAdvisory"];
 	/** Resolved repository identity for this delegated lane (#2901). */
 	repositoryBinding?: SingleResult["repositoryBinding"];
-	/** Runtime-derived review source disposition and rerun guidance (#3469). */
-	reviewSource?: SingleResult["reviewSource"];
-
 	roi?: TaskRoi;
 }
 
@@ -296,6 +294,7 @@ export function buildTaskReceipt(raw: SingleResult): TaskResultReceipt {
 		retryFailure: raw.retryFailure
 			? { attempt: raw.retryFailure.attempt, errorSummary: "Retry failure recorded." }
 			: undefined,
+		duplicateDisposition: raw.duplicateDisposition,
 		errorSummary:
 			raw.setupFailure?.summary ??
 			(raw.error
@@ -314,7 +313,6 @@ export function buildTaskReceipt(raw: SingleResult): TaskResultReceipt {
 		forkContext: raw.forkContext,
 		forkContextAdvisory: raw.forkContextAdvisory,
 		repositoryBinding: raw.repositoryBinding,
-		reviewSource: raw.reviewSource,
 		roi: buildTaskRoi(raw),
 	};
 }

package/src/task/render.ts

@@ -916,36 +916,6 @@ function renderAgentResult(result: TaskResultReceipt, isLast: boolean, expanded:
 	if (result.roi?.lowRoi) {
 		lines.push(`${continuePrefix}${theme.fg("warning", "low ROI: produced no material contribution")}`);
 	}
-	if (result.reviewSource?.disposition === "stale_review_delivery") {
-		lines.push(
-			`${continuePrefix}${theme.fg(
-				"warning",
-				truncateToWidth(
-					replaceTabs(
-						sanitizeText(
-							`STALE REVIEW: source advanced after dispatch; excluded from review gates. Rerun: ${result.reviewSource.rerunCommand}`,
-						),
-					),
-
-					100,
-				),
-			)}`,
-		);
-	} else if (result.reviewSource?.disposition === "invalid_provenance") {
-		lines.push(
-			`${continuePrefix}${theme.fg(
-				"error",
-				truncateToWidth(
-					replaceTabs(
-						sanitizeText(
-							`INVALID REVIEW PROVENANCE: receipt cannot satisfy review gates. Rerun: ${result.reviewSource.rerunCommand}`,
-						),
-					),
-					100,
-				),
-			)}`,
-		);
-	}
 
 	if (result.persistence?.recoveryRef) {
 		const label = result.persistence.ownerWorktreeApplied ? "Recovery patch" : "Unapplied recovery patch";

package/src/task/types.ts

@@ -2,7 +2,6 @@ import type { ThinkingLevel } from "@gajae-code/agent-core";
 import type { Usage } from "@gajae-code/ai";
 import { $env } from "@gajae-code/utils";
 import * as z from "zod/v4";
-import type { ReviewDeliveryDisposition, ReviewSourceLane } from "../gjc-runtime/ultragoal-review-source";
 import { isValidTaskId, TASK_ID_DESCRIPTION } from "./id";
 import type { TaskResultReceipt } from "./receipt";
 import type { SpawnRoiReconciliation } from "./roi-reconciliation";
@@ -115,26 +114,9 @@ const createTaskItemSchema = (_contextEnabled: boolean) =>
 			.describe(
 				"authoritative repository identity; omitted items are stamped from session cwd before discovery/spawn and still fail closed on sibling drift",
 			),
-		reviewSource: reviewSourceSchema.optional(),
+		duplicate_policy: z.enum(["warn", "supersede"]).optional().describe("duplicate launch policy; defaults to warn"),
 	});
 
-const reviewSourceSchema = z
-	.object({
-		schema: z.literal("gjc.review_source_dispatch.v1"),
-		cohortId: z.string().min(1),
-		generation: z.number().int().min(1),
-		lane: z.enum(["cleaner", "architect", "qa", "critic"]),
-		snapshotId: z.string().startsWith("sha256:"),
-		repositoryBindingDigest: z.string().startsWith("sha256:"),
-		stateRevision: z.number().int().min(0),
-		dispatchId: z.string().min(1),
-		rerunCommand: z.string().min(1),
-		taskId: z.string().min(1),
-		createdAt: z.string().min(1),
-	})
-	.strict()
-	.describe("leader-issued immutable review source identity; review lanes only");
-
 /** Single task item for parallel execution (default shape with context enabled). */
 export const taskItemSchema = createTaskItemSchema(true);
 export type TaskItem = z.infer<typeof taskItemSchema>;
@@ -218,6 +200,7 @@ export interface TaskParams {
 	spawnPlan?: SpawnPlanReceipt;
 	tasks: TaskItem[];
 	isolated?: boolean;
+	duplicate_policy?: "warn" | "supersede";
 }
 
 /** A code review finding reported by the reviewer agent */
@@ -452,6 +435,12 @@ export interface TaskRecoveryArtifactRef {
 	durability: "session";
 }
 
+/** Bounded duplicate-launch disposition carried into task receipts. */
+export interface DuplicateDisposition {
+	action: "warned" | "superseded";
+	predecessorIds: string[];
+}
+
 export interface TaskPersistenceResult {
 	outcome: "applied" | "no_changes" | "recovery_available";
 	ownerWorktreeApplied: boolean;
@@ -488,6 +477,8 @@ export interface SingleResult {
 	setupFailure?: SetupFailureSummary;
 	aborted?: boolean;
 	abortReason?: string;
+
+	duplicateDisposition?: DuplicateDisposition;
 	paused?: boolean;
 	/** Aggregated usage from the subprocess, accumulated incrementally from message_end events. */
 	usage?: Usage;
@@ -543,21 +534,6 @@ export interface SingleResult {
 		head?: string;
 		branch?: string;
 	};
-	/** Leader-issued immutable source identity for source-aware review lanes (#3469). */
-	reviewSource?: {
-		schema: "gjc.review_source_dispatch.v1";
-		cohortId: string;
-		generation: number;
-		lane: ReviewSourceLane;
-		snapshotId: string;
-		repositoryBindingDigest: string;
-		stateRevision: number;
-		dispatchId: string;
-		rerunCommand: string;
-		disposition: ReviewDeliveryDisposition;
-		currentSnapshotId?: string;
-		deliveryId?: string;
-	};
 }
 
 /** True only for complete, factual five-bucket cost accounting. */

package/src/tools/ask.ts

@@ -1613,7 +1613,7 @@ export class AskTool implements AgentTool<AskParametersSchema, AskToolDetails> {
 					signal,
 					initialSelection,
 					navigation: options?.navigation,
-					scrollTitleRows: isDeepInterviewQuestion ? DEEP_INTERVIEW_SELECTOR_SCROLL_TITLE_ROWS : undefined,
+					scrollTitleRows: DEEP_INTERVIEW_SELECTOR_SCROLL_TITLE_ROWS,
 					otherOptionLabel,
 					autoSelectOnTimeout: !intentContract(q.deepInterview) && !intentReview(q.deepInterview),
 					clarificationOptionLabel,