@danypops/papyrus 0.5.0 → 0.7.0

package/src/cli.ts

@@ -10,6 +10,7 @@ import { serveMain } from "./daemon.ts";
 import type { GateResult } from "./domain/gate.ts";
 import type { TaskExecutionPlan } from "./task-execution.ts";
 import type { TaskBlockage, TaskCompletion } from "./task-service.ts";
+import type { TaskAutomationResult, TaskAutomationSettings } from "./task-automation.ts";
 
 export interface SystemdUnitOptions {
 	bunBin: string;
@@ -56,12 +57,15 @@ function installService(): void {
 const USAGE = `Usage:
   papyrus serve
   papyrus service <install|start|stop|restart|status>
-  papyrus migrate task-history [--json]
+  papyrus migrate task-scope [--json]
+  papyrus automation <status|run> [--json]
   papyrus skills run <id> [--arguments-json <json>] [--run-id <id>] [--json]
   papyrus tasks plan [--json]
   papyrus tasks graph [--json]
   papyrus tasks active [--json]
   papyrus tasks history <id> [--json]
+  papyrus tasks scope [project|all|graph <root-id>] [--json]
+  papyrus tasks assign-project <id> [project-root] [--json]
   papyrus tasks focus <id> [--json]
   papyrus tasks complete <id> [--json]
   papyrus tasks start <id> [--json]
@@ -69,6 +73,7 @@ const USAGE = `Usage:
   papyrus tasks reject <id> [--json]
   papyrus tasks retry <id> [--json]
   papyrus tasks cancel <id> [--json]
+  papyrus tasks automate <id> <on|off> [--json]
   papyrus tasks depend <id> <prerequisite-id> [--json]`;
 
 function usage(): never {
@@ -107,8 +112,8 @@ function planText(plan: TaskExecutionPlan): string {
 export async function runMigrationCli(args: string[], client: TaskCliClient): Promise<string> {
 	const json = args.includes("--json");
 	const positional = args.filter((arg) => arg !== "--json");
-	if (positional.length !== 1 || positional[0] !== "task-history") {
-		throw new Error("migrate requires exactly `task-history`");
+	if (positional.length !== 1 || positional[0] !== "task-scope") {
+		throw new Error("migrate requires exactly `task-scope`");
 	}
 	const result = await client.call<Record<string, never>, MigrationResult>("system.migrate", {});
 	if (json) return JSON.stringify(result);
@@ -116,7 +121,21 @@ export async function runMigrationCli(args: string[], client: TaskCliClient): Pr
 	return `Migrated schema ${result.from} → ${result.to}: ${result.applied.join(", ")}`;
 }
 
-export async function runSkillCli(args: string[], client: TaskCliClient): Promise<string> {
+export async function runAutomationCli(args: string[], client: TaskCliClient): Promise<string> {
+	const json = args.includes("--json");
+	const positional = args.filter((argument) => argument !== "--json");
+	if (positional.length !== 1 || (positional[0] !== "status" && positional[0] !== "run")) {
+		throw new Error("automation requires exactly `status` or `run`");
+	}
+	if (positional[0] === "status") {
+		const status = await client.call<Record<string, never>, TaskAutomationSettings & { inFlight: boolean }>("automation.status", {});
+		return json ? JSON.stringify(status) : `Automation: ${status.enabled ? "enabled" : "disabled"} · interval ${status.intervalMs}ms · max ${status.maxTasksPerSweep} tasks · concurrency ${status.gateConcurrency}`;
+	}
+	const result = await client.call<Record<string, never>, TaskAutomationResult>("automation.reconcile", {});
+	return json ? JSON.stringify(result) : `Automation sweep: ${result.examined} examined · ${result.completed} completed · ${result.rejected} rejected · ${result.started} started · ${result.errors.length} errors${result.skipped ? ` · skipped ${result.skipped}` : ""}`;
+}
+
+export async function runSkillCli(args: string[], client: TaskCliClient, projectRoot: string = process.cwd()): Promise<string> {
 	const json = args.includes("--json");
 	const positional: string[] = [];
 	let runId: string | undefined;
@@ -143,7 +162,7 @@ export async function runSkillCli(args: string[], client: TaskCliClient): Promis
 		positional.push(argument);
 	}
 	if (positional.length !== 2 || positional[0] !== "run") throw new Error("skills requires `run <id>`");
-	const input: Record<string, unknown> = { id: positional[1], arguments: arguments_ };
+	const input: Record<string, unknown> = { id: positional[1], arguments: arguments_, project_root: projectRoot };
 	if (runId) input["run_id"] = runId;
 	const result = await client.call<Record<string, unknown>, {
 		runId: string;
@@ -161,7 +180,7 @@ export async function runSkillCli(args: string[], client: TaskCliClient): Promis
 	].join("\n");
 }
 
-export async function runTaskCli(args: string[], client: TaskCliClient): Promise<string> {
+export async function runTaskCli(args: string[], client: TaskCliClient, projectRoot: string = process.cwd()): Promise<string> {
 	const json = args.includes("--json");
 	const positional = args.filter((arg) => arg !== "--json");
 	const [action, id, dependencyId] = positional;
@@ -170,7 +189,7 @@ export async function runTaskCli(args: string[], client: TaskCliClient): Promise
 	switch (action) {
 		case "active": {
 			if (id) throw new Error("tasks active accepts no positional arguments");
-			const active = await client.call<Record<string, never>, CliArtifact | null>("tasks.active", {});
+			const active = await client.call<Record<string, string>, CliArtifact | null>("tasks.active", { project_root: projectRoot });
 			result = active;
 			human = active ? `Active: ${artifactLabel(active)}` : "No active task.";
 			break;
@@ -184,6 +203,37 @@ export async function runTaskCli(args: string[], client: TaskCliClient): Promise
 				: [...page.events].reverse().map((event) => `${event.occurredAt} ${event.type} ${event.fromStatus ?? "∅"} → ${event.toStatus ?? "∅"} · ${event.actor}/${event.source}${event.reason ? ` · ${event.reason}` : ""}`).join("\n");
 			break;
 		}
+		case "scope": {
+			if (!id) {
+				const selection = await client.call<Record<string, string>, import("./domain/task-scope.ts").TaskViewSelection>("tasks.scope", { project_root: projectRoot });
+				result = selection;
+				human = `Task scope: ${selection.label}`;
+				break;
+			}
+			if (id !== "project" && id !== "all" && id !== "graph") throw new Error("tasks scope mode must be project, all, or graph");
+			if (id === "graph" && !dependencyId) throw new Error("tasks scope graph requires a root task id");
+			if (id !== "graph" && dependencyId) throw new Error(`tasks scope ${id} accepts no root task id`);
+			const selection = await client.call<Record<string, unknown>, import("./domain/task-scope.ts").TaskViewSelection>("tasks.set_scope", {
+				project_root: projectRoot,
+				scope: id,
+				...(dependencyId ? { root_task_id: dependencyId } : {}),
+			});
+			result = selection;
+			human = `Task scope: ${selection.label}`;
+			break;
+		}
+		case "assign-project": {
+			if (!id || positional.length > 3) throw new Error("tasks assign-project requires a task id and optional project root");
+			const artifact = await client.call<Record<string, unknown>, CliArtifact>("tasks.assign_project", {
+				id,
+				project_root: dependencyId ?? projectRoot,
+				actor: "user",
+				source: "cli",
+			});
+			result = artifact;
+			human = `Project assigned: ${artifactLabel(artifact)}`;
+			break;
+		}
 		case "focus": {
 			if (!id || dependencyId) throw new Error("tasks focus requires exactly one task id");
 			const active = await client.call<{ id: string }, CliArtifact>("tasks.focus", { id });
@@ -193,10 +243,10 @@ export async function runTaskCli(args: string[], client: TaskCliClient): Promise
 		}
 		case "graph": {
 			if (id) throw new Error("tasks graph accepts no positional arguments");
-			const graph = await client.call<{ limit: number }, {
+			const graph = await client.call<{ limit: number; project_root: string }, {
 				nodes: Array<{ dependencyIds: string[]; childIds: string[] }>;
 				rootIds: string[];
-			}>("tasks.graph", { limit: TASK_EXECUTION_MAX_NODES + 1 });
+			}>("tasks.graph", { limit: TASK_EXECUTION_MAX_NODES + 1, project_root: projectRoot });
 			result = graph;
 			const dependencies = graph.nodes.reduce((count, node) => count + node.dependencyIds.length, 0);
 			const children = graph.nodes.reduce((count, node) => count + node.childIds.length, 0);
@@ -205,7 +255,7 @@ export async function runTaskCli(args: string[], client: TaskCliClient): Promise
 		}
 		case "plan": {
 			if (id) throw new Error("tasks plan accepts no positional arguments");
-			const plan = await client.call<Record<string, never>, TaskExecutionPlan>("tasks.plan", {});
+			const plan = await client.call<Record<string, string>, TaskExecutionPlan>("tasks.plan", { project_root: projectRoot });
 			result = plan;
 			human = planText(plan);
 			break;
@@ -241,6 +291,18 @@ export async function runTaskCli(args: string[], client: TaskCliClient): Promise
 			human = `${action[0]!.toUpperCase()}${action.slice(1)}: ${artifactLabel(artifact)}`;
 			break;
 		}
+		case "automate": {
+			if (!id || (dependencyId !== "on" && dependencyId !== "off") || positional.length !== 3) throw new Error("tasks automate requires a task id and on or off");
+			const artifact = await client.call<Record<string, unknown>, CliArtifact>("tasks.set_automation", {
+				id,
+				enabled: dependencyId === "on",
+				actor: "user",
+				source: "cli",
+			});
+			result = artifact;
+			human = `Automation ${dependencyId}: ${artifactLabel(artifact)}`;
+			break;
+		}
 		case "depend": {
 			if (!id || !dependencyId || positional.length !== 3) throw new Error("tasks depend requires a task id and prerequisite id");
 			const artifact = await client.call<{ id: string; dependency_id: string }, CliArtifact>("tasks.depend", {
@@ -252,7 +314,7 @@ export async function runTaskCli(args: string[], client: TaskCliClient): Promise
 			break;
 		}
 		default:
-			throw new Error("tasks action must be active, focus, graph, plan, history, complete, start, submit, reject, retry, cancel, or depend");
+			throw new Error("tasks action must be active, focus, graph, plan, history, scope, assign-project, complete, start, submit, reject, retry, cancel, automate, or depend");
 	}
 	return json ? JSON.stringify(result) : human;
 }
@@ -265,6 +327,11 @@ export async function main(args: string[] = process.argv.slice(2)): Promise<void
 		console.log(await runTaskCli(args.slice(1), client));
 		return;
 	}
+	if (command === "automation") {
+		const client = await connectPapyrusClient();
+		console.log(await runAutomationCli(args.slice(1), client));
+		return;
+	}
 	if (command === "skills") {
 		const client = await connectPapyrusClient();
 		console.log(await runSkillCli(args.slice(1), client));

package/src/constants.ts

@@ -7,7 +7,7 @@ export const DAEMON_PROBE_TIMEOUT_MS = 800;
 export const DAEMON_UNIT_NAME = "papyrus.service";
 export const DAEMON_DIR_ENV = "PAPYRUS_DAEMON_DIR";
 export const SQLITE_BUSY_TIMEOUT_MS = 5_000;
-export const SQLITE_SCHEMA_VERSION = 3;
+export const SQLITE_SCHEMA_VERSION = 4;
 export const SERVICE_MAX_BODY_BYTES = 1_048_576;
 export const WAL_CHECKPOINT_INTERVAL_MS = 60_000;
 export const DB_OPTIMIZE_INTERVAL_MS = 24 * 60 * 60_000;
@@ -15,6 +15,7 @@ export const GATE_COMMAND_TIMEOUT_MS = 30_000;
 export const GATE_TEST_TIMEOUT_MS = 60_000;
 export const GATE_OUTPUT_LIMIT = 200;
 export const GATE_MAX_BUFFER_BYTES = 1_048_576;
+export const GATE_FILE_MAX_BYTES = 1_048_576;
 
 /** Compact task-context limits keep recurring prompt injection bounded. */
 export const TASK_CONTEXT_CURRENT_LIMIT = 3;
@@ -48,6 +49,22 @@ export const TASK_HISTORY_MAX_LIMIT = 100;
 export const TASK_EVENT_MAX_EVIDENCE_BYTES = 65_536;
 export const TASK_EVENT_ACTOR_MAX_LENGTH = 128;
 export const TASK_EVENT_REASON_MAX_LENGTH = 2_000;
+/** Explicitly opt-in supervised Task graph reconciliation bounds. */
+export const TASK_AUTOMATION_INTERVAL_MS = 60_000;
+export const TASK_AUTOMATION_MIN_INTERVAL_MS = 10_000;
+export const TASK_AUTOMATION_MAX_INTERVAL_MS = 3_600_000;
+export const TASK_AUTOMATION_MAX_TASKS_PER_SWEEP = 10;
+export const TASK_AUTOMATION_HARD_MAX_TASKS_PER_SWEEP = 100;
+export const TASK_AUTOMATION_GATE_CONCURRENCY = 1;
+export const TASK_AUTOMATION_MAX_GATE_CONCURRENCY = 4;
+export const TASK_AUTOMATION_MAX_RUNTIME_MS = 120_000;
+export const TASK_AUTOMATION_HARD_MAX_RUNTIME_MS = 600_000;
+export const TASK_AUTOMATION_MAX_CANDIDATE_SCAN = 1_000;
+export const TASK_AUTOMATION_ERROR_ID_MAX_LENGTH = 128;
+export const TASK_AUTOMATION_ERROR_MESSAGE_MAX_LENGTH = 500;
+/** Persisted project and focused-graph Task view bounds. */
+export const TASK_SCOPE_MAX_TASKS = 1_000;
+export const TASK_PROJECT_ROOT_MAX_LENGTH = 4_096;
 export const GRAPH_RENDER_PADDING_X = 2;
 export const GRAPH_RENDER_PADDING_Y = 1;
 export const GRAPH_RENDER_BOX_PADDING = 0;

package/src/daemon.ts

@@ -1,12 +1,15 @@
 import { DAEMON_HOST, DB_OPTIMIZE_INTERVAL_MS, WAL_CHECKPOINT_INTERVAL_MS, dbPath } from "./constants.ts";
 import { clearDaemonPort, daemonStateDir, loadOrCreateToken, writeDaemonPort } from "./daemon-state.ts";
 import { createApp, createPapyrusService } from "./service.ts";
+import { scheduleTaskAutomation, taskAutomationSettings, type TaskAutomationResult } from "./task-automation.ts";
+import { logEvent } from "./log.ts";
 
 /** Start the supervised, long-running Papyrus service. */
 export function serveMain(): void {
 	const stateDir = daemonStateDir();
 	const token = loadOrCreateToken(stateDir);
-	const service = createPapyrusService(dbPath());
+	const automation = taskAutomationSettings(process.env);
+	const service = createPapyrusService(dbPath(), { automation });
 	const app = createApp({ service, token });
 	const server = Bun.serve({
 		hostname: DAEMON_HOST,
@@ -19,11 +22,23 @@ export function serveMain(): void {
 	}
 	writeDaemonPort(stateDir, server.port);
 	const checkpointTimer = setInterval(() => {
-		try { service.checkpoint(); } catch (error) { console.error("[papyrus] checkpoint failed", error); }
+		try { service.checkpoint(); } catch (error) { logEvent("error", "checkpoint_failed", { message: error instanceof Error ? error.message : String(error) }); }
 	}, WAL_CHECKPOINT_INTERVAL_MS);
 	const optimizeTimer = setInterval(() => {
-		try { service.optimize(); } catch (error) { console.error("[papyrus] optimize failed", error); }
+		try { service.optimize(); } catch (error) { logEvent("error", "optimize_failed", { message: error instanceof Error ? error.message : String(error) }); }
 	}, DB_OPTIMIZE_INTERVAL_MS);
+	const stopAutomation = scheduleTaskAutomation(automation, async () => {
+		const result = await service.execute("automation.reconcile", {}) as TaskAutomationResult;
+		logEvent(result.errors.length > 0 ? "warn" : "info", "automation_sweep", {
+			examined: result.examined,
+			completed: result.completed,
+			rejected: result.rejected,
+			started: result.started,
+			errors: result.errors.length,
+			timedOut: result.timedOut,
+			skipped: result.skipped,
+		});
+	}, (error) => logEvent("error", "automation_sweep_failed", { message: error instanceof Error ? error.message : String(error) }));
 
 	let stopping = false;
 	const shutdown = () => {
@@ -31,11 +46,12 @@ export function serveMain(): void {
 		stopping = true;
 		clearInterval(checkpointTimer);
 		clearInterval(optimizeTimer);
+		stopAutomation();
 		clearDaemonPort(stateDir);
 		service.close();
 		void server.stop(true).finally(() => process.exit(0));
 	};
 	process.on("SIGINT", shutdown);
 	process.on("SIGTERM", shutdown);
-	console.error(`[papyrus] listening on ${DAEMON_HOST}:${server.port}`);
+	logEvent("info", "listening", { host: DAEMON_HOST, port: server.port, automationEnabled: automation.enabled });
 }

package/src/db.ts

@@ -122,6 +122,20 @@ CREATE TRIGGER IF NOT EXISTS task_events_no_update BEFORE UPDATE ON task_events
 BEGIN SELECT RAISE(ABORT, 'task_events are append-only'); END;
 CREATE TRIGGER IF NOT EXISTS task_events_no_delete BEFORE DELETE ON task_events
 BEGIN SELECT RAISE(ABORT, 'task_events are append-only'); END;
+CREATE TABLE IF NOT EXISTS task_scopes (
+	task_id       TEXT PRIMARY KEY REFERENCES artifacts(id),
+	project_root  TEXT,
+	source        TEXT NOT NULL CHECK (source IN ('cwd', 'explicit', 'unscoped')),
+	assigned_at   TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS task_scopes_project_idx ON task_scopes(project_root, task_id);
+CREATE TABLE IF NOT EXISTS task_views (
+	project_root  TEXT PRIMARY KEY,
+	mode          TEXT NOT NULL CHECK (mode IN ('project', 'graph', 'all')),
+	root_task_id  TEXT REFERENCES artifacts(id),
+	updated_at    TEXT NOT NULL,
+	CHECK ((mode = 'graph' AND root_task_id IS NOT NULL) OR (mode != 'graph' AND root_task_id IS NULL))
+);
 `;
 
 const SEED_SQL = `
@@ -185,7 +199,7 @@ export function migrateDb(db: Db): MigrationResult {
 		throw new Error(`database schema ${from} is newer than supported ${SQLITE_SCHEMA_VERSION}`);
 	}
 	if (from === SQLITE_SCHEMA_VERSION) return { from, to: from, applied: [] };
-	if (from !== 1 && from !== 2) throw new Error(`no explicit migration path from database schema ${from}`);
+	if (from !== 1 && from !== 2 && from !== 3) throw new Error(`no explicit migration path from database schema ${from}`);
 	const applied: string[] = [];
 
 	inTransaction(db, () => {
@@ -243,6 +257,29 @@ export function migrateDb(db: Db): MigrationResult {
 			`);
 			applied.push("task-history");
 		}
+		if (schemaVersion(db) === 3) {
+			db.exec(`
+				CREATE TABLE task_scopes (
+					task_id TEXT PRIMARY KEY REFERENCES artifacts(id),
+					project_root TEXT,
+					source TEXT NOT NULL CHECK (source IN ('cwd', 'explicit', 'unscoped')),
+					assigned_at TEXT NOT NULL
+				);
+				CREATE INDEX task_scopes_project_idx ON task_scopes(project_root, task_id);
+				CREATE TABLE task_views (
+					project_root TEXT PRIMARY KEY,
+					mode TEXT NOT NULL CHECK (mode IN ('project', 'graph', 'all')),
+					root_task_id TEXT REFERENCES artifacts(id),
+					updated_at TEXT NOT NULL,
+					CHECK ((mode = 'graph' AND root_task_id IS NOT NULL) OR (mode != 'graph' AND root_task_id IS NULL))
+				);
+				INSERT INTO task_scopes (task_id, project_root, source, assigned_at)
+				SELECT id, NULL, 'unscoped', strftime('%Y-%m-%dT%H:%M:%fZ','now')
+				FROM artifacts WHERE kind = 'task';
+				PRAGMA user_version = 4;
+			`);
+			applied.push("task-project-scope");
+		}
 	});
 	return { from, to: schemaVersion(db), applied };
 }

package/src/domain/gate.ts

@@ -4,6 +4,11 @@ export interface Gate {
 	expect?: string;
 }
 
+export interface GateRunOptions {
+	/** Absolute Unix epoch deadline for the full gate sequence. */
+	deadlineMs?: number;
+}
+
 export interface GateResult {
 	gate: Gate;
 	passed: boolean;

package/src/domain/task-event.ts

@@ -13,6 +13,9 @@ export const TASK_EVENT_TYPES = [
 	"submitted",
 	"completion_attempted",
 	"gates_evaluated",
+	"automation_enabled",
+	"automation_disabled",
+	"project_assigned",
 	"review_rejected",
 	"retried",
 	"completed",

package/src/domain/task-scope.ts

@@ -0,0 +1,39 @@
+import { basename, isAbsolute, normalize } from "node:path";
+import { TASK_PROJECT_ROOT_MAX_LENGTH } from "../constants.ts";
+
+export type TaskViewMode = "project" | "graph" | "all";
+export type TaskScopeSource = "cwd" | "explicit" | "unscoped";
+
+export interface TaskProjectScope {
+	taskId: string;
+	projectRoot?: string;
+	source: TaskScopeSource;
+}
+
+export interface TaskViewPreference {
+	projectRoot: string;
+	mode: TaskViewMode;
+	rootTaskId?: string;
+}
+
+export interface TaskViewSelection {
+	mode: TaskViewMode;
+	label: string;
+	projectRoot?: string;
+	rootTaskId?: string;
+}
+
+export function normalizeProjectRoot(value: string): string {
+	if (!isAbsolute(value)) throw new Error("project_root must be an absolute path");
+	const normalized = normalize(value);
+	if (normalized.length > TASK_PROJECT_ROOT_MAX_LENGTH) {
+		throw new Error(`project_root cannot exceed ${TASK_PROJECT_ROOT_MAX_LENGTH} characters`);
+	}
+	return normalized;
+}
+
+export function taskScopeLabel(mode: TaskViewMode, projectRoot?: string, rootTitle?: string): string {
+	if (mode === "all") return "All projects";
+	const project = projectRoot ? basename(projectRoot) || projectRoot : "Unscoped";
+	return mode === "graph" ? `${project} · ${rootTitle ?? "focused graph"}` : project;
+}

package/src/log.ts

@@ -0,0 +1,6 @@
+export type LogLevel = "info" | "warn" | "error";
+
+/** Credential-safe structured daemon event. Callers must pass bounded, non-sensitive fields. */
+export function logEvent(level: LogLevel, event: string, fields: Record<string, unknown> = {}): void {
+	console.error(JSON.stringify({ timestamp: new Date().toISOString(), level, component: "papyrus-daemon", event, ...fields }));
+}

package/src/ops.ts

@@ -7,7 +7,7 @@ import { exec } from "node:child_process";
 import type { Db } from "./db.ts";
 import { inTransaction } from "./db.ts";
 import type { Artifact, CreateArtifactInput } from "./domain/artifact.ts";
-import type { Gate, GateResult } from "./domain/gate.ts";
+import type { Gate, GateResult, GateRunOptions } from "./domain/gate.ts";
 export type { Artifact } from "./domain/artifact.ts";
 export type { Gate, GateResult } from "./domain/gate.ts";
 export type CreateInput = CreateArtifactInput;
@@ -20,6 +20,7 @@ import {
 	GATE_TEST_TIMEOUT_MS,
 	GATE_OUTPUT_LIMIT,
 	GATE_MAX_BUFFER_BYTES,
+	GATE_FILE_MAX_BYTES,
 } from "./constants.ts";
 
 const require_ = createRequire(import.meta.url);
@@ -234,6 +235,12 @@ export function injectableRules(db: Db): Array<{ id: string; title: string; body
 	});
 }
 
+function readBoundedGateFile(path: string): string {
+	const { readFileSync, statSync } = require_("node:fs");
+	if (statSync(path).size > GATE_FILE_MAX_BYTES) throw new Error(`file exceeds ${GATE_FILE_MAX_BYTES} bytes`);
+	return readFileSync(path, "utf-8") as string;
+}
+
 export function runGates(db: Db, artifactId: string): GateResult[] {
 	const art = getArtifact(db, artifactId);
 	if (!art) throw new Error("artifact not found");
@@ -246,9 +253,8 @@ export function runGates(db: Db, artifactId: string): GateResult[] {
 				return { gate, passed: exists, output: exists ? "exists" : "not found" };
 			}
 			case "contains": {
-				const { readFileSync } = require_("node:fs");
 				try {
-					const content = readFileSync(gate.target, "utf-8");
+					const content = readBoundedGateFile(gate.target);
 					const found = gate.expect ? content.includes(gate.expect) : content.length > 0;
 					return { gate, passed: found, output: found ? "found" : `"${gate.expect ?? ""}" not found` };
 				} catch {
@@ -299,9 +305,8 @@ function runNonProcessGate(gate: Gate): GateResult {
 		return { gate, passed: exists, output: exists ? "exists" : "not found" };
 	}
 	if (gate.type === "contains") {
-		const { readFileSync } = require_("node:fs");
 		try {
-			const content = readFileSync(gate.target, "utf-8");
+			const content = readBoundedGateFile(gate.target);
 			const found = gate.expect ? content.includes(gate.expect) : content.length > 0;
 			return { gate, passed: found, output: found ? "found" : `"${gate.expect ?? ""}" not found` };
 		} catch {
@@ -312,15 +317,21 @@ function runNonProcessGate(gate: Gate): GateResult {
 }
 
 /** Gate runner for daemon request paths; subprocess gates never block the event loop. */
-export async function runGatesAsync(db: Db, artifactId: string): Promise<GateResult[]> {
+export async function runGatesAsync(db: Db, artifactId: string, options: GateRunOptions = {}): Promise<GateResult[]> {
 	const art = getArtifact(db, artifactId);
 	if (!art) throw new Error("artifact not found");
 	const gates = (art.extra["gates"] as Gate[]) ?? [];
 	const results: GateResult[] = [];
 	for (const gate of gates) {
+		const remainingMs = options.deadlineMs === undefined ? undefined : options.deadlineMs - Date.now();
+		if (remainingMs !== undefined && remainingMs <= 0) {
+			results.push({ gate, passed: false, output: "gate runtime deadline exceeded" });
+			continue;
+		}
 		if (gate.type === "command" || gate.type === "test") {
 			const command = gate.type === "test" ? `npx vitest run ${gate.target} --reporter=dot` : gate.target;
-			const timeout = gate.type === "test" ? GATE_TEST_TIMEOUT_MS : GATE_COMMAND_TIMEOUT_MS;
+			const configuredTimeout = gate.type === "test" ? GATE_TEST_TIMEOUT_MS : GATE_COMMAND_TIMEOUT_MS;
+			const timeout = remainingMs === undefined ? configuredTimeout : Math.max(1, Math.min(configuredTimeout, remainingMs));
 			const executed = await executeGateCommand(command, timeout);
 			results.push({
 				gate,

package/src/ports/gate-runner.ts

@@ -1,6 +1,6 @@
-import type { GateResult } from "../domain/gate.ts";
+import type { GateResult, GateRunOptions } from "../domain/gate.ts";
 
 export interface GateRunner {
 	run(artifactId: string): GateResult[];
-	runAsync(artifactId: string): Promise<GateResult[]>;
+	runAsync(artifactId: string, options?: GateRunOptions): Promise<GateResult[]>;
 }

package/src/ports/task-scope-store.ts

@@ -0,0 +1,40 @@
+import type { TaskProjectScope, TaskScopeSource, TaskViewMode, TaskViewPreference } from "../domain/task-scope.ts";
+
+export interface TaskScopeStore {
+	assign(taskId: string, projectRoot: string | undefined, source: TaskScopeSource): TaskProjectScope;
+	get(taskId: string): TaskProjectScope | undefined;
+	taskIds(projectRoot: string | undefined, limit: number): string[];
+	view(projectRoot: string): TaskViewPreference;
+	setView(projectRoot: string, mode: TaskViewMode, rootTaskId?: string): TaskViewPreference;
+}
+
+export class InMemoryTaskScopeStore implements TaskScopeStore {
+	private readonly scopes = new Map<string, TaskProjectScope>();
+	private readonly views = new Map<string, TaskViewPreference>();
+
+	assign(taskId: string, projectRoot: string | undefined, source: TaskScopeSource): TaskProjectScope {
+		const scope = { taskId, ...(projectRoot === undefined ? {} : { projectRoot }), source };
+		this.scopes.set(taskId, scope);
+		return scope;
+	}
+
+	get(taskId: string): TaskProjectScope | undefined { return this.scopes.get(taskId); }
+
+	taskIds(projectRoot: string | undefined, limit: number): string[] {
+		return [...this.scopes.values()]
+			.filter((scope) => scope.projectRoot === projectRoot)
+			.map((scope) => scope.taskId)
+			.sort()
+			.slice(0, limit);
+	}
+
+	view(projectRoot: string): TaskViewPreference {
+		return this.views.get(projectRoot) ?? { projectRoot, mode: "project" };
+	}
+
+	setView(projectRoot: string, mode: TaskViewMode, rootTaskId?: string): TaskViewPreference {
+		const view = { projectRoot, mode, ...(rootTaskId === undefined ? {} : { rootTaskId }) };
+		this.views.set(projectRoot, view);
+		return view;
+	}
+}