@danypops/papyrus 0.4.0 → 0.6.0

package/README.md

@@ -37,6 +37,8 @@ papyrus tasks plan
 papyrus tasks depend <task-id> <prerequisite-id>
 papyrus tasks start <task-id>
 papyrus tasks complete <task-id>
+papyrus tasks automate <task-id> <on|off>
+papyrus automation status
 ```
 
 For repository work, install the versioned ownership guard once:
@@ -101,7 +103,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 +124,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 +132,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
@@ -137,8 +140,31 @@ papyrus tasks complete <id> --json
 papyrus tasks reject <id> --json
 papyrus tasks retry <id> --json
 papyrus tasks cancel <id> --json
+papyrus tasks automate <id> <on|off> --json
+papyrus automation status --json
+papyrus automation run --json
 ```
 
+### Opt-in supervised automation
+
+Background graph reconciliation is off by default and requires two independent opt-ins: daemon configuration and `automation.enabled` on each Task. Only opted-in Tasks already in `review` are eligible for automatic gate/checklist review; Papyrus never skips the review lifecycle. When one completes, directly dependent opted-in successors that become ready may move from `todo` to `in-progress`. Every completion, rejection, and start is written to append-only history with actor `daemon`, source `automation-reconciler`, reason, and bounded gate evidence.
+
+Enable the daemon with a systemd user-service override and restart it:
+
+```ini
+[Service]
+Environment=PAPYRUS_AUTOMATION_ENABLED=1
+```
+
+```bash
+systemctl --user edit papyrus.service
+systemctl --user restart papyrus.service
+papyrus tasks automate <task-id> on
+papyrus automation status
+```
+
+Secure defaults are a 60-second interval, 10 Task transitions per sweep, gate concurrency 1, and a 120-second sweep deadline. Optional environment settings are `PAPYRUS_AUTOMATION_INTERVAL_MS` (10 seconds–1 hour), `PAPYRUS_AUTOMATION_MAX_TASKS` (1–100), `PAPYRUS_AUTOMATION_GATE_CONCURRENCY` (1–4), and `PAPYRUS_AUTOMATION_MAX_RUNTIME_MS` (1 ms–10 minutes). Candidate scans are capped at 1,000 review Tasks, sweeps are single-flight, subprocess gates inherit the sweep deadline, result arrays are bounded by the Task limit, and logs contain counts rather than gate output. `papyrus automation run` uses the same policy and refuses to reconcile while global automation is disabled.
+
 Checklist criteria are an item-to-proof map. Every new item requires one or more typed references to inspectable evidence; proof presence does not imply that the evidence passed an executable gate:
 
 ```ts
@@ -171,10 +197,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, set_automation, 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,11 @@ 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()),
+			enabled: Type.Optional(Type.Boolean()),
 			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 +58,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 +71,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 +104,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 +114,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 = {
@@ -112,12 +124,13 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 					reject: "tasks.reject",
 					retry: "tasks.retry",
 					cancel: "tasks.cancel",
+					set_automation: "tasks.set_automation",
 					depend: "tasks.depend",
 					contain: "tasks.contain",
 				} as const;
 				const operation = operations[action as keyof typeof operations];
 				if (!operation) return text(`Unknown tasks action: ${action}`);
-				const artifact = await callService<Record<string, unknown>, Artifact>(operation, params);
+				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";
@@ -29,6 +30,12 @@ const STATUS_ACTIONS: Record<string, string[]> = {
 
 type TaskRow = Artifact;
 
+function taskAutomationEnabled(task: Artifact): boolean {
+	const automation = task.extra["automation"];
+	return typeof automation === "object" && automation !== null && !Array.isArray(automation)
+		&& (automation as Record<string, unknown>)["enabled"] === true;
+}
+
 export interface TaskHierarchyRow {
 	task: TaskRow;
 	depth: number;
@@ -70,7 +77,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();
 			}
 		}
@@ -85,9 +92,11 @@ export async function showTasks(ctx: ExtensionCommandContext): Promise<void> {
 		if (action.type !== "action" || !action.row) continue;
 
 		const active = graph.nodes.find((node) => node.task.id === action.row!.id)?.active === true;
+		const automationEnabled = taskAutomationEnabled(action.row);
 		const choices = [
 			"Show details",
 			...(!active && action.row.status !== "done" && action.row.status !== "canceled" ? ["Make active"] : []),
+			...(action.row.status !== "done" && action.row.status !== "canceled" ? [automationEnabled ? "Disable automation" : "Enable automation"] : []),
 			...(action.row.status === "review" ? ["Run gates"] : []),
 			...(STATUS_ACTIONS[action.row.status] ?? []),
 		];
@@ -97,7 +106,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 });
@@ -105,9 +115,23 @@ export async function showTasks(ctx: ExtensionCommandContext): Promise<void> {
 			} catch (error) {
 				ctx.ui.notify(`Focus failed: ${error instanceof Error ? error.message : error}`, "error");
 			}
+		} else if (choice === "Enable automation" || choice === "Disable automation") {
+			try {
+				const enabled = choice === "Enable automation";
+				const updated = await callService<Record<string, unknown>, Artifact>("tasks.set_automation", {
+					id: action.row.id,
+					enabled,
+					actor: "user",
+					source: "tasks-tui",
+				});
+				action.row.extra = updated.extra;
+				ctx.ui.notify(`Automation ${enabled ? "enabled" : "disabled"}: ${action.row.title}`, enabled ? "warning" : "info");
+			} catch (error) {
+				ctx.ui.notify(`Automation setting failed: ${error instanceof Error ? error.message : error}`, "error");
+			}
 		} else if (choice === "Run gates") {
 			try {
-				const results = await callService<Record<string, unknown>, GateResult[]>("tasks.run_gates", { id: action.row.id });
+				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 +150,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 +165,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.6.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-gate-runner.ts

@@ -1,5 +1,5 @@
 import type { Db } from "../db.ts";
-import type { GateResult } from "../domain/gate.ts";
+import type { GateResult, GateRunOptions } from "../domain/gate.ts";
 import type { GateRunner } from "../ports/gate-runner.ts";
 import { runGates, runGatesAsync } from "../ops.ts";
 
@@ -10,7 +10,7 @@ export class SQLiteGateRunner implements GateRunner {
 		return runGates(this.db, artifactId);
 	}
 
-	runAsync(artifactId: string): Promise<GateResult[]> {
-		return runGatesAsync(this.db, artifactId);
+	runAsync(artifactId: string, options?: GateRunOptions): Promise<GateResult[]> {
+		return runGatesAsync(this.db, artifactId, options);
 	}
 }

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

@@ -10,6 +10,7 @@ import { serveMain } from "./daemon.ts";
 import type { GateResult } from "./domain/gate.ts";
 import type { TaskExecutionPlan } from "./task-execution.ts";
 import type { TaskBlockage, TaskCompletion } from "./task-service.ts";
+import type { TaskAutomationResult, TaskAutomationSettings } from "./task-automation.ts";
 
 export interface SystemdUnitOptions {
 	bunBin: string;
@@ -56,11 +57,13 @@ 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 automation <status|run> [--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]
@@ -68,6 +71,7 @@ const USAGE = `Usage:
   papyrus tasks reject <id> [--json]
   papyrus tasks retry <id> [--json]
   papyrus tasks cancel <id> [--json]
+  papyrus tasks automate <id> <on|off> [--json]
   papyrus tasks depend <id> <prerequisite-id> [--json]`;
 
 function usage(): never {
@@ -106,8 +110,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);
@@ -115,6 +119,20 @@ export async function runMigrationCli(args: string[], client: TaskCliClient): Pr
 	return `Migrated schema ${result.from} → ${result.to}: ${result.applied.join(", ")}`;
 }
 
+export async function runAutomationCli(args: string[], client: TaskCliClient): Promise<string> {
+	const json = args.includes("--json");
+	const positional = args.filter((argument) => argument !== "--json");
+	if (positional.length !== 1 || (positional[0] !== "status" && positional[0] !== "run")) {
+		throw new Error("automation requires exactly `status` or `run`");
+	}
+	if (positional[0] === "status") {
+		const status = await client.call<Record<string, never>, TaskAutomationSettings & { inFlight: boolean }>("automation.status", {});
+		return json ? JSON.stringify(status) : `Automation: ${status.enabled ? "enabled" : "disabled"} · interval ${status.intervalMs}ms · max ${status.maxTasksPerSweep} tasks · concurrency ${status.gateConcurrency}`;
+	}
+	const result = await client.call<Record<string, never>, TaskAutomationResult>("automation.reconcile", {});
+	return json ? JSON.stringify(result) : `Automation sweep: ${result.examined} examined · ${result.completed} completed · ${result.rejected} rejected · ${result.started} started · ${result.errors.length} errors${result.skipped ? ` · skipped ${result.skipped}` : ""}`;
+}
+
 export async function runSkillCli(args: string[], client: TaskCliClient): Promise<string> {
 	const json = args.includes("--json");
 	const positional: string[] = [];
@@ -174,6 +192,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 +229,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 +242,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,11 +253,23 @@ 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;
 		}
+		case "automate": {
+			if (!id || (dependencyId !== "on" && dependencyId !== "off") || positional.length !== 3) throw new Error("tasks automate requires a task id and on or off");
+			const artifact = await client.call<Record<string, unknown>, CliArtifact>("tasks.set_automation", {
+				id,
+				enabled: dependencyId === "on",
+				actor: "user",
+				source: "cli",
+			});
+			result = artifact;
+			human = `Automation ${dependencyId}: ${artifactLabel(artifact)}`;
+			break;
+		}
 		case "depend": {
 			if (!id || !dependencyId || positional.length !== 3) throw new Error("tasks depend requires a task id and prerequisite id");
 			const artifact = await client.call<{ id: string; dependency_id: string }, CliArtifact>("tasks.depend", {
@@ -242,7 +281,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, automate, or depend");
 	}
 	return json ? JSON.stringify(result) : human;
 }
@@ -255,6 +294,11 @@ export async function main(args: string[] = process.argv.slice(2)): Promise<void
 		console.log(await runTaskCli(args.slice(1), client));
 		return;
 	}
+	if (command === "automation") {
+		const client = await connectPapyrusClient();
+		console.log(await runAutomationCli(args.slice(1), client));
+		return;
+	}
 	if (command === "skills") {
 		const client = await connectPapyrusClient();
 		console.log(await runSkillCli(args.slice(1), client));

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;
@@ -15,6 +15,7 @@ export const GATE_COMMAND_TIMEOUT_MS = 30_000;
 export const GATE_TEST_TIMEOUT_MS = 60_000;
 export const GATE_OUTPUT_LIMIT = 200;
 export const GATE_MAX_BUFFER_BYTES = 1_048_576;
+export const GATE_FILE_MAX_BYTES = 1_048_576;
 
 /** Compact task-context limits keep recurring prompt injection bounded. */
 export const TASK_CONTEXT_CURRENT_LIMIT = 3;
@@ -42,6 +43,25 @@ 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;
+/** Explicitly opt-in supervised Task graph reconciliation bounds. */
+export const TASK_AUTOMATION_INTERVAL_MS = 60_000;
+export const TASK_AUTOMATION_MIN_INTERVAL_MS = 10_000;
+export const TASK_AUTOMATION_MAX_INTERVAL_MS = 3_600_000;
+export const TASK_AUTOMATION_MAX_TASKS_PER_SWEEP = 10;
+export const TASK_AUTOMATION_HARD_MAX_TASKS_PER_SWEEP = 100;
+export const TASK_AUTOMATION_GATE_CONCURRENCY = 1;
+export const TASK_AUTOMATION_MAX_GATE_CONCURRENCY = 4;
+export const TASK_AUTOMATION_MAX_RUNTIME_MS = 120_000;
+export const TASK_AUTOMATION_HARD_MAX_RUNTIME_MS = 600_000;
+export const TASK_AUTOMATION_MAX_CANDIDATE_SCAN = 1_000;
+export const TASK_AUTOMATION_ERROR_ID_MAX_LENGTH = 128;
+export const TASK_AUTOMATION_ERROR_MESSAGE_MAX_LENGTH = 500;
 export const GRAPH_RENDER_PADDING_X = 2;
 export const GRAPH_RENDER_PADDING_Y = 1;
 export const GRAPH_RENDER_BOX_PADDING = 0;