@danypops/papyrus 0.41.0 → 0.42.1

package/README.md

@@ -42,7 +42,7 @@ The daemon uses WAL, foreign keys, a bounded busy timeout, versioned migrations,
 
 `artifacts` is the shared graph-identity supertype, not a second copy of every application's database. `edges` references that single identity table at both endpoints, preserving foreign-key integrity for cross-domain links. Domain extension tables exist only where application invariants require indexed relational state: Task chronology/focus/scope and Discourse posts/events/session cursors/projection checkpoints. This is a class-table/table-per-type variant with explicit child-to-parent foreign keys; Papyrus does not use SQLite table inheritance or orphan-prone `(target_type, target_id)` links.
 
-The owning application remains the mutation authority. Discourse commits its extension rows and `context-thread`/`context-message` Doc projections atomically through `discourse.store`; generic artifact, document, Skill-template, lifecycle, and graph-link operations reject those owned subtypes and the `reply_to`/`discusses` relations. SQLite triggers additionally verify that each extension row references the expected Doc subtype. Domain tables are canonical for domain invariants; graph bodies and metadata are read-oriented projections committed in the same transaction.
+The owning application remains the mutation authority. Discourse commits its extension rows and `context-thread`/`context-message` Doc projections atomically through `discourse.store`; generic artifact, document, lifecycle, and graph-link operations reject those owned subtypes and the `reply_to`/`discusses` relations. SQLite triggers additionally verify that each extension row references the expected Doc subtype. Domain tables are canonical for domain invariants; graph bodies and metadata are read-oriented projections committed in the same transaction.
 
 The authenticated CLI exposes the same operation for diagnostics and adapter parity:
 
@@ -59,7 +59,7 @@ Papyrus enforces four artifact kinds:
 - `doc` — knowledge: specifications, decisions, and research
 - `task` — work: desired outcomes, gates, checklists, and dependencies
 - `rule` — governance injected into the Pi system prompt
-- `skill` — a parameterized workflow bundle whose validated arguments render a connected collection of deterministic Tasks plus contextual Rules and Docs
+- `playbook` — a trigger and an ordered list of steps whose validated arguments render a connected collection of deterministic Tasks plus contextual Rules and Docs
 
 Each kind has an enforced status vocabulary. Every edge endpoint must exist, and every edge relation must be registered in `relation_names`. Relations are universal: any artifact kind can link to any other kind.
 
@@ -67,21 +67,18 @@ Each kind has an enforced status vocabulary. Every edge endpoint must exist, and
 
 Use `contains` and `part_of` for explicit parent/child structure; use `depends_on` for execution ordering. Dependency edges form an executable DAG: self-dependencies and cycles are rejected, fan-in waits for every prerequisite, and fan-out can expose several ready successors while active focus remains singular. Graph reads are cycle-safe and bounded by `depth` and `max_nodes` (defaults: depth 4, 100 nodes; hard ceilings: depth 20, 1,000 nodes). Executable task plans are additionally bounded to 1,000 tasks and 10,000 relationships.
 
-### Skills and compatibility templates
+### Playbooks
 
-A Papyrus Skill is distinct from a conventional prompt-only skill: its input API and blueprints define a connected Task/Rule/Doc workflow. `skills.run` validates and normalizes all arguments, safely renders placeholders in memory, validates the complete graph, then persists artifacts and edges in one transaction. Task dependencies, containment, gates, checklists, and context survive rendering. Run Rules are injected only while active focus belongs to that run. Docs retain invocation context and provenance; missing evidence references remain unknown and no gate runs during instantiation.
+A Playbook's steps are a plain prose string (a Task), or a structured object: `{kind:'doc',...}` creates a Doc, `{kind:'rule',...}` creates a Rule, `{kind:'call',...}` nests another Playbook's own run as a pipeline step. `playbooks.invoke` validates and normalizes all arguments, safely renders placeholders in memory, validates the complete graph, then persists artifacts and edges in one transaction. Task dependencies, containment, gates, checklists, and context survive rendering. Run Rules are injected only while active focus belongs to that run. Docs retain invocation context and provenance; missing evidence references remain unknown and no gate runs during instantiation.
 
-A run result has a stable schema: Skill ID, run ID, normalized arguments, created IDs grouped by kind, ready root task IDs, and the bounded execution plan. Explicit run IDs produce deterministic artifact IDs (`<run-id>-<blueprint-ref>`); collisions roll back the entire run.
+A run result has a stable schema: Playbook ID, run ID, normalized arguments, created IDs grouped by kind, ready root task IDs, and the bounded execution plan. Explicit run IDs produce deterministic artifact IDs (`<run-id>-<blueprint-ref>`); collisions roll back the entire run.
 
 ```bash
-papyrus skills run <skill-id> \
+papyrus playbooks invoke <playbook-id> \
   --arguments-json '{"project":"Papyrus"}' \
-  --run-id papyrus-001 \
   --json
 ```
 
-The existing `artifact-template` skill subtype remains a compatibility mechanism for one-artifact templates with metadata `{targetKind, defaults, required}`. Instantiate it via the `skills.instantiate` operation with `template_id`; defaults merge recursively, explicit arrays replace defaults, required paths such as `extra.owner` are validated, and target-kind mismatches are rejected.
-
 ### Removing an artifact
 
 Artifacts are never hard-deleted on request: every artifact gets a permanent, immutable `created` row in the mutation event log the moment it exists, so removal is a real, time-gated trash rather than a status flip. `remove` (the shared `artifact.remove`/`artifact.remove_subtree` operations every agent-facing domain routes through, or `papyrus artifact remove <id> [--reason <text>]`) moves an artifact to the trash: it is immediately excluded from every list/query, still directly reachable by id, and fully recoverable via `restore` until its purge deadline (30 days later) passes. `remove` refuses a Task that is the live Task Focus in any scope.
@@ -90,11 +87,11 @@ Once the deadline passes, the daemon's periodic sweep performs a real, cascading
 
 ### Naming vs. ids
 
-Every agent domain tool (tasks, docs, rules, skills, notes, discuss) addresses its artifacts by `name` (the exact title) wherever `id` would otherwise be required -- `dependency_name`/`parent_name`/`child_name`/`root_task_name`/`depends_on_names` (tasks), `target_name` (docs link, searches every kind since a link target can be any of them), `task_name` (rules gate, discuss block/unblock), `template_name` (skills instantiate), and `blocks_task_names` (discuss open) are the name-based equivalents of their `*_id` counterparts. Resolution is an exact, case-insensitive, trimmed title match scoped like a plain list call; an unmatched or ambiguous name fails with a clear error (ambiguous names list the real ids, since that's the one point disambiguation genuinely needs them). Results returned to the agent likewise lead with name and status, never id, unless two artifacts in the same result share a title -- id is a backend implementation detail, not a conversational handle. `id` itself still works exactly as before for every action, in every tool.
+Every agent domain tool (tasks, docs, rules, playbooks, notes, discuss) addresses its artifacts by `name` (the exact title) wherever `id` would otherwise be required -- `dependency_name`/`parent_name`/`child_name`/`root_task_name`/`depends_on_names` (tasks), `target_name` (docs link, searches every kind since a link target can be any of them), `task_name` (rules gate, discuss block/unblock), and `blocks_task_names` (discuss open) are the name-based equivalents of their `*_id` counterparts. Resolution is an exact, case-insensitive, trimmed title match scoped like a plain list call; an unmatched or ambiguous name fails with a clear error (ambiguous names list the real ids, since that's the one point disambiguation genuinely needs them). Results returned to the agent likewise lead with name and status, never id, unless two artifacts in the same result share a title -- id is a backend implementation detail, not a conversational handle. `id` itself still works exactly as before for every action, in every tool.
 
 ### Mutability
 
-Tasks, Docs, Rules, and Skills all support first-class `update` (title/body/labels, at least one required) alongside creation -- a Doc's body is no longer immutable once created. Every update is bounded the same way creation is (Rules keep their own stricter combined condition+action+body ceiling; Docs/Skills share Tasks' own length bounds) and recorded on the artifact's append-only mutation history, queryable via `graph.history`. An artifact carrying a `source:<system>` label (e.g. `source:web-spider` on an ingested page) is a read-only projection from a system Papyrus doesn't own the source of; updating one is refused with a clear error rather than silently forking it -- capture a correction as a new linked Doc instead until a write-back capability to that system exists. Notes stay behind their own facade for any content change, same as every other Notes mutation.
+Tasks, Docs, Rules, and Playbooks all support first-class `update` (title/body/labels, at least one required) alongside creation -- a Doc's body is no longer immutable once created. Every update is bounded the same way creation is (Rules keep their own stricter combined condition+action+body ceiling; Docs/Playbooks share Tasks' own length bounds) and recorded on the artifact's append-only mutation history, queryable via `graph.history`. An artifact carrying a `source:<system>` label (e.g. `source:web-spider` on an ingested page) is a read-only projection from a system Papyrus doesn't own the source of; updating one is refused with a clear error rather than silently forking it -- capture a correction as a new linked Doc instead until a write-back capability to that system exists. Notes stay behind their own facade for any content change, same as every other Notes mutation.
 
 Internally, application services depend on the `ArtifactStore` and `GateRunner` ports. SQLite and subprocess execution are adapters composed only by the daemon; task behavior is unit-tested against fakes without a database. Task visualization projects the same `TaskGraph` into semantic display graphs and sends them through a `GraphRenderer` port -- the Pi adapter (in `@danypops/pi-papyrus`) uses `beautiful-mermaid` for terminal Unicode output without leaking Mermaid syntax into the task domain.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/papyrus",
-  "version": "0.41.0",
+  "version": "0.42.1",
   "description": "Daemon-backed graph artifacts, evidence-bearing tasks, rules, skills, and native TUI workflows for Pi",
   "type": "module",
   "keywords": ["pi-package"],
@@ -36,6 +36,6 @@
   "dependencies": {
     "@danypops/vehicle-core": "^0.2.0",
     "@danypops/vehicle-client": "^0.1.1",
-    "@danypops/vehicle-server": "^0.3.2"
+    "@danypops/vehicle-server": "^0.4.1"
   }
 }

package/src/adapters/sqlite-artifact-scope-store.ts

@@ -8,29 +8,38 @@ export class SQLiteArtifactScopeStore implements ArtifactScopeStore {
 
 	assign(artifactId: string, projectRoot: string | undefined, source: TaskScopeSource): ArtifactScope {
 		inTransaction(this.db, () => {
-			this.db.prepare(`
+			this.db
+				.prepare(`
 				INSERT INTO artifact_scopes (artifact_id, project_root, source, assigned_at)
 				VALUES (?, ?, ?, ?)
 				ON CONFLICT(artifact_id) DO UPDATE SET
 					project_root = excluded.project_root,
 					source = excluded.source,
 					assigned_at = excluded.assigned_at
-			`).run(artifactId, projectRoot ?? null, source, new Date().toISOString());
+			`)
+				.run(artifactId, projectRoot ?? null, source, new Date().toISOString());
 		});
 		return { artifactId, ...(projectRoot === undefined ? {} : { projectRoot }), source };
 	}
 
 	get(artifactId: string): ArtifactScope | undefined {
-		const row = this.db.prepare("SELECT artifact_id, project_root, source FROM artifact_scopes WHERE artifact_id = ?").get(artifactId) as
-			| { artifact_id: string; project_root: string | null; source: TaskScopeSource }
-			| null;
-		return row ? { artifactId: row.artifact_id, ...(row.project_root === null ? {} : { projectRoot: row.project_root }), source: row.source } : undefined;
+		const row = this.db.prepare("SELECT artifact_id, project_root, source FROM artifact_scopes WHERE artifact_id = ?").get(artifactId) as {
+			artifact_id: string;
+			project_root: string | null;
+			source: TaskScopeSource;
+		} | null;
+		return row
+			? { artifactId: row.artifact_id, ...(row.project_root === null ? {} : { projectRoot: row.project_root }), source: row.source }
+			: undefined;
 	}
 
 	ids(projectRoot: string | undefined, limit: number): string[] {
-		const rows = projectRoot === undefined
-			? this.db.prepare("SELECT artifact_id FROM artifact_scopes WHERE project_root IS NULL ORDER BY artifact_id LIMIT ?").all(limit)
-			: this.db.prepare("SELECT artifact_id FROM artifact_scopes WHERE project_root = ? ORDER BY artifact_id LIMIT ?").all(projectRoot, limit);
+		const rows =
+			projectRoot === undefined
+				? this.db.prepare("SELECT artifact_id FROM artifact_scopes WHERE project_root IS NULL ORDER BY artifact_id LIMIT ?").all(limit)
+				: this.db
+						.prepare("SELECT artifact_id FROM artifact_scopes WHERE project_root = ? ORDER BY artifact_id LIMIT ?")
+						.all(projectRoot, limit);
 		return (rows as Array<{ artifact_id: string }>).map((row) => row.artifact_id);
 	}
 }

package/src/adapters/sqlite-artifact-store.ts

@@ -1,8 +1,5 @@
 import type { Db } from "../db.ts";
 import { inTransaction } from "../db.ts";
-import type { AtomicArtifactStore } from "../ports/atomic-artifact-store.ts";
-import type { ArtifactEventReader } from "../ports/artifact-event-reader.ts";
-import type { ArtifactTrashStore } from "../ports/artifact-trash-store.ts";
 import type {
 	Artifact,
 	ArtifactEdge,
@@ -31,6 +28,9 @@ import {
 	updateExtra,
 	updateStatus,
 } from "../ops.ts";
+import type { ArtifactEventReader } from "../ports/artifact-event-reader.ts";
+import type { ArtifactTrashStore } from "../ports/artifact-trash-store.ts";
+import type { AtomicArtifactStore } from "../ports/atomic-artifact-store.ts";
 
 export class SQLiteArtifactStore implements AtomicArtifactStore, ArtifactTrashStore, ArtifactEventReader {
 	constructor(private readonly db: Db) {}
@@ -115,7 +115,8 @@ export class SQLiteArtifactStore implements AtomicArtifactStore, ArtifactTrashSt
 			limit = "LIMIT ?";
 			parameters.push(filter.limit);
 		}
-		return this.db.prepare(`
+		return this.db
+			.prepare(`
 			SELECT edges.from_id AS "from", edges.relation, edges.to_id AS "to"
 			FROM edges
 			JOIN artifacts AS source ON source.id = edges.from_id
@@ -123,6 +124,7 @@ export class SQLiteArtifactStore implements AtomicArtifactStore, ArtifactTrashSt
 			${where}
 			ORDER BY edges.rowid
 			${limit}
-		`).all(...parameters) as ArtifactEdge[];
+		`)
+			.all(...parameters) as ArtifactEdge[];
 	}
 }

package/src/adapters/sqlite-discussion-round-store.ts

@@ -1,13 +1,13 @@
-import type { Db } from "../db.ts";
 import { DISCUSSION_ROUNDS_DEFAULT_LIMIT, DISCUSSION_ROUNDS_MAX_LIMIT } from "../constants.ts";
+import type { Db } from "../db.ts";
 import {
-	validateDiscussionActor,
-	validateDiscussionContent,
-	validateDiscussionOptions,
 	type AppendDiscussionRound,
 	type DiscussionOptionsMode,
 	type DiscussionRound,
 	type DiscussionRoundQuery,
+	validateDiscussionActor,
+	validateDiscussionContent,
+	validateDiscussionOptions,
 } from "../domain/discussion.ts";
 import type { DiscussionRoundStore } from "../ports/discussion-round-store.ts";
 
@@ -48,19 +48,26 @@ export class SQLiteDiscussionRoundStore implements DiscussionRoundStore {
 		// selected isn't validated here -- it requires cross-referencing the Discussion's
 		// currently pending options (extra.discussion), which this store, deliberately scoped to
 		// the rounds table alone, has no access to. discussion-service.ts validates it beforehand.
-		const posed = round.options !== undefined || round.optionsMode !== undefined
-			? validateDiscussionOptions(round.options ?? [], round.optionsMode ?? "", round.optionDescriptions)
-			: undefined;
-		const result = this.db.prepare(`
+		const posed =
+			round.options !== undefined || round.optionsMode !== undefined
+				? validateDiscussionOptions(round.options ?? [], round.optionsMode ?? "", round.optionDescriptions)
+				: undefined;
+		const result = this.db
+			.prepare(`
 			INSERT INTO discussion_rounds (discussion_id, round_number, actor, content, occurred_at, event_schema_version, options, options_mode, selected, option_descriptions)
 			VALUES (?, ?, ?, ?, ?, 1, ?, ?, ?, ?)
-		`).run(
-			round.discussionId, round.roundNumber, actor, content, occurredAt,
-			posed ? JSON.stringify(posed.options) : null,
-			posed ? posed.mode : null,
-			round.selected !== undefined ? JSON.stringify(round.selected) : null,
-			posed?.optionDescriptions ? JSON.stringify(posed.optionDescriptions) : null,
-		);
+		`)
+			.run(
+				round.discussionId,
+				round.roundNumber,
+				actor,
+				content,
+				occurredAt,
+				posed ? JSON.stringify(posed.options) : null,
+				posed ? posed.mode : null,
+				round.selected !== undefined ? JSON.stringify(round.selected) : null,
+				posed?.optionDescriptions ? JSON.stringify(posed.optionDescriptions) : null,
+			);
 		return {
 			id: Number(result.lastInsertRowid),
 			discussionId: round.discussionId,
@@ -76,13 +83,15 @@ export class SQLiteDiscussionRoundStore implements DiscussionRoundStore {
 
 	list(query: DiscussionRoundQuery): DiscussionRound[] {
 		const limit = Math.min(DISCUSSION_ROUNDS_MAX_LIMIT, Math.max(1, Math.floor(query.limit ?? DISCUSSION_ROUNDS_DEFAULT_LIMIT)));
-		const rows = this.db.prepare(`
+		const rows = this.db
+			.prepare(`
 			SELECT id, discussion_id, round_number, actor, content, occurred_at, options, options_mode, selected, option_descriptions
 			FROM discussion_rounds
 			WHERE discussion_id = ? AND round_number > ?
 			ORDER BY round_number ASC
 			LIMIT ?
-		`).all(query.discussionId, query.afterRound ?? 0, limit) as DiscussionRoundRow[];
+		`)
+			.all(query.discussionId, query.afterRound ?? 0, limit) as DiscussionRoundRow[];
 		return rows.map(mapRow);
 	}
 

package/src/adapters/sqlite-gate-runner.ts

@@ -1,7 +1,7 @@
 import type { Db } from "../db.ts";
 import type { GateResult, GateRunOptions } from "../domain/gate.ts";
-import type { GateRunner } from "../ports/gate-runner.ts";
 import { runGates, runGatesAsync } from "../ops.ts";
+import type { GateRunner } from "../ports/gate-runner.ts";
 
 export class SQLiteGateRunner implements GateRunner {
 	constructor(private readonly db: Db) {}

package/src/adapters/sqlite-graph-projection-store.ts

@@ -7,35 +7,39 @@ export class SQLiteGraphProjectionStore implements GraphProjectionStore {
 	constructor(private readonly db: Db) {}
 
 	getCheckpoint(producerId: string): ProjectionCheckpoint | null {
-		const row = this.db.prepare("SELECT producer_id, last_sequence, last_batch_id, applied_at FROM graph_projection_checkpoints WHERE producer_id = ?").get(producerId) as
-			| { producer_id: string; last_sequence: number; last_batch_id: string; applied_at: string }
-			| null;
+		const row = this.db
+			.prepare("SELECT producer_id, last_sequence, last_batch_id, applied_at FROM graph_projection_checkpoints WHERE producer_id = ?")
+			.get(producerId) as { producer_id: string; last_sequence: number; last_batch_id: string; applied_at: string } | null;
 		if (row == null) return null;
 		return { producerId: row.producer_id, lastSequence: row.last_sequence, lastBatchId: row.last_batch_id, appliedAt: row.applied_at };
 	}
 
 	resolveIdentity(producerId: string, externalId: string): string | undefined {
-		const row = this.db.prepare("SELECT artifact_id FROM graph_projection_identities WHERE producer_id = ? AND external_id = ?").get(producerId, externalId) as
-			| { artifact_id: string }
-			| null;
+		const row = this.db
+			.prepare("SELECT artifact_id FROM graph_projection_identities WHERE producer_id = ? AND external_id = ?")
+			.get(producerId, externalId) as { artifact_id: string } | null;
 		return row?.artifact_id;
 	}
 
 	recordIdentity(producerId: string, externalId: string, artifactId: string): void {
 		inTransaction(this.db, () => {
-			this.db.prepare(`
+			this.db
+				.prepare(`
 				INSERT INTO graph_projection_identities (producer_id, external_id, artifact_id) VALUES (?, ?, ?)
 				ON CONFLICT(producer_id, external_id) DO UPDATE SET artifact_id = excluded.artifact_id
-			`).run(producerId, externalId, artifactId);
+			`)
+				.run(producerId, externalId, artifactId);
 		});
 	}
 
 	commitCheckpoint(checkpoint: ProjectionCheckpoint): void {
 		inTransaction(this.db, () => {
-			this.db.prepare(`
+			this.db
+				.prepare(`
 				INSERT INTO graph_projection_checkpoints (producer_id, last_sequence, last_batch_id, applied_at) VALUES (?, ?, ?, ?)
 				ON CONFLICT(producer_id) DO UPDATE SET last_sequence = excluded.last_sequence, last_batch_id = excluded.last_batch_id, applied_at = excluded.applied_at
-			`).run(checkpoint.producerId, checkpoint.lastSequence, checkpoint.lastBatchId, checkpoint.appliedAt);
+			`)
+				.run(checkpoint.producerId, checkpoint.lastSequence, checkpoint.lastBatchId, checkpoint.appliedAt);
 		});
 	}
 }

package/src/adapters/sqlite-log-store.ts

@@ -43,34 +43,51 @@ export class SQLiteLogStore implements LogStore {
 	constructor(private readonly db: Db) {}
 
 	ensureSource(sourceId: string, label: string, projectRoot: string | null): LogSource {
-		const existing = this.db.prepare("SELECT id, label, project_root, created_at FROM log_sources WHERE id = ?").get(sourceId) as SourceRow | undefined;
+		const existing = this.db.prepare("SELECT id, label, project_root, created_at FROM log_sources WHERE id = ?").get(sourceId) as
+			| SourceRow
+			| undefined;
 		if (existing) return toSource(existing);
 		const createdAt = new Date().toISOString();
-		this.db.prepare("INSERT INTO log_sources (id, label, project_root, created_at) VALUES (?, ?, ?, ?)").run(sourceId, label, projectRoot, createdAt);
+		this.db
+			.prepare("INSERT INTO log_sources (id, label, project_root, created_at) VALUES (?, ?, ?, ?)")
+			.run(sourceId, label, projectRoot, createdAt);
 		return { id: sourceId, label, projectRoot, createdAt };
 	}
 
 	findEntryByOperationId(sourceId: string, operationId: string): LogEntry | undefined {
-		const row = this.db.prepare(
-			"SELECT id, source_id, occurred_at, level, message, truncated, fields_json, operation_id, session_id FROM log_entries WHERE source_id = ? AND operation_id = ?",
-		).get(sourceId, operationId) as EntryRow | undefined;
+		const row = this.db
+			.prepare(
+				"SELECT id, source_id, occurred_at, level, message, truncated, fields_json, operation_id, session_id FROM log_entries WHERE source_id = ? AND operation_id = ?",
+			)
+			.get(sourceId, operationId) as EntryRow | undefined;
 		return row ? toEntry(row) : undefined;
 	}
 
 	insertEntry(entry: LogEntry): void {
-		this.db.prepare(
-			`INSERT INTO log_entries (id, source_id, occurred_at, level, message, truncated, fields_json, operation_id, session_id)
+		this.db
+			.prepare(
+				`INSERT INTO log_entries (id, source_id, occurred_at, level, message, truncated, fields_json, operation_id, session_id)
 			 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-		).run(
-			entry.id, entry.sourceId, entry.occurredAt, entry.level, entry.message,
-			entry.truncated ? 1 : 0, JSON.stringify(entry.fields), entry.operationId, entry.sessionId ?? null,
-		);
+			)
+			.run(
+				entry.id,
+				entry.sourceId,
+				entry.occurredAt,
+				entry.level,
+				entry.message,
+				entry.truncated ? 1 : 0,
+				JSON.stringify(entry.fields),
+				entry.operationId,
+				entry.sessionId ?? null,
+			);
 	}
 
 	entriesForSource(sourceId: string): readonly LogEntry[] {
-		const rows = this.db.prepare(
-			"SELECT id, source_id, occurred_at, level, message, truncated, fields_json, operation_id, session_id FROM log_entries WHERE source_id = ? ORDER BY occurred_at, id",
-		).all(sourceId) as EntryRow[];
+		const rows = this.db
+			.prepare(
+				"SELECT id, source_id, occurred_at, level, message, truncated, fields_json, operation_id, session_id FROM log_entries WHERE source_id = ? ORDER BY occurred_at, id",
+			)
+			.all(sourceId) as EntryRow[];
 		return rows.map(toEntry);
 	}
 
@@ -78,11 +95,13 @@ export class SQLiteLogStore implements LogStore {
 		const countRow = this.db.prepare("SELECT COUNT(*) as count FROM log_entries WHERE source_id = ?").get(sourceId) as { count: number };
 		const excess = countRow.count - maxEntries;
 		if (excess <= 0) return 0;
-		this.db.prepare(
-			`DELETE FROM log_entries WHERE id IN (
+		this.db
+			.prepare(
+				`DELETE FROM log_entries WHERE id IN (
 				SELECT id FROM log_entries WHERE source_id = ? ORDER BY occurred_at, id LIMIT ?
 			)`,
-		).run(sourceId, excess);
+			)
+			.run(sourceId, excess);
 		return excess;
 	}
 }

package/src/adapters/sqlite-note-event-store.ts

@@ -1,12 +1,12 @@
 import type { Db } from "../db.ts";
 import {
-	normalizeNoteHistoryQuery,
-	validateNoteEvent,
 	type AppendNoteEvent,
 	type NoteEvent,
 	type NoteEventType,
 	type NoteHistoryPage,
 	type NoteHistoryQuery,
+	normalizeNoteHistoryQuery,
+	validateNoteEvent,
 } from "../domain/note-event.ts";
 import type { NoteEventStore } from "../ports/note-event-store.ts";
 
@@ -45,21 +45,23 @@ export class SQLiteNoteEventStore implements NoteEventStore {
 
 	append(input: AppendNoteEvent): NoteEvent {
 		const event = validateNoteEvent(input);
-		const result = this.db.prepare(`
+		const result = this.db
+			.prepare(`
 			INSERT INTO note_events (
 				note_id, occurred_at, event_type, actor, source, session_id, reason, related_id, disposition, event_schema_version
 			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 1)
-		`).run(
-			event.noteId,
-			new Date().toISOString(),
-			event.type,
-			event.actor,
-			event.source,
-			event.sessionId ?? null,
-			event.reason ?? null,
-			event.relatedId ?? null,
-			event.disposition ?? null,
-		);
+		`)
+			.run(
+				event.noteId,
+				new Date().toISOString(),
+				event.type,
+				event.actor,
+				event.source,
+				event.sessionId ?? null,
+				event.reason ?? null,
+				event.relatedId ?? null,
+				event.disposition ?? null,
+			);
 		return mapRow(this.db.prepare("SELECT * FROM note_events WHERE id = ?").get(result.lastInsertRowid) as NoteEventRow);
 	}
 
@@ -67,12 +69,14 @@ export class SQLiteNoteEventStore implements NoteEventStore {
 		const { limit, direction, cursor } = normalizeNoteHistoryQuery(query);
 		const comparator = direction === "desc" ? "<" : ">";
 		const order = direction === "desc" ? "DESC" : "ASC";
-		const rows = this.db.prepare(`
+		const rows = this.db
+			.prepare(`
 			SELECT * FROM note_events
 			WHERE note_id = ? ${cursor === undefined ? "" : `AND id ${comparator} ?`}
 			ORDER BY occurred_at ${order}, id ${order}
 			LIMIT ?
-		`).all(...(cursor === undefined ? [noteId, limit + 1] : [noteId, cursor, limit + 1])) as NoteEventRow[];
+		`)
+			.all(...(cursor === undefined ? [noteId, limit + 1] : [noteId, cursor, limit + 1])) as NoteEventRow[];
 		const hasMore = rows.length > limit;
 		const events = rows.slice(0, limit).map(mapRow);
 		return { events, ...(hasMore ? { nextCursor: events.at(-1)!.id } : {}) };

package/src/adapters/sqlite-session-identity-store.ts

@@ -7,20 +7,24 @@ export class SQLiteSessionIdentityStore implements SessionIdentityStore {
 	constructor(private readonly db: Db) {}
 
 	find(sessionId: string): SessionIdentityRecord | undefined {
-		const row = this.db.prepare("SELECT session_id, secret_hash, registered_at, last_seen_at FROM session_identities WHERE session_id = ?").get(sessionId) as
-			| { session_id: string; secret_hash: string; registered_at: string; last_seen_at: string }
-			| null;
-		return row ? { sessionId: row.session_id, secretHash: row.secret_hash, registeredAt: row.registered_at, lastSeenAt: row.last_seen_at } : undefined;
+		const row = this.db
+			.prepare("SELECT session_id, secret_hash, registered_at, last_seen_at FROM session_identities WHERE session_id = ?")
+			.get(sessionId) as { session_id: string; secret_hash: string; registered_at: string; last_seen_at: string } | null;
+		return row
+			? { sessionId: row.session_id, secretHash: row.secret_hash, registeredAt: row.registered_at, lastSeenAt: row.last_seen_at }
+			: undefined;
 	}
 
 	upsert(record: SessionIdentityRecord): void {
 		inTransaction(this.db, () => {
 			this.evictOldestBeyondCap(record.sessionId);
-			this.db.prepare(`
+			this.db
+				.prepare(`
 				INSERT INTO session_identities (session_id, secret_hash, registered_at, last_seen_at)
 				VALUES (?, ?, ?, ?)
 				ON CONFLICT(session_id) DO UPDATE SET secret_hash = excluded.secret_hash, registered_at = excluded.registered_at, last_seen_at = excluded.last_seen_at
-			`).run(record.sessionId, record.secretHash, record.registeredAt, record.lastSeenAt);
+			`)
+				.run(record.sessionId, record.secretHash, record.registeredAt, record.lastSeenAt);
 		});
 	}
 
@@ -41,6 +45,8 @@ export class SQLiteSessionIdentityStore implements SessionIdentityStore {
 		const exists = this.db.prepare("SELECT 1 FROM session_identities WHERE session_id = ?").get(sessionId);
 		if (exists) return;
 		if (this.count() < SESSION_IDENTITY_MAX_ROWS) return;
-		this.db.exec("DELETE FROM session_identities WHERE session_id = (SELECT session_id FROM session_identities ORDER BY last_seen_at ASC LIMIT 1)");
+		this.db.exec(
+			"DELETE FROM session_identities WHERE session_id = (SELECT session_id FROM session_identities ORDER BY last_seen_at ASC LIMIT 1)",
+		);
 	}
 }

package/src/adapters/sqlite-task-event-store.ts

@@ -1,10 +1,9 @@
 import type { Db } from "../db.ts";
 import { inTransaction } from "../db.ts";
 import {
+	type AppendTaskEvent,
 	normalizeTaskEventFeedQuery,
 	normalizeTaskHistoryQuery,
-	validateTaskEvent,
-	type AppendTaskEvent,
 	type TaskEvent,
 	type TaskEventEvidence,
 	type TaskEventFeedPage,
@@ -13,6 +12,7 @@ import {
 	type TaskHistoryPage,
 	type TaskHistoryQuery,
 	type TaskLifecycleStatus,
+	validateTaskEvent,
 } from "../domain/task-event.ts";
 import type { TaskEventStore } from "../ports/task-event-store.ts";
 
@@ -53,28 +53,32 @@ function mapRow(row: TaskEventRow): TaskEvent {
 export class SQLiteTaskEventStore implements TaskEventStore {
 	constructor(private readonly db: Db) {}
 
-	atomic<T>(operation: () => T): T { return inTransaction(this.db, operation); }
+	atomic<T>(operation: () => T): T {
+		return inTransaction(this.db, operation);
+	}
 
 	append(input: AppendTaskEvent): TaskEvent {
 		const event = validateTaskEvent(input);
-		const result = this.db.prepare(`
+		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),
-		);
+		`)
+			.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);
 	}
 
@@ -82,12 +86,14 @@ export class SQLiteTaskEventStore implements TaskEventStore {
 		const { limit, direction, cursor } = normalizeTaskHistoryQuery(query);
 		const comparator = direction === "desc" ? "<" : ">";
 		const order = direction === "desc" ? "DESC" : "ASC";
-		const rows = this.db.prepare(`
+		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[];
+		`)
+			.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 } : {}) };
@@ -100,12 +106,14 @@ export class SQLiteTaskEventStore implements TaskEventStore {
 		if (cursor !== undefined) params.push(cursor);
 		if (eventTypes) params.push(...eventTypes);
 		params.push(limit + 1);
-		const rows = this.db.prepare(`
+		const rows = this.db
+			.prepare(`
 			SELECT * FROM task_events
 			WHERE 1=1 ${cursor === undefined ? "" : "AND id > ?"} ${typeFilter}
 			ORDER BY id ASC
 			LIMIT ?
-		`).all(...params) as TaskEventRow[];
+		`)
+			.all(...params) as TaskEventRow[];
 		const hasMore = rows.length > limit;
 		const events = rows.slice(0, limit).map(mapRow);
 		return { events, ...(hasMore ? { nextCursor: events.at(-1)!.id } : {}) };