@danypops/papyrus 0.2.0 → 0.3.0

package/extension/src/tasks.ts

@@ -15,23 +15,16 @@ export { showTaskDetails } from "./task-detail-view.ts";
 import type { Artifact } from "../../src/domain/artifact.ts";
 import type { GateResult } from "../../src/domain/gate.ts";
 import { projectTaskExecution } from "../../src/task-execution.ts";
-import type { TaskCompletion, TaskGraph } from "../../src/task-service.ts";
-
-const GLYPHS: Record<string, string> = {
-	pending: "○",
-	ready: "◇",
-	blocked: "○",
-	active: "●",
-	done: "■",
-	failed: "▲",
-	invalid: "!",
-};
+import type { TaskCompletion, TaskGraph, TaskStatus } from "../../src/task-service.ts";
+import { TASK_STATUS_PRESENTATION, taskTreeConnector } from "./task-presentation.ts";
 
 const STATUS_ACTIONS: Record<string, string[]> = {
-	pending: ["Start", "Fail"],
-	active: ["Complete (run gates)", "Fail"],
+	todo: ["Start", "Cancel"],
+	"in-progress": ["Submit for review", "Cancel"],
+	review: ["Complete review", "Reject", "Cancel"],
+	rejected: ["Retry", "Cancel"],
 	done: [],
-	failed: ["Retry"],
+	canceled: [],
 };
 
 type TaskRow = Artifact;
@@ -41,6 +34,7 @@ export interface TaskHierarchyRow {
 	depth: number;
 	childCount: number;
 	dependencies: string[];
+	active: boolean;
 }
 
 export function buildTaskHierarchy(graph: TaskGraph): TaskHierarchyRow[] {
@@ -53,7 +47,7 @@ export function buildTaskHierarchy(graph: TaskGraph): TaskHierarchyRow[] {
 		if (!node) return;
 		visited.add(id);
 		const children = node.childIds.filter((childId) => byId.has(childId));
-		result.push({ task: node.task, depth, childCount: children.length, dependencies: [...node.dependencyIds] });
+		result.push({ task: node.task, depth, childCount: children.length, dependencies: [...node.dependencyIds], active: node.active === true });
 		for (const childId of children) visit(childId, depth + 1);
 	};
 	for (const rootId of graph.rootIds) visit(rootId, 0);
@@ -90,7 +84,13 @@ export async function showTasks(ctx: ExtensionCommandContext): Promise<void> {
 		if (action.type === "graph") { await showTaskGraph(ctx, graph); continue; }
 		if (action.type !== "action" || !action.row) continue;
 
-		const choices = ["Show details", "Run gates", ...(STATUS_ACTIONS[action.row.status] ?? [])];
+		const active = graph.nodes.find((node) => node.task.id === action.row!.id)?.active === true;
+		const choices = [
+			"Show details",
+			...(!active && action.row.status !== "done" && action.row.status !== "canceled" ? ["Make active"] : []),
+			...(action.row.status === "review" ? ["Run gates"] : []),
+			...(STATUS_ACTIONS[action.row.status] ?? []),
+		];
 		const choice = await ctx.ui.select(action.row.title, choices);
 		if (!choice) continue;
 
@@ -98,6 +98,13 @@ export async function showTasks(ctx: ExtensionCommandContext): Promise<void> {
 			const art = await callService<Record<string, unknown>, Artifact | null>("tasks.show", { id: action.row.id });
 			if (!art) { ctx.ui.notify("Not found", "error"); continue; }
 			await showTaskDetails(ctx, art, graph);
+		} else if (choice === "Make active") {
+			try {
+				await callService<Record<string, unknown>, Artifact>("tasks.focus", { id: action.row.id });
+				ctx.ui.notify(`Active: ${action.row.title}`, "info");
+			} catch (error) {
+				ctx.ui.notify(`Focus failed: ${error instanceof Error ? error.message : error}`, "error");
+			}
 		} else if (choice === "Run gates") {
 			try {
 				const results = await callService<Record<string, unknown>, GateResult[]>("tasks.run_gates", { id: action.row.id });
@@ -107,19 +114,30 @@ export async function showTasks(ctx: ExtensionCommandContext): Promise<void> {
 			}
 		} else {
 			try {
-				const operation = choice === "Start" ? "tasks.start" : choice === "Fail" ? "tasks.fail" : choice === "Retry" ? "tasks.retry" : "tasks.complete";
+				const operation = choice === "Start"
+					? "tasks.start"
+					: choice === "Submit for review"
+						? "tasks.submit"
+						: choice === "Reject"
+							? "tasks.reject"
+							: choice === "Retry"
+								? "tasks.retry"
+								: choice === "Cancel"
+									? "tasks.cancel"
+									: "tasks.complete";
 				if (operation === "tasks.complete") {
 					const result = await callService<Record<string, unknown>, TaskCompletion>(operation, { id: action.row.id });
 					action.row.status = result.artifact.status;
 					const gates = result.gates.map((gate) => `${gate.passed ? "✓" : "✗"} ${gate.gate.type}: ${gate.gate.target}`).join("\n");
-					const started = result.started.length > 0 ? `\nStarted: ${result.started.map((task) => task.title).join(", ")}` : "";
+					const checklist = result.checklist.map((item) => `${item.accepted ? "✓" : "✗"} proof: ${item.item}`).join("\n");
+					const focused = result.focused ? `\nActive: ${result.focused.title}` : "";
 					const blocked = result.blocked.length > 0
 						? `\nWaiting: ${result.blocked.map((entry) => `${entry.artifact.title} needs ${entry.dependencyIds.join(", ")}`).join("; ")}`
 						: "";
 					ctx.ui.notify(
 						result.completed
-							? `Completed ${result.artifact.id}${started}${blocked}${gates ? `\n${gates}` : ""}`
-							: `Not complete; gates failed\n${gates}`,
+							? `Completed ${result.artifact.id}${focused}${blocked}${checklist ? `\n${checklist}` : ""}${gates ? `\n${gates}` : ""}`
+							: `Review rejected${checklist ? `\n${checklist}` : ""}${gates ? `\n${gates}` : ""}`,
 						result.completed ? "info" : "warning",
 					);
 				} else {
@@ -162,11 +180,15 @@ function renderPanel(ctx: ExtensionCommandContext, graph: TaskGraph): Promise<Pa
 
 		function statusLine(): string {
 			const counts: Record<string, number> = {};
-			for (const node of executionById.values()) counts[node.state] = (counts[node.state] ?? 0) + 1;
-			return ["ready", "active", "blocked", "done", "failed", "invalid"]
-				.filter((state) => (counts[state] ?? 0) > 0)
-				.map((state) => `${GLYPHS[state] ?? state} ${counts[state]} ${state}`)
-				.join(", ");
+			for (const entry of hierarchy) counts[entry.task.status] = (counts[entry.task.status] ?? 0) + 1;
+			const parts = hierarchy.some((entry) => entry.active) ? ["▶ 1 active"] : [];
+			for (const status of ["todo", "in-progress", "review", "rejected", "done", "canceled"] as TaskStatus[]) {
+				if ((counts[status] ?? 0) > 0) {
+					const presentation = TASK_STATUS_PRESENTATION[status];
+					parts.push(`${presentation.glyph} ${counts[status]} ${presentation.label}`);
+				}
+			}
+			return parts.join(", ");
 		}
 
 		const header = {
@@ -210,14 +232,29 @@ function renderPanel(ctx: ExtensionCommandContext, graph: TaskGraph): Promise<Pa
 					const row = entry.task;
 					const selected = i === selectedIndex;
 					const cursor = selected ? theme.fg("accent", "❯") : " ";
+					const focus = entry.active ? theme.fg("accent", "▶") : " ";
 					const execution = executionById.get(row.id);
 					const state = execution?.state ?? row.status;
-					const glyph = GLYPHS[state] ?? "?";
-					const statusColor = state === "active" || state === "ready" ? "accent" : state === "done" ? "dim" : state === "failed" || state === "invalid" ? "warning" : "muted";
-					const glyphStyled = theme.fg(statusColor, glyph);
+					const presentation = TASK_STATUS_PRESENTATION[row.status as TaskStatus];
+					const glyphStyled = state === "invalid"
+						? theme.fg("error", "!")
+						: presentation
+							? theme.fg(presentation.color, presentation.glyph)
+							: theme.fg("muted", "?");
 					const title = selected ? theme.bold(row.title) : row.title;
-					const indent = "  ".repeat(entry.depth);
-					const node = entry.childCount > 0 ? theme.fg("accent", "▾") : theme.fg("dim", "·");
+					let laterSibling = false;
+					for (let candidate = i + 1; candidate < filtered.length; candidate++) {
+						if (filtered[candidate]!.depth < entry.depth) break;
+						if (filtered[candidate]!.depth === entry.depth) { laterSibling = true; break; }
+					}
+					const connector = taskTreeConnector({
+						depth: entry.depth,
+						hasChildren: entry.childCount > 0,
+						hasLaterSibling: laterSibling,
+					});
+					const node = entry.depth === 0 && entry.childCount > 0
+						? theme.fg("accent", connector)
+						: theme.fg("dim", connector);
 					const gates = (row.extra?.["gates"] as any[])?.length;
 					const relationParts: string[] = [];
 					if (execution) relationParts.push(execution.layer === null ? state : `layer ${execution.layer + 1} · ${state}`);
@@ -228,7 +265,7 @@ function renderPanel(ctx: ExtensionCommandContext, graph: TaskGraph): Promise<Pa
 					}
 					if (gates) relationParts.push(`${gates} gate${gates === 1 ? "" : "s"}`);
 					const relationText = relationParts.length > 0 ? theme.fg("dim", ` · ${relationParts.join(" · ")}`) : "";
-					lines.push(truncateToWidth(`${cursor} ${indent}${node} ${glyphStyled} ${title}${relationText}`, width, ""));
+					lines.push(truncateToWidth(`${cursor}${focus} ${node} ${glyphStyled} ${title}${relationText}`, width, ""));
 				}
 				const hasScroll = start > 0 || end < filtered.length;
 				lines.push(theme.fg("muted", `  ${hasScroll ? `${selectedIndex + 1}/${filtered.length} · ` : ""}↑/↓ navigate · Enter actions`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/papyrus",
-  "version": "0.2.0",
+  "version": "0.3.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-task-focus-store.ts

@@ -0,0 +1,31 @@
+import type { Db } from "../db.ts";
+import { inTransaction } from "../db.ts";
+import type { 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 }
+			| null;
+		return row?.task_id;
+	}
+
+	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());
+		});
+	}
+
+	clear(taskId?: string): void {
+		inTransaction(this.db, () => {
+			if (taskId === undefined) this.db.prepare("DELETE FROM task_focus WHERE scope = 'global'").run();
+			else this.db.prepare("DELETE FROM task_focus WHERE scope = 'global' AND task_id = ?").run(taskId);
+		});
+	}
+}

package/src/cli.ts

@@ -56,9 +56,16 @@ function installService(): void {
 const USAGE = `Usage:
   papyrus serve
   papyrus service <install|start|stop|restart|status>
+  papyrus migrate task-lifecycle [--json]
   papyrus tasks plan [--json]
+  papyrus tasks active [--json]
+  papyrus tasks focus <id> [--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 depend <id> <prerequisite-id> [--json]`;
 
 function usage(): never {
@@ -67,10 +74,10 @@ function usage(): never {
 }
 
 type TaskCliClient = Pick<PapyrusClient, "call">;
+type MigrationResult = { from: number; to: number; applied: string[] };
 type CliArtifact = { id: string; title: string; status: string };
-type CliCompletion = Omit<TaskCompletion, "artifact" | "started" | "blocked"> & {
+type CliCompletion = Omit<TaskCompletion, "artifact" | "blocked"> & {
 	artifact: CliArtifact;
-	started: CliArtifact[];
 	blocked: Array<Omit<TaskBlockage, "artifact"> & { artifact: CliArtifact }>;
 	gates: GateResult[];
 };
@@ -94,6 +101,18 @@ function planText(plan: TaskExecutionPlan): string {
 	return lines.join("\n");
 }
 
+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-lifecycle") {
+		throw new Error("migrate requires exactly `task-lifecycle`");
+	}
+	const result = await client.call<Record<string, never>, MigrationResult>("system.migrate", {});
+	if (json) return JSON.stringify(result);
+	if (result.applied.length === 0) return `Schema already current at version ${result.to}.`;
+	return `Migrated schema ${result.from} → ${result.to}: ${result.applied.join(", ")}`;
+}
+
 export async function runTaskCli(args: string[], client: TaskCliClient): Promise<string> {
 	const json = args.includes("--json");
 	const positional = args.filter((arg) => arg !== "--json");
@@ -101,6 +120,20 @@ export async function runTaskCli(args: string[], client: TaskCliClient): Promise
 	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", {});
+			result = active;
+			human = active ? `Active: ${artifactLabel(active)}` : "No active task.";
+			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 });
+			result = active;
+			human = `Active: ${artifactLabel(active)}`;
+			break;
+		}
 		case "plan": {
 			if (id) throw new Error("tasks plan accepts no positional arguments");
 			const plan = await client.call<Record<string, never>, TaskExecutionPlan>("tasks.plan", {});
@@ -112,8 +145,8 @@ export async function runTaskCli(args: string[], client: TaskCliClient): Promise
 			if (!id || dependencyId) throw new Error("tasks complete requires exactly one task id");
 			const completion = await client.call<{ id: string }, CliCompletion>("tasks.complete", { id });
 			result = completion;
-			const lines = [`${completion.completed ? "Completed" : "Not completed"}: ${artifactLabel(completion.artifact)}`];
-			if (completion.started.length > 0) lines.push(`Started: ${completion.started.map(artifactLabel).join(", ")}`);
+			const lines = [`${completion.completed ? "Completed" : "Rejected"}: ${artifactLabel(completion.artifact)}`];
+			if (completion.focused) lines.push(`Active: ${artifactLabel(completion.focused)}`);
 			if (completion.blocked.length > 0) {
 				lines.push(`Blocked: ${completion.blocked.map((entry) => `${artifactLabel(entry.artifact)} waits for ${entry.dependencyIds.join(", ")}`).join("; ")}`);
 			}
@@ -128,6 +161,17 @@ export async function runTaskCli(args: string[], client: TaskCliClient): Promise
 			human = `Started: ${artifactLabel(artifact)}`;
 			break;
 		}
+		case "submit":
+		case "reject":
+		case "retry":
+		case "cancel": {
+			if (!id || dependencyId) throw new Error(`tasks ${action} requires exactly one task id`);
+			const operation = `tasks.${action}` as "tasks.submit" | "tasks.reject" | "tasks.retry" | "tasks.cancel";
+			const artifact = await client.call<{ id: string }, CliArtifact>(operation, { id });
+			result = artifact;
+			human = `${action[0]!.toUpperCase()}${action.slice(1)}: ${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", {
@@ -139,7 +183,7 @@ export async function runTaskCli(args: string[], client: TaskCliClient): Promise
 			break;
 		}
 		default:
-			throw new Error("tasks action must be plan, complete, start, or depend");
+			throw new Error("tasks action must be active, focus, plan, complete, start, submit, reject, retry, cancel, or depend");
 	}
 	return json ? JSON.stringify(result) : human;
 }
@@ -152,6 +196,11 @@ export async function main(args: string[] = process.argv.slice(2)): Promise<void
 		console.log(await runTaskCli(args.slice(1), client));
 		return;
 	}
+	if (command === "migrate") {
+		const client = await connectPapyrusClient();
+		console.log(await runMigrationCli(args.slice(1), client));
+		return;
+	}
 	if (command !== "service") usage();
 	switch (action) {
 		case "install": installService(); break;

package/src/client.ts

@@ -1,6 +1,6 @@
 import { DAEMON_CLIENT_TIMEOUT_MS, DAEMON_PROBE_TIMEOUT_MS } from "./constants.ts";
 import { daemonStateDir, readDaemonHandle } from "./daemon-state.ts";
-import type { OperationName } from "./service.ts";
+import type { OperationName, SchemaState } from "./service.ts";
 
 export type FetchAdapter = (request: Request) => Promise<Response>;
 
@@ -28,7 +28,7 @@ export class PapyrusClient {
 		return body;
 	}
 
-	health(): Promise<{ ok: true; version: string }> {
+	health(): Promise<{ ok: true; version: string; schema: SchemaState }> {
 		return this.request("/health");
 	}
 

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 = 1;
+export const SQLITE_SCHEMA_VERSION = 2;
 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;
@@ -17,9 +17,9 @@ export const GATE_OUTPUT_LIMIT = 200;
 export const GATE_MAX_BUFFER_BYTES = 1_048_576;
 
 /** Compact task-context limits keep recurring prompt injection bounded. */
-export const TASK_CONTEXT_ACTIVE_LIMIT = 3;
-export const TASK_CONTEXT_FAILED_LIMIT = 3;
-export const TASK_WIDGET_ACTIVE_LIMIT = 3;
+export const TASK_CONTEXT_CURRENT_LIMIT = 3;
+export const TASK_CONTEXT_REJECTED_LIMIT = 3;
+export const TASK_WIDGET_OPEN_LIMIT = 3;
 export const TASK_DETAIL_MIN_VISIBLE_LINES = 8;
 export const TASK_DETAIL_MAX_VISIBLE_LINES = 24;
 export const TASK_DETAIL_RESERVED_ROWS = 8;
@@ -32,8 +32,7 @@ export const TASK_GRAPH_HORIZONTAL_PAN_COLUMNS = 4;
 export const TASK_EXECUTION_MAX_NODES = 1_000;
 export const TASK_EXECUTION_MAX_EDGES = 10_000;
 export const TASK_EXECUTION_MAX_DEGREE = 100;
-/** Bounded automatic Pi continuations while active Papyrus Tasks remain. */
-export const TASK_DRIVER_ACTIVE_LIMIT = 4;
+/** 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;
 export const GRAPH_RENDER_PADDING_X = 2;
@@ -58,7 +57,7 @@ export const TASK_RECONCILIATION_INSTRUCTION = [
 	'• For each current task, ask: "Did we accomplish this task?"',
 	"• If yes, run its gates before marking it done; a claim is not verification.",
 	"• If no, continue with the next concrete action toward its desired state.",
-	"• Address blocked work or explicitly leave it failed with the reason.",
+	"• Address blocked work or explicitly move failed review to rejected with the reason.",
 ].join("\n");
 
 /** $XDG_DATA_HOME/papyrus/papyrus.db */
@@ -88,10 +87,12 @@ export const SEED_STATUSES = [
 	{ name: "draft", kind: "doc" },
 	{ name: "active", kind: "doc" },
 	{ name: "archived", kind: "doc" },
-	{ name: "pending", kind: "task" },
-	{ name: "active", kind: "task" },
+	{ name: "todo", kind: "task" },
+	{ name: "in-progress", kind: "task" },
+	{ name: "review", kind: "task" },
+	{ name: "rejected", kind: "task" },
 	{ name: "done", kind: "task" },
-	{ name: "failed", kind: "task" },
+	{ name: "canceled", kind: "task" },
 	{ name: "active", kind: "rule" },
 	{ name: "deprecated", kind: "rule" },
 	{ name: "active", kind: "skill" },

package/src/db.ts

@@ -74,6 +74,11 @@ CREATE TABLE IF NOT EXISTS relation_names (
 	name        TEXT PRIMARY KEY,
 	description TEXT
 );
+CREATE TABLE IF NOT EXISTS task_focus (
+	scope       TEXT PRIMARY KEY CHECK (scope = 'global'),
+	task_id     TEXT NOT NULL UNIQUE REFERENCES artifacts(id),
+	updated_at  TEXT NOT NULL
+);
 `;
 
 const SEED_SQL = `
@@ -84,10 +89,12 @@ INSERT OR IGNORE INTO kinds VALUES ('skill','Parameterized workflow bundle — i
 INSERT OR IGNORE INTO statuses VALUES ('draft','doc');
 INSERT OR IGNORE INTO statuses VALUES ('active','doc');
 INSERT OR IGNORE INTO statuses VALUES ('archived','doc');
-INSERT OR IGNORE INTO statuses VALUES ('pending','task');
-INSERT OR IGNORE INTO statuses VALUES ('active','task');
+INSERT OR IGNORE INTO statuses VALUES ('todo','task');
+INSERT OR IGNORE INTO statuses VALUES ('in-progress','task');
+INSERT OR IGNORE INTO statuses VALUES ('review','task');
+INSERT OR IGNORE INTO statuses VALUES ('rejected','task');
 INSERT OR IGNORE INTO statuses VALUES ('done','task');
-INSERT OR IGNORE INTO statuses VALUES ('failed','task');
+INSERT OR IGNORE INTO statuses VALUES ('canceled','task');
 INSERT OR IGNORE INTO statuses VALUES ('active','rule');
 INSERT OR IGNORE INTO statuses VALUES ('deprecated','rule');
 INSERT OR IGNORE INTO statuses VALUES ('active','skill');
@@ -107,23 +114,64 @@ INSERT OR IGNORE INTO relation_names VALUES ('part_of','Artifact belongs to a pa
 CREATE INDEX IF NOT EXISTS edges_to_id_idx ON edges(to_id);
 `;
 
-function migrate(db: Db): void {
-	const row = db.prepare("PRAGMA user_version").get() as { user_version: number };
-	let version = row.user_version;
-	if (version > SQLITE_SCHEMA_VERSION) {
-		throw new Error(`database schema ${version} is newer than supported ${SQLITE_SCHEMA_VERSION}`);
-	}
-	if (version < 1) {
-		inTransaction(db, () => {
-			db.exec(SCHEMA);
-			db.exec(SEED_SQL);
-			db.exec("PRAGMA user_version = 1");
-		});
-		version = 1;
-	}
-	if (version !== SQLITE_SCHEMA_VERSION) {
-		throw new Error(`missing migration from schema ${version} to ${SQLITE_SCHEMA_VERSION}`);
+export interface MigrationResult {
+	from: number;
+	to: number;
+	applied: string[];
+}
+
+export function schemaVersion(db: Db): number {
+	return (db.prepare("PRAGMA user_version").get() as { user_version: number }).user_version;
+}
+
+function bootstrapEmptyDatabase(db: Db): void {
+	const existing = db
+		.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' LIMIT 1")
+		.get();
+	if (existing) throw new Error("database schema is unversioned; refusing to migrate existing data during boot");
+	inTransaction(db, () => {
+		db.exec(SCHEMA);
+		db.exec(SEED_SQL);
+		db.exec(`PRAGMA user_version = ${SQLITE_SCHEMA_VERSION}`);
+	});
+}
+
+export function migrateDb(db: Db): MigrationResult {
+	const from = schemaVersion(db);
+	if (from > SQLITE_SCHEMA_VERSION) {
+		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) throw new Error(`no explicit migration path from database schema ${from}`);
+
+	inTransaction(db, () => {
+		db.exec(`
+			INSERT OR IGNORE INTO statuses VALUES ('todo','task');
+			INSERT OR IGNORE INTO statuses VALUES ('in-progress','task');
+			INSERT OR IGNORE INTO statuses VALUES ('review','task');
+			INSERT OR IGNORE INTO statuses VALUES ('rejected','task');
+			INSERT OR IGNORE INTO statuses VALUES ('done','task');
+			INSERT OR IGNORE INTO statuses VALUES ('canceled','task');
+			CREATE TABLE task_focus (
+				scope TEXT PRIMARY KEY CHECK (scope = 'global'),
+				task_id TEXT NOT NULL UNIQUE REFERENCES artifacts(id),
+				updated_at TEXT NOT NULL
+			);
+			INSERT INTO task_focus (scope, task_id, updated_at)
+			SELECT 'global', id, strftime('%Y-%m-%dT%H:%M:%fZ','now')
+			FROM artifacts WHERE kind = 'task' AND status = 'active'
+			ORDER BY updated_at DESC, id ASC LIMIT 1;
+			UPDATE artifacts SET status = CASE status
+				WHEN 'pending' THEN 'todo'
+				WHEN 'active' THEN 'in-progress'
+				WHEN 'failed' THEN 'rejected'
+				ELSE status END
+			WHERE kind = 'task';
+			DELETE FROM statuses WHERE kind = 'task' AND name IN ('pending', 'active', 'failed');
+			PRAGMA user_version = 2;
+		`);
+	});
+	return { from, to: SQLITE_SCHEMA_VERSION, applied: ["task-lifecycle-and-focus"] };
 }
 
 export function openDb(path: string): Db {
@@ -132,7 +180,12 @@ export function openDb(path: string): Db {
 	db.exec("PRAGMA foreign_keys = ON");
 	db.exec(`PRAGMA busy_timeout = ${SQLITE_BUSY_TIMEOUT_MS}`);
 	if (path !== ":memory:") db.exec("PRAGMA journal_mode = WAL");
-	migrate(db);
+	const current = schemaVersion(db);
+	if (current > SQLITE_SCHEMA_VERSION) {
+		db.close();
+		throw new Error(`database schema ${current} is newer than supported ${SQLITE_SCHEMA_VERSION}`);
+	}
+	if (current === 0) bootstrapEmptyDatabase(db);
 	db.exec("PRAGMA optimize=0x10002");
 	return db;
 }

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

@@ -0,0 +1,21 @@
+export interface TaskFocusStore {
+	get(): string | undefined;
+	set(taskId: string): void;
+	clear(taskId?: string): void;
+}
+
+export class InMemoryTaskFocusStore implements TaskFocusStore {
+	private taskId: string | undefined;
+
+	get(): string | undefined {
+		return this.taskId;
+	}
+
+	set(taskId: string): void {
+		this.taskId = taskId;
+	}
+
+	clear(taskId?: string): void {
+		if (taskId === undefined || taskId === this.taskId) this.taskId = undefined;
+	}
+}