@danypops/papyrus 0.6.0 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/papyrus",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "Daemon-backed graph artifacts, evidence-bearing tasks, rules, skills, and native TUI workflows for Pi",
   "type": "module",
   "keywords": ["pi-package"],

package/src/adapters/sqlite-artifact-store.ts

@@ -9,8 +9,9 @@ import type {
 	ArtifactQuery,
 	CreateArtifactInput,
 	RelationshipQuery,
+	UpdateArtifactInput,
 } from "../domain/artifact.ts";
-import { createArtifact, getArtifact, linkArtifacts, queryArtifacts, updateExtra, updateStatus } from "../ops.ts";
+import { createArtifact, getArtifact, linkArtifacts, queryArtifacts, updateArtifactContent, updateExtra, updateStatus } from "../ops.ts";
 
 export class SQLiteArtifactStore implements AtomicArtifactStore {
 	constructor(private readonly db: Db) {}
@@ -43,6 +44,10 @@ export class SQLiteArtifactStore implements AtomicArtifactStore {
 		return updateExtra(this.db, id, extra);
 	}
 
+	updateContent(id: string, input: UpdateArtifactInput): Artifact | null {
+		return updateArtifactContent(this.db, id, input);
+	}
+
 	relationships(filter: RelationshipQuery = {}): ArtifactEdge[] {
 		if (filter.artifactIds?.length === 0) return [];
 		const conditions: string[] = [];

package/src/adapters/sqlite-task-focus-store.ts

@@ -1,26 +1,20 @@
 import type { Db } from "../db.ts";
 import { inTransaction } from "../db.ts";
-import type { TaskFocusStore } from "../ports/task-focus-store.ts";
+import type { TaskFocusState, TaskFocusStatus, TaskFocusStore } from "../ports/task-focus-store.ts";
 
 export class SQLiteTaskFocusStore implements TaskFocusStore {
 	constructor(private readonly db: Db) {}
 
-	get(): string | undefined {
-		const row = this.db.prepare("SELECT task_id FROM task_focus WHERE scope = 'global'").get() as
-			| { task_id: string }
+	get(): TaskFocusState | undefined {
+		const row = this.db.prepare("SELECT task_id, status, pause_reason, updated_at FROM task_focus WHERE scope = 'global'").get() as
+			| { task_id: string; status: TaskFocusStatus; pause_reason: string | null; updated_at: string }
 			| null;
-		return row?.task_id;
+		return row ? { taskId: row.task_id, status: row.status, updatedAt: row.updated_at, ...(row.pause_reason ? { pauseReason: row.pause_reason } : {}) } : undefined;
 	}
 
-	set(taskId: string): void {
-		inTransaction(this.db, () => {
-			this.db.prepare(`
-				INSERT INTO task_focus (scope, task_id, updated_at)
-				VALUES ('global', ?, ?)
-				ON CONFLICT(scope) DO UPDATE SET task_id = excluded.task_id, updated_at = excluded.updated_at
-			`).run(taskId, new Date().toISOString());
-		});
-	}
+	set(taskId: string): TaskFocusState { return this.write(taskId, "active"); }
+	pause(taskId: string, reason?: string): TaskFocusState { return this.transition(taskId, "active", "paused", reason); }
+	unpause(taskId: string): TaskFocusState { return this.transition(taskId, "paused", "active"); }
 
 	clear(taskId?: string): void {
 		inTransaction(this.db, () => {
@@ -28,4 +22,23 @@ export class SQLiteTaskFocusStore implements TaskFocusStore {
 			else this.db.prepare("DELETE FROM task_focus WHERE scope = 'global' AND task_id = ?").run(taskId);
 		});
 	}
+
+	private transition(taskId: string, expected: TaskFocusStatus, status: TaskFocusStatus, reason?: string): TaskFocusState {
+		const current = this.get();
+		if (current?.taskId !== taskId) throw new Error(`task "${taskId}" is not focused`);
+		if (current.status !== expected) throw new Error(`focus is ${current.status}, expected ${expected}`);
+		return this.write(taskId, status, reason);
+	}
+
+	private write(taskId: string, status: TaskFocusStatus, pauseReason?: string): TaskFocusState {
+		const updatedAt = new Date().toISOString();
+		inTransaction(this.db, () => {
+			this.db.prepare(`
+				INSERT INTO task_focus (scope, task_id, status, pause_reason, updated_at)
+				VALUES ('global', ?, ?, ?, ?)
+				ON CONFLICT(scope) DO UPDATE SET task_id = excluded.task_id, status = excluded.status, pause_reason = excluded.pause_reason, updated_at = excluded.updated_at
+			`).run(taskId, status, pauseReason ?? null, updatedAt);
+		});
+		return { taskId, status, updatedAt, ...(pauseReason ? { pauseReason } : {}) };
+	}
 }

package/src/adapters/sqlite-task-scope-store.ts

@@ -0,0 +1,59 @@
+import type { Db } from "../db.ts";
+import { inTransaction } from "../db.ts";
+import type { TaskProjectScope, TaskScopeSource, TaskViewMode, TaskViewPreference } from "../domain/task-scope.ts";
+import type { TaskScopeStore } from "../ports/task-scope-store.ts";
+
+export class SQLiteTaskScopeStore implements TaskScopeStore {
+	constructor(private readonly db: Db) {}
+
+	assign(taskId: string, projectRoot: string | undefined, source: TaskScopeSource): TaskProjectScope {
+		inTransaction(this.db, () => {
+			this.db.prepare(`
+				INSERT INTO task_scopes (task_id, project_root, source, assigned_at)
+				VALUES (?, ?, ?, ?)
+				ON CONFLICT(task_id) DO UPDATE SET
+					project_root = excluded.project_root,
+					source = excluded.source,
+					assigned_at = excluded.assigned_at
+			`).run(taskId, projectRoot ?? null, source, new Date().toISOString());
+		});
+		return { taskId, ...(projectRoot === undefined ? {} : { projectRoot }), source };
+	}
+
+	get(taskId: string): TaskProjectScope | undefined {
+		const row = this.db.prepare("SELECT task_id, project_root, source FROM task_scopes WHERE task_id = ?").get(taskId) as
+			| { task_id: string; project_root: string | null; source: TaskScopeSource }
+			| null;
+		return row ? { taskId: row.task_id, ...(row.project_root === null ? {} : { projectRoot: row.project_root }), source: row.source } : undefined;
+	}
+
+	taskIds(projectRoot: string | undefined, limit: number): string[] {
+		const rows = projectRoot === undefined
+			? this.db.prepare("SELECT task_id FROM task_scopes WHERE project_root IS NULL ORDER BY task_id LIMIT ?").all(limit)
+			: this.db.prepare("SELECT task_id FROM task_scopes WHERE project_root = ? ORDER BY task_id LIMIT ?").all(projectRoot, limit);
+		return (rows as Array<{ task_id: string }>).map((row) => row.task_id);
+	}
+
+	view(projectRoot: string): TaskViewPreference {
+		const row = this.db.prepare("SELECT project_root, mode, root_task_id FROM task_views WHERE project_root = ?").get(projectRoot) as
+			| { project_root: string; mode: TaskViewMode; root_task_id: string | null }
+			| null;
+		return row
+			? { projectRoot: row.project_root, mode: row.mode, ...(row.root_task_id === null ? {} : { rootTaskId: row.root_task_id }) }
+			: { projectRoot, mode: "project" };
+	}
+
+	setView(projectRoot: string, mode: TaskViewMode, rootTaskId?: string): TaskViewPreference {
+		inTransaction(this.db, () => {
+			this.db.prepare(`
+				INSERT INTO task_views (project_root, mode, root_task_id, updated_at)
+				VALUES (?, ?, ?, ?)
+				ON CONFLICT(project_root) DO UPDATE SET
+					mode = excluded.mode,
+					root_task_id = excluded.root_task_id,
+					updated_at = excluded.updated_at
+			`).run(projectRoot, mode, rootTaskId ?? null, new Date().toISOString());
+		});
+		return { projectRoot, mode, ...(rootTaskId === undefined ? {} : { rootTaskId }) };
+	}
+}

package/src/cli.ts

@@ -10,7 +10,6 @@ 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;
@@ -57,21 +56,26 @@ function installService(): void {
 const USAGE = `Usage:
   papyrus serve
   papyrus service <install|start|stop|restart|status>
-  papyrus migrate task-history [--json]
-  papyrus automation <status|run> [--json]
+  papyrus migrate task-focus [--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 focused [--json]
+  papyrus tasks pause [--json]
+  papyrus tasks unpause [--json]
+  papyrus tasks clear-focus [--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 update <id> [--title <title>] [--body <body>] [--labels-json <json>] [--json]
   papyrus tasks complete <id> [--json]
   papyrus tasks start <id> [--json]
   papyrus tasks submit <id> [--json]
   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 {
@@ -110,8 +114,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-focus") {
+		throw new Error("migrate requires exactly `task-focus`");
 	}
 	const result = await client.call<Record<string, never>, MigrationResult>("system.migrate", {});
 	if (json) return JSON.stringify(result);
@@ -119,21 +123,7 @@ export async function runMigrationCli(args: string[], client: TaskCliClient): Pr
 	return `Migrated schema ${result.from} → ${result.to}: ${result.applied.join(", ")}`;
 }
 
-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): Promise<string> {
+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;
@@ -160,7 +150,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;
@@ -178,20 +168,69 @@ 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 positional: string[] = [];
+	const updateInput: { title?: string; body?: string; labels?: string[] } = {};
+	for (let index = 0; index < args.length; index++) {
+		const argument = args[index]!;
+		if (argument === "--json") continue;
+		if (argument === "--title" || argument === "--body" || argument === "--labels-json") {
+			const value = args[++index];
+			if (value === undefined) throw new Error(`${argument} requires a value`);
+			if (argument === "--title") updateInput.title = value;
+			else if (argument === "--body") updateInput.body = value;
+			else {
+				const parsed = JSON.parse(value) as unknown;
+				if (!Array.isArray(parsed) || parsed.some((entry) => typeof entry !== "string")) throw new Error("--labels-json requires a JSON string array");
+				updateInput.labels = parsed as string[];
+			}
+			continue;
+		}
+		positional.push(argument);
+	}
 	const [action, id, dependencyId] = positional;
 	let result: unknown;
 	let human: string;
 	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;
 		}
+		case "focused": {
+			if (id) throw new Error("tasks focused accepts no positional arguments");
+			const focus = await client.call<Record<string, string>, { artifact: CliArtifact; status: "active" | "paused"; updatedAt: string } | null>("tasks.focused", { project_root: projectRoot });
+			result = focus;
+			human = focus ? `Focused (${focus.status}): ${artifactLabel(focus.artifact)}` : "No focused task.";
+			break;
+		}
+		case "pause":
+		case "unpause": {
+			if (id) throw new Error(`tasks ${action} accepts no positional arguments`);
+			const operation = action === "pause" ? "tasks.pause" : "tasks.unpause";
+			const focus = await client.call<Record<string, string>, { artifact: CliArtifact; status: string }>(operation, { actor: "user", source: "cli" });
+			result = focus;
+			human = `Focused (${focus.status}): ${artifactLabel(focus.artifact)}`;
+			break;
+		}
+		case "clear-focus": {
+			if (id) throw new Error("tasks clear-focus accepts no positional arguments");
+			const cleared = await client.call<Record<string, string>, { cleared: boolean }>("tasks.clear_focus", { actor: "user", source: "cli" });
+			result = cleared;
+			human = cleared.cleared ? "Task focus cleared." : "No focused task.";
+			break;
+		}
+		case "update": {
+			if (!id || dependencyId) throw new Error("tasks update requires exactly one task id");
+			if (Object.keys(updateInput).length === 0) throw new Error("tasks update requires --title, --body, or --labels-json");
+			const artifact = await client.call<Record<string, unknown>, CliArtifact>("tasks.update", { id, ...updateInput, actor: "user", source: "cli" });
+			result = artifact;
+			human = `Updated: ${artifactLabel(artifact)}`;
+			break;
+		}
 		case "history": {
 			if (!id || dependencyId) throw new Error("tasks history requires exactly one task id");
 			const page = await client.call<{ id: string; direction: "desc" }, import("./domain/task-event.ts").TaskHistoryPage>("tasks.history", { id, direction: "desc" });
@@ -201,19 +240,50 @@ 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 });
+			const active = await client.call<Record<string, string>, CliArtifact>("tasks.focus", { id, actor: "user", source: "cli" });
 			result = active;
 			human = `Active: ${artifactLabel(active)}`;
 			break;
 		}
 		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);
@@ -222,7 +292,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;
@@ -258,18 +328,6 @@ 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", {
@@ -281,7 +339,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, automate, or depend");
+			throw new Error("tasks action must be active, focused, focus, pause, unpause, clear-focus, update, graph, plan, history, scope, assign-project, complete, start, submit, reject, retry, cancel, or depend");
 	}
 	return json ? JSON.stringify(result) : human;
 }
@@ -294,11 +352,6 @@ 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 = 5;
 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;
@@ -43,25 +43,20 @@ export const SKILL_RUN_ID_MAX_LENGTH = 64;
 /** Bounded automatic Pi continuations while a focused Papyrus Task remains. */
 export const TASK_DRIVER_MAX_TURNS = 20;
 export const TASK_DRIVER_MAX_UNCHANGED_TURNS = 6;
+/** Mutable Task content bounds. */
+export const TASK_TITLE_MAX_LENGTH = 500;
+export const TASK_BODY_MAX_LENGTH = 100_000;
+export const TASK_LABEL_MAX_COUNT = 64;
+export const TASK_LABEL_MAX_LENGTH = 128;
 /** Append-only Task chronology query and evidence bounds. */
 export const TASK_HISTORY_DEFAULT_LIMIT = 25;
 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,15 +1,13 @@
 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 automation = taskAutomationSettings(process.env);
-	const service = createPapyrusService(dbPath(), { automation });
+	const service = createPapyrusService(dbPath());
 	const app = createApp({ service, token });
 	const server = Bun.serve({
 		hostname: DAEMON_HOST,
@@ -27,31 +25,17 @@ export function serveMain(): void {
 	const optimizeTimer = setInterval(() => {
 		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 = () => {
 		if (stopping) return;
 		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);
-	logEvent("info", "listening", { host: DAEMON_HOST, port: server.port, automationEnabled: automation.enabled });
+	logEvent("info", "listening", { host: DAEMON_HOST, port: server.port });
 }

package/src/db.ts

@@ -100,6 +100,8 @@ CREATE TABLE IF NOT EXISTS relation_names (
 CREATE TABLE IF NOT EXISTS task_focus (
 	scope       TEXT PRIMARY KEY CHECK (scope = 'global'),
 	task_id     TEXT NOT NULL UNIQUE REFERENCES artifacts(id),
+	status      TEXT NOT NULL CHECK (status IN ('active', 'paused')),
+	pause_reason TEXT,
 	updated_at  TEXT NOT NULL
 );
 CREATE TABLE IF NOT EXISTS task_events (
@@ -122,11 +124,25 @@ 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 = `
 INSERT OR IGNORE INTO kinds VALUES ('doc','Knowledge — what we know (specs, decisions, research, designs)');
-INSERT OR IGNORE INTO kinds VALUES ('task','Work — what we are doing (goals, steps, checklists)');
+INSERT OR IGNORE INTO kinds VALUES ('task','Work — what we are doing (objectives, steps, checklists)');
 INSERT OR IGNORE INTO kinds VALUES ('rule','Governance — when doing X, follow Y');
 INSERT OR IGNORE INTO kinds VALUES ('skill','Parameterized workflow bundle — inputs and templates load tasks, rules, and docs');
 INSERT OR IGNORE INTO statuses VALUES ('draft','doc');
@@ -185,7 +201,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 && from !== 4) throw new Error(`no explicit migration path from database schema ${from}`);
 	const applied: string[] = [];
 
 	inTransaction(db, () => {
@@ -243,6 +259,37 @@ 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");
+		}
+		if (schemaVersion(db) === 4) {
+			db.exec(`
+				ALTER TABLE task_focus ADD COLUMN status TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('active', 'paused'));
+				ALTER TABLE task_focus ADD COLUMN pause_reason TEXT;
+				PRAGMA user_version = 5;
+			`);
+			applied.push("task-focus-continuation");
+		}
 	});
 	return { from, to: schemaVersion(db), applied };
 }

package/src/domain/artifact.ts

@@ -30,6 +30,12 @@ export interface CreateArtifactInput {
 	templateId?: string;
 }
 
+export interface UpdateArtifactInput {
+	title?: string;
+	body?: string;
+	labels?: string[];
+}
+
 export interface ArtifactQuery {
 	kind?: string;
 	status?: string;

package/src/domain/task-event.ts

@@ -9,12 +9,16 @@ export type TaskLifecycleStatus = "todo" | "in-progress" | "review" | "rejected"
 
 export const TASK_EVENT_TYPES = [
 	"created",
+	"updated",
 	"started",
 	"submitted",
 	"completion_attempted",
 	"gates_evaluated",
-	"automation_enabled",
-	"automation_disabled",
+	"focus_set",
+	"focus_paused",
+	"focus_unpaused",
+	"focus_cleared",
+	"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;
+}