@danypops/papyrus 0.6.0 → 0.8.0

package/src/task-service.ts

@@ -1,18 +1,38 @@
-import { TASK_EXECUTION_MAX_DEGREE, TASK_EXECUTION_MAX_EDGES, TASK_EXECUTION_MAX_NODES } from "./constants.ts";
+import {
+	TASK_BODY_MAX_LENGTH,
+	TASK_EXECUTION_MAX_DEGREE,
+	TASK_EXECUTION_MAX_EDGES,
+	TASK_EXECUTION_MAX_NODES,
+	TASK_LABEL_MAX_COUNT,
+	TASK_LABEL_MAX_LENGTH,
+	TASK_SCOPE_MAX_TASKS,
+	TASK_TITLE_MAX_LENGTH,
+} from "./constants.ts";
 import type { Artifact } from "./domain/artifact.ts";
 import { checklistEntries, validateChecklist, type Checklist, type ProofReference } from "./domain/checklist.ts";
 import type { Gate, GateResult } from "./domain/gate.ts";
 import type { AppendTaskEvent, TaskEventContext, TaskHistoryPage, TaskHistoryQuery, TaskLifecycleStatus } from "./domain/task-event.ts";
+import { normalizeProjectRoot, taskScopeLabel, type TaskScopeSource, type TaskViewMode, type TaskViewSelection } from "./domain/task-scope.ts";
 import type { ArtifactStore } from "./ports/artifact-store.ts";
 import type { GateRunner } from "./ports/gate-runner.ts";
-import { InMemoryTaskFocusStore, type TaskFocusStore } from "./ports/task-focus-store.ts";
+import { InMemoryTaskFocusStore, type TaskFocusStatus, type TaskFocusStore } from "./ports/task-focus-store.ts";
 import { InMemoryTaskEventStore, type TaskEventStore } from "./ports/task-event-store.ts";
+import { InMemoryTaskScopeStore, type TaskScopeStore } from "./ports/task-scope-store.ts";
 import { assertDependencyEdgeAllowed } from "./task-execution.ts";
 
+export interface UpdateTaskInput {
+	title?: string;
+	body?: string;
+	labels?: string[];
+}
+
 export interface TaskFilter {
 	status?: string;
 	text?: string;
 	limit?: number;
+	projectRoot?: string;
+	scope?: TaskViewMode;
+	rootTaskId?: string;
 }
 
 export type TaskStatus = TaskLifecycleStatus;
@@ -30,6 +50,8 @@ export interface CreateTaskInput {
 	templateId?: string;
 	parentId?: string;
 	dependsOn?: string[];
+	projectRoot?: string;
+	projectSource?: TaskScopeSource;
 }
 
 export type TaskTransition = "start" | "submit" | "reject" | "retry" | "cancel";
@@ -46,6 +68,13 @@ export interface ChecklistReview {
 	reason?: string;
 }
 
+export interface TaskFocus {
+	artifact: Artifact;
+	status: TaskFocusStatus;
+	updatedAt: string;
+	pauseReason?: string;
+}
+
 export interface TaskCompletionOptions {
 	focusSuccessor?: boolean;
 	gateDeadlineMs?: number;
@@ -63,6 +92,7 @@ export interface TaskCompletion {
 export interface TaskNode {
 	task: Artifact;
 	active?: boolean;
+	focusStatus?: TaskFocusStatus;
 	parentIds: string[];
 	childIds: string[];
 	dependencyIds: string[];
@@ -71,6 +101,7 @@ export interface TaskNode {
 export interface TaskGraph {
 	nodes: TaskNode[];
 	rootIds: string[];
+	scope?: TaskViewSelection;
 }
 
 const TASK_TRANSITIONS: Record<TaskTransition, { from: TaskStatus[]; to: TaskStatus }> = {
@@ -87,6 +118,7 @@ export class Tasks {
 		private readonly gates: GateRunner,
 		private readonly focusStore: TaskFocusStore = new InMemoryTaskFocusStore(),
 		private readonly events: TaskEventStore = new InMemoryTaskEventStore(),
+		private readonly scopes: TaskScopeStore = new InMemoryTaskScopeStore(),
 	) {}
 
 	private require(id: string): Artifact {
@@ -106,6 +138,10 @@ export class Tasks {
 			const extra: Record<string, unknown> = { ...(input.extra ?? {}) };
 			if (input.gates !== undefined) extra["gates"] = input.gates;
 			if (input.checklist !== undefined) extra["checklist"] = validateChecklist(input.checklist);
+			const projectRoot = input.projectRoot === undefined ? undefined : normalizeProjectRoot(input.projectRoot);
+			if (input.parentId && this.scopes.get(input.parentId)?.projectRoot !== projectRoot) {
+				throw new Error(`parent task "${input.parentId}" is outside project scope`);
+			}
 			const task = this.artifacts.create({
 				id: input.id,
 				kind: "task",
@@ -117,6 +153,7 @@ export class Tasks {
 				extra,
 				templateId: input.templateId,
 			});
+			this.scopes.assign(task.id, projectRoot, input.projectSource ?? (projectRoot ? "explicit" : "unscoped"));
 			if (input.parentId) this.contain(input.parentId, task.id);
 			for (const dependency of input.dependsOn ?? []) this.depend(task.id, dependency);
 			this.appendEvent({ taskId: task.id, type: "created", toStatus: task.status as TaskStatus }, context);
@@ -124,11 +161,85 @@ export class Tasks {
 		});
 	}
 
+	update(id: string, input: UpdateTaskInput, context: TaskEventContext = {}): Artifact {
+		const fields = (["title", "body", "labels"] as const).filter((field) => input[field] !== undefined);
+		if (fields.length === 0) throw new Error("task update requires title, body, or labels");
+		if (input.title !== undefined && (input.title.trim().length === 0 || input.title.length > TASK_TITLE_MAX_LENGTH)) {
+			throw new Error(`title must be between 1 and ${TASK_TITLE_MAX_LENGTH} characters`);
+		}
+		if (input.body !== undefined && input.body.length > TASK_BODY_MAX_LENGTH) throw new Error(`body cannot exceed ${TASK_BODY_MAX_LENGTH} characters`);
+		if (input.labels !== undefined) {
+			if (input.labels.length > TASK_LABEL_MAX_COUNT) throw new Error(`labels cannot exceed ${TASK_LABEL_MAX_COUNT} entries`);
+			if (input.labels.some((label) => label.length === 0 || label.length > TASK_LABEL_MAX_LENGTH)) {
+				throw new Error(`each label must be between 1 and ${TASK_LABEL_MAX_LENGTH} characters`);
+			}
+		}
+		return this.events.atomic(() => {
+			this.require(id);
+			const updated = this.artifacts.updateContent(id, input);
+			if (!updated) throw new Error(`task "${id}" not found`);
+			this.appendEvent({ taskId: id, type: "updated", evidence: { result: `fields:${fields.sort().join(",")}` } }, context);
+			return updated;
+		});
+	}
+
 	list(filter: TaskFilter = {}): Artifact[] {
-		return this.artifacts.query({ kind: "task", ...filter });
+		const selection = this.scopeSelection(filter.projectRoot, filter.scope, filter.rootTaskId);
+		const limit = filter.limit ?? TASK_SCOPE_MAX_TASKS;
+		if (!Number.isInteger(limit) || limit < 1 || limit > TASK_SCOPE_MAX_TASKS + 1) {
+			throw new Error(`task list limit must be between 1 and ${TASK_SCOPE_MAX_TASKS + 1}`);
+		}
+		if (selection.mode === "all") {
+			return this.artifacts.query({ kind: "task", status: filter.status, text: filter.text, limit });
+		}
+		const ids = this.scopes.taskIds(selection.projectRoot, TASK_SCOPE_MAX_TASKS + 1);
+		if (ids.length > TASK_SCOPE_MAX_TASKS) throw new Error(`task project scope exceeds ${TASK_SCOPE_MAX_TASKS} tasks`);
+		const selectedIds = selection.mode === "graph" ? this.descendantIds(selection.rootTaskId!, ids) : new Set(ids);
+		const text = filter.text?.toLowerCase();
+		return [...selectedIds]
+			.map((id) => this.artifacts.get(id))
+			.filter((task): task is Artifact => task?.kind === "task")
+			.filter((task) => filter.status === undefined || task.status === filter.status)
+			.filter((task) => text === undefined || task.title.toLowerCase().includes(text) || task.body.toLowerCase().includes(text))
+			.sort((left, right) => right.updated_at.localeCompare(left.updated_at) || left.id.localeCompare(right.id))
+			.slice(0, limit);
+	}
+
+	scopeSelection(projectRoot?: string, mode?: TaskViewMode, rootTaskId?: string): TaskViewSelection {
+		if (mode !== undefined && mode !== "project" && mode !== "graph" && mode !== "all") throw new Error("task scope must be project, graph, or all");
+		if (projectRoot === undefined) return { mode: "all", label: taskScopeLabel("all") };
+		const normalized = normalizeProjectRoot(projectRoot);
+		const persisted = this.scopes.view(normalized);
+		const selectedMode = mode ?? persisted.mode;
+		const selectedRoot = rootTaskId ?? (selectedMode === "graph" ? persisted.rootTaskId : undefined);
+		if (selectedMode === "graph" && !selectedRoot) throw new Error("graph scope requires root_task_id");
+		const root = selectedRoot ? this.require(selectedRoot) : undefined;
+		if (root && this.scopes.get(root.id)?.projectRoot !== normalized) throw new Error(`task "${root.id}" is outside project scope`);
+		return {
+			mode: selectedMode,
+			label: taskScopeLabel(selectedMode, normalized, root?.title),
+			projectRoot: normalized,
+			...(selectedRoot === undefined ? {} : { rootTaskId: selectedRoot }),
+		};
+	}
+
+	setView(projectRoot: string, mode: TaskViewMode, rootTaskId?: string): TaskViewSelection {
+		const selection = this.scopeSelection(projectRoot, mode, rootTaskId);
+		this.scopes.setView(selection.projectRoot!, selection.mode, selection.rootTaskId);
+		return selection;
+	}
+
+	assignProject(id: string, projectRoot: string, context: TaskEventContext = {}): Artifact {
+		return this.events.atomic(() => {
+			const task = this.require(id);
+			this.scopes.assign(id, normalizeProjectRoot(projectRoot), "explicit");
+			this.appendEvent({ taskId: id, type: "project_assigned", reason: context.reason }, context);
+			return task;
+		});
 	}
 
 	graph(filter: TaskFilter = {}): TaskGraph {
+		const scope = this.scopeSelection(filter.projectRoot, filter.scope, filter.rootTaskId);
 		const requestedLimit = filter.limit ?? TASK_EXECUTION_MAX_NODES + 1;
 		if (!Number.isInteger(requestedLimit) || requestedLimit < 1 || requestedLimit > TASK_EXECUTION_MAX_NODES + 1) {
 			throw new Error(`task graph limit must be between 1 and ${TASK_EXECUTION_MAX_NODES + 1}`);
@@ -138,10 +249,12 @@ export class Tasks {
 			throw new Error(`task execution graph exceeds ${TASK_EXECUTION_MAX_NODES} nodes`);
 		}
 		const byId = new Map(tasks.map((task) => [task.id, task]));
-		const focusedId = this.focusStore.get();
+		const focus = this.focusStore.get();
+		const focusedId = focus?.taskId;
 		const nodes = new Map(tasks.map((task) => [task.id, {
 			task,
 			active: task.id === focusedId,
+			...(task.id === focusedId ? { focusStatus: focus!.status } : {}),
 			parentIds: [] as string[],
 			childIds: [] as string[],
 			dependencyIds: [] as string[],
@@ -172,6 +285,7 @@ export class Tasks {
 		return {
 			nodes: tasks.map((task) => nodes.get(task.id)!),
 			rootIds: tasks.filter((task) => nodes.get(task.id)!.parentIds.length === 0).map((task) => task.id),
+			scope,
 		};
 	}
 
@@ -180,24 +294,60 @@ export class Tasks {
 		return this.artifacts.get(id, { tree: true })!;
 	}
 
-	active(): Artifact | null {
-		const id = this.focusStore.get();
-		if (!id) return null;
-		const task = this.artifacts.get(id);
+	focused(filter?: TaskFilter): TaskFocus | null {
+		const focus = this.focusStore.get();
+		if (!focus) return null;
+		const task = this.artifacts.get(focus.taskId);
 		if (!task || task.kind !== "task" || task.status === "done" || task.status === "canceled") {
-			this.focusStore.clear(id);
+			this.focusStore.clear(focus.taskId);
 			return null;
 		}
-		return task;
+		if (filter?.projectRoot && !this.list(filter).some((candidate) => candidate.id === task.id)) return null;
+		return { artifact: task, status: focus.status, updatedAt: focus.updatedAt, ...(focus.pauseReason ? { pauseReason: focus.pauseReason } : {}) };
 	}
 
-	focus(id: string): Artifact {
-		const task = this.require(id);
-		if (task.status === "done" || task.status === "canceled") {
-			throw new Error(`cannot focus task from ${task.status}`);
-		}
-		this.focusStore.set(id);
-		return task;
+	active(filter?: TaskFilter): Artifact | null {
+		const focus = this.focused(filter);
+		return focus?.status === "active" ? focus.artifact : null;
+	}
+
+	focus(id: string, context: TaskEventContext = {}): Artifact {
+		return this.events.atomic(() => {
+			const task = this.require(id);
+			if (task.status === "done" || task.status === "canceled") throw new Error(`cannot focus task from ${task.status}`);
+			this.focusStore.set(id);
+			this.appendEvent({ taskId: id, type: "focus_set" }, context);
+			return task;
+		});
+	}
+
+	pauseFocus(context: TaskEventContext = {}): TaskFocus {
+		return this.events.atomic(() => {
+			const focus = this.focused();
+			if (!focus) throw new Error("no focused task");
+			const state = this.focusStore.pause(focus.artifact.id, context.reason);
+			this.appendEvent({ taskId: focus.artifact.id, type: "focus_paused" }, context);
+			return { artifact: focus.artifact, status: state.status, updatedAt: state.updatedAt, ...(state.pauseReason ? { pauseReason: state.pauseReason } : {}) };
+		});
+	}
+
+	unpauseFocus(context: TaskEventContext = {}): TaskFocus {
+		return this.events.atomic(() => {
+			const focus = this.focused();
+			if (!focus) throw new Error("no focused task");
+			const state = this.focusStore.unpause(focus.artifact.id);
+			this.appendEvent({ taskId: focus.artifact.id, type: "focus_unpaused" }, context);
+			return { artifact: focus.artifact, status: state.status, updatedAt: state.updatedAt };
+		});
+	}
+
+	clearFocus(context: TaskEventContext = {}): { cleared: boolean } {
+		return this.events.atomic(() => {
+			const focus = this.focusStore.get();
+			if (focus) this.appendEvent({ taskId: focus.taskId, type: "focus_cleared" }, context);
+			this.focusStore.clear();
+			return { cleared: focus !== undefined };
+		});
 	}
 
 	transition(id: string, action: TaskTransition, context: TaskEventContext = {}): Artifact {
@@ -256,19 +406,6 @@ export class Tasks {
 		return this.artifacts.setExtra(id, { ...task.extra, checklist: validateChecklist(checklist) })!;
 	}
 
-	setAutomation(id: string, enabled: boolean, context: TaskEventContext = {}): Artifact {
-		return this.events.atomic(() => {
-			const task = this.require(id);
-			const current = task.extra["automation"];
-			const automation = typeof current === "object" && current !== null && !Array.isArray(current)
-				? current as Record<string, unknown>
-				: {};
-			const updated = this.artifacts.setExtra(id, { ...task.extra, automation: { ...automation, enabled } })!;
-			this.appendEvent({ taskId: id, type: enabled ? "automation_enabled" : "automation_disabled" }, context);
-			return updated;
-		});
-	}
-
 	depend(id: string, dependencyId: string): Artifact {
 		this.require(id);
 		this.require(dependencyId);
@@ -295,6 +432,36 @@ export class Tasks {
 		return this.show(parentId);
 	}
 
+	private descendantIds(rootTaskId: string, projectTaskIds: string[]): Set<string> {
+		const allowed = new Set(projectTaskIds);
+		if (!allowed.has(rootTaskId)) throw new Error(`task "${rootTaskId}" is outside project scope`);
+		const relationships = this.artifacts.relationships({
+			kind: "task",
+			artifactIds: projectTaskIds,
+			limit: TASK_EXECUTION_MAX_EDGES + 1,
+		});
+		if (relationships.length > TASK_EXECUTION_MAX_EDGES) throw new Error(`task project scope exceeds ${TASK_EXECUTION_MAX_EDGES} relationships`);
+		const children = new Map<string, string[]>();
+		for (const edge of relationships) {
+			const parentId = edge.relation === "contains" ? edge.from : edge.relation === "part_of" ? edge.to : undefined;
+			const childId = edge.relation === "contains" ? edge.to : edge.relation === "part_of" ? edge.from : undefined;
+			if (!parentId || !childId || !allowed.has(parentId) || !allowed.has(childId)) continue;
+			const values = children.get(parentId) ?? [];
+			if (!values.includes(childId)) values.push(childId);
+			children.set(parentId, values);
+		}
+		const selected = new Set<string>();
+		const pending = [rootTaskId];
+		while (pending.length > 0) {
+			const id = pending.shift()!;
+			if (selected.has(id)) continue;
+			if (selected.size >= TASK_SCOPE_MAX_TASKS) throw new Error(`focused task graph exceeds ${TASK_SCOPE_MAX_TASKS} tasks`);
+			selected.add(id);
+			pending.push(...(children.get(id) ?? []));
+		}
+		return selected;
+	}
+
 	private relationships(id: string) {
 		const relationships = this.artifacts.relationships({
 			kind: "task",

package/src/task-automation.ts

@@ -1,188 +0,0 @@
-import {
-	TASK_AUTOMATION_ERROR_ID_MAX_LENGTH,
-	TASK_AUTOMATION_ERROR_MESSAGE_MAX_LENGTH,
-	TASK_AUTOMATION_GATE_CONCURRENCY,
-	TASK_AUTOMATION_HARD_MAX_RUNTIME_MS,
-	TASK_AUTOMATION_HARD_MAX_TASKS_PER_SWEEP,
-	TASK_AUTOMATION_INTERVAL_MS,
-	TASK_AUTOMATION_MAX_CANDIDATE_SCAN,
-	TASK_AUTOMATION_MAX_GATE_CONCURRENCY,
-	TASK_AUTOMATION_MAX_INTERVAL_MS,
-	TASK_AUTOMATION_MAX_RUNTIME_MS,
-	TASK_AUTOMATION_MAX_TASKS_PER_SWEEP,
-	TASK_AUTOMATION_MIN_INTERVAL_MS,
-} from "./constants.ts";
-import type { Artifact } from "./domain/artifact.ts";
-import { projectTaskExecution } from "./task-execution.ts";
-import type { Tasks } from "./task-service.ts";
-
-export interface TaskAutomationSettings {
-	enabled: boolean;
-	intervalMs: number;
-	maxTasksPerSweep: number;
-	gateConcurrency: number;
-	maxRuntimeMs: number;
-}
-
-export interface TaskAutomationResult {
-	skipped?: "disabled" | "in-flight";
-	examined: number;
-	completed: number;
-	rejected: number;
-	started: number;
-	errors: Array<{ taskId: string; message: string }>;
-	timedOut: boolean;
-}
-
-function boundedInteger(
-	env: Record<string, string | undefined>,
-	name: string,
-	fallback: number,
-	minimum: number,
-	maximum: number,
-): number {
-	const source = env[name];
-	if (source === undefined || source === "") return fallback;
-	const value = Number(source);
-	if (!Number.isInteger(value) || value < minimum || value > maximum) {
-		throw new Error(`${name} must be an integer between ${minimum} and ${maximum}`);
-	}
-	return value;
-}
-
-export function taskAutomationSettings(env: Record<string, string | undefined> = process.env): TaskAutomationSettings {
-	const enabled = env["PAPYRUS_AUTOMATION_ENABLED"] === "1";
-	if (env["PAPYRUS_AUTOMATION_ENABLED"] !== undefined && env["PAPYRUS_AUTOMATION_ENABLED"] !== "0" && !enabled) {
-		throw new Error("PAPYRUS_AUTOMATION_ENABLED must be 0 or 1");
-	}
-	return {
-		enabled,
-		intervalMs: boundedInteger(env, "PAPYRUS_AUTOMATION_INTERVAL_MS", TASK_AUTOMATION_INTERVAL_MS, TASK_AUTOMATION_MIN_INTERVAL_MS, TASK_AUTOMATION_MAX_INTERVAL_MS),
-		maxTasksPerSweep: boundedInteger(env, "PAPYRUS_AUTOMATION_MAX_TASKS", TASK_AUTOMATION_MAX_TASKS_PER_SWEEP, 1, TASK_AUTOMATION_HARD_MAX_TASKS_PER_SWEEP),
-		gateConcurrency: boundedInteger(env, "PAPYRUS_AUTOMATION_GATE_CONCURRENCY", TASK_AUTOMATION_GATE_CONCURRENCY, 1, TASK_AUTOMATION_MAX_GATE_CONCURRENCY),
-		maxRuntimeMs: boundedInteger(env, "PAPYRUS_AUTOMATION_MAX_RUNTIME_MS", TASK_AUTOMATION_MAX_RUNTIME_MS, 1, TASK_AUTOMATION_HARD_MAX_RUNTIME_MS),
-	};
-}
-
-function automationEnabled(task: Artifact): boolean {
-	const automation = task.extra["automation"];
-	return typeof automation === "object"
-		&& automation !== null
-		&& !Array.isArray(automation)
-		&& (automation as Record<string, unknown>)["enabled"] === true;
-}
-
-function emptyResult(skipped?: TaskAutomationResult["skipped"]): TaskAutomationResult {
-	return { ...(skipped ? { skipped } : {}), examined: 0, completed: 0, rejected: 0, started: 0, errors: [], timedOut: false };
-}
-
-function boundedError(taskId: string, error: unknown): TaskAutomationResult["errors"][number] {
-	const message = error instanceof Error ? error.message : String(error);
-	return {
-		taskId: taskId.slice(0, TASK_AUTOMATION_ERROR_ID_MAX_LENGTH),
-		message: message.slice(0, TASK_AUTOMATION_ERROR_MESSAGE_MAX_LENGTH),
-	};
-}
-
-export interface TaskAutomationScheduler {
-	setInterval(callback: () => void, intervalMs: number): unknown;
-	clearInterval(handle: unknown): void;
-}
-
-const SYSTEM_SCHEDULER: TaskAutomationScheduler = {
-	setInterval: (callback, intervalMs) => setInterval(callback, intervalMs),
-	clearInterval: (handle) => clearInterval(handle as ReturnType<typeof setInterval>),
-};
-
-export function scheduleTaskAutomation(
-	settings: TaskAutomationSettings,
-	sweep: () => Promise<unknown>,
-	onError: (error: unknown) => void,
-	scheduler: TaskAutomationScheduler = SYSTEM_SCHEDULER,
-): () => void {
-	if (!settings.enabled) return () => {};
-	const handle = scheduler.setInterval(() => { void sweep().catch(onError); }, settings.intervalMs);
-	return () => scheduler.clearInterval(handle);
-}
-
-export class TaskAutomationReconciler {
-	private inFlight = false;
-
-	constructor(
-		private readonly tasks: Tasks,
-		private readonly settings: TaskAutomationSettings,
-		private readonly now: () => number = () => Date.now(),
-	) {}
-
-	status(): TaskAutomationSettings & { inFlight: boolean } {
-		return { ...this.settings, inFlight: this.inFlight };
-	}
-
-	async reconcile(): Promise<TaskAutomationResult> {
-		if (!this.settings.enabled) return emptyResult("disabled");
-		if (this.inFlight) return emptyResult("in-flight");
-		this.inFlight = true;
-		try { return await this.runSweep(); }
-		finally { this.inFlight = false; }
-	}
-
-	private async runSweep(): Promise<TaskAutomationResult> {
-		const result = emptyResult();
-		const deadline = this.now() + this.settings.maxRuntimeMs;
-		const candidates = this.tasks.list({ status: "review", limit: TASK_AUTOMATION_MAX_CANDIDATE_SCAN })
-			.filter(automationEnabled)
-			.sort((left, right) => left.id.localeCompare(right.id))
-			.slice(0, this.settings.maxTasksPerSweep);
-		const completedIds = new Set<string>();
-
-		for (let offset = 0; offset < candidates.length; offset += this.settings.gateConcurrency) {
-			if (this.now() >= deadline) { result.timedOut = true; break; }
-			const batch = candidates.slice(offset, offset + this.settings.gateConcurrency);
-			await Promise.all(batch.map(async (task) => {
-				result.examined += 1;
-				try {
-					const completion = await this.tasks.completeAsync(task.id, {
-						actor: "daemon",
-						source: "automation-reconciler",
-						reason: "automation-enabled review reconciliation",
-					}, { focusSuccessor: false, gateDeadlineMs: deadline });
-					if (completion.completed) {
-						result.completed += 1;
-						completedIds.add(task.id);
-					} else result.rejected += 1;
-				} catch (error) {
-					result.errors.push(boundedError(task.id, error));
-				}
-			}));
-		}
-
-		let remaining = Math.max(0, this.settings.maxTasksPerSweep - result.examined);
-		if (remaining > 0 && completedIds.size > 0 && this.now() < deadline) {
-			let graph: ReturnType<Tasks["graph"]>;
-			try { graph = this.tasks.graph(); }
-			catch (error) {
-				result.errors.push(boundedError("graph", error));
-				return result;
-			}
-			const stateById = new Map(projectTaskExecution(graph).nodes.map((node) => [node.id, node.state]));
-			for (const node of [...graph.nodes].sort((left, right) => left.task.id.localeCompare(right.task.id))) {
-				if (remaining === 0 || this.now() >= deadline) break;
-				if (node.task.status !== "todo" || !automationEnabled(node.task) || stateById.get(node.task.id) !== "ready") continue;
-				if (!node.dependencyIds.some((id) => completedIds.has(id))) continue;
-				try {
-					this.tasks.transition(node.task.id, "start", {
-						actor: "daemon",
-						source: "automation-reconciler",
-						reason: "automation-enabled successor became ready",
-					});
-					result.started += 1;
-					remaining -= 1;
-				} catch (error) {
-					result.errors.push(boundedError(node.task.id, error));
-				}
-			}
-		}
-		if (this.now() >= deadline) result.timedOut = true;
-		return result;
-	}
-}