@danypops/papyrus 0.42.0 → 0.42.2

package/package.json

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

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

@@ -7,15 +7,33 @@ export class SQLiteTaskFocusStore implements TaskFocusStore {
 	constructor(private readonly db: Db) {}
 
 	get(scope?: string): TaskFocusState | undefined {
-		const row = this.db.prepare("SELECT task_id, status, pause_reason, updated_at FROM task_focus WHERE scope = ?").get(normalizeFocusScope(scope)) as
-			| { task_id: string; status: TaskFocusStatus; pause_reason: string | null; updated_at: string }
-			| null;
-		return row ? { taskId: row.task_id, status: row.status, updatedAt: row.updated_at, ...(row.pause_reason ? { pauseReason: row.pause_reason } : {}) } : undefined;
+		const row = this.db
+			.prepare("SELECT task_id, status, pause_reason, updated_at FROM task_focus WHERE scope = ?")
+			.get(normalizeFocusScope(scope)) as {
+			task_id: string;
+			status: TaskFocusStatus;
+			pause_reason: string | null;
+			updated_at: string;
+		} | null;
+		return row
+			? {
+					taskId: row.task_id,
+					status: row.status,
+					updatedAt: row.updated_at,
+					...(row.pause_reason ? { pauseReason: row.pause_reason } : {}),
+				}
+			: undefined;
 	}
 
-	set(taskId: string, scope?: string): TaskFocusState { return this.write(taskId, "active", scope); }
-	pause(taskId: string, reason?: string, scope?: string): TaskFocusState { return this.transition(taskId, "active", "paused", reason, scope); }
-	unpause(taskId: string, scope?: string): TaskFocusState { return this.transition(taskId, "paused", "active", undefined, scope); }
+	set(taskId: string, scope?: string): TaskFocusState {
+		return this.write(taskId, "active", scope);
+	}
+	pause(taskId: string, reason?: string, scope?: string): TaskFocusState {
+		return this.transition(taskId, "active", "paused", reason, scope);
+	}
+	unpause(taskId: string, scope?: string): TaskFocusState {
+		return this.transition(taskId, "paused", "active", undefined, scope);
+	}
 
 	clear(taskId?: string, scope?: string): void {
 		const key = normalizeFocusScope(scope);
@@ -35,7 +53,13 @@ export class SQLiteTaskFocusStore implements TaskFocusStore {
 		return this.db.prepare("DELETE FROM task_focus WHERE updated_at < ?").run(olderThanIso).changes;
 	}
 
-	private transition(taskId: string, expected: TaskFocusStatus, status: TaskFocusStatus, reason: string | undefined, scope: string | undefined): TaskFocusState {
+	private transition(
+		taskId: string,
+		expected: TaskFocusStatus,
+		status: TaskFocusStatus,
+		reason: string | undefined,
+		scope: string | undefined,
+	): TaskFocusState {
 		const current = this.get(scope);
 		if (current?.taskId !== taskId) throw new Error(`task "${taskId}" is not focused`);
 		if (current.status !== expected) throw new Error(`focus is ${current.status}, expected ${expected}`);
@@ -56,11 +80,13 @@ export class SQLiteTaskFocusStore implements TaskFocusStore {
 		const updatedAt = new Date().toISOString();
 		inTransaction(this.db, () => {
 			this.evictOldestBeyondCap(key);
-			this.db.prepare(`
+			this.db
+				.prepare(`
 				INSERT INTO task_focus (scope, task_id, status, pause_reason, updated_at)
 				VALUES (?, ?, ?, ?, ?)
 				ON CONFLICT(scope) DO UPDATE SET task_id = excluded.task_id, status = excluded.status, pause_reason = excluded.pause_reason, updated_at = excluded.updated_at
-			`).run(key, taskId, status, pauseReason ?? null, updatedAt);
+			`)
+				.run(key, taskId, status, pauseReason ?? null, updatedAt);
 		});
 		return { taskId, status, updatedAt, ...(pauseReason ? { pauseReason } : {}) };
 	}

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

@@ -1,7 +1,7 @@
 import { TASK_LEASE_DEFAULT_TTL_MS } from "../constants.ts";
 import type { Db } from "../db.ts";
 import { inTransaction } from "../db.ts";
-import { isLeaseExpired, validateLeaseNote, validateLeaseOwner, validateLeaseTtlMs, type TaskLease } from "../domain/task-lease.ts";
+import { isLeaseExpired, type TaskLease, validateLeaseNote, validateLeaseOwner, validateLeaseTtlMs } from "../domain/task-lease.ts";
 import type { TaskLeaseStore } from "../ports/task-lease-store.ts";
 
 interface TaskLeaseRow {
@@ -49,12 +49,14 @@ export class SQLiteTaskLeaseStore implements TaskLeaseStore {
 			const token = renewingSameOwner ? current!.token : crypto.randomUUID();
 			const claimedAt = renewingSameOwner ? current!.claimedAt : nowIso;
 			const leaseExpiresAt = new Date(now.getTime() + ttlMs).toISOString();
-			this.db.prepare(`
+			this.db
+				.prepare(`
 				INSERT INTO task_leases (task_id, owner, token, claimed_at, lease_expires_at, heartbeat_at, note)
 				VALUES (?, ?, ?, ?, ?, NULL, ?)
 				ON CONFLICT(task_id) DO UPDATE SET owner = excluded.owner, token = excluded.token, claimed_at = excluded.claimed_at,
 					lease_expires_at = excluded.lease_expires_at, heartbeat_at = NULL, note = excluded.note
-			`).run(taskId, owner, token, claimedAt, leaseExpiresAt, note ?? null);
+			`)
+				.run(taskId, owner, token, claimedAt, leaseExpiresAt, note ?? null);
 			return fromRow(this.row(taskId)!);
 		});
 	}
@@ -66,9 +68,12 @@ export class SQLiteTaskLeaseStore implements TaskLeaseStore {
 			const existing = this.row(taskId);
 			const current = existing ? fromRow(existing) : undefined;
 			if (!current || isLeaseExpired(current, nowIso)) throw new Error(`task "${taskId}" has no live lease to renew`);
-			if (current.owner !== owner || current.token !== token) throw new Error(`lease for task "${taskId}" is held by a different owner/token`);
+			if (current.owner !== owner || current.token !== token)
+				throw new Error(`lease for task "${taskId}" is held by a different owner/token`);
 			const leaseExpiresAt = new Date(Date.now() + ttlMs).toISOString();
-			this.db.prepare("UPDATE task_leases SET lease_expires_at = ?, heartbeat_at = ? WHERE task_id = ?").run(leaseExpiresAt, nowIso, taskId);
+			this.db
+				.prepare("UPDATE task_leases SET lease_expires_at = ?, heartbeat_at = ? WHERE task_id = ?")
+				.run(leaseExpiresAt, nowIso, taskId);
 			return fromRow(this.row(taskId)!);
 		});
 	}
@@ -79,7 +84,8 @@ export class SQLiteTaskLeaseStore implements TaskLeaseStore {
 			const existing = this.row(taskId);
 			const current = existing ? fromRow(existing) : undefined;
 			if (!current || isLeaseExpired(current, nowIso)) return { released: false };
-			if (current.owner !== owner || current.token !== token) throw new Error(`lease for task "${taskId}" is held by a different owner/token`);
+			if (current.owner !== owner || current.token !== token)
+				throw new Error(`lease for task "${taskId}" is held by a different owner/token`);
 			this.db.prepare("DELETE FROM task_leases WHERE task_id = ?").run(taskId);
 			return { released: true };
 		});