@danypops/papyrus 0.4.0 → 0.6.0

package/src/daemon.ts

@@ -1,12 +1,15 @@
 import { DAEMON_HOST, DB_OPTIMIZE_INTERVAL_MS, WAL_CHECKPOINT_INTERVAL_MS, dbPath } from "./constants.ts";
 import { clearDaemonPort, daemonStateDir, loadOrCreateToken, writeDaemonPort } from "./daemon-state.ts";
 import { createApp, createPapyrusService } from "./service.ts";
+import { scheduleTaskAutomation, taskAutomationSettings, type TaskAutomationResult } from "./task-automation.ts";
+import { logEvent } from "./log.ts";
 
 /** Start the supervised, long-running Papyrus service. */
 export function serveMain(): void {
 	const stateDir = daemonStateDir();
 	const token = loadOrCreateToken(stateDir);
-	const service = createPapyrusService(dbPath());
+	const automation = taskAutomationSettings(process.env);
+	const service = createPapyrusService(dbPath(), { automation });
 	const app = createApp({ service, token });
 	const server = Bun.serve({
 		hostname: DAEMON_HOST,
@@ -19,11 +22,23 @@ export function serveMain(): void {
 	}
 	writeDaemonPort(stateDir, server.port);
 	const checkpointTimer = setInterval(() => {
-		try { service.checkpoint(); } catch (error) { console.error("[papyrus] checkpoint failed", error); }
+		try { service.checkpoint(); } catch (error) { logEvent("error", "checkpoint_failed", { message: error instanceof Error ? error.message : String(error) }); }
 	}, WAL_CHECKPOINT_INTERVAL_MS);
 	const optimizeTimer = setInterval(() => {
-		try { service.optimize(); } catch (error) { console.error("[papyrus] optimize failed", error); }
+		try { service.optimize(); } catch (error) { logEvent("error", "optimize_failed", { message: error instanceof Error ? error.message : String(error) }); }
 	}, DB_OPTIMIZE_INTERVAL_MS);
+	const stopAutomation = scheduleTaskAutomation(automation, async () => {
+		const result = await service.execute("automation.reconcile", {}) as TaskAutomationResult;
+		logEvent(result.errors.length > 0 ? "warn" : "info", "automation_sweep", {
+			examined: result.examined,
+			completed: result.completed,
+			rejected: result.rejected,
+			started: result.started,
+			errors: result.errors.length,
+			timedOut: result.timedOut,
+			skipped: result.skipped,
+		});
+	}, (error) => logEvent("error", "automation_sweep_failed", { message: error instanceof Error ? error.message : String(error) }));
 
 	let stopping = false;
 	const shutdown = () => {
@@ -31,11 +46,12 @@ export function serveMain(): void {
 		stopping = true;
 		clearInterval(checkpointTimer);
 		clearInterval(optimizeTimer);
+		stopAutomation();
 		clearDaemonPort(stateDir);
 		service.close();
 		void server.stop(true).finally(() => process.exit(0));
 	};
 	process.on("SIGINT", shutdown);
 	process.on("SIGTERM", shutdown);
-	console.error(`[papyrus] listening on ${DAEMON_HOST}:${server.port}`);
+	logEvent("info", "listening", { host: DAEMON_HOST, port: server.port, automationEnabled: automation.enabled });
 }

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/gate.ts

@@ -4,6 +4,11 @@ export interface Gate {
 	expect?: string;
 }
 
+export interface GateRunOptions {
+	/** Absolute Unix epoch deadline for the full gate sequence. */
+	deadlineMs?: number;
+}
+
 export interface GateResult {
 	gate: Gate;
 	passed: boolean;

package/src/domain/task-event.ts

@@ -0,0 +1,104 @@
+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",
+	"automation_enabled",
+	"automation_disabled",
+	"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/log.ts

@@ -0,0 +1,6 @@
+export type LogLevel = "info" | "warn" | "error";
+
+/** Credential-safe structured daemon event. Callers must pass bounded, non-sensitive fields. */
+export function logEvent(level: LogLevel, event: string, fields: Record<string, unknown> = {}): void {
+	console.error(JSON.stringify({ timestamp: new Date().toISOString(), level, component: "papyrus-daemon", event, ...fields }));
+}

package/src/ops.ts

@@ -7,7 +7,7 @@ import { exec } from "node:child_process";
 import type { Db } from "./db.ts";
 import { inTransaction } from "./db.ts";
 import type { Artifact, CreateArtifactInput } from "./domain/artifact.ts";
-import type { Gate, GateResult } from "./domain/gate.ts";
+import type { Gate, GateResult, GateRunOptions } from "./domain/gate.ts";
 export type { Artifact } from "./domain/artifact.ts";
 export type { Gate, GateResult } from "./domain/gate.ts";
 export type CreateInput = CreateArtifactInput;
@@ -20,6 +20,7 @@ import {
 	GATE_TEST_TIMEOUT_MS,
 	GATE_OUTPUT_LIMIT,
 	GATE_MAX_BUFFER_BYTES,
+	GATE_FILE_MAX_BYTES,
 } from "./constants.ts";
 
 const require_ = createRequire(import.meta.url);
@@ -234,6 +235,12 @@ export function injectableRules(db: Db): Array<{ id: string; title: string; body
 	});
 }
 
+function readBoundedGateFile(path: string): string {
+	const { readFileSync, statSync } = require_("node:fs");
+	if (statSync(path).size > GATE_FILE_MAX_BYTES) throw new Error(`file exceeds ${GATE_FILE_MAX_BYTES} bytes`);
+	return readFileSync(path, "utf-8") as string;
+}
+
 export function runGates(db: Db, artifactId: string): GateResult[] {
 	const art = getArtifact(db, artifactId);
 	if (!art) throw new Error("artifact not found");
@@ -246,9 +253,8 @@ export function runGates(db: Db, artifactId: string): GateResult[] {
 				return { gate, passed: exists, output: exists ? "exists" : "not found" };
 			}
 			case "contains": {
-				const { readFileSync } = require_("node:fs");
 				try {
-					const content = readFileSync(gate.target, "utf-8");
+					const content = readBoundedGateFile(gate.target);
 					const found = gate.expect ? content.includes(gate.expect) : content.length > 0;
 					return { gate, passed: found, output: found ? "found" : `"${gate.expect ?? ""}" not found` };
 				} catch {
@@ -299,9 +305,8 @@ function runNonProcessGate(gate: Gate): GateResult {
 		return { gate, passed: exists, output: exists ? "exists" : "not found" };
 	}
 	if (gate.type === "contains") {
-		const { readFileSync } = require_("node:fs");
 		try {
-			const content = readFileSync(gate.target, "utf-8");
+			const content = readBoundedGateFile(gate.target);
 			const found = gate.expect ? content.includes(gate.expect) : content.length > 0;
 			return { gate, passed: found, output: found ? "found" : `"${gate.expect ?? ""}" not found` };
 		} catch {
@@ -312,15 +317,21 @@ function runNonProcessGate(gate: Gate): GateResult {
 }
 
 /** Gate runner for daemon request paths; subprocess gates never block the event loop. */
-export async function runGatesAsync(db: Db, artifactId: string): Promise<GateResult[]> {
+export async function runGatesAsync(db: Db, artifactId: string, options: GateRunOptions = {}): Promise<GateResult[]> {
 	const art = getArtifact(db, artifactId);
 	if (!art) throw new Error("artifact not found");
 	const gates = (art.extra["gates"] as Gate[]) ?? [];
 	const results: GateResult[] = [];
 	for (const gate of gates) {
+		const remainingMs = options.deadlineMs === undefined ? undefined : options.deadlineMs - Date.now();
+		if (remainingMs !== undefined && remainingMs <= 0) {
+			results.push({ gate, passed: false, output: "gate runtime deadline exceeded" });
+			continue;
+		}
 		if (gate.type === "command" || gate.type === "test") {
 			const command = gate.type === "test" ? `npx vitest run ${gate.target} --reporter=dot` : gate.target;
-			const timeout = gate.type === "test" ? GATE_TEST_TIMEOUT_MS : GATE_COMMAND_TIMEOUT_MS;
+			const configuredTimeout = gate.type === "test" ? GATE_TEST_TIMEOUT_MS : GATE_COMMAND_TIMEOUT_MS;
+			const timeout = remainingMs === undefined ? configuredTimeout : Math.max(1, Math.min(configuredTimeout, remainingMs));
 			const executed = await executeGateCommand(command, timeout);
 			results.push({
 				gate,

package/src/ports/gate-runner.ts

@@ -1,6 +1,6 @@
-import type { GateResult } from "../domain/gate.ts";
+import type { GateResult, GateRunOptions } from "../domain/gate.ts";
 
 export interface GateRunner {
 	run(artifactId: string): GateResult[];
-	runAsync(artifactId: string): Promise<GateResult[]>;
+	runAsync(artifactId: string, options?: GateRunOptions): Promise<GateResult[]>;
 }

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,12 +4,16 @@ 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 { TaskAutomationReconciler, taskAutomationSettings, type TaskAutomationSettings } from "./task-automation.ts";
 import {
 	createArtifactTemplate,
 	createDocument,
@@ -37,6 +41,8 @@ import { instantiateSkillWorkflow } from "./skill-execution.ts";
 
 export const EXPECTED_OPERATION_NAMES = [
 	"system.migrate",
+	"automation.status",
+	"automation.reconcile",
 	"artifact.create",
 	"artifact.query",
 	"artifact.show",
@@ -50,6 +56,7 @@ export const EXPECTED_OPERATION_NAMES = [
 	"tasks.graph",
 	"tasks.plan",
 	"tasks.show",
+	"tasks.history",
 	"tasks.active",
 	"tasks.focus",
 	"tasks.start",
@@ -57,6 +64,7 @@ export const EXPECTED_OPERATION_NAMES = [
 	"tasks.complete",
 	"tasks.run_gates",
 	"tasks.set_checklist",
+	"tasks.set_automation",
 	"tasks.context",
 	"tasks.reject",
 	"tasks.retry",
@@ -140,8 +148,20 @@ function handlers(
 	artifacts: ArtifactStore,
 	gates: GateRunner,
 	tasks: Tasks,
+	automation: TaskAutomationReconciler,
+	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 +169,22 @@ function handlers(
 	});
 	return {
 		"system.migrate": () => migrate(),
-		"artifact.create": (input) => artifacts.create(normalizeCreateInput(input)),
+		"automation.status": () => automation.status(),
+		"automation.reconcile": () => automation.reconcile(),
+		"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 +207,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 +231,31 @@ 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.set_automation": (input) => {
+			if (typeof input["enabled"] !== "boolean") throw new Error("enabled must be a boolean");
+			return tasks.setAutomation(string(input, "id"), input["enabled"], eventContext(input));
+		},
 		"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,20 +297,22 @@ 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)),
 	};
 }
 
-export function createPapyrusService(path: string): PapyrusService {
+export function createPapyrusService(path: string, options: { automation?: TaskAutomationSettings } = {}): PapyrusService {
 	const db = openDb(path);
 	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 automation = new TaskAutomationReconciler(tasks, options.automation ?? taskAutomationSettings({}));
+	const registry = handlers(artifacts, gates, tasks, automation, events, () => migrateDb(db));
 	const state = (): SchemaState => {
 		const current = schemaVersion(db);
 		return { current, required: SQLITE_SCHEMA_VERSION, migrationRequired: current !== SQLITE_SCHEMA_VERSION };
@@ -268,8 +323,8 @@ export function createPapyrusService(path: string): PapyrusService {
 		async execute(operation, input = {}) {
 			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`");
+			if (operation !== "system.migrate" && operation !== "automation.status" && state().migrationRequired) {
+				throw new MigrationRequiredError("database migration required; run `papyrus migrate task-history`");
 			}
 			return handler(input);
 		},