@danypops/papyrus 0.2.1 → 0.4.0

package/README.md

@@ -62,11 +62,20 @@ Each kind has an enforced status vocabulary. Every edge endpoint must exist, and
 
 ### Hierarchy and traversal
 
-Use `contains` and `part_of` for explicit parent/child structure; use `depends_on` for execution ordering. Dependency edges form an executable DAG: self-dependencies and cycles are rejected, fan-in waits for every prerequisite, and fan-out may activate several successors. Graph reads are cycle-safe and bounded by `depth` and `max_nodes` (defaults: depth 4, 100 nodes; hard ceilings: depth 20, 1,000 nodes). Executable task plans are additionally bounded to 1,000 tasks and 10,000 relationships.
+Use `contains` and `part_of` for explicit parent/child structure; use `depends_on` for execution ordering. Dependency edges form an executable DAG: self-dependencies and cycles are rejected, fan-in waits for every prerequisite, and fan-out can expose several ready successors while active focus remains singular. Graph reads are cycle-safe and bounded by `depth` and `max_nodes` (defaults: depth 4, 100 nodes; hard ceilings: depth 20, 1,000 nodes). Executable task plans are additionally bounded to 1,000 tasks and 10,000 relationships.
 
 ### Skills and compatibility templates
 
-A Papyrus Skill is distinct from a conventional prompt-only skill: its input API and templates define a connected Task/Rule/Doc workflow. Task dependencies and gates provide deterministic execution; Rules provide scoped governance; Docs provide invocation context and provenance. The versioned workflow-instantiation API is tracked as active Papyrus work.
+A Papyrus Skill is distinct from a conventional prompt-only skill: its input API and blueprints define a connected Task/Rule/Doc workflow. `skills.run` validates and normalizes all arguments, safely renders placeholders in memory, validates the complete graph, then persists artifacts and edges in one transaction. Task dependencies, containment, gates, checklists, and context survive rendering. Run Rules are injected only while active focus belongs to that run. Docs retain invocation context and provenance; missing evidence references remain unknown and no gate runs during instantiation.
+
+A run result has a stable schema: Skill ID, run ID, normalized arguments, created IDs grouped by kind, ready root task IDs, and the bounded execution plan. Explicit run IDs produce deterministic artifact IDs (`<run-id>-<blueprint-ref>`); collisions roll back the entire run.
+
+```bash
+papyrus skills run <skill-id> \
+  --arguments-json '{"project":"Papyrus"}' \
+  --run-id papyrus-001 \
+  --json
+```
 
 The existing `artifact-template` skill subtype remains a compatibility mechanism for one-artifact templates with metadata `{targetKind, defaults, required}`. Instantiate it through `papyrus_create` with `template_id`; defaults merge recursively, explicit arrays replace defaults, required paths such as `extra.owner` are validated, and target-kind mismatches are rejected.
 
@@ -81,10 +90,10 @@ The `papyrus_*` tools are the low-level graph-store API:
 
 Agent-facing domain tools own lifecycle invariants and sit above this store API:
 
-- **`tasks`** — create/list/show/plan, replace evidence-bearing checklists, hierarchy/dependencies, start/fail/retry, non-blocking gates, and gate-enforced completion with automatic activation of newly ready successors
+- **`tasks`** — create/list/show/plan, manage the singleton active focus, replace evidence-bearing checklists, hierarchy/dependencies, lifecycle transitions, non-blocking gates, and review completion that focuses one deterministic ready successor without claiming effort
 - **`docs`** — create/list/show, activate/archive/reopen, and document-safe graph links
 - **`rules`** — create/list/show/preview, enable/disable, and attach governance gates to tasks
-- **`skills`** — create/list/show/invoke, enable/disable, create templates, and instantiate templates
+- **`skills`** — create/list/show/invoke/run, enable/disable, create compatibility templates, and atomically instantiate parameterized workflow runs
 
 Every tool operation is registered in the daemon’s `/api/v1/ops` registry; parity is verified in tests. The task consumer uses the `tasks.graph` operation, which returns task nodes with explicit parent, child, and dependency IDs rather than leaking SQLite rows or asking the UI to reconstruct relationships.
 
@@ -105,12 +114,30 @@ Run `/tasks` for the interactive task panel:
 
 - `/` filters; arrow keys navigate; Enter opens task actions
 - `g` opens the programmatic Unicode graph; Tab switches dependency/composition views and arrow keys pan
-- advance the `pending → active → done` lifecycle or retry `failed → pending`
-- completing an active task runs only that task’s gates; success marks it done and activates every direct pending successor whose full prerequisite set is done
-- successors are never auto-completed: each must pass its own gates; fan-in, fan-out, diamonds, and disconnected DAGs remain explicit
-- inspect deterministic execution layers, readiness, a nested task hierarchy, composition, dependencies, evidence-bearing checklists, and verification gates
-- Show details keeps Checklist and Validation gates separate from incidental Metadata, then renders relationships as a Unicode graph footer; `↑/↓` scrolls and `←/→` pans wide graphs
-- the compact persistent widget shows active work in containment order, indents active children beneath active parents, and points to `/tasks` for the complete graph
+- routed graph layouts are bounded to 48 nodes/96 edges; larger graphs use a deterministic, box-drawn line fallback, and renderer failures are contained inside the viewport rather than escaping Pi
+- advance the `todo → in-progress → review → done` lifecycle; failed review becomes `rejected`, retry returns to `in-progress`, and `canceled` is terminal
+- use **active** only as the independent singleton focus that auto-drive continues; focusing a task never changes its lifecycle
+- starting nested effort moves todo ancestors to in-progress; submitting enters review; completing review checks both typed checklist proofs and executable gates
+- passing review marks only that task done and focuses one deterministic ready successor while leaving the successor todo until effort starts
+- successors are never auto-completed; fan-in, fan-out, diamonds, and disconnected DAGs remain explicit
+- inspect deterministic execution layers, readiness, a box-drawn nested hierarchy, composition, dependencies, evidence-bearing checklists, and verification gates
+- lifecycle colors are semantic and redundant with text/glyphs: To-Do grey, in-progress yellow, review blue, rejected orange, done green, and canceled red; `▶` marks active focus
+- Show details keeps Checklist and Validation gates separate from incidental Metadata, then renders relationships as a Unicode box-drawing graph footer; `↑/↓` scrolls and `←/→` pans wide graphs
+- the compact persistent widget shows bounded open work in containment order and always retains the active focus
+
+Authenticated CLI parity covers the changed lifecycle and focus operations:
+
+```bash
+papyrus tasks graph --json
+papyrus tasks active --json
+papyrus tasks focus <id> --json
+papyrus tasks start <id> --json
+papyrus tasks submit <id> --json
+papyrus tasks complete <id> --json
+papyrus tasks reject <id> --json
+papyrus tasks retry <id> --json
+papyrus tasks cancel <id> --json
+```
 
 Checklist criteria are an item-to-proof map. Every new item requires one or more typed references to inspectable evidence; proof presence does not imply that the evidence passed an executable gate:
 
@@ -127,9 +154,9 @@ checklist: {
 
 Proof types are `file`, `symbol`, `code`, `test`, `command`, `artifact`, and `url`. Existing array checklists remain readable as legacy items with `proof: missing`; Papyrus does not invent evidence.
 
-Papyrus also injects an Alef-style reconciliation block on every agent turn while work remains: `Current`, `Desired`, `Verify`, and `Next`. The agent is explicitly instructed to ask **“Did we accomplish this task?”** and run gates before marking it done. The injection disappears when every task is complete.
+Papyrus also injects an Alef-style reconciliation block on every agent turn while work remains: `Current`, `Desired`, `Verify`, and `Next`. The agent is explicitly instructed to ask **“Did we accomplish this task?”** and run review before marking it done. The injection disappears when every task is done or canceled.
 
-In TUI and RPC modes, the extension checks bounded active Tasks at Pi’s public `agent_settled` lifecycle boundary. If active work remains and no continuation is already pending, it queues one hidden next turn so the agent continues instead of handing off merely because a low-level run ended. Active Tasks are the trigger; no manual command is required. Driving is single-flight and pauses after 20 automatic turns or 6 unchanged task snapshots; human input and task progress reset the bounded counters automatically.
+In TUI and RPC modes, the extension checks the singleton active focus at Pi’s public `agent_settled` lifecycle boundary. If a focused task remains and no continuation is already pending, it queues one hidden next turn. No manual driving command is required. Driving is single-flight and pauses after 20 automatic turns or 6 unchanged task snapshots; human input and task progress reset the bounded counters automatically.
 
 ## Why
 
@@ -140,12 +167,20 @@ Papyrus keeps SQLite’s local simplicity while centralizing writes, migrations,
 Install the published Pi package, then install its supervised user service:
 
 ```bash
-pi install npm:@danypops/papyrus
+packed install npm:@danypops/papyrus
 ~/.pi/agent/npm/node_modules/.bin/papyrus service install
 ```
 
+Existing databases are never migrated on daemon boot. After upgrading across the task-lifecycle schema boundary, run the authenticated CLI migration explicitly:
+
+```bash
+~/.pi/agent/npm/node_modules/.bin/papyrus migrate task-lifecycle
+```
+
+Until that command succeeds, health reports `migrationRequired` and normal domain operations are rejected with actionable guidance. Migration is not exposed as a Pi tool or MCP action. New empty databases bootstrap directly at the current schema.
+
 Reload Pi once the service is active. Git installs remain available for development builds:
 
 ```bash
-pi install git:github.com/DanyPops/papyrus
+packed install git:github.com/DanyPops/papyrus
 ```

package/extension/src/active-task-continuation.ts

@@ -22,23 +22,17 @@ export interface ActiveTaskContinuationDecision {
 	prompt?: string;
 }
 
-const DISPLAYED_TASK_LIMIT = 3;
 const TITLE_LIMIT = 120;
 
-function fingerprint(tasks: ActiveTaskMarker[]): string {
-	return [...tasks]
-		.sort((left, right) => left.id.localeCompare(right.id))
-		.map((task) => `${task.id}:${task.updated_at}`)
-		.join("|");
+function fingerprint(task: ActiveTaskMarker): string {
+	return `${task.id}:${task.updated_at}`;
 }
 
-function continuationPrompt(tasks: ActiveTaskMarker[]): string {
-	const names = tasks.slice(0, DISPLAYED_TASK_LIMIT).map((task) => `- ${task.id}: ${task.title.slice(0, TITLE_LIMIT)}`);
+function continuationPrompt(task: ActiveTaskMarker): string {
 	return [
-		"Continue active Papyrus work now; do not hand off merely because the previous Pi run settled.",
-		"Reconcile the active Tasks, choose the next concrete action, use tools, run gates before completion, and continue until done, blocked, or the bounded continuation pauses.",
-		"Active tasks:",
-		...names,
+		"Continue the active Papyrus Task now; do not hand off merely because the previous Pi run settled.",
+		"Reconcile its lifecycle, take the next concrete action, use tools, submit it for review when implementation effort is ready, and run gates plus checklist review before completion.",
+		`Active task: ${task.id}: ${task.title.slice(0, TITLE_LIMIT)}`,
 	].join("\n");
 }
 
@@ -56,16 +50,16 @@ export class ActiveTaskContinuation {
 		}
 	}
 
-	evaluate(tasks: ActiveTaskMarker[], context: { idle: boolean; pendingMessages: boolean }): ActiveTaskContinuationDecision {
+	evaluate(task: ActiveTaskMarker | null, context: { idle: boolean; pendingMessages: boolean }): ActiveTaskContinuationDecision {
 		if (!context.idle) return { action: "wait", reason: "Pi is not settled" };
 		if (context.pendingMessages) return { action: "wait", reason: "Pi already has pending messages" };
 		if (this.queued) return { action: "wait", reason: "continuation already queued" };
-		if (tasks.length === 0) {
+		if (!task) {
 			this.resetProgress();
-			return { action: "wait", reason: "no active tasks" };
+			return { action: "wait", reason: "no active task" };
 		}
 
-		const currentFingerprint = fingerprint(tasks);
+		const currentFingerprint = fingerprint(task);
 		if (currentFingerprint !== this.lastFingerprint) {
 			this.lastFingerprint = currentFingerprint;
 			this.unchangedTurns = 0;
@@ -85,8 +79,8 @@ export class ActiveTaskContinuation {
 		this.consecutiveTurns += 1;
 		return {
 			action: "continue",
-			reason: "active tasks remain",
-			prompt: continuationPrompt(tasks),
+			reason: "an active task remains",
+			prompt: continuationPrompt(task),
 		};
 	}
 

package/extension/src/artifact-format.ts

@@ -6,10 +6,12 @@ import {
 } from "../../src/constants.ts";
 
 const STATUS_GLYPHS: Record<string, string> = {
-	pending: "○",
-	active: "●",
+	todo: "○",
+	"in-progress": "●",
+	review: "◆",
+	rejected: "▲",
 	done: "■",
-	failed: "▲",
+	canceled: "×",
 };
 
 export interface MetadataFormatOptions {

package/extension/src/beautiful-mermaid-renderer.ts

@@ -1,6 +1,9 @@
 import { renderMermaidASCII } from "beautiful-mermaid";
 import {
 	GRAPH_RENDER_BOX_PADDING,
+	GRAPH_RENDER_MAX_FALLBACK_LINES,
+	GRAPH_RENDER_MAX_ROUTED_EDGES,
+	GRAPH_RENDER_MAX_ROUTED_NODES,
 	GRAPH_RENDER_PADDING_X,
 	GRAPH_RENDER_PADDING_Y,
 } from "../../src/constants.ts";
@@ -30,9 +33,29 @@ export function mermaidSource(graph: DisplayGraph): string {
 	return lines.join("\n");
 }
 
+function boundedLineFallback(graph: DisplayGraph): RenderedGraph {
+	const candidates = [
+		"┌─ Task graph ─",
+		`│ ${graph.nodes.length} nodes · ${graph.edges.length} edges · routed layout skipped above ${GRAPH_RENDER_MAX_ROUTED_NODES} nodes`,
+		"├─ Nodes",
+		...graph.nodes.map((node) => `│ ${node.label}`),
+		"├─ Edges",
+		...graph.edges.map((edge) => `│ ${edge.from} ─${edge.label ? `${edge.label}─` : ""}→ ${edge.to}`),
+	];
+	const contentLimit = Math.max(1, GRAPH_RENDER_MAX_FALLBACK_LINES - 1);
+	const lines = candidates.slice(0, contentLimit);
+	const omitted = candidates.length - lines.length;
+	if (omitted > 0) lines[lines.length - 1] = `│ … ${omitted + 1} lines omitted`;
+	lines.push("└─");
+	return { lines };
+}
+
 export class BeautifulMermaidRenderer implements GraphRenderer {
 	render(graph: DisplayGraph): RenderedGraph {
 		if (graph.nodes.length === 0) return { lines: [] };
+		if (graph.nodes.length > GRAPH_RENDER_MAX_ROUTED_NODES || graph.edges.length > GRAPH_RENDER_MAX_ROUTED_EDGES) {
+			return boundedLineFallback(graph);
+		}
 		const output = renderMermaidASCII(mermaidSource(graph), {
 			useAscii: false,
 			paddingX: GRAPH_RENDER_PADDING_X,

package/extension/src/domain-tools.ts

@@ -4,7 +4,8 @@ import type { Artifact } from "../../src/domain/artifact.ts";
 import { PROOF_TYPES } from "../../src/domain/checklist.ts";
 import type { GateResult } from "../../src/domain/gate.ts";
 import type { TaskExecutionPlan } from "../../src/task-execution.ts";
-import type { TaskCompletion } from "../../src/task-service.ts";
+import type { TaskCompletion, TaskGraph } from "../../src/task-service.ts";
+import type { SkillWorkflowRunResult } from "../../src/skill-execution.ts";
 import { callService } from "./service-client.ts";
 
 function text(message: string, details: Record<string, unknown> = {}) {
@@ -29,7 +30,7 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 	pi.registerTool({
 		name: "tasks",
 		label: "Tasks",
-		description: "Task domain tool. ACTIONS: create, list, show, plan, start, complete (runs gates, refuses done on failure, and starts newly ready successors), fail, retry, run_gates, set_checklist, depend, contain. Dependency graphs support deterministic execution layers, fan-in, and fan-out; cycles are rejected. Checklist is an item-to-proof map; every item requires one or more typed evidence references. Prefer this over low-level papyrus_* tools for task work.",
+		description: "Task domain tool. ACTIONS: create, list, show, graph, plan, active, focus, start, submit, complete, reject, retry, cancel, run_gates, set_checklist, depend, contain. Lifecycle is todo → in-progress → review → done, with review failure → rejected and retry → in-progress; canceled is terminal. Active focus is independent and identifies the one task auto-drive continues. Completion runs gates and checklist-proof review, then focuses one deterministic ready successor without claiming effort. Dependency cycles are rejected. Prefer this over low-level papyrus_* tools for task work.",
 		parameters: Type.Object({
 			action: Type.String(),
 			id: Type.Optional(Type.String()),
@@ -63,6 +64,16 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 					const artifact = await callService<Record<string, unknown>, Artifact>("tasks.show", params);
 					return text(`${artifactLine(artifact)}\n\n${artifact.body}`, { artifact });
 				}
+				if (action === "active") {
+					const artifact = await callService<Record<string, unknown>, Artifact | null>("tasks.active", params);
+					return text(artifact ? `Active: ${artifactLine(artifact)}` : "No active task.", { artifact });
+				}
+				if (action === "graph") {
+					const graph = await callService<Record<string, unknown>, TaskGraph>("tasks.graph", params);
+					const dependencies = graph.nodes.reduce((count, node) => count + node.dependencyIds.length, 0);
+					const containment = graph.nodes.reduce((count, node) => count + node.childIds.length, 0);
+					return text(`Task graph: ${graph.nodes.length} nodes, ${graph.rootIds.length} roots, ${dependencies} dependencies, ${containment} containment edges.`, { graph });
+				}
 				if (action === "plan") {
 					const plan = await callService<Record<string, unknown>, TaskExecutionPlan>("tasks.plan", params);
 					const byId = new Map(plan.nodes.map((node) => [node.id, node]));
@@ -83,17 +94,27 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 				if (action === "complete") {
 					const result = await callService<Record<string, unknown>, TaskCompletion>("tasks.complete", params);
 					const gates = result.gates.map((gate) => `${gate.passed ? "✓" : "✗"} ${gate.gate.type}: ${gate.gate.target} — ${gate.output}`).join("\n");
-					const started = result.started.length > 0 ? `\nStarted: ${result.started.map(artifactLine).join(", ")}` : "";
+					const checklist = result.checklist.map((item) => `${item.accepted ? "✓" : "✗"} proof: ${item.item}${item.reason ? ` — ${item.reason}` : ""}`).join("\n");
+					const focused = result.focused ? `\nActive: ${artifactLine(result.focused)}` : "";
 					const blocked = result.blocked.length > 0
 						? `\nBlocked: ${result.blocked.map((entry) => `${artifactLine(entry.artifact)} waits for ${entry.dependencyIds.join(", ")}`).join("; ")}`
 						: "";
-					return text(`${result.completed ? "Completed" : "Not completed"}: ${artifactLine(result.artifact)}${started}${blocked}${gates ? `\n${gates}` : ""}`, { ...result });
+					return text(`${result.completed ? "Completed" : "Rejected"}: ${artifactLine(result.artifact)}${focused}${blocked}${checklist ? `\n${checklist}` : ""}${gates ? `\n${gates}` : ""}`, { ...result });
 				}
 				if (action === "run_gates") {
 					const gates = await callService<Record<string, unknown>, GateResult[]>("tasks.run_gates", params);
 					return text(gates.map((gate) => `${gate.passed ? "✓" : "✗"} ${gate.gate.type}: ${gate.gate.target} — ${gate.output}`).join("\n") || "No gates configured.", { gates });
 				}
-				const operations = { start: "tasks.start", fail: "tasks.fail", retry: "tasks.retry", depend: "tasks.depend", contain: "tasks.contain" } as const;
+				const operations = {
+					focus: "tasks.focus",
+					start: "tasks.start",
+					submit: "tasks.submit",
+					reject: "tasks.reject",
+					retry: "tasks.retry",
+					cancel: "tasks.cancel",
+					depend: "tasks.depend",
+					contain: "tasks.contain",
+				} as const;
 				const operation = operations[action as keyof typeof operations];
 				if (!operation) return text(`Unknown tasks action: ${action}`);
 				const artifact = await callService<Record<string, unknown>, Artifact>(operation, params);
@@ -189,11 +210,13 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 	pi.registerTool({
 		name: "skills",
 		label: "Skills",
-		description: "Papyrus Skill workflow and compatibility-template domain tool. Papyrus Skills are parameterized Task/Rule/Doc bundles, distinct from prompt-only skills. ACTIONS: create, create_template, list, show, invoke, enable, disable, instantiate.",
+		description: "Papyrus Skill workflow and compatibility-template domain tool. Papyrus Skills are parameterized Task/Rule/Doc bundles, distinct from prompt-only skills. ACTIONS: create, create_template, list, show, invoke, run, enable, disable, instantiate. run validates arguments and atomically creates one scoped workflow run.",
 		parameters: Type.Object({
 			action: Type.String(), id: Type.Optional(Type.String()), title: Type.Optional(Type.String()),
 			body: Type.Optional(Type.String()), trigger: Type.Optional(Type.String()), steps: Type.Optional(Type.Array(Type.String())),
-			tools: Type.Optional(Type.Array(Type.String())), labels: Type.Optional(Type.Array(Type.String())),
+			tools: Type.Optional(Type.Array(Type.String())), definition: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+			arguments: Type.Optional(Type.Record(Type.String(), Type.Unknown())), run_id: Type.Optional(Type.String()),
+			labels: Type.Optional(Type.Array(Type.String())),
 			extra: Type.Optional(Type.Record(Type.String(), Type.Unknown())), status: Type.Optional(Type.String()),
 			text: Type.Optional(Type.String()), limit: Type.Optional(Type.Number()), template_id: Type.Optional(Type.String()),
 			target_kind: Type.Optional(Type.String()), defaults: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
@@ -215,6 +238,17 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 					const invocation = await callService<Record<string, unknown>, string>("skills.invoke", params);
 					return text(invocation, { invocation });
 				}
+				if (action === "run") {
+					const run = await callService<Record<string, unknown>, SkillWorkflowRunResult>("skills.run", params);
+					const execution = run.execution.nodes.map((node) => `  [${node.state}] ${node.id} ${node.title}`).join("\n");
+					return text([
+						`Created Skill run ${run.runId}: ${run.created.tasks.length} tasks, ${run.created.rules.length} rules, ${run.created.docs.length} docs.`,
+						`Ready roots: ${run.rootTaskIds.join(", ") || "none"}.`,
+						`Context docs: ${run.created.docs.join(", ") || "none"}.`,
+						`Scoped rules: ${run.created.rules.join(", ") || "none"}.`,
+						...(execution ? ["Execution:", execution] : []),
+					].join("\n"), { run });
+				}
 				const operations = { show: "skills.show", enable: "skills.enable", disable: "skills.disable", instantiate: "skills.instantiate" } as const;
 				const operation = operations[action as keyof typeof operations];
 				if (!operation) return text(`Unknown skills action: ${action}`);

package/extension/src/index.ts

@@ -11,7 +11,6 @@ import type { ExtensionAPI, ExtensionContext, ExtensionUIContext, Theme } from "
 import { Type } from "typebox";
 import { truncateToWidth } from "@earendil-works/pi-tui";
 import {
-	TASK_DRIVER_ACTIVE_LIMIT,
 	TASK_DRIVER_MAX_TURNS,
 	TASK_DRIVER_MAX_UNCHANGED_TURNS,
 } from "../../src/constants.ts";
@@ -20,9 +19,10 @@ import type { GateResult } from "../../src/domain/gate.ts";
 import { formatMetadata } from "./artifact-format.ts";
 import { callService } from "./service-client.ts";
 import { registerDomainTools } from "./domain-tools.ts";
-import type { TaskGraph } from "../../src/task-service.ts";
+import type { TaskGraph, TaskStatus } from "../../src/task-service.ts";
 import { ActiveTaskContinuation, type ActiveTaskMarker } from "./active-task-continuation.ts";
-import { buildTaskWidgetProjection } from "./task-widget.ts";
+import { buildTaskWidgetProjection, type TaskWidgetProjection } from "./task-widget.ts";
+import { TASK_STATUS_PRESENTATION, taskTreeConnector } from "./task-presentation.ts";
 
 function text(t: string, details: Record<string, unknown> = {}) {
 	return { content: [{ type: "text" as const, text: t }], details };
@@ -32,15 +32,23 @@ function text(t: string, details: Record<string, unknown> = {}) {
 // Task widget (TodoOverlay pattern from rpiv-todo: factory form, requestRender)
 // ---------------------------------------------------------------------------
 
-const GLYPHS: Record<string, (theme: Theme) => string> = {
-	pending:   (t) => t.fg("dim", "○"),
-	active:    (t) => t.fg("warning", "●"),
-	done:      (t) => t.fg("success", "■"),
-	failed:    (t) => t.fg("error", "▲"),
-};
-
 const WIDGET_KEY = "pi-papyrus";
 
+export function renderTaskWidgetLines(theme: Theme, projection: TaskWidgetProjection, width: number): string[] {
+	if (projection.openTotal === 0) return [];
+	const lines: string[] = [];
+	for (let index = 0; index < projection.rows.length; index++) {
+		const row = projection.rows[index]!;
+		const laterSibling = projection.rows.slice(index + 1).some((candidate) => candidate.depth === row.depth);
+		const hierarchy = taskTreeConnector({ depth: row.depth, hasChildren: row.hasOpenChildren, hasLaterSibling: laterSibling });
+		const focus = row.active ? theme.fg("accent", "▶") : " ";
+		const presentation = TASK_STATUS_PRESENTATION[row.task.status as TaskStatus];
+		const glyph = presentation ? theme.fg(presentation.color, presentation.glyph) : theme.fg("muted", "?");
+		lines.push(truncateToWidth(`${focus} ${hierarchy} ${glyph} ${row.task.title}`, width, "…"));
+	}
+	return lines;
+}
+
 class TaskOverlay {
 	private uiCtx: ExtensionUIContext | undefined;
 	private registered = false;
@@ -100,27 +108,7 @@ class TaskOverlay {
 	}
 
 	private renderLines(theme: Theme, width: number): string[] {
-		const projection = buildTaskWidgetProjection(this.snapshot);
-		if (projection.total === 0) return [];
-
-		if (projection.activeTotal === 0) {
-			return [truncateToWidth(theme.bold("Tasks · no active tasks · /tasks"), width, "…")];
-		}
-
-		const lines = [
-			truncateToWidth(
-				theme.bold(`Tasks · ${GLYPHS.active!(theme)} ${projection.activeTotal} active`),
-				width,
-				"…",
-			),
-		];
-		for (const row of projection.active) {
-			const hierarchy = row.depth === 0
-				? row.hasActiveChildren ? "▾" : "·"
-				: `${"  ".repeat(row.depth)}↳`;
-			lines.push(truncateToWidth(`  ${hierarchy} ${GLYPHS.active!(theme)} ${row.task.title}`, width, "…"));
-		}
-		return lines;
+		return renderTaskWidgetLines(theme, buildTaskWidgetProjection(this.snapshot), width);
 	}
 
 	dispose(): void {
@@ -145,10 +133,7 @@ export default async function (pi: ExtensionAPI) {
 	const driveActiveTasks = async (ctx: ExtensionContext): Promise<void> => {
 		if (ctx.mode !== "tui" && ctx.mode !== "rpc") return;
 		try {
-			const active = await callService<Record<string, unknown>, ActiveTaskMarker[]>("tasks.list", {
-				status: "active",
-				limit: TASK_DRIVER_ACTIVE_LIMIT,
-			});
+			const active = await callService<Record<string, never>, ActiveTaskMarker | null>("tasks.active", {});
 			const decision = taskContinuation.evaluate(active, {
 				idle: ctx.isIdle(),
 				pendingMessages: ctx.hasPendingMessages(),
@@ -372,7 +357,7 @@ export default async function (pi: ExtensionAPI) {
 	pi.on("agent_settled", async (_event, ctx) => { await driveActiveTasks(ctx); });
 
 	// ── "Are we there yet?" — inject active tasks into every turn ──────
-	// The agent sees its open work items every turn. If there are failed
+	// The agent sees its open work items every turn. If there are rejected
 	// tasks, they're explicitly called out — the agent should address them.
 
 	pi.on("before_agent_start", async (event, _ctx) => {

package/extension/src/skills.ts

@@ -1,7 +1,10 @@
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import type { Artifact } from "../../src/domain/artifact.ts";
+import type { SkillWorkflowRunResult } from "../../src/skill-execution.ts";
+import type { TaskGraph } from "../../src/task-service.ts";
 import { showArtifactBrowser, showArtifactDetails } from "./artifact-browser.ts";
 import { callService } from "./service-client.ts";
+import { showTaskGraph } from "./task-graph.ts";
 
 const SKILL_GLYPHS: Record<string, string> = { active: "●", deprecated: "○" };
 
@@ -14,6 +17,15 @@ export function skillRowMeta(skill: Artifact): string {
 		const target = typeof skill.extra["targetKind"] === "string" ? skill.extra["targetKind"] : "artifact";
 		return `template → ${target}`;
 	}
+	if (skill.subtype === "workflow") {
+		const definition = skill.extra["definition"] as Record<string, unknown> | undefined;
+		const inputs = definition?.["inputs"] && typeof definition["inputs"] === "object"
+			? Object.keys(definition["inputs"] as Record<string, unknown>).length
+			: 0;
+		const blueprints = definition?.["blueprints"] as Record<string, unknown> | undefined;
+		const tasks = Array.isArray(blueprints?.["tasks"]) ? blueprints["tasks"].length : 0;
+		return `workflow · ${inputs} inputs · ${tasks} tasks`;
+	}
 	const trigger = typeof skill.extra["trigger"] === "string" ? `when ${skill.extra["trigger"]}` : "manual";
 	const tools = strings(skill.extra["tools"]);
 	return [trigger, tools.join(", ")].filter(Boolean).join(" · ");
@@ -23,6 +35,12 @@ export function skillInvocationPrompt(skill: Artifact): string {
 	if (skill.subtype === "artifact-template") {
 		return [`Create an artifact using Papyrus template \"${skill.title}\".`, `template_id: ${skill.id}`, "Ask for or infer the title and all required template fields, then call papyrus_create."].join("\n");
 	}
+	if (skill.subtype === "workflow") {
+		return [
+			`Run Papyrus workflow Skill \"${skill.title}\" (${skill.id}).`,
+			"Collect its required arguments, then call the skills domain tool with action=run.",
+		].join("\n");
+	}
 	const trigger = typeof skill.extra["trigger"] === "string" ? skill.extra["trigger"] : "manual invocation";
 	const steps = strings(skill.extra["steps"]);
 	const tools = strings(skill.extra["tools"]);
@@ -35,6 +53,20 @@ export function skillInvocationPrompt(skill: Artifact): string {
 	].join("\n");
 }
 
+export function skillRunTaskGraph(run: SkillWorkflowRunResult, taskArtifacts: Artifact[]): TaskGraph {
+	const executionById = new Map(run.execution.nodes.map((node) => [node.id, node]));
+	return {
+		nodes: taskArtifacts.map((task) => ({
+			task,
+			active: executionById.get(task.id)?.active === true,
+			parentIds: [],
+			childIds: [],
+			dependencyIds: executionById.get(task.id)?.prerequisiteIds ?? [],
+		})),
+		rootIds: run.rootTaskIds,
+	};
+}
+
 export async function showSkills(ctx: ExtensionCommandContext): Promise<void> {
 	await showArtifactBrowser(ctx, {
 		kind: "skill",
@@ -43,10 +75,37 @@ export async function showSkills(ctx: ExtensionCommandContext): Promise<void> {
 		statusOrder: ["active", "deprecated"],
 		glyphs: SKILL_GLYPHS,
 		rowMeta: skillRowMeta,
-		actions: (skill) => ["Show details", skill.subtype === "artifact-template" ? "Use template" : "Invoke skill", skill.status === "active" ? "Disable" : "Enable"],
+		actions: (skill) => [
+			"Show details",
+			skill.subtype === "artifact-template" ? "Use template" : skill.subtype === "workflow" ? "Run workflow" : "Invoke skill",
+			skill.status === "active" ? "Disable" : "Enable",
+		],
 		handleAction: async (choice, skill, commandCtx) => {
 			if (choice === "Show details") await showArtifactDetails(commandCtx, skill.id, "skills.show");
-			else if (choice === "Invoke skill" || choice === "Use template") {
+			else if (choice === "Run workflow") {
+				const source = await commandCtx.ui.input("Workflow arguments JSON:", "{}");
+				if (source === undefined) return;
+				try {
+					const arguments_ = JSON.parse(source) as unknown;
+					if (typeof arguments_ !== "object" || arguments_ === null || Array.isArray(arguments_)) {
+						throw new Error("arguments must be a JSON object");
+					}
+					const run = await callService<Record<string, unknown>, SkillWorkflowRunResult>("skills.run", {
+						id: skill.id,
+						arguments: arguments_ as Record<string, unknown>,
+					});
+					commandCtx.ui.notify([
+						`Created ${run.runId} · ${run.created.tasks.length} tasks · ${run.rootTaskIds.length} ready roots`,
+						`Context docs: ${run.created.docs.join(", ") || "none"}`,
+						`Scoped rules: ${run.created.rules.join(", ") || "none"}`,
+					].join("\n"), "info");
+					const taskArtifacts = await Promise.all(run.execution.nodes.map((node) =>
+						callService<Record<string, unknown>, Artifact>("tasks.show", { id: node.id })));
+					await showTaskGraph(commandCtx, skillRunTaskGraph(run, taskArtifacts));
+				} catch (error) {
+					commandCtx.ui.notify(`Workflow run failed: ${error instanceof Error ? error.message : error}`, "error");
+				}
+			} else if (choice === "Invoke skill" || choice === "Use template") {
 				const invocation = await callService<Record<string, unknown>, string>("skills.invoke", { id: skill.id });
 				commandCtx.ui.setEditorText(invocation);
 				commandCtx.ui.notify("Invocation placed in the editor", "info");

package/extension/src/task-detail-format.ts

@@ -3,10 +3,12 @@ import { checklistEntries, type ProofReference } from "../../src/domain/checklis
 import { formatMetadata } from "./artifact-format.ts";
 
 const TASK_STATUS_GLYPHS: Record<string, string> = {
-	pending: "○",
-	active: "●",
+	todo: "○",
+	"in-progress": "●",
+	review: "◆",
+	rejected: "▲",
 	done: "■",
-	failed: "▲",
+	canceled: "×",
 };
 
 function proofLine(proof: ProofReference): string {

package/extension/src/task-graph.ts

@@ -10,9 +10,18 @@ import type { GraphRenderer } from "../../src/ports/graph-renderer.ts";
 import { projectTaskGraph, type TaskGraphView } from "../../src/task-graph-view.ts";
 import type { TaskGraph } from "../../src/task-service.ts";
 import { BeautifulMermaidRenderer } from "./beautiful-mermaid-renderer.ts";
+import { TASK_STATUS_PRESENTATION } from "./task-presentation.ts";
 
 const GRAPH_VIEWS: TaskGraphView[] = ["execution", "dependencies", "composition"];
 
+export function colorizeTaskGraphLine(theme: Theme, line: string): string {
+	let colored = line;
+	for (const presentation of Object.values(TASK_STATUS_PRESENTATION)) {
+		colored = colored.replaceAll(presentation.glyph, theme.fg(presentation.color, presentation.glyph));
+	}
+	return colored.replaceAll("▶", theme.fg("accent", "▶"));
+}
+
 export class TaskGraphViewport {
 	private viewIndex = 0;
 	private offsetX = 0;
@@ -51,7 +60,8 @@ export class TaskGraphViewport {
 			truncateToWidth(this.theme.bold(`Task graph · ${GRAPH_VIEWS[this.viewIndex]}`), contentWidth, ""),
 			truncateToWidth(this.theme.fg("dim", `Tab switch · arrows pan · Esc back${position}`), contentWidth, ""),
 			border,
-			...this.graphLines.slice(this.offsetY, end).map((line) => sliceByColumn(line, this.offsetX, contentWidth, true)),
+			...this.graphLines.slice(this.offsetY, end).map((line) =>
+				colorizeTaskGraphLine(this.theme, sliceByColumn(line, this.offsetX, contentWidth, true))),
 			border,
 		];
 	}
@@ -76,8 +86,17 @@ export class TaskGraphViewport {
 
 	private rebuild(): void {
 		const view = GRAPH_VIEWS[this.viewIndex]!;
-		this.graphLines = this.renderer.render(projectTaskGraph(this.graph, view)).lines;
-		if (this.graphLines.length === 0) this.graphLines = [`No task ${view} relationships`];
+		try {
+			this.graphLines = this.renderer.render(projectTaskGraph(this.graph, view)).lines;
+			if (this.graphLines.length === 0) this.graphLines = [`No task ${view} relationships`];
+		} catch {
+			this.graphLines = [
+				"┌─ Task graph ─",
+				`│ Graph rendering failed for ${view} view.`,
+				"│ Press Tab for another view or Esc to close.",
+				"└─",
+			];
+		}
 		this.offsetY = Math.min(this.offsetY, Math.max(0, this.graphLines.length - this.viewportHeight));
 	}
 }

package/extension/src/task-presentation.ts

@@ -0,0 +1,26 @@
+import type { ThemeColor } from "@earendil-works/pi-coding-agent";
+import type { TaskStatus } from "../../src/task-service.ts";
+
+export interface TaskStatusPresentation {
+	label: string;
+	glyph: string;
+	color: ThemeColor;
+}
+
+export const TASK_STATUS_PRESENTATION: Record<TaskStatus, TaskStatusPresentation> = {
+	todo: { label: "To-Do", glyph: "○", color: "muted" },
+	"in-progress": { label: "in-progress", glyph: "●", color: "warning" },
+	review: { label: "review", glyph: "◆", color: "mdLink" },
+	rejected: { label: "rejected", glyph: "▲", color: "accent" },
+	done: { label: "done", glyph: "■", color: "success" },
+	canceled: { label: "canceled", glyph: "×", color: "error" },
+};
+
+export function taskTreeConnector(options: {
+	depth: number;
+	hasChildren: boolean;
+	hasLaterSibling: boolean;
+}): string {
+	if (options.depth === 0) return options.hasChildren ? "▾" : "·";
+	return `${"│ ".repeat(Math.max(0, options.depth - 1))}${options.hasLaterSibling ? "├─" : "└─"}`;
+}