@danypops/papyrus 0.2.1 → 0.4.0

package/extension/src/task-widget.ts

@@ -1,49 +1,56 @@
-import { TASK_WIDGET_ACTIVE_LIMIT } from "../../src/constants.ts";
+import { TASK_WIDGET_OPEN_LIMIT } from "../../src/constants.ts";
 import type { Artifact } from "../../src/domain/artifact.ts";
 import type { TaskGraph } from "../../src/task-service.ts";
 
 export interface TaskWidgetRow {
 	task: Artifact;
 	depth: number;
-	hasActiveChildren: boolean;
+	hasOpenChildren: boolean;
+	active: boolean;
 }
 
 export interface TaskWidgetProjection {
-	active: TaskWidgetRow[];
-	activeTotal: number;
+	rows: TaskWidgetRow[];
+	openTotal: number;
 	total: number;
 }
 
-/** Keep active work in containment order; /tasks owns full graph navigation. */
+function isOpen(task: Artifact): boolean {
+	return task.status !== "done" && task.status !== "canceled";
+}
+
+/** Keep bounded actionable work in containment order while always retaining active focus. */
 export function buildTaskWidgetProjection(
 	graph: TaskGraph,
-	activeLimit = TASK_WIDGET_ACTIVE_LIMIT,
+	openLimit = TASK_WIDGET_OPEN_LIMIT,
 ): TaskWidgetProjection {
-	const visibleNodes = graph.nodes.filter((node) => node.task.status !== "deleted");
-	const byId = new Map(visibleNodes.map((node) => [node.task.id, node]));
+	const byId = new Map(graph.nodes.map((node) => [node.task.id, node]));
 	const visited = new Set<string>();
 	const ordered: TaskWidgetRow[] = [];
 
-	const visit = (id: string, activeDepth: number): void => {
+	const visit = (id: string, openDepth: number): void => {
 		if (visited.has(id)) return;
 		const node = byId.get(id);
 		if (!node) return;
 		visited.add(id);
-		const active = node.task.status === "active";
-		if (active) ordered.push({ task: node.task, depth: activeDepth, hasActiveChildren: false });
-		const childDepth = active ? activeDepth + 1 : activeDepth;
+		const open = isOpen(node.task);
+		if (open) ordered.push({ task: node.task, depth: openDepth, hasOpenChildren: false, active: node.active === true });
+		const childDepth = open ? openDepth + 1 : openDepth;
 		for (const childId of node.childIds) visit(childId, childDepth);
 	};
 
 	for (const rootId of graph.rootIds) visit(rootId, 0);
-	for (const node of visibleNodes) visit(node.task.id, 0);
+	for (const node of graph.nodes) visit(node.task.id, 0);
 	for (let index = 0; index < ordered.length - 1; index++) {
-		ordered[index]!.hasActiveChildren = ordered[index + 1]!.depth > ordered[index]!.depth;
+		ordered[index]!.hasOpenChildren = ordered[index + 1]!.depth > ordered[index]!.depth;
 	}
-	const active = ordered.slice(0, Math.max(0, activeLimit));
-	return {
-		active,
-		activeTotal: ordered.length,
-		total: visibleNodes.length,
-	};
+
+	const limit = Math.max(0, openLimit);
+	let rows = ordered.slice(0, limit);
+	const active = ordered.find((row) => row.active);
+	if (active && !rows.some((row) => row.task.id === active.task.id) && limit > 0) {
+		rows = [...rows.slice(0, Math.max(0, limit - 1)), active]
+			.sort((left, right) => ordered.indexOf(left) - ordered.indexOf(right));
+	}
+	return { rows, openTotal: ordered.length, total: graph.nodes.length };
 }

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.1",
+  "version": "0.4.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

@@ -1,5 +1,6 @@
 import type { Db } from "../db.ts";
-import type { ArtifactStore } from "../ports/artifact-store.ts";
+import { inTransaction } from "../db.ts";
+import type { AtomicArtifactStore } from "../ports/atomic-artifact-store.ts";
 import type {
 	Artifact,
 	ArtifactEdge,
@@ -11,9 +12,13 @@ import type {
 } from "../domain/artifact.ts";
 import { createArtifact, getArtifact, linkArtifacts, queryArtifacts, updateExtra, updateStatus } from "../ops.ts";
 
-export class SQLiteArtifactStore implements ArtifactStore {
+export class SQLiteArtifactStore implements AtomicArtifactStore {
 	constructor(private readonly db: Db) {}
 
+	atomic<T>(operation: () => T): T {
+		return inTransaction(this.db, operation);
+	}
+
 	create(input: CreateArtifactInput): Artifact {
 		return createArtifact(this.db, input);
 	}

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

@@ -5,7 +5,7 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { connectPapyrusClient, type PapyrusClient } from "./client.ts";
-import { DAEMON_UNIT_NAME } from "./constants.ts";
+import { DAEMON_UNIT_NAME, TASK_EXECUTION_MAX_NODES } from "./constants.ts";
 import { serveMain } from "./daemon.ts";
 import type { GateResult } from "./domain/gate.ts";
 import type { TaskExecutionPlan } from "./task-execution.ts";
@@ -56,9 +56,18 @@ function installService(): void {
 const USAGE = `Usage:
   papyrus serve
   papyrus service <install|start|stop|restart|status>
+  papyrus migrate task-lifecycle [--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 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 +76,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 +103,63 @@ 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 runSkillCli(args: string[], client: TaskCliClient): Promise<string> {
+	const json = args.includes("--json");
+	const positional: string[] = [];
+	let runId: string | undefined;
+	let arguments_: Record<string, unknown> = {};
+	for (let index = 0; index < args.length; index++) {
+		const argument = args[index]!;
+		if (argument === "--json") continue;
+		if (argument === "--run-id") {
+			runId = args[++index];
+			if (!runId) throw new Error("--run-id requires a value");
+			continue;
+		}
+		if (argument === "--arguments-json") {
+			const source = args[++index];
+			if (!source) throw new Error("--arguments-json requires a JSON object");
+			const parsed = JSON.parse(source) as unknown;
+			if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+				throw new Error("--arguments-json must be a JSON object");
+			}
+			arguments_ = parsed as Record<string, unknown>;
+			continue;
+		}
+		if (argument.startsWith("--")) throw new Error(`unknown skills option ${argument}`);
+		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_ };
+	if (runId) input["run_id"] = runId;
+	const result = await client.call<Record<string, unknown>, {
+		runId: string;
+		created: { tasks: string[]; rules: string[]; docs: string[] };
+		rootTaskIds: string[];
+		execution: TaskExecutionPlan;
+	}>("skills.run", input);
+	if (json) return JSON.stringify(result);
+	return [
+		`Created Skill run ${result.runId}: ${result.created.tasks.length} tasks, ${result.created.rules.length} rules, ${result.created.docs.length} docs`,
+		`Ready roots: ${result.rootTaskIds.join(", ") || "none"}`,
+		`Context docs: ${result.created.docs.join(", ") || "none"}`,
+		`Scoped rules: ${result.created.rules.join(", ") || "none"}`,
+		...result.execution.nodes.map((node) => `[${node.state}] ${node.id} ${node.title}`),
+	].join("\n");
+}
+
 export async function runTaskCli(args: string[], client: TaskCliClient): Promise<string> {
 	const json = args.includes("--json");
 	const positional = args.filter((arg) => arg !== "--json");
@@ -101,6 +167,32 @@ 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 "graph": {
+			if (id) throw new Error("tasks graph accepts no positional arguments");
+			const graph = await client.call<{ limit: number }, {
+				nodes: Array<{ dependencyIds: string[]; childIds: string[] }>;
+				rootIds: string[];
+			}>("tasks.graph", { limit: TASK_EXECUTION_MAX_NODES + 1 });
+			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);
+			human = `Task graph: ${graph.nodes.length} nodes, ${graph.rootIds.length} roots, ${dependencies} dependencies, ${children} containment edges`;
+			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 +204,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 +220,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 +242,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, graph, plan, complete, start, submit, reject, retry, cancel, or depend");
 	}
 	return json ? JSON.stringify(result) : human;
 }
@@ -152,6 +255,16 @@ export async function main(args: string[] = process.argv.slice(2)): Promise<void
 		console.log(await runTaskCli(args.slice(1), client));
 		return;
 	}
+	if (command === "skills") {
+		const client = await connectPapyrusClient();
+		console.log(await runSkillCli(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,13 +32,23 @@ 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 parameterized Skill definitions and rendered workflow runs. */
+export const SKILL_MAX_INPUTS = 32;
+export const SKILL_MAX_ENUM_VALUES = 32;
+export const SKILL_MAX_BLUEPRINTS = 100;
+export const SKILL_MAX_LINKS = 500;
+export const SKILL_MAX_RENDERED_BYTES = 1_048_576;
+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;
 export const GRAPH_RENDER_PADDING_X = 2;
 export const GRAPH_RENDER_PADDING_Y = 1;
 export const GRAPH_RENDER_BOX_PADDING = 0;
+/** beautiful-mermaid routed layouts become unsafe on larger task graphs; use bounded line fallback. */
+export const GRAPH_RENDER_MAX_ROUTED_NODES = 48;
+export const GRAPH_RENDER_MAX_ROUTED_EDGES = 96;
+export const GRAPH_RENDER_MAX_FALLBACK_LINES = 200;
 
 /** Safe defaults and hard ceilings for graph expansion. */
 export const DEFAULT_GRAPH_DEPTH = 4;
@@ -58,7 +68,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 +98,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" },