@danypops/papyrus 0.41.0 → 0.42.1

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 };
 		});

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

@@ -8,36 +8,45 @@ export class SQLiteTaskScopeStore implements TaskScopeStore {
 
 	assign(taskId: string, projectRoot: string | undefined, source: TaskScopeSource): TaskProjectScope {
 		inTransaction(this.db, () => {
-			this.db.prepare(`
+			this.db
+				.prepare(`
 				INSERT INTO task_scopes (task_id, project_root, source, assigned_at)
 				VALUES (?, ?, ?, ?)
 				ON CONFLICT(task_id) DO UPDATE SET
 					project_root = excluded.project_root,
 					source = excluded.source,
 					assigned_at = excluded.assigned_at
-			`).run(taskId, projectRoot ?? null, source, new Date().toISOString());
+			`)
+				.run(taskId, projectRoot ?? null, source, new Date().toISOString());
 		});
 		return { taskId, ...(projectRoot === undefined ? {} : { projectRoot }), source };
 	}
 
 	get(taskId: string): TaskProjectScope | undefined {
-		const row = this.db.prepare("SELECT task_id, project_root, source FROM task_scopes WHERE task_id = ?").get(taskId) as
-			| { task_id: string; project_root: string | null; source: TaskScopeSource }
-			| null;
-		return row ? { taskId: row.task_id, ...(row.project_root === null ? {} : { projectRoot: row.project_root }), source: row.source } : undefined;
+		const row = this.db.prepare("SELECT task_id, project_root, source FROM task_scopes WHERE task_id = ?").get(taskId) as {
+			task_id: string;
+			project_root: string | null;
+			source: TaskScopeSource;
+		} | null;
+		return row
+			? { taskId: row.task_id, ...(row.project_root === null ? {} : { projectRoot: row.project_root }), source: row.source }
+			: undefined;
 	}
 
 	taskIds(projectRoot: string | undefined, limit: number): string[] {
-		const rows = projectRoot === undefined
-			? this.db.prepare("SELECT task_id FROM task_scopes WHERE project_root IS NULL ORDER BY task_id LIMIT ?").all(limit)
-			: this.db.prepare("SELECT task_id FROM task_scopes WHERE project_root = ? ORDER BY task_id LIMIT ?").all(projectRoot, limit);
+		const rows =
+			projectRoot === undefined
+				? this.db.prepare("SELECT task_id FROM task_scopes WHERE project_root IS NULL ORDER BY task_id LIMIT ?").all(limit)
+				: this.db.prepare("SELECT task_id FROM task_scopes WHERE project_root = ? ORDER BY task_id LIMIT ?").all(projectRoot, limit);
 		return (rows as Array<{ task_id: string }>).map((row) => row.task_id);
 	}
 
 	view(projectRoot: string): TaskViewPreference {
-		const row = this.db.prepare("SELECT project_root, mode, root_task_id FROM task_views WHERE project_root = ?").get(projectRoot) as
-			| { project_root: string; mode: TaskViewMode; root_task_id: string | null }
-			| null;
+		const row = this.db.prepare("SELECT project_root, mode, root_task_id FROM task_views WHERE project_root = ?").get(projectRoot) as {
+			project_root: string;
+			mode: TaskViewMode;
+			root_task_id: string | null;
+		} | null;
 		return row
 			? { projectRoot: row.project_root, mode: row.mode, ...(row.root_task_id === null ? {} : { rootTaskId: row.root_task_id }) }
 			: { projectRoot, mode: "project" };
@@ -45,14 +54,16 @@ export class SQLiteTaskScopeStore implements TaskScopeStore {
 
 	setView(projectRoot: string, mode: TaskViewMode, rootTaskId?: string): TaskViewPreference {
 		inTransaction(this.db, () => {
-			this.db.prepare(`
+			this.db
+				.prepare(`
 				INSERT INTO task_views (project_root, mode, root_task_id, updated_at)
 				VALUES (?, ?, ?, ?)
 				ON CONFLICT(project_root) DO UPDATE SET
 					mode = excluded.mode,
 					root_task_id = excluded.root_task_id,
 					updated_at = excluded.updated_at
-			`).run(projectRoot, mode, rootTaskId ?? null, new Date().toISOString());
+			`)
+				.run(projectRoot, mode, rootTaskId ?? null, new Date().toISOString());
 		});
 		return { projectRoot, mode, ...(rootTaskId === undefined ? {} : { rootTaskId }) };
 	}

package/src/artifact-relationship-view.ts

@@ -4,7 +4,7 @@ import { fallbackLabel } from "./task-relationship-view.ts";
 
 /**
  * The generic-artifact counterpart to projectTaskRelationships: unlike a Task, which already
- * has its containing TaskGraph's real titles in memory, a generic Doc/Rule/Skill/Playbook only
+ * has its containing TaskGraph's real titles in memory, a generic Doc/Rule/Playbook only
  * has raw edge id pairs (artifact.show's tree fetch never resolves neighbor titles -- see
  * ops.ts getArtifact). Reuses the same fallbackLabel heuristic rather than adding a network
  * round-trip per neighbor, which would turn a rendering concern into a new daemon-adjacent one.
@@ -16,8 +16,8 @@ export function projectArtifactRelationships(artifact: Artifact): DisplayGraph {
 		nodeIds.add(edge.from);
 		nodeIds.add(edge.to);
 	}
-	const nodes: DisplayGraphNode[] = [...nodeIds].map((id) => id === artifact.id
-		? { id, label: artifact.title, status: artifact.status }
-		: { id, label: fallbackLabel(id) });
+	const nodes: DisplayGraphNode[] = [...nodeIds].map((id) =>
+		id === artifact.id ? { id, label: artifact.title, status: artifact.status } : { id, label: fallbackLabel(id) },
+	);
 	return { direction: "LR", nodes, edges };
 }

package/src/artifact-subtree.ts

@@ -38,8 +38,10 @@ export function removeArtifactSubtree(
 		const current = queue.shift()!;
 		if (visited.has(current)) continue;
 		visited.add(current);
-		if (visited.size > ARTIFACT_REMOVE_SUBTREE_MAX_NODES) throw new Error(`remove_subtree exceeds ${ARTIFACT_REMOVE_SUBTREE_MAX_NODES} artifacts`);
-		const childIds = store.relationships({ artifactIds: [current] })
+		if (visited.size > ARTIFACT_REMOVE_SUBTREE_MAX_NODES)
+			throw new Error(`remove_subtree exceeds ${ARTIFACT_REMOVE_SUBTREE_MAX_NODES} artifacts`);
+		const childIds = store
+			.relationships({ artifactIds: [current] })
 			.filter((edge) => edge.from === current && edge.relation === "contains")
 			.map((edge) => edge.to);
 		queue.push(...childIds);

package/src/authority-registry.ts

@@ -18,8 +18,9 @@
  * claims are constructed at the composition root (src/service.ts) where that knowledge
  * already lives, matching "the core has generic registries" from the decision doc.
  */
-import type { ArtifactEventContext } from "./domain/artifact-event.ts";
+
 import type { Artifact, ArtifactLink } from "./domain/artifact.ts";
+import type { ArtifactEventContext } from "./domain/artifact-event.ts";
 import type { ArtifactStore } from "./ports/artifact-store.ts";
 
 export type ArtifactAction = "create" | "link" | "status" | "update";