@danypops/papyrus 0.2.1 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/papyrus",
-  "version": "0.2.1",
+  "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;
+	}
+}

package/src/service.ts

@@ -1,14 +1,15 @@
-import { SERVICE_MAX_BODY_BYTES } from "./constants.ts";
+import { SERVICE_MAX_BODY_BYTES, SQLITE_SCHEMA_VERSION } from "./constants.ts";
 import { VERSION } from "./version.ts";
-import { openDb } from "./db.ts";
+import { migrateDb, openDb, schemaVersion } from "./db.ts";
 import { SQLiteArtifactStore } from "./adapters/sqlite-artifact-store.ts";
 import { SQLiteGateRunner } from "./adapters/sqlite-gate-runner.ts";
+import { SQLiteTaskFocusStore } from "./adapters/sqlite-task-focus-store.ts";
 import type { CreateArtifactInput } from "./domain/artifact.ts";
 import type { Checklist } from "./domain/checklist.ts";
 import type { ArtifactStore } from "./ports/artifact-store.ts";
 import type { GateRunner } from "./ports/gate-runner.ts";
 import { projectTaskExecution } from "./task-execution.ts";
-import { Tasks } from "./task-service.ts";
+import { Tasks, type TaskStatus } from "./task-service.ts";
 import {
 	createArtifactTemplate,
 	createDocument,
@@ -33,6 +34,7 @@ import {
 import { taskContext } from "./task-context.ts";
 
 export const EXPECTED_OPERATION_NAMES = [
+	"system.migrate",
 	"artifact.create",
 	"artifact.query",
 	"artifact.show",
@@ -46,13 +48,17 @@ export const EXPECTED_OPERATION_NAMES = [
 	"tasks.graph",
 	"tasks.plan",
 	"tasks.show",
+	"tasks.active",
+	"tasks.focus",
 	"tasks.start",
+	"tasks.submit",
 	"tasks.complete",
 	"tasks.run_gates",
 	"tasks.set_checklist",
 	"tasks.context",
-	"tasks.fail",
+	"tasks.reject",
 	"tasks.retry",
+	"tasks.cancel",
 	"tasks.depend",
 	"tasks.contain",
 	"docs.create",
@@ -84,6 +90,7 @@ type OperationInput = Record<string, unknown>;
 type OperationHandler = (input: OperationInput) => unknown;
 
 export class UnknownOperationError extends Error {}
+export class MigrationRequiredError extends Error {}
 export class PayloadTooLargeError extends Error {}
 
 function string(input: OperationInput, key: string): string {
@@ -111,21 +118,34 @@ function normalizeCreateInput(input: OperationInput): CreateArtifactInput {
 	return { ...rest, templateId: typeof template_id === "string" ? template_id : undefined } as CreateArtifactInput;
 }
 
+export interface SchemaState {
+	current: number;
+	required: number;
+	migrationRequired: boolean;
+}
+
 export interface PapyrusService {
 	operationNames(): OperationName[];
+	schemaState(): SchemaState;
 	execute(operation: string, input?: OperationInput): Promise<unknown>;
 	checkpoint(): void;
 	optimize(): void;
 	close(): void;
 }
 
-function handlers(artifacts: ArtifactStore, gates: GateRunner, tasks: Tasks): Record<OperationName, OperationHandler> {
+function handlers(
+	artifacts: ArtifactStore,
+	gates: GateRunner,
+	tasks: Tasks,
+	migrate: () => unknown,
+): Record<OperationName, OperationHandler> {
 	const taskFilter = (input: OperationInput) => ({
 		status: optionalString(input, "status"),
 		text: optionalString(input, "text"),
 		limit: optionalNumber(input, "limit"),
 	});
 	return {
+		"system.migrate": () => migrate(),
 		"artifact.create": (input) => artifacts.create(normalizeCreateInput(input)),
 		"artifact.query": (input) => artifacts.query(input),
 		"artifact.show": (input) => artifacts.get(string(input, "id"), {
@@ -156,7 +176,7 @@ function handlers(artifacts: ArtifactStore, gates: GateRunner, tasks: Tasks): Re
 		"tasks.create": (input) => tasks.create({
 			title: string(input, "title"),
 			body: optionalString(input, "body"),
-			status: optionalString(input, "status") as "pending" | "active" | "done" | "failed" | undefined,
+			status: optionalString(input, "status") as TaskStatus | undefined,
 			labels: input["labels"] as string[] | undefined,
 			extra: input["extra"] as Record<string, unknown> | undefined,
 			gates: input["gates"] as Parameters<Tasks["create"]>[0]["gates"],
@@ -169,13 +189,17 @@ function handlers(artifacts: ArtifactStore, gates: GateRunner, tasks: Tasks): Re
 		"tasks.graph": (input) => tasks.graph(taskFilter(input)),
 		"tasks.plan": (input) => projectTaskExecution(tasks.graph(taskFilter(input))),
 		"tasks.show": (input) => tasks.show(string(input, "id")),
+		"tasks.active": () => tasks.active(),
+		"tasks.focus": (input) => tasks.focus(string(input, "id")),
 		"tasks.start": (input) => tasks.transition(string(input, "id"), "start"),
+		"tasks.submit": (input) => tasks.transition(string(input, "id"), "submit"),
 		"tasks.complete": (input) => tasks.completeAsync(string(input, "id")),
 		"tasks.run_gates": (input) => tasks.runGates(string(input, "id")),
 		"tasks.set_checklist": (input) => tasks.setChecklist(string(input, "id"), input["checklist"] as Checklist),
-		"tasks.context": () => taskContext(artifacts),
-		"tasks.fail": (input) => tasks.transition(string(input, "id"), "fail"),
+		"tasks.context": () => taskContext(artifacts, tasks.active()?.id),
+		"tasks.reject": (input) => tasks.transition(string(input, "id"), "reject"),
 		"tasks.retry": (input) => tasks.transition(string(input, "id"), "retry"),
+		"tasks.cancel": (input) => tasks.transition(string(input, "id"), "cancel"),
 		"tasks.depend": (input) => tasks.depend(string(input, "id"), string(input, "dependency_id")),
 		"tasks.contain": (input) => tasks.contain(string(input, "parent_id"), string(input, "child_id")),
 		"docs.create": (input) => createDocument(artifacts, {
@@ -223,13 +247,22 @@ export function createPapyrusService(path: string): PapyrusService {
 	const db = openDb(path);
 	const artifacts = new SQLiteArtifactStore(db);
 	const gates = new SQLiteGateRunner(db);
-	const tasks = new Tasks(artifacts, gates);
-	const registry = handlers(artifacts, gates, tasks);
+	const focus = new SQLiteTaskFocusStore(db);
+	const tasks = new Tasks(artifacts, gates, focus);
+	const registry = handlers(artifacts, gates, tasks, () => migrateDb(db));
+	const state = (): SchemaState => {
+		const current = schemaVersion(db);
+		return { current, required: SQLITE_SCHEMA_VERSION, migrationRequired: current !== SQLITE_SCHEMA_VERSION };
+	};
 	return {
 		operationNames: () => [...EXPECTED_OPERATION_NAMES],
+		schemaState: state,
 		async execute(operation, input = {}) {
 			const handler = registry[operation as OperationName];
 			if (!handler) throw new UnknownOperationError(`unknown operation "${operation}"`);
+			if (operation !== "system.migrate" && state().migrationRequired) {
+				throw new MigrationRequiredError("database migration required; run `papyrus migrate task-lifecycle`");
+			}
 			return handler(input);
 		},
 		checkpoint: () => { db.exec("PRAGMA wal_checkpoint(PASSIVE)"); },
@@ -278,7 +311,7 @@ export function createApp(deps: { service: PapyrusService; token: string }): { f
 			}
 			const url = new URL(request.url);
 			if (request.method === "GET" && url.pathname === "/health") {
-				return json({ ok: true, version: VERSION });
+				return json({ ok: true, version: VERSION, schema: deps.service.schemaState() });
 			}
 			if (request.method === "GET" && url.pathname === "/api/v1/ops") {
 				return json({ operations: deps.service.operationNames() });

package/src/task-context.ts

@@ -1,8 +1,8 @@
 import type { Artifact } from "./domain/artifact.ts";
 import type { ArtifactStore } from "./ports/artifact-store.ts";
 import {
-	TASK_CONTEXT_ACTIVE_LIMIT,
-	TASK_CONTEXT_FAILED_LIMIT,
+	TASK_CONTEXT_CURRENT_LIMIT,
+	TASK_CONTEXT_REJECTED_LIMIT,
 	TASK_RECONCILIATION_INSTRUCTION,
 } from "./constants.ts";
 
@@ -34,19 +34,20 @@ function renderCurrent(task: Artifact): string[] {
 	];
 }
 
-export function taskContext(artifacts: ArtifactStore): string | null {
+export function taskContext(artifacts: ArtifactStore, activeTaskId?: string): string | null {
 	const tasks = artifacts.query({ kind: "task" }).sort((left, right) => left.updated_at.localeCompare(right.updated_at));
-	const open = tasks.filter((task) => task.status !== "done");
+	const open = tasks.filter((task) => task.status !== "done" && task.status !== "canceled");
 	if (open.length === 0) return null;
 
 	const done = tasks.length - open.length;
-	const active = open.filter((task) => task.status === "active").slice(0, TASK_CONTEXT_ACTIVE_LIMIT);
-	const next = open.find((task) => task.status === "pending");
-	const failed = open.filter((task) => task.status === "failed").slice(0, TASK_CONTEXT_FAILED_LIMIT);
+	const active = activeTaskId ? open.find((task) => task.id === activeTaskId) : undefined;
+	const current = active ? [active] : open.filter((task) => task.status === "in-progress" || task.status === "review").slice(0, TASK_CONTEXT_CURRENT_LIMIT);
+	const next = open.find((task) => task.status === "todo");
+	const rejected = open.filter((task) => task.status === "rejected").slice(0, TASK_CONTEXT_REJECTED_LIMIT);
 	const lines = [`Progress: ${done}/${tasks.length} done`];
-	for (const task of active) lines.push(...renderCurrent(task));
+	for (const task of current) lines.push(...renderCurrent(task));
 	if (next) lines.push(`Next: ${next.title} (${next.id})`);
-	if (failed.length > 0) lines.push(`Blocked: ${failed.map((task) => `${task.title} (${task.id})`).join(", ")}`);
+	if (rejected.length > 0) lines.push(`Rejected: ${rejected.map((task) => `${task.title} (${task.id})`).join(", ")}`);
 	lines.push("", TASK_RECONCILIATION_INSTRUCTION);
 	return lines.join("\n");
 }

package/src/task-execution.ts

@@ -1,12 +1,22 @@
 import { TASK_EXECUTION_MAX_DEGREE, TASK_EXECUTION_MAX_EDGES, TASK_EXECUTION_MAX_NODES } from "./constants.ts";
 import type { TaskGraph } from "./task-service.ts";
 
-export type TaskExecutionState = "done" | "active" | "ready" | "blocked" | "failed" | "invalid";
+export type TaskExecutionState =
+	| "todo"
+	| "in-progress"
+	| "review"
+	| "rejected"
+	| "done"
+	| "canceled"
+	| "ready"
+	| "blocked"
+	| "invalid";
 
 export interface TaskExecutionNode {
 	id: string;
 	title: string;
 	status: string;
+	active: boolean;
 	state: TaskExecutionState;
 	layer: number | null;
 	prerequisiteIds: string[];
@@ -21,8 +31,10 @@ export interface TaskExecutionPlan {
 
 function executionState(status: string, invalid: boolean, prerequisitesDone: boolean): TaskExecutionState {
 	if (invalid) return "invalid";
-	if (status === "done" || status === "active" || status === "failed") return status;
-	if (status === "pending" && prerequisitesDone) return "ready";
+	if (status === "todo") return prerequisitesDone ? "ready" : "blocked";
+	if (["in-progress", "review", "rejected", "done", "canceled"].includes(status)) {
+		return status as TaskExecutionState;
+	}
 	return "blocked";
 }
 
@@ -96,6 +108,7 @@ export function projectTaskExecution(graph: TaskGraph): TaskExecutionPlan {
 				id: node.task.id,
 				title: node.task.title,
 				status: node.task.status,
+				active: node.active === true,
 				state,
 				layer: layerById.get(node.task.id) ?? null,
 				prerequisiteIds,

package/src/task-graph-view.ts

@@ -5,11 +5,14 @@ import type { TaskGraph } from "./task-service.ts";
 export type TaskGraphView = "execution" | "dependencies" | "composition";
 
 const EXECUTION_GLYPHS: Record<TaskExecutionState, string> = {
+	todo: "○",
+	"in-progress": "●",
+	review: "◆",
+	rejected: "▲",
 	done: "■",
-	active: "●",
+	canceled: "×",
 	ready: "◇",
 	blocked: "○",
-	failed: "▲",
 	invalid: "!",
 };
 
@@ -39,7 +42,7 @@ export function projectTaskGraph(graph: TaskGraph, view: TaskGraphView): Display
 	const nodes = view === "execution"
 		? projectTaskExecution(graph).nodes.map((node) => ({
 			id: node.id,
-			label: `${EXECUTION_GLYPHS[node.state]} ${node.title} · ${node.layer === null ? "no layer" : `layer ${node.layer + 1}`} · ${node.state}`,
+			label: `${node.active ? "▶ " : ""}${EXECUTION_GLYPHS[node.state]} ${node.title} · ${node.layer === null ? "no layer" : `layer ${node.layer + 1}`} · ${node.state}`,
 			status: node.state,
 		}))
 		: graph.nodes