@danypops/papyrus 0.3.0 → 0.5.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.
 
@@ -84,7 +93,7 @@ Agent-facing domain tools own lifecycle invariants and sit above this store API:
 - **`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.
 
@@ -92,7 +101,7 @@ Internally, application services depend on the `ArtifactStore` and `GateRunner`
 
 ## Interactive frontends
 
-- `/tasks` — task lifecycle, gates, dependencies, and nested metadata
+- `/tasks` — task lifecycle, append-only history, gates, dependencies, and nested metadata
 - `/docs` — searchable documents, lifecycle, details, and graph links
 - `/rules` — severity/condition rows, exact injection preview, enable/disable, and task gating
 - `/skills` — trigger/tools rows, invocation into the editor, and artifact templates
@@ -105,6 +114,7 @@ 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
+- 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
@@ -112,13 +122,15 @@ Run `/tasks` for the interactive task panel:
 - 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
+- Show details keeps Checklist and Validation gates separate from incidental Metadata, renders bounded post-migration lifecycle history with actor/source/reason and gate evidence, 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 history <id> --json
 papyrus tasks focus <id> --json
 papyrus tasks start <id> --json
 papyrus tasks submit <id> --json
@@ -160,10 +172,10 @@ 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:
+Existing databases are never migrated on daemon boot. After upgrading to append-only task history, run the authenticated CLI migration explicitly. A v1 database receives the lifecycle prerequisite and history schema in one transaction; existing tasks receive no fabricated events:
 
 ```bash
-~/.pi/agent/npm/node_modules/.bin/papyrus migrate task-lifecycle
+~/.pi/agent/npm/node_modules/.bin/papyrus migrate task-history
 ```
 
 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.

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,9 @@ 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 { TaskHistoryPage } from "../../src/domain/task-event.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 +31,7 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 	pi.registerTool({
 		name: "tasks",
 		label: "Tasks",
-		description: "Task domain tool. ACTIONS: create, list, show, 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.",
+		description: "Task domain tool. ACTIONS: create, list, show, history, 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()),
@@ -38,6 +40,10 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 			status: Type.Optional(Type.String()),
 			text: Type.Optional(Type.String()),
 			limit: Type.Optional(Type.Number()),
+			cursor: Type.Optional(Type.Number()),
+			direction: Type.Optional(Type.Union([Type.Literal("asc"), Type.Literal("desc")])),
+			reason: Type.Optional(Type.String()),
+			session_id: Type.Optional(Type.String()),
 			labels: Type.Optional(Type.Array(Type.String())),
 			extra: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
 			gates: Type.Optional(Type.Array(Type.Record(Type.String(), Type.Unknown()))),
@@ -51,8 +57,9 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 		async execute(_id, params) {
 			try {
 				const action = params.action;
+				const request = { ...params, actor: "agent", source: "pi-tool" };
 				if (action === "create") {
-					const artifact = await callService<Record<string, unknown>, Artifact>("tasks.create", params);
+					const artifact = await callService<Record<string, unknown>, Artifact>("tasks.create", request);
 					return text(`Created task ${artifactLine(artifact)}`, { artifact });
 				}
 				if (action === "list") {
@@ -63,10 +70,21 @@ 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 === "history") {
+					const page = await callService<Record<string, unknown>, TaskHistoryPage>("tasks.history", request);
+					const lines = page.events.map((event) => `${event.occurredAt} ${event.type} ${event.fromStatus ?? "∅"} → ${event.toStatus ?? "∅"} · ${event.actor}/${event.source}${event.reason ? ` · ${event.reason}` : ""}`);
+					return text(lines.join("\n") || "No recorded history for this task.", { page });
+				}
 				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]));
@@ -85,7 +103,7 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 					return text(`Updated checklist: ${artifactLine(artifact)}`, { artifact });
 				}
 				if (action === "complete") {
-					const result = await callService<Record<string, unknown>, TaskCompletion>("tasks.complete", params);
+					const result = await callService<Record<string, unknown>, TaskCompletion>("tasks.complete", request);
 					const gates = result.gates.map((gate) => `${gate.passed ? "✓" : "✗"} ${gate.gate.type}: ${gate.gate.target} — ${gate.output}`).join("\n");
 					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)}` : "";
@@ -95,7 +113,7 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 					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);
+					const gates = await callService<Record<string, unknown>, GateResult[]>("tasks.run_gates", request);
 					return text(gates.map((gate) => `${gate.passed ? "✓" : "✗"} ${gate.gate.type}: ${gate.gate.target} — ${gate.output}`).join("\n") || "No gates configured.", { gates });
 				}
 				const operations = {
@@ -110,7 +128,7 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 				} 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);
+				const artifact = await callService<Record<string, unknown>, Artifact>(operation, request);
 				return text(artifactLine(artifact), { artifact });
 			} catch (error) {
 				return text(`tasks failed: ${error instanceof Error ? error.message : error}`);
@@ -203,11 +221,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())),
@@ -229,6 +249,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

@@ -21,7 +21,7 @@ import { callService } from "./service-client.ts";
 import { registerDomainTools } from "./domain-tools.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> = {}) {
@@ -34,6 +34,21 @@ function text(t: string, details: Record<string, unknown> = {}) {
 
 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;
@@ -93,31 +108,7 @@ class TaskOverlay {
 	}
 
 	private renderLines(theme: Theme, width: number): string[] {
-		const projection = buildTaskWidgetProjection(this.snapshot);
-		if (projection.total === 0) return [];
-
-		if (projection.openTotal === 0) {
-			return [truncateToWidth(theme.bold("Tasks · no open tasks · /tasks"), width, "…")];
-		}
-
-		const active = projection.rows.find((row) => row.active);
-		const lines = [
-			truncateToWidth(
-				theme.bold(`Tasks · ${active ? theme.fg("accent", "▶ active") : "no active focus"} · ${projection.openTotal} open`),
-				width,
-				"…",
-			),
-		];
-		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;
+		return renderTaskWidgetLines(theme, buildTaskWidgetProjection(this.snapshot), width);
 	}
 
 	dispose(): void {

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

@@ -1,4 +1,5 @@
 import type { Artifact } from "../../src/domain/artifact.ts";
+import type { TaskEvent } from "../../src/domain/task-event.ts";
 import { checklistEntries, type ProofReference } from "../../src/domain/checklist.ts";
 import { formatMetadata } from "./artifact-format.ts";
 
@@ -48,7 +49,28 @@ function gateLines(value: unknown): string[] {
 	return lines;
 }
 
-export function taskDetailsText(task: Artifact, relationshipGraphLines: string[] = []): string {
+function historyLines(history: TaskEvent[]): string[] {
+	if (history.length === 0) return ["History:", "  (no post-migration events recorded)"];
+	const lines = ["History:"];
+	for (const event of history) {
+		const transition = event.fromStatus || event.toStatus ? ` · ${event.fromStatus ?? "∅"} → ${event.toStatus ?? "∅"}` : "";
+		const reason = event.reason ? ` · ${event.reason}` : "";
+		lines.push(`  ${event.occurredAt} · ${event.type}${transition} · ${event.actor}/${event.source}${reason}`);
+		if (event.evidence?.result) lines.push(`    result: ${event.evidence.result}`);
+		if (Array.isArray(event.evidence?.gates)) {
+			for (const value of event.evidence.gates) {
+				if (typeof value !== "object" || value === null || Array.isArray(value)) continue;
+				const result = value as Record<string, unknown>;
+				const gate = typeof result["gate"] === "object" && result["gate"] !== null ? result["gate"] as Record<string, unknown> : {};
+				const passed = result["passed"] === true;
+				lines.push(`    ${passed ? "✓" : "✗"} ${String(gate["type"] ?? "gate")} · ${String(gate["target"] ?? "unknown")}`);
+			}
+		}
+	}
+	return lines;
+}
+
+export function taskDetailsText(task: Artifact, relationshipGraphLines: string[] = [], history: TaskEvent[] = []): string {
 	let output = `${TASK_STATUS_GLYPHS[task.status] ?? "?"} ${task.title}\n${task.id} [task|${task.status}]`;
 	if (task.labels.length > 0) output += `\nLabels: ${task.labels.join(", ")}`;
 	output += `\n\n${task.body || "(no body)"}`;
@@ -60,6 +82,7 @@ export function taskDetailsText(task: Artifact, relationshipGraphLines: string[]
 	if (Object.keys(metadata).length > 0) {
 		output += `\n\nMetadata:\n${formatMetadata(metadata).map((line) => `  ${line}`).join("\n")}`;
 	}
+	output += `\n\n${historyLines(history).join("\n")}`;
 	if (task.edges?.length) {
 		const graph = relationshipGraphLines.length > 0 ? relationshipGraphLines.join("\n") : "  (graph unavailable)";
 		output += `\n\nRelationships:\n  Dependencies point prerequisite → dependent.\n${graph}`;

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

@@ -7,6 +7,7 @@ import {
 	TASK_DETAIL_RESERVED_ROWS,
 } from "../../src/constants.ts";
 import type { Artifact } from "../../src/domain/artifact.ts";
+import type { TaskEvent } from "../../src/domain/task-event.ts";
 import type { GraphRenderer } from "../../src/ports/graph-renderer.ts";
 import { projectTaskRelationships } from "../../src/task-relationship-view.ts";
 import type { TaskGraph } from "../../src/task-service.ts";
@@ -31,13 +32,14 @@ class TaskDetailViewport {
 		private readonly theme: Theme,
 		task: Artifact,
 		private readonly graphLines: string[],
+		history: TaskEvent[],
 		private readonly close: () => void,
 	) {
 		this.visibleLines = Math.max(
 			TASK_DETAIL_MIN_VISIBLE_LINES,
 			Math.min(TASK_DETAIL_MAX_VISIBLE_LINES, tui.terminal.rows - TASK_DETAIL_RESERVED_ROWS),
 		);
-		this.narrative = taskDetailsText({ ...task, edges: undefined });
+		this.narrative = taskDetailsText({ ...task, edges: undefined }, [], history);
 	}
 
 	invalidate(): void { this.renderedWidth = 0; }
@@ -99,13 +101,14 @@ export async function showTaskDetails(
 	task: Artifact,
 	graph?: TaskGraph,
 	renderer: GraphRenderer = new BeautifulMermaidRenderer(),
+	history: TaskEvent[] = [],
 ): Promise<void> {
 	const relationshipGraph = renderer.render(projectTaskRelationships(task, graph)).lines;
-	const content = taskDetailsText(task, relationshipGraph);
+	const content = taskDetailsText(task, relationshipGraph, history);
 	if (ctx.mode !== "tui") {
 		ctx.ui.notify(content, "info");
 		return;
 	}
 	await ctx.ui.custom<void>((tui, theme, _keybindings, done) =>
-		new TaskDetailViewport(tui, theme, task, relationshipGraph, done));
+		new TaskDetailViewport(tui, theme, task, relationshipGraph, history, done));
 }

package/extension/src/task-graph.ts

@@ -86,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/tasks.ts

@@ -14,6 +14,7 @@ export { taskDetailsText } from "./task-detail-format.ts";
 export { showTaskDetails } from "./task-detail-view.ts";
 import type { Artifact } from "../../src/domain/artifact.ts";
 import type { GateResult } from "../../src/domain/gate.ts";
+import type { TaskHistoryPage } from "../../src/domain/task-event.ts";
 import { projectTaskExecution } from "../../src/task-execution.ts";
 import type { TaskCompletion, TaskGraph, TaskStatus } from "../../src/task-service.ts";
 import { TASK_STATUS_PRESENTATION, taskTreeConnector } from "./task-presentation.ts";
@@ -70,7 +71,7 @@ export async function showTasks(ctx: ExtensionCommandContext): Promise<void> {
 		if (create === "Create a task") {
 			const title = await ctx.ui.input("Task title:", "");
 			if (title) {
-				await callService("tasks.create", { title });
+				await callService("tasks.create", { title, actor: "user", source: "tasks-tui" });
 				graph = await loadTaskGraph();
 			}
 		}
@@ -97,7 +98,8 @@ export async function showTasks(ctx: ExtensionCommandContext): Promise<void> {
 		if (choice === "Show details") {
 			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);
+			const history = await callService<Record<string, unknown>, TaskHistoryPage>("tasks.history", { id: art.id, direction: "desc" });
+			await showTaskDetails(ctx, art, graph, undefined, [...history.events].reverse());
 		} else if (choice === "Make active") {
 			try {
 				await callService<Record<string, unknown>, Artifact>("tasks.focus", { id: action.row.id });
@@ -107,7 +109,7 @@ export async function showTasks(ctx: ExtensionCommandContext): Promise<void> {
 			}
 		} else if (choice === "Run gates") {
 			try {
-				const results = await callService<Record<string, unknown>, GateResult[]>("tasks.run_gates", { id: action.row.id });
+				const results = await callService<Record<string, unknown>, GateResult[]>("tasks.run_gates", { id: action.row.id, actor: "user", source: "tasks-tui" });
 				ctx.ui.notify(`Gates:\n${results.map((gate) => `${gate.passed ? "✓" : "✗"} ${gate.gate.type}: ${gate.gate.target} — ${gate.output}`).join("\n")}`, "info");
 			} catch (error) {
 				ctx.ui.notify(`Gates failed: ${error instanceof Error ? error.message : error}`, "error");
@@ -126,7 +128,7 @@ export async function showTasks(ctx: ExtensionCommandContext): Promise<void> {
 									? "tasks.cancel"
 									: "tasks.complete";
 				if (operation === "tasks.complete") {
-					const result = await callService<Record<string, unknown>, TaskCompletion>(operation, { id: action.row.id });
+					const result = await callService<Record<string, unknown>, TaskCompletion>(operation, { id: action.row.id, actor: "user", source: "tasks-tui" });
 					action.row.status = result.artifact.status;
 					const gates = result.gates.map((gate) => `${gate.passed ? "✓" : "✗"} ${gate.gate.type}: ${gate.gate.target}`).join("\n");
 					const checklist = result.checklist.map((item) => `${item.accepted ? "✓" : "✗"} proof: ${item.item}`).join("\n");
@@ -141,7 +143,7 @@ export async function showTasks(ctx: ExtensionCommandContext): Promise<void> {
 						result.completed ? "info" : "warning",
 					);
 				} else {
-					const updated = await callService<Record<string, unknown>, Artifact>(operation, { id: action.row.id });
+					const updated = await callService<Record<string, unknown>, Artifact>(operation, { id: action.row.id, actor: "user", source: "tasks-tui" });
 					action.row.status = updated.status;
 					ctx.ui.notify(`${updated.id} → [${updated.status}]`, "info");
 				}

package/package.json

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