@danypops/papyrus 0.4.0 → 0.5.0

package/README.md

@@ -101,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
@@ -122,7 +122,7 @@ 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:
@@ -130,6 +130,7 @@ 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
@@ -171,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/domain-tools.ts

@@ -4,6 +4,7 @@ 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 { 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";
@@ -30,7 +31,7 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 	pi.registerTool({
 		name: "tasks",
 		label: "Tasks",
-		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.",
+		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()),
@@ -39,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()))),
@@ -52,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") {
@@ -64,6 +70,11 @@ 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 });
@@ -92,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)}` : "";
@@ -102,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 = {
@@ -117,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}`);

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/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.4.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-task-event-store.ts

@@ -0,0 +1,92 @@
+import type { Db } from "../db.ts";
+import { inTransaction } from "../db.ts";
+import {
+	normalizeTaskHistoryQuery,
+	validateTaskEvent,
+	type AppendTaskEvent,
+	type TaskEvent,
+	type TaskEventEvidence,
+	type TaskEventType,
+	type TaskHistoryPage,
+	type TaskHistoryQuery,
+	type TaskLifecycleStatus,
+} from "../domain/task-event.ts";
+import type { TaskEventStore } from "../ports/task-event-store.ts";
+
+interface TaskEventRow {
+	id: number;
+	task_id: string;
+	occurred_at: string;
+	event_type: TaskEventType;
+	actor: string;
+	source: string;
+	session_id: string | null;
+	reason: string | null;
+	from_status: TaskLifecycleStatus | null;
+	to_status: TaskLifecycleStatus | null;
+	attempt_id: string | null;
+	evidence_json: string | null;
+	event_schema_version: 1;
+}
+
+function mapRow(row: TaskEventRow): TaskEvent {
+	return {
+		id: row.id,
+		taskId: row.task_id,
+		occurredAt: row.occurred_at,
+		type: row.event_type,
+		actor: row.actor,
+		source: row.source,
+		...(row.session_id === null ? {} : { sessionId: row.session_id }),
+		...(row.reason === null ? {} : { reason: row.reason }),
+		...(row.from_status === null ? {} : { fromStatus: row.from_status }),
+		...(row.to_status === null ? {} : { toStatus: row.to_status }),
+		...(row.attempt_id === null ? {} : { attemptId: row.attempt_id }),
+		...(row.evidence_json === null ? {} : { evidence: JSON.parse(row.evidence_json) as TaskEventEvidence }),
+		schemaVersion: row.event_schema_version,
+	};
+}
+
+export class SQLiteTaskEventStore implements TaskEventStore {
+	constructor(private readonly db: Db) {}
+
+	atomic<T>(operation: () => T): T { return inTransaction(this.db, operation); }
+
+	append(input: AppendTaskEvent): TaskEvent {
+		const event = validateTaskEvent(input);
+		const result = this.db.prepare(`
+			INSERT INTO task_events (
+				task_id, occurred_at, event_type, actor, source, session_id, reason,
+				from_status, to_status, attempt_id, evidence_json, event_schema_version
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1)
+		`).run(
+			event.taskId,
+			new Date().toISOString(),
+			event.type,
+			event.actor,
+			event.source,
+			event.sessionId ?? null,
+			event.reason ?? null,
+			event.fromStatus ?? null,
+			event.toStatus ?? null,
+			event.attemptId ?? null,
+			event.evidence === undefined ? null : JSON.stringify(event.evidence),
+		);
+		return mapRow(this.db.prepare("SELECT * FROM task_events WHERE id = ?").get(result.lastInsertRowid) as TaskEventRow);
+	}
+
+	history(taskId: string, query: TaskHistoryQuery = {}): TaskHistoryPage {
+		const { limit, direction, cursor } = normalizeTaskHistoryQuery(query);
+		const comparator = direction === "desc" ? "<" : ">";
+		const order = direction === "desc" ? "DESC" : "ASC";
+		const rows = this.db.prepare(`
+			SELECT * FROM task_events
+			WHERE task_id = ? ${cursor === undefined ? "" : `AND id ${comparator} ?`}
+			ORDER BY occurred_at ${order}, id ${order}
+			LIMIT ?
+		`).all(...(cursor === undefined ? [taskId, limit + 1] : [taskId, cursor, limit + 1])) as TaskEventRow[];
+		const hasMore = rows.length > limit;
+		const events = rows.slice(0, limit).map(mapRow);
+		return { events, ...(hasMore ? { nextCursor: events.at(-1)!.id } : {}) };
+	}
+}

package/src/cli.ts

@@ -56,11 +56,12 @@ function installService(): void {
 const USAGE = `Usage:
   papyrus serve
   papyrus service <install|start|stop|restart|status>
-  papyrus migrate task-lifecycle [--json]
+  papyrus migrate task-history [--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 history <id> [--json]
   papyrus tasks focus <id> [--json]
   papyrus tasks complete <id> [--json]
   papyrus tasks start <id> [--json]
@@ -106,8 +107,8 @@ function planText(plan: TaskExecutionPlan): string {
 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`");
+	if (positional.length !== 1 || positional[0] !== "task-history") {
+		throw new Error("migrate requires exactly `task-history`");
 	}
 	const result = await client.call<Record<string, never>, MigrationResult>("system.migrate", {});
 	if (json) return JSON.stringify(result);
@@ -174,6 +175,15 @@ export async function runTaskCli(args: string[], client: TaskCliClient): Promise
 			human = active ? `Active: ${artifactLabel(active)}` : "No active task.";
 			break;
 		}
+		case "history": {
+			if (!id || dependencyId) throw new Error("tasks history requires exactly one task id");
+			const page = await client.call<{ id: string; direction: "desc" }, import("./domain/task-event.ts").TaskHistoryPage>("tasks.history", { id, direction: "desc" });
+			result = page;
+			human = page.events.length === 0
+				? `No recorded history for ${id}.`
+				: [...page.events].reverse().map((event) => `${event.occurredAt} ${event.type} ${event.fromStatus ?? "∅"} → ${event.toStatus ?? "∅"} · ${event.actor}/${event.source}${event.reason ? ` · ${event.reason}` : ""}`).join("\n");
+			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 });
@@ -202,7 +212,7 @@ export async function runTaskCli(args: string[], client: TaskCliClient): Promise
 		}
 		case "complete": {
 			if (!id || dependencyId) throw new Error("tasks complete requires exactly one task id");
-			const completion = await client.call<{ id: string }, CliCompletion>("tasks.complete", { id });
+			const completion = await client.call<Record<string, string>, CliCompletion>("tasks.complete", { id, actor: "user", source: "cli" });
 			result = completion;
 			const lines = [`${completion.completed ? "Completed" : "Rejected"}: ${artifactLabel(completion.artifact)}`];
 			if (completion.focused) lines.push(`Active: ${artifactLabel(completion.focused)}`);
@@ -215,7 +225,7 @@ export async function runTaskCli(args: string[], client: TaskCliClient): Promise
 		}
 		case "start": {
 			if (!id || dependencyId) throw new Error("tasks start requires exactly one task id");
-			const artifact = await client.call<{ id: string }, CliArtifact>("tasks.start", { id });
+			const artifact = await client.call<Record<string, string>, CliArtifact>("tasks.start", { id, actor: "user", source: "cli" });
 			result = artifact;
 			human = `Started: ${artifactLabel(artifact)}`;
 			break;
@@ -226,7 +236,7 @@ export async function runTaskCli(args: string[], client: TaskCliClient): Promise
 		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 });
+			const artifact = await client.call<Record<string, string>, CliArtifact>(operation, { id, actor: "user", source: "cli" });
 			result = artifact;
 			human = `${action[0]!.toUpperCase()}${action.slice(1)}: ${artifactLabel(artifact)}`;
 			break;
@@ -242,7 +252,7 @@ export async function runTaskCli(args: string[], client: TaskCliClient): Promise
 			break;
 		}
 		default:
-			throw new Error("tasks action must be active, focus, graph, plan, complete, start, submit, reject, retry, cancel, or depend");
+			throw new Error("tasks action must be active, focus, graph, plan, history, complete, start, submit, reject, retry, cancel, or depend");
 	}
 	return json ? JSON.stringify(result) : human;
 }

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 = 2;
+export const SQLITE_SCHEMA_VERSION = 3;
 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;
@@ -42,6 +42,12 @@ 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;
+/** Append-only Task chronology query and evidence bounds. */
+export const TASK_HISTORY_DEFAULT_LIMIT = 25;
+export const TASK_HISTORY_MAX_LIMIT = 100;
+export const TASK_EVENT_MAX_EVIDENCE_BYTES = 65_536;
+export const TASK_EVENT_ACTOR_MAX_LENGTH = 128;
+export const TASK_EVENT_REASON_MAX_LENGTH = 2_000;
 export const GRAPH_RENDER_PADDING_X = 2;
 export const GRAPH_RENDER_PADDING_Y = 1;
 export const GRAPH_RENDER_BOX_PADDING = 0;

package/src/db.ts

@@ -102,6 +102,26 @@ CREATE TABLE IF NOT EXISTS task_focus (
 	task_id     TEXT NOT NULL UNIQUE REFERENCES artifacts(id),
 	updated_at  TEXT NOT NULL
 );
+CREATE TABLE IF NOT EXISTS task_events (
+	id                   INTEGER PRIMARY KEY AUTOINCREMENT,
+	task_id              TEXT NOT NULL REFERENCES artifacts(id),
+	occurred_at           TEXT NOT NULL,
+	event_type            TEXT NOT NULL,
+	actor                 TEXT NOT NULL,
+	source                TEXT NOT NULL,
+	session_id            TEXT,
+	reason                TEXT,
+	from_status           TEXT,
+	to_status             TEXT,
+	attempt_id             TEXT,
+	evidence_json         TEXT,
+	event_schema_version  INTEGER NOT NULL DEFAULT 1
+);
+CREATE INDEX IF NOT EXISTS task_events_history_idx ON task_events(task_id, occurred_at, id);
+CREATE TRIGGER IF NOT EXISTS task_events_no_update BEFORE UPDATE ON task_events
+BEGIN SELECT RAISE(ABORT, 'task_events are append-only'); END;
+CREATE TRIGGER IF NOT EXISTS task_events_no_delete BEFORE DELETE ON task_events
+BEGIN SELECT RAISE(ABORT, 'task_events are append-only'); END;
 `;
 
 const SEED_SQL = `
@@ -165,36 +185,66 @@ export function migrateDb(db: Db): MigrationResult {
 		throw new Error(`database schema ${from} is newer than supported ${SQLITE_SCHEMA_VERSION}`);
 	}
 	if (from === SQLITE_SCHEMA_VERSION) return { from, to: from, applied: [] };
-	if (from !== 1) throw new Error(`no explicit migration path from database schema ${from}`);
+	if (from !== 1 && from !== 2) throw new Error(`no explicit migration path from database schema ${from}`);
+	const applied: string[] = [];
 
 	inTransaction(db, () => {
-		db.exec(`
-			INSERT OR IGNORE INTO statuses VALUES ('todo','task');
-			INSERT OR IGNORE INTO statuses VALUES ('in-progress','task');
-			INSERT OR IGNORE INTO statuses VALUES ('review','task');
-			INSERT OR IGNORE INTO statuses VALUES ('rejected','task');
-			INSERT OR IGNORE INTO statuses VALUES ('done','task');
-			INSERT OR IGNORE INTO statuses VALUES ('canceled','task');
-			CREATE TABLE task_focus (
-				scope TEXT PRIMARY KEY CHECK (scope = 'global'),
-				task_id TEXT NOT NULL UNIQUE REFERENCES artifacts(id),
-				updated_at TEXT NOT NULL
-			);
-			INSERT INTO task_focus (scope, task_id, updated_at)
-			SELECT 'global', id, strftime('%Y-%m-%dT%H:%M:%fZ','now')
-			FROM artifacts WHERE kind = 'task' AND status = 'active'
-			ORDER BY updated_at DESC, id ASC LIMIT 1;
-			UPDATE artifacts SET status = CASE status
-				WHEN 'pending' THEN 'todo'
-				WHEN 'active' THEN 'in-progress'
-				WHEN 'failed' THEN 'rejected'
-				ELSE status END
-			WHERE kind = 'task';
-			DELETE FROM statuses WHERE kind = 'task' AND name IN ('pending', 'active', 'failed');
-			PRAGMA user_version = 2;
-		`);
+		if (schemaVersion(db) === 1) {
+			db.exec(`
+				INSERT OR IGNORE INTO statuses VALUES ('todo','task');
+				INSERT OR IGNORE INTO statuses VALUES ('in-progress','task');
+				INSERT OR IGNORE INTO statuses VALUES ('review','task');
+				INSERT OR IGNORE INTO statuses VALUES ('rejected','task');
+				INSERT OR IGNORE INTO statuses VALUES ('done','task');
+				INSERT OR IGNORE INTO statuses VALUES ('canceled','task');
+				CREATE TABLE task_focus (
+					scope TEXT PRIMARY KEY CHECK (scope = 'global'),
+					task_id TEXT NOT NULL UNIQUE REFERENCES artifacts(id),
+					updated_at TEXT NOT NULL
+				);
+				INSERT INTO task_focus (scope, task_id, updated_at)
+				SELECT 'global', id, strftime('%Y-%m-%dT%H:%M:%fZ','now')
+				FROM artifacts WHERE kind = 'task' AND status = 'active'
+				ORDER BY updated_at DESC, id ASC LIMIT 1;
+				UPDATE artifacts SET status = CASE status
+					WHEN 'pending' THEN 'todo'
+					WHEN 'active' THEN 'in-progress'
+					WHEN 'failed' THEN 'rejected'
+					ELSE status END
+				WHERE kind = 'task';
+				DELETE FROM statuses WHERE kind = 'task' AND name IN ('pending', 'active', 'failed');
+				PRAGMA user_version = 2;
+			`);
+			applied.push("task-lifecycle-and-focus");
+		}
+		if (schemaVersion(db) === 2) {
+			db.exec(`
+				CREATE TABLE task_events (
+					id INTEGER PRIMARY KEY AUTOINCREMENT,
+					task_id TEXT NOT NULL REFERENCES artifacts(id),
+					occurred_at TEXT NOT NULL,
+					event_type TEXT NOT NULL,
+					actor TEXT NOT NULL,
+					source TEXT NOT NULL,
+					session_id TEXT,
+					reason TEXT,
+					from_status TEXT,
+					to_status TEXT,
+					attempt_id TEXT,
+					evidence_json TEXT,
+					event_schema_version INTEGER NOT NULL DEFAULT 1
+				);
+				CREATE INDEX task_events_history_idx ON task_events(task_id, occurred_at, id);
+				CREATE TRIGGER task_events_no_update BEFORE UPDATE ON task_events
+				BEGIN SELECT RAISE(ABORT, 'task_events are append-only'); END;
+				CREATE TRIGGER task_events_no_delete BEFORE DELETE ON task_events
+				BEGIN SELECT RAISE(ABORT, 'task_events are append-only'); END;
+				PRAGMA user_version = 3;
+			`);
+			applied.push("task-history");
+		}
 	});
-	return { from, to: SQLITE_SCHEMA_VERSION, applied: ["task-lifecycle-and-focus"] };
+	return { from, to: schemaVersion(db), applied };
 }
 
 export function openDb(path: string): Db {

package/src/domain/task-event.ts

@@ -0,0 +1,102 @@
+import {
+	TASK_EVENT_ACTOR_MAX_LENGTH,
+	TASK_EVENT_MAX_EVIDENCE_BYTES,
+	TASK_EVENT_REASON_MAX_LENGTH,
+	TASK_HISTORY_DEFAULT_LIMIT,
+	TASK_HISTORY_MAX_LIMIT,
+} from "../constants.ts";
+export type TaskLifecycleStatus = "todo" | "in-progress" | "review" | "rejected" | "done" | "canceled";
+
+export const TASK_EVENT_TYPES = [
+	"created",
+	"started",
+	"submitted",
+	"completion_attempted",
+	"gates_evaluated",
+	"review_rejected",
+	"retried",
+	"completed",
+	"canceled",
+] as const;
+
+export type TaskEventType = typeof TASK_EVENT_TYPES[number];
+export type TaskEventDirection = "asc" | "desc";
+
+export interface TaskEventContext {
+	actor?: string;
+	source?: string;
+	sessionId?: string;
+	reason?: string;
+}
+
+export interface TaskEventEvidence {
+	gates?: unknown;
+	checklist?: unknown;
+	result?: string;
+}
+
+export interface TaskEvent {
+	id: number;
+	taskId: string;
+	occurredAt: string;
+	type: TaskEventType;
+	actor: string;
+	source: string;
+	sessionId?: string;
+	reason?: string;
+	fromStatus?: TaskLifecycleStatus;
+	toStatus?: TaskLifecycleStatus;
+	attemptId?: string;
+	evidence?: TaskEventEvidence;
+	schemaVersion: 1;
+}
+
+export interface AppendTaskEvent {
+	taskId: string;
+	type: TaskEventType;
+	actor: string;
+	source: string;
+	sessionId?: string;
+	reason?: string;
+	fromStatus?: TaskLifecycleStatus;
+	toStatus?: TaskLifecycleStatus;
+	attemptId?: string;
+	evidence?: TaskEventEvidence;
+}
+
+export interface TaskHistoryQuery {
+	limit?: number;
+	cursor?: number;
+	direction?: TaskEventDirection;
+}
+
+export interface TaskHistoryPage {
+	events: TaskEvent[];
+	nextCursor?: number;
+}
+
+export function normalizeTaskHistoryQuery(query: TaskHistoryQuery = {}): Required<Pick<TaskHistoryQuery, "limit" | "direction">> & Pick<TaskHistoryQuery, "cursor"> {
+	const limit = query.limit ?? TASK_HISTORY_DEFAULT_LIMIT;
+	if (!Number.isInteger(limit) || limit < 1 || limit > TASK_HISTORY_MAX_LIMIT) {
+		throw new Error(`task history limit must be between 1 and ${TASK_HISTORY_MAX_LIMIT}`);
+	}
+	if (query.cursor !== undefined && (!Number.isInteger(query.cursor) || query.cursor < 1)) {
+		throw new Error("task history cursor must be a positive integer");
+	}
+	if (query.direction !== undefined && query.direction !== "asc" && query.direction !== "desc") {
+		throw new Error("task history direction must be asc or desc");
+	}
+	return { limit, direction: query.direction ?? "desc", ...(query.cursor === undefined ? {} : { cursor: query.cursor }) };
+}
+
+export function validateTaskEvent(event: AppendTaskEvent): AppendTaskEvent {
+	for (const [field, value] of [["actor", event.actor], ["source", event.source]] as const) {
+		if (!value || value.length > TASK_EVENT_ACTOR_MAX_LENGTH) throw new Error(`${field} must be between 1 and ${TASK_EVENT_ACTOR_MAX_LENGTH} characters`);
+	}
+	if (event.sessionId !== undefined && event.sessionId.length > TASK_EVENT_ACTOR_MAX_LENGTH) throw new Error(`sessionId cannot exceed ${TASK_EVENT_ACTOR_MAX_LENGTH} characters`);
+	if (event.reason !== undefined && event.reason.length > TASK_EVENT_REASON_MAX_LENGTH) throw new Error(`reason cannot exceed ${TASK_EVENT_REASON_MAX_LENGTH} characters`);
+	if (event.evidence !== undefined && new TextEncoder().encode(JSON.stringify(event.evidence)).byteLength > TASK_EVENT_MAX_EVIDENCE_BYTES) {
+		throw new Error(`task event evidence cannot exceed ${TASK_EVENT_MAX_EVIDENCE_BYTES} bytes`);
+	}
+	return event;
+}

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

@@ -0,0 +1,43 @@
+import { normalizeTaskHistoryQuery, validateTaskEvent, type AppendTaskEvent, type TaskEvent, type TaskHistoryPage, type TaskHistoryQuery } from "../domain/task-event.ts";
+
+export interface TaskEventStore {
+	atomic<T>(operation: () => T): T;
+	append(event: AppendTaskEvent): TaskEvent;
+	history(taskId: string, query?: TaskHistoryQuery): TaskHistoryPage;
+}
+
+export class InMemoryTaskEventStore implements TaskEventStore {
+	private events: TaskEvent[] = [];
+	private nextId = 1;
+
+	atomic<T>(operation: () => T): T {
+		const length = this.events.length;
+		const nextId = this.nextId;
+		try { return operation(); }
+		catch (error) {
+			this.events.length = length;
+			this.nextId = nextId;
+			throw error;
+		}
+	}
+
+	append(event: AppendTaskEvent): TaskEvent {
+		const stored: TaskEvent = {
+			...validateTaskEvent(event),
+			id: this.nextId++,
+			occurredAt: new Date().toISOString(),
+			schemaVersion: 1,
+		};
+		this.events.push(stored);
+		return stored;
+	}
+
+	history(taskId: string, query: TaskHistoryQuery = {}): TaskHistoryPage {
+		const { direction, limit, cursor } = normalizeTaskHistoryQuery(query);
+		const ordered = this.events
+			.filter((event) => event.taskId === taskId && (cursor === undefined || (direction === "desc" ? event.id < cursor : event.id > cursor)))
+			.sort((left, right) => direction === "desc" ? right.id - left.id : left.id - right.id);
+		const events = ordered.slice(0, limit);
+		return { events, ...(ordered.length > limit ? { nextCursor: events.at(-1)!.id } : {}) };
+	}
+}

package/src/service.ts

@@ -4,10 +4,13 @@ import { migrateDb, openDb, schemaVersion } from "./db.ts";
 import { SQLiteArtifactStore } from "./adapters/sqlite-artifact-store.ts";
 import { SQLiteGateRunner } from "./adapters/sqlite-gate-runner.ts";
 import { SQLiteTaskFocusStore } from "./adapters/sqlite-task-focus-store.ts";
+import { SQLiteTaskEventStore } from "./adapters/sqlite-task-event-store.ts";
 import type { CreateArtifactInput } from "./domain/artifact.ts";
 import type { Checklist } from "./domain/checklist.ts";
+import type { TaskEventContext, TaskEventDirection } from "./domain/task-event.ts";
 import type { ArtifactStore } from "./ports/artifact-store.ts";
 import type { GateRunner } from "./ports/gate-runner.ts";
+import type { TaskEventStore } from "./ports/task-event-store.ts";
 import { projectTaskExecution } from "./task-execution.ts";
 import { Tasks, type TaskStatus } from "./task-service.ts";
 import {
@@ -50,6 +53,7 @@ export const EXPECTED_OPERATION_NAMES = [
 	"tasks.graph",
 	"tasks.plan",
 	"tasks.show",
+	"tasks.history",
 	"tasks.active",
 	"tasks.focus",
 	"tasks.start",
@@ -140,8 +144,19 @@ function handlers(
 	artifacts: ArtifactStore,
 	gates: GateRunner,
 	tasks: Tasks,
+	events: TaskEventStore,
 	migrate: () => unknown,
 ): Record<OperationName, OperationHandler> {
+	const eventContext = (input: OperationInput): TaskEventContext => ({
+		actor: optionalString(input, "actor"),
+		source: optionalString(input, "source"),
+		sessionId: optionalString(input, "session_id") ?? optionalString(input, "sessionId"),
+		reason: optionalString(input, "reason"),
+	});
+	const eventContextFor = (input: OperationInput, source: string): TaskEventContext => {
+		const context = eventContext(input);
+		return { ...context, source: context.source ?? source };
+	};
 	const taskFilter = (input: OperationInput) => ({
 		status: optionalString(input, "status"),
 		text: optionalString(input, "text"),
@@ -149,7 +164,20 @@ function handlers(
 	});
 	return {
 		"system.migrate": () => migrate(),
-		"artifact.create": (input) => artifacts.create(normalizeCreateInput(input)),
+		"artifact.create": (input) => {
+			const normalized = normalizeCreateInput(input);
+			if (normalized.kind !== "task") return artifacts.create(normalized);
+			return tasks.create({
+				id: normalized.id,
+				title: string(input, "title"),
+				body: normalized.body,
+				subtype: normalized.subtype,
+				status: normalized.status as TaskStatus | undefined,
+				labels: normalized.labels,
+				extra: normalized.extra,
+				templateId: normalized.templateId,
+			}, eventContextFor(input, "artifact-api"));
+		},
 		"artifact.query": (input) => artifacts.query(input),
 		"artifact.show": (input) => artifacts.get(string(input, "id"), {
 			tree: input["tree"] === true,
@@ -172,8 +200,17 @@ function handlers(
 			depth: optionalNumber(input, "depth"),
 			maxNodes: optionalNumber(input, "max_nodes") ?? optionalNumber(input, "maxNodes"),
 		}),
-		"graph.status": (input) => artifacts.setStatus(string(input, "id"), string(input, "status")),
-		"gates.run": (input) => gates.runAsync(string(input, "id")),
+		"graph.status": (input) => {
+			const id = string(input, "id");
+			if (artifacts.get(id)?.kind === "task") throw new Error("task lifecycle changes require a tasks.* operation so history and review invariants are preserved");
+			return artifacts.setStatus(id, string(input, "status"));
+		},
+		"gates.run": (input) => {
+			const id = string(input, "id");
+			return artifacts.get(id)?.kind === "task"
+				? tasks.runGates(id, eventContextFor(input, "gates-api"))
+				: gates.runAsync(id);
+		},
 		"rules.injectable": () => listInjectableRules(artifacts, tasks.active()?.id)
 			.map(({ id, title, body, extra }) => ({ id, title, body, extra })),
 		"tasks.create": (input) => tasks.create({
@@ -187,22 +224,27 @@ function handlers(
 			templateId: optionalString(input, "template_id") ?? optionalString(input, "templateId"),
 			parentId: optionalString(input, "parent_id") ?? optionalString(input, "parentId"),
 			dependsOn: (input["depends_on"] ?? input["dependsOn"]) as string[] | undefined,
-		}),
+		}, eventContext(input)),
 		"tasks.list": (input) => tasks.list(taskFilter(input)),
 		"tasks.graph": (input) => tasks.graph(taskFilter(input)),
 		"tasks.plan": (input) => projectTaskExecution(tasks.graph(taskFilter(input))),
 		"tasks.show": (input) => tasks.show(string(input, "id")),
+		"tasks.history": (input) => tasks.history(string(input, "id"), {
+			limit: optionalNumber(input, "limit"),
+			cursor: optionalNumber(input, "cursor"),
+			direction: optionalString(input, "direction") as TaskEventDirection | undefined,
+		}),
 		"tasks.active": () => tasks.active(),
 		"tasks.focus": (input) => tasks.focus(string(input, "id")),
-		"tasks.start": (input) => tasks.transition(string(input, "id"), "start"),
-		"tasks.submit": (input) => tasks.transition(string(input, "id"), "submit"),
-		"tasks.complete": (input) => tasks.completeAsync(string(input, "id")),
-		"tasks.run_gates": (input) => tasks.runGates(string(input, "id")),
+		"tasks.start": (input) => tasks.transition(string(input, "id"), "start", eventContext(input)),
+		"tasks.submit": (input) => tasks.transition(string(input, "id"), "submit", eventContext(input)),
+		"tasks.complete": (input) => tasks.completeAsync(string(input, "id"), eventContext(input)),
+		"tasks.run_gates": (input) => tasks.runGates(string(input, "id"), eventContext(input)),
 		"tasks.set_checklist": (input) => tasks.setChecklist(string(input, "id"), input["checklist"] as Checklist),
 		"tasks.context": () => taskContext(artifacts, tasks.active()?.id),
-		"tasks.reject": (input) => tasks.transition(string(input, "id"), "reject"),
-		"tasks.retry": (input) => tasks.transition(string(input, "id"), "retry"),
-		"tasks.cancel": (input) => tasks.transition(string(input, "id"), "cancel"),
+		"tasks.reject": (input) => tasks.transition(string(input, "id"), "reject", eventContext(input)),
+		"tasks.retry": (input) => tasks.transition(string(input, "id"), "retry", eventContext(input)),
+		"tasks.cancel": (input) => tasks.transition(string(input, "id"), "cancel", eventContext(input)),
 		"tasks.depend": (input) => tasks.depend(string(input, "id"), string(input, "dependency_id")),
 		"tasks.contain": (input) => tasks.contain(string(input, "parent_id"), string(input, "child_id")),
 		"docs.create": (input) => createDocument(artifacts, {
@@ -244,7 +286,7 @@ function handlers(
 		"skills.run": (input) => instantiateSkillWorkflow(artifacts, string(input, "id"), {
 			runId: optionalString(input, "run_id") ?? optionalString(input, "runId"),
 			arguments: input["arguments"] as Record<string, unknown> | undefined,
-		}),
+		}, { events, context: eventContextFor(input, "skill-run") }),
 		"skills.enable": (input) => transitionSkill(artifacts, string(input, "id"), "enable"),
 		"skills.disable": (input) => transitionSkill(artifacts, string(input, "id"), "disable"),
 		"skills.instantiate": (input) => instantiateTemplate(artifacts, string(input, "template_id"), normalizeCreateInput(input)),
@@ -256,8 +298,9 @@ export function createPapyrusService(path: string): PapyrusService {
 	const artifacts = new SQLiteArtifactStore(db);
 	const gates = new SQLiteGateRunner(db);
 	const focus = new SQLiteTaskFocusStore(db);
-	const tasks = new Tasks(artifacts, gates, focus);
-	const registry = handlers(artifacts, gates, tasks, () => migrateDb(db));
+	const events = new SQLiteTaskEventStore(db);
+	const tasks = new Tasks(artifacts, gates, focus, events);
+	const registry = handlers(artifacts, gates, tasks, events, () => migrateDb(db));
 	const state = (): SchemaState => {
 		const current = schemaVersion(db);
 		return { current, required: SQLITE_SCHEMA_VERSION, migrationRequired: current !== SQLITE_SCHEMA_VERSION };
@@ -269,7 +312,7 @@ export function createPapyrusService(path: string): PapyrusService {
 			const handler = registry[operation as OperationName];
 			if (!handler) throw new UnknownOperationError(`unknown operation "${operation}"`);
 			if (operation !== "system.migrate" && state().migrationRequired) {
-				throw new MigrationRequiredError("database migration required; run `papyrus migrate task-lifecycle`");
+				throw new MigrationRequiredError("database migration required; run `papyrus migrate task-history`");
 			}
 			return handler(input);
 		},

package/src/skill-execution.ts

@@ -9,9 +9,11 @@ import {
 	type SkillDefinition,
 } from "./domain/skill-definition.ts";
 import type { ArtifactStore } from "./ports/artifact-store.ts";
+import type { TaskEventContext } from "./domain/task-event.ts";
+import type { TaskEventStore } from "./ports/task-event-store.ts";
 import { requireAtomicArtifactStore } from "./ports/atomic-artifact-store.ts";
 import { projectTaskExecution, type TaskExecutionPlan } from "./task-execution.ts";
-import type { TaskGraph, TaskNode } from "./task-service.ts";
+import type { TaskGraph, TaskNode, TaskStatus } from "./task-service.ts";
 
 const RUN_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
 const EXACT_PLACEHOLDER_PATTERN = /^{{\s*([A-Za-z][A-Za-z0-9_-]{0,63})\s*}}$/;
@@ -115,6 +117,7 @@ export function instantiateSkillWorkflow(
 	artifacts: ArtifactStore,
 	skillId: string,
 	input: InstantiateSkillWorkflowInput = {},
+	history?: { events: TaskEventStore; context?: TaskEventContext },
 ): SkillWorkflowRunResult {
 	const { definition } = requireWorkflowSkill(artifacts, skillId);
 	const arguments_ = resolveSkillArguments(definition, input.arguments);
@@ -138,7 +141,7 @@ export function instantiateSkillWorkflow(
 	}
 
 	const atomic = requireAtomicArtifactStore(artifacts);
-	return atomic.atomic(() => {
+	const persist = () => atomic.atomic(() => {
 		const docs = rendered.blueprints.docs.map((blueprint) => artifacts.create({
 			id: ids.get(blueprint.ref),
 			kind: "doc",
@@ -163,14 +166,26 @@ export function instantiateSkillWorkflow(
 				scope: { type: "skill-run", runId, taskIds },
 			},
 		}));
-		const tasks = rendered.blueprints.tasks.map((blueprint) => artifacts.create({
-			id: ids.get(blueprint.ref),
-			kind: "task",
-			title: blueprint.title,
-			body: blueprint.body,
-			labels: withRunLabel(blueprint.labels, runId),
-			extra: { ...(blueprint.extra ?? {}), skillRun: { id: runId, skillId, ref: blueprint.ref } },
-		}));
+		const tasks = rendered.blueprints.tasks.map((blueprint) => {
+			const task = artifacts.create({
+				id: ids.get(blueprint.ref),
+				kind: "task",
+				title: blueprint.title,
+				body: blueprint.body,
+				labels: withRunLabel(blueprint.labels, runId),
+				extra: { ...(blueprint.extra ?? {}), skillRun: { id: runId, skillId, ref: blueprint.ref } },
+			});
+			if (history) history.events.append({
+				taskId: task.id,
+				type: "created",
+				actor: history.context?.actor ?? "system",
+				source: history.context?.source ?? "skill-run",
+				toStatus: task.status as TaskStatus,
+				...(history.context?.sessionId === undefined ? {} : { sessionId: history.context.sessionId }),
+				...(history.context?.reason === undefined ? {} : { reason: history.context.reason }),
+			});
+			return task;
+		});
 
 		for (const blueprint of rendered.blueprints.tasks) {
 			const id = ids.get(blueprint.ref)!;
@@ -201,4 +216,5 @@ export function instantiateSkillWorkflow(
 			execution: projectTaskExecution(executionGraph(tasks, rendered, ids)),
 		};
 	});
+	return history ? history.events.atomic(persist) : persist();
 }

package/src/task-service.ts

@@ -2,9 +2,11 @@ import { TASK_EXECUTION_MAX_DEGREE, TASK_EXECUTION_MAX_EDGES, TASK_EXECUTION_MAX
 import type { Artifact } from "./domain/artifact.ts";
 import { checklistEntries, validateChecklist, type Checklist, type ProofReference } from "./domain/checklist.ts";
 import type { Gate, GateResult } from "./domain/gate.ts";
+import type { AppendTaskEvent, TaskEventContext, TaskHistoryPage, TaskHistoryQuery, TaskLifecycleStatus } from "./domain/task-event.ts";
 import type { ArtifactStore } from "./ports/artifact-store.ts";
 import type { GateRunner } from "./ports/gate-runner.ts";
 import { InMemoryTaskFocusStore, type TaskFocusStore } from "./ports/task-focus-store.ts";
+import { InMemoryTaskEventStore, type TaskEventStore } from "./ports/task-event-store.ts";
 import { assertDependencyEdgeAllowed } from "./task-execution.ts";
 
 export interface TaskFilter {
@@ -13,11 +15,13 @@ export interface TaskFilter {
 	limit?: number;
 }
 
-export type TaskStatus = "todo" | "in-progress" | "review" | "rejected" | "done" | "canceled";
+export type TaskStatus = TaskLifecycleStatus;
 
 export interface CreateTaskInput {
+	id?: string;
 	title: string;
 	body?: string;
+	subtype?: string;
 	status?: TaskStatus;
 	labels?: string[];
 	extra?: Record<string, unknown>;
@@ -77,6 +81,7 @@ export class Tasks {
 		private readonly artifacts: ArtifactStore,
 		private readonly gates: GateRunner,
 		private readonly focusStore: TaskFocusStore = new InMemoryTaskFocusStore(),
+		private readonly events: TaskEventStore = new InMemoryTaskEventStore(),
 	) {}
 
 	private require(id: string): Artifact {
@@ -86,27 +91,32 @@ export class Tasks {
 		return artifact;
 	}
 
-	create(input: CreateTaskInput): Artifact {
-		if ((input.dependsOn?.length ?? 0) > TASK_EXECUTION_MAX_DEGREE) {
-			throw new Error(`task cannot exceed ${TASK_EXECUTION_MAX_DEGREE} prerequisites`);
-		}
-		if (input.parentId) this.require(input.parentId);
-		for (const dependency of input.dependsOn ?? []) this.require(dependency);
-		const extra: Record<string, unknown> = { ...(input.extra ?? {}) };
-		if (input.gates !== undefined) extra["gates"] = input.gates;
-		if (input.checklist !== undefined) extra["checklist"] = validateChecklist(input.checklist);
-		const task = this.artifacts.create({
-			kind: "task",
-			title: input.title,
-			body: input.body,
-			status: input.status,
-			labels: input.labels,
-			extra,
-			templateId: input.templateId,
+	create(input: CreateTaskInput, context: TaskEventContext = {}): Artifact {
+		return this.events.atomic(() => {
+			if ((input.dependsOn?.length ?? 0) > TASK_EXECUTION_MAX_DEGREE) {
+				throw new Error(`task cannot exceed ${TASK_EXECUTION_MAX_DEGREE} prerequisites`);
+			}
+			if (input.parentId) this.require(input.parentId);
+			for (const dependency of input.dependsOn ?? []) this.require(dependency);
+			const extra: Record<string, unknown> = { ...(input.extra ?? {}) };
+			if (input.gates !== undefined) extra["gates"] = input.gates;
+			if (input.checklist !== undefined) extra["checklist"] = validateChecklist(input.checklist);
+			const task = this.artifacts.create({
+				id: input.id,
+				kind: "task",
+				title: input.title,
+				body: input.body,
+				subtype: input.subtype,
+				status: input.status,
+				labels: input.labels,
+				extra,
+				templateId: input.templateId,
+			});
+			if (input.parentId) this.contain(input.parentId, task.id);
+			for (const dependency of input.dependsOn ?? []) this.depend(task.id, dependency);
+			this.appendEvent({ taskId: task.id, type: "created", toStatus: task.status as TaskStatus }, context);
+			return this.show(task.id);
 		});
-		if (input.parentId) this.contain(input.parentId, task.id);
-		for (const dependency of input.dependsOn ?? []) this.depend(task.id, dependency);
-		return this.show(task.id);
 	}
 
 	list(filter: TaskFilter = {}): Artifact[] {
@@ -185,48 +195,55 @@ export class Tasks {
 		return task;
 	}
 
-	transition(id: string, action: TaskTransition): Artifact {
-		const task = this.require(id);
-		const transition = TASK_TRANSITIONS[action];
-		if (!transition.from.includes(task.status as TaskStatus)) throw new Error(`cannot ${action} task from ${task.status}`);
-		if (action === "start") {
-			const blocking = this.dependencyIds(id).filter((dependencyId) => this.require(dependencyId).status !== "done");
-			if (blocking.length > 0) throw new Error(`task "${id}" is blocked by dependencies: ${blocking.join(", ")}`);
-			this.focusStore.set(id);
-		}
-		const updated = this.artifacts.setStatus(id, transition.to)!;
-		if (action === "start" || action === "retry") this.propagateProgressToAncestors(id);
-		if (action === "retry") this.focusStore.set(id);
-		if (action === "cancel") this.focusStore.clear(id);
-		return updated;
+	transition(id: string, action: TaskTransition, context: TaskEventContext = {}): Artifact {
+		return this.events.atomic(() => {
+			const task = this.require(id);
+			const transition = TASK_TRANSITIONS[action];
+			if (!transition.from.includes(task.status as TaskStatus)) throw new Error(`cannot ${action} task from ${task.status}`);
+			if (action === "start") {
+				const blocking = this.dependencyIds(id).filter((dependencyId) => this.require(dependencyId).status !== "done");
+				if (blocking.length > 0) throw new Error(`task "${id}" is blocked by dependencies: ${blocking.join(", ")}`);
+				this.focusStore.set(id);
+			}
+			const updated = this.artifacts.setStatus(id, transition.to)!;
+			const eventType = { start: "started", submit: "submitted", reject: "review_rejected", retry: "retried", cancel: "canceled" }[action] as AppendTaskEvent["type"];
+			this.appendEvent({ taskId: id, type: eventType, fromStatus: task.status as TaskStatus, toStatus: transition.to }, context);
+			if (action === "start" || action === "retry") this.propagateProgressToAncestors(id, context);
+			if (action === "retry") this.focusStore.set(id);
+			if (action === "cancel") this.focusStore.clear(id);
+			return updated;
+		});
 	}
 
-	complete(id: string): TaskCompletion {
+	complete(id: string, context: TaskEventContext = {}): TaskCompletion {
 		const task = this.requireReview(id);
+		const attemptId = crypto.randomUUID();
+		this.events.atomic(() => this.appendEvent({ taskId: id, type: "completion_attempted", fromStatus: "review", toStatus: "review", attemptId }, context));
 		const checklist = this.reviewChecklist(task);
 		const results = this.gates.run(id);
-		if (results.some((gate) => !gate.passed) || checklist.some((item) => !item.accepted)) {
-			const artifact = this.artifacts.setStatus(id, "rejected")!;
-			return { artifact, gates: results, checklist, completed: false, focused: this.active(), blocked: [] };
-		}
-		return this.finish(id, results, checklist);
+		return this.resolveCompletion(id, attemptId, results, checklist, context);
 	}
 
-	async completeAsync(id: string): Promise<TaskCompletion> {
+	async completeAsync(id: string, context: TaskEventContext = {}): Promise<TaskCompletion> {
 		const task = this.requireReview(id);
+		const attemptId = crypto.randomUUID();
+		this.events.atomic(() => this.appendEvent({ taskId: id, type: "completion_attempted", fromStatus: "review", toStatus: "review", attemptId }, context));
 		const checklist = this.reviewChecklist(task);
 		const results = await this.gates.runAsync(id);
-		if (results.some((gate) => !gate.passed) || checklist.some((item) => !item.accepted)) {
-			const artifact = this.artifacts.setStatus(id, "rejected")!;
-			return { artifact, gates: results, checklist, completed: false, focused: this.active(), blocked: [] };
-		}
-		const current = this.requireReview(id);
-		return this.finish(current.id, results, checklist);
+		this.requireReview(id);
+		return this.resolveCompletion(id, attemptId, results, checklist, context);
+	}
+
+	async runGates(id: string, context: TaskEventContext = {}): Promise<GateResult[]> {
+		this.require(id);
+		const results = await this.gates.runAsync(id);
+		this.events.atomic(() => this.appendEvent({ taskId: id, type: "gates_evaluated", evidence: { gates: results, result: results.every((gate) => gate.passed) ? "passed" : "failed" } }, context));
+		return results;
 	}
 
-	runGates(id: string): Promise<GateResult[]> {
+	history(id: string, query: TaskHistoryQuery = {}): TaskHistoryPage {
 		this.require(id);
-		return this.gates.runAsync(id);
+		return this.events.history(id, query);
 	}
 
 	setChecklist(id: string, checklist: Checklist): Artifact {
@@ -282,7 +299,7 @@ export class Tasks {
 			.filter((parentId, index, ids) => ids.indexOf(parentId) === index);
 	}
 
-	private propagateProgressToAncestors(id: string): void {
+	private propagateProgressToAncestors(id: string, context: TaskEventContext): void {
 		const pending = this.parentIds(id);
 		const visited = new Set<string>();
 		while (pending.length > 0) {
@@ -291,7 +308,14 @@ export class Tasks {
 			if (visited.size >= TASK_EXECUTION_MAX_NODES) throw new Error("task ancestry exceeds execution node bound");
 			visited.add(parentId);
 			const parent = this.require(parentId);
-			if (parent.status === "todo") this.artifacts.setStatus(parentId, "in-progress");
+			if (parent.status === "todo") {
+				this.artifacts.setStatus(parentId, "in-progress");
+				this.appendEvent({ taskId: parentId, type: "started", fromStatus: "todo", toStatus: "in-progress" }, {
+					...context,
+					source: "task-ancestry",
+					reason: `nested task ${id} entered progress`,
+				});
+			}
 			pending.push(...this.parentIds(parentId));
 		}
 	}
@@ -315,7 +339,32 @@ export class Tasks {
 		return ids;
 	}
 
-	private finish(id: string, gates: GateResult[], checklist: ChecklistReview[]): TaskCompletion {
+	private resolveCompletion(
+		id: string,
+		attemptId: string,
+		gates: GateResult[],
+		checklist: ChecklistReview[],
+		context: TaskEventContext,
+	): TaskCompletion {
+		const failed = gates.some((gate) => !gate.passed) || checklist.some((item) => !item.accepted);
+		if (failed) {
+			return this.events.atomic(() => {
+				const artifact = this.artifacts.setStatus(id, "rejected")!;
+				this.appendEvent({
+					taskId: id,
+					type: "review_rejected",
+					fromStatus: "review",
+					toStatus: "rejected",
+					attemptId,
+					evidence: { gates, checklist, result: "rejected" },
+				}, context);
+				return { artifact, gates, checklist, completed: false, focused: this.active(), blocked: [] };
+			});
+		}
+		return this.events.atomic(() => this.finish(id, attemptId, gates, checklist, context));
+	}
+
+	private finish(id: string, attemptId: string, gates: GateResult[], checklist: ChecklistReview[], context: TaskEventContext): TaskCompletion {
 		const successorIds = this.relationships(id)
 			.filter((edge) => edge.relation === "depends_on" && edge.to === id)
 			.map((edge) => edge.from);
@@ -323,6 +372,14 @@ export class Tasks {
 			throw new Error(`task "${id}" exceeds ${TASK_EXECUTION_MAX_DEGREE} successors`);
 		}
 		const artifact = this.artifacts.setStatus(id, "done")!;
+		this.appendEvent({
+			taskId: id,
+			type: "completed",
+			fromStatus: "review",
+			toStatus: "done",
+			attemptId,
+			evidence: { gates, checklist, result: "completed" },
+		}, context);
 		this.focusStore.clear(id);
 		const blocked: TaskBlockage[] = [];
 		let focused: Artifact | null = null;
@@ -343,6 +400,16 @@ export class Tasks {
 		return { artifact, gates, checklist, completed: true, focused, blocked };
 	}
 
+	private appendEvent(event: Omit<AppendTaskEvent, "actor" | "source">, context: TaskEventContext): void {
+		this.events.append({
+			...event,
+			actor: context.actor ?? "system",
+			source: context.source ?? "task-domain",
+			...(context.sessionId === undefined ? {} : { sessionId: context.sessionId }),
+			...(context.reason === undefined ? {} : { reason: context.reason }),
+		});
+	}
+
 	private requireReview(id: string): Artifact {
 		const task = this.require(id);
 		if (task.status !== "review") throw new Error(`cannot complete task from ${task.status}`);