@danypops/papyrus 0.42.0 → 0.42.2

package/src/ports/task-focus-store.ts

@@ -37,7 +37,9 @@ export interface TaskFocusStore {
 export class InMemoryTaskFocusStore implements TaskFocusStore {
 	private readonly state = new Map<string, TaskFocusState>();
 
-	get(scope?: string): TaskFocusState | undefined { return this.state.get(normalizeFocusScope(scope)); }
+	get(scope?: string): TaskFocusState | undefined {
+		return this.state.get(normalizeFocusScope(scope));
+	}
 
 	set(taskId: string, scope?: string): TaskFocusState {
 		const key = normalizeFocusScope(scope);
@@ -51,7 +53,12 @@ export class InMemoryTaskFocusStore implements TaskFocusStore {
 		const key = normalizeFocusScope(scope);
 		const current = this.state.get(key);
 		if (current?.taskId !== taskId) throw new Error(`task "${taskId}" is not focused`);
-		const focus: TaskFocusState = { ...current, status: "paused", updatedAt: new Date().toISOString(), ...(reason ? { pauseReason: reason } : {}) };
+		const focus: TaskFocusState = {
+			...current,
+			status: "paused",
+			updatedAt: new Date().toISOString(),
+			...(reason ? { pauseReason: reason } : {}),
+		};
 		this.state.set(key, focus);
 		return focus;
 	}
@@ -79,7 +86,10 @@ export class InMemoryTaskFocusStore implements TaskFocusStore {
 	reapStale(olderThanIso: string): number {
 		let removed = 0;
 		for (const [key, focus] of this.state) {
-			if (focus.updatedAt < olderThanIso) { this.state.delete(key); removed++; }
+			if (focus.updatedAt < olderThanIso) {
+				this.state.delete(key);
+				removed++;
+			}
 		}
 		return removed;
 	}
@@ -88,7 +98,10 @@ export class InMemoryTaskFocusStore implements TaskFocusStore {
 		let oldestKey: string | undefined;
 		let oldestAt: string | undefined;
 		for (const [key, focus] of this.state) {
-			if (oldestAt === undefined || focus.updatedAt < oldestAt) { oldestKey = key; oldestAt = focus.updatedAt; }
+			if (oldestAt === undefined || focus.updatedAt < oldestAt) {
+				oldestKey = key;
+				oldestAt = focus.updatedAt;
+			}
 		}
 		if (oldestKey !== undefined) this.state.delete(oldestKey);
 	}

package/src/ports/task-lease-store.ts

@@ -1,5 +1,5 @@
 import { TASK_LEASE_DEFAULT_TTL_MS } from "../constants.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";
 
 export interface TaskLeaseStore {
 	/**
@@ -51,7 +51,8 @@ export class InMemoryTaskLeaseStore implements TaskLeaseStore {
 		const nowIso = new Date().toISOString();
 		const current = this.leases.get(taskId);
 		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 renewed: TaskLease = { ...current, leaseExpiresAt: new Date(Date.now() + ttlMs).toISOString(), heartbeatAt: nowIso };
 		this.leases.set(taskId, renewed);
 		return renewed;
@@ -61,7 +62,8 @@ export class InMemoryTaskLeaseStore implements TaskLeaseStore {
 		const nowIso = new Date().toISOString();
 		const current = this.leases.get(taskId);
 		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.leases.delete(taskId);
 		return { released: true };
 	}
@@ -75,7 +77,10 @@ export class InMemoryTaskLeaseStore implements TaskLeaseStore {
 	reapExpired(olderThanIso: string): number {
 		let removed = 0;
 		for (const [taskId, lease] of this.leases) {
-			if (lease.leaseExpiresAt < olderThanIso) { this.leases.delete(taskId); removed++; }
+			if (lease.leaseExpiresAt < olderThanIso) {
+				this.leases.delete(taskId);
+				removed++;
+			}
 		}
 		return removed;
 	}

package/src/ports/task-scope-store.ts

@@ -18,7 +18,9 @@ export class InMemoryTaskScopeStore implements TaskScopeStore {
 		return scope;
 	}
 
-	get(taskId: string): TaskProjectScope | undefined { return this.scopes.get(taskId); }
+	get(taskId: string): TaskProjectScope | undefined {
+		return this.scopes.get(taskId);
+	}
 
 	taskIds(projectRoot: string | undefined, limit: number): string[] {
 		return [...this.scopes.values()]

package/src/service.ts

@@ -1,50 +1,49 @@
-import { SERVICE_MAX_BODY_BYTES, SQLITE_SCHEMA_VERSION } from "./constants.ts";
-import { VERSION } from "./version.ts";
-import { migrateDb, openDb, schemaVersion } from "./db.ts";
-import { removeArtifactSubtree } from "./artifact-subtree.ts";
+import type { VehicleRegistry } from "@danypops/vehicle-server";
+import { createVehicleHttpApp } from "@danypops/vehicle-server/http";
+import type { Logger } from "@danypops/vehicle-server/logging";
+import { SQLiteArtifactScopeStore } from "./adapters/sqlite-artifact-scope-store.ts";
 import { SQLiteArtifactStore } from "./adapters/sqlite-artifact-store.ts";
+import { SQLiteDiscussionRoundStore } from "./adapters/sqlite-discussion-round-store.ts";
 import { SQLiteGateRunner } from "./adapters/sqlite-gate-runner.ts";
-import { SQLiteArtifactScopeStore } from "./adapters/sqlite-artifact-scope-store.ts";
 import { SQLiteGraphProjectionStore } from "./adapters/sqlite-graph-projection-store.ts";
+import { SQLiteLogStore } from "./adapters/sqlite-log-store.ts";
+import { SQLiteNoteEventStore } from "./adapters/sqlite-note-event-store.ts";
+import { SQLiteSessionIdentityStore } from "./adapters/sqlite-session-identity-store.ts";
+import { SQLiteTaskEventStore } from "./adapters/sqlite-task-event-store.ts";
 import { SQLiteTaskFocusStore } from "./adapters/sqlite-task-focus-store.ts";
 import { SQLiteTaskLeaseStore } from "./adapters/sqlite-task-lease-store.ts";
-import { SQLiteTaskEventStore } from "./adapters/sqlite-task-event-store.ts";
-import { SQLiteNoteEventStore } from "./adapters/sqlite-note-event-store.ts";
 import { SQLiteTaskScopeStore } from "./adapters/sqlite-task-scope-store.ts";
-import { SQLiteSessionIdentityStore } from "./adapters/sqlite-session-identity-store.ts";
+import { removeArtifactSubtree } from "./artifact-subtree.ts";
+import { type AuthorityClaim, AuthorityRegistry, AuthorizedArtifactWriter } from "./authority-registry.ts";
+import { SERVICE_MAX_BODY_BYTES, SQLITE_SCHEMA_VERSION } from "./constants.ts";
+import { migrateDb, openDb, schemaVersion } from "./db.ts";
+import { Discussions } from "./discussion-service.ts";
 import type { CreateArtifactInput } from "./domain/artifact.ts";
-import { AuthorityRegistry, AuthorizedArtifactWriter, type AuthorityClaim } from "./authority-registry.ts";
 import type { TaskEventContext } from "./domain/task-event.ts";
 import type { TaskViewMode } from "./domain/task-scope.ts";
-import type { ArtifactStore } from "./ports/artifact-store.ts";
+import { listInjectableRules } from "./domain-services.ts";
+import { Logs } from "./log-service.ts";
+import { OperationRegistry } from "./module-registry.ts";
+import { DISCUSS_OPERATION_NAMES, discussOperations } from "./modules/discuss.ts";
+import { DOCS_OPERATION_NAMES, docsOperations } from "./modules/docs.ts";
+import { GRAPH_PROJECTION_OPERATION_NAMES, graphProjectionOperations } from "./modules/graph-projection.ts";
+import { LOGS_OPERATION_NAMES, logsOperations } from "./modules/logs.ts";
+import { NOTES_OPERATION_NAMES, notesOperations } from "./modules/notes.ts";
+import { PLAYBOOKS_OPERATION_NAMES, playbooksOperations } from "./modules/playbooks.ts";
+import { RULES_OPERATION_NAMES, rulesOperations } from "./modules/rules.ts";
+import { SESSION_IDENTITY_OPERATION_NAMES, sessionIdentityOperations } from "./modules/session-identity.ts";
+import { TASKS_OPERATION_NAMES, tasksOperations } from "./modules/tasks.ts";
+import { NOTE_SUBTYPE, Notes } from "./note-service.ts";
 import type { ArtifactEventReader } from "./ports/artifact-event-reader.ts";
+import type { ArtifactStore } from "./ports/artifact-store.ts";
 import type { ArtifactTrashStore } from "./ports/artifact-trash-store.ts";
 import type { GateRunner } from "./ports/gate-runner.ts";
 import type { TaskEventStore } from "./ports/task-event-store.ts";
 import type { TaskScopeStore } from "./ports/task-scope-store.ts";
-import { Tasks, type TaskStatus } from "./task-service.ts";
-import {
-	listInjectableRules,
-} from "./domain-services.ts";
-import { Notes, NOTE_SUBTYPE } from "./note-service.ts";
+import { InvalidSessionSecretError, SessionIdentity } from "./session-identity-service.ts";
+import { type TaskStatus, Tasks } from "./task-service.ts";
 import { createPapyrusVehicleRegistry } from "./vehicle/papyrus-vehicle.ts";
-import type { VehicleRegistry } from "@danypops/vehicle-server";
-import { createVehicleHttpApp } from "@danypops/vehicle-server/http";
-import { Logs } from "./log-service.ts";
-import { SQLiteLogStore } from "./adapters/sqlite-log-store.ts";
-import { SessionIdentity, InvalidSessionSecretError } from "./session-identity-service.ts";
-import { OperationRegistry } from "./module-registry.ts";
-import { docsOperations, DOCS_OPERATION_NAMES } from "./modules/docs.ts";
-import { graphProjectionOperations, GRAPH_PROJECTION_OPERATION_NAMES } from "./modules/graph-projection.ts";
-import { logsOperations, LOGS_OPERATION_NAMES } from "./modules/logs.ts";
-import { notesOperations, NOTES_OPERATION_NAMES } from "./modules/notes.ts";
-import { rulesOperations, RULES_OPERATION_NAMES } from "./modules/rules.ts";
-import { playbooksOperations, PLAYBOOKS_OPERATION_NAMES } from "./modules/playbooks.ts";
-import { sessionIdentityOperations, SESSION_IDENTITY_OPERATION_NAMES } from "./modules/session-identity.ts";
-import { discussOperations, DISCUSS_OPERATION_NAMES } from "./modules/discuss.ts";
-import { tasksOperations, TASKS_OPERATION_NAMES } from "./modules/tasks.ts";
-import { Discussions } from "./discussion-service.ts";
-import { SQLiteDiscussionRoundStore } from "./adapters/sqlite-discussion-round-store.ts";
+import { VERSION } from "./version.ts";
 
 /**
  * Operations with no registered module: the generic, cross-cutting kernel surface
@@ -57,9 +56,21 @@ import { SQLiteDiscussionRoundStore } from "./adapters/sqlite-discussion-round-s
  * @danypops/discourse package plus host adapters.
  */
 const COMPOSITION_ROOT_OPERATION_NAMES = [
-	"system.migrate", "artifact.create", "artifact.query", "artifact.show",
-	"artifact.remove", "artifact.remove_subtree", "artifact.restore", "artifact.trash_status", "artifact.trash_list",
-	"graph.link", "graph.unlink", "graph.tree", "graph.status", "graph.history", "gates.run",
+	"system.migrate",
+	"artifact.create",
+	"artifact.query",
+	"artifact.show",
+	"artifact.remove",
+	"artifact.remove_subtree",
+	"artifact.restore",
+	"artifact.trash_status",
+	"artifact.trash_list",
+	"graph.link",
+	"graph.unlink",
+	"graph.tree",
+	"graph.status",
+	"graph.history",
+	"gates.run",
 	"rules.injectable",
 ] as const;
 
@@ -85,7 +96,7 @@ export const EXPECTED_OPERATION_NAMES = [
 	...DISCUSS_OPERATION_NAMES,
 ] as const;
 
-export type OperationName = typeof EXPECTED_OPERATION_NAMES[number];
+export type OperationName = (typeof EXPECTED_OPERATION_NAMES)[number];
 type OperationInput = Record<string, unknown>;
 type OperationHandler = (input: OperationInput) => unknown;
 
@@ -107,7 +118,7 @@ function optionalString(input: OperationInput, key: string): string | undefined
 	return value;
 }
 
-function optionalStringArray(input: OperationInput, key: string): string[] | undefined {
+function _optionalStringArray(input: OperationInput, key: string): string[] | undefined {
 	const value = input[key];
 	if (value === undefined) return undefined;
 	if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) throw new Error(`${key} must be an array of strings`);
@@ -128,9 +139,9 @@ function normalizeCreateInput(input: OperationInput): CreateArtifactInput {
 
 function templateSubtype(artifacts: ArtifactStore, templateId: string | undefined): string | undefined {
 	if (!templateId) return undefined;
-	const defaults = artifacts.get(templateId)?.extra["defaults"];
+	const defaults = artifacts.get(templateId)?.extra.defaults;
 	if (typeof defaults !== "object" || defaults === null || Array.isArray(defaults)) return undefined;
-	const subtype = (defaults as Record<string, unknown>)["subtype"];
+	const subtype = (defaults as Record<string, unknown>).subtype;
 	return typeof subtype === "string" ? subtype : undefined;
 }
 
@@ -225,9 +236,9 @@ function handlers(
 	artifacts: ArtifactStore & ArtifactTrashStore & ArtifactEventReader,
 	gates: GateRunner,
 	tasks: Tasks,
-	notes: Notes,
-	events: TaskEventStore,
-	scopes: TaskScopeStore,
+	_notes: Notes,
+	_events: TaskEventStore,
+	_scopes: TaskScopeStore,
 	migrate: () => unknown,
 	moduleRegistry: OperationRegistry,
 	authority: AuthorityRegistry,
@@ -237,7 +248,10 @@ function handlers(
 	// these six entries stay in this completeness-checked table only as a thin forward so
 	// `Record<OperationName, OperationHandler>` still guarantees every operation has an entry
 	// at compile time. The actual notes.* logic now lives in the module, not here.
-	const forwardToModule = (name: OperationName): OperationHandler => (input) => moduleRegistry.get(name)!.execute(input);
+	const forwardToModule =
+		(name: OperationName): OperationHandler =>
+		(input) =>
+			moduleRegistry.get(name)!.execute(input);
 	const eventContext = (input: OperationInput): TaskEventContext => ({
 		actor: optionalString(input, "actor"),
 		source: optionalString(input, "source"),
@@ -264,30 +278,41 @@ function handlers(
 		"system.migrate": () => migrate(),
 		"artifact.create": (input) => {
 			const normalized = normalizeCreateInput(input);
-			authority.requireArtifactAllowed(normalized.kind, normalized.subtype ?? templateSubtype(artifacts, normalized.templateId), "create", GENERIC_CALLER);
+			authority.requireArtifactAllowed(
+				normalized.kind,
+				normalized.subtype ?? templateSubtype(artifacts, normalized.templateId),
+				"create",
+				GENERIC_CALLER,
+			);
 			authority.requireArtifactAllowed(normalized.kind, normalized.subtype, "create", GENERIC_CALLER);
 			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,
-				projectRoot: string(input, "project_root"),
-				projectSource: "cwd",
-			}, eventContextFor(input, "artifact-api"));
+			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,
+					projectRoot: string(input, "project_root"),
+					projectSource: "cwd",
+				},
+				eventContextFor(input, "artifact-api"),
+			);
 		},
 		"artifact.query": (input) => artifacts.query(input),
-		"artifact.show": (input) => artifacts.get(string(input, "id"), {
-			tree: input["tree"] === true,
-			depth: optionalNumber(input, "depth"),
-			maxNodes: optionalNumber(input, "max_nodes") ?? optionalNumber(input, "maxNodes"),
-		}),
-		"artifact.remove": (input) => artifacts.trash(string(input, "id"), { reason: optionalString(input, "reason"), context: eventContext(input) }),
-		"artifact.remove_subtree": (input) => removeArtifactSubtree(artifacts, string(input, "id"), { reason: optionalString(input, "reason"), context: eventContext(input) }),
+		"artifact.show": (input) =>
+			artifacts.get(string(input, "id"), {
+				tree: input.tree === true,
+				depth: optionalNumber(input, "depth"),
+				maxNodes: optionalNumber(input, "max_nodes") ?? optionalNumber(input, "maxNodes"),
+			}),
+		"artifact.remove": (input) =>
+			artifacts.trash(string(input, "id"), { reason: optionalString(input, "reason"), context: eventContext(input) }),
+		"artifact.remove_subtree": (input) =>
+			removeArtifactSubtree(artifacts, string(input, "id"), { reason: optionalString(input, "reason"), context: eventContext(input) }),
 		"artifact.restore": (input) => artifacts.restore(string(input, "id"), eventContext(input)),
 		"artifact.trash_status": (input) => artifacts.trashStatus(string(input, "id")),
 		"artifact.trash_list": () => artifacts.listTrash(),
@@ -310,7 +335,11 @@ function handlers(
 			genericWriter.checkLink({ from, relation, to });
 			let removed: boolean;
 			if (relation === "depends_on" && artifacts.get(from)?.kind === "task" && artifacts.get(to)?.kind === "task") {
-				const before = tasks.graph().nodes.find((node) => node.task.id === from)?.dependencyIds.includes(to) ?? false;
+				const before =
+					tasks
+						.graph()
+						.nodes.find((node) => node.task.id === from)
+						?.dependencyIds.includes(to) ?? false;
 				tasks.undepend(from, to, eventContext(input));
 				removed = before;
 			} else {
@@ -318,29 +347,29 @@ function handlers(
 			}
 			return { removed };
 		},
-		"graph.tree": (input) => artifacts.get(string(input, "id"), {
-			tree: true,
-			depth: optionalNumber(input, "depth"),
-			maxNodes: optionalNumber(input, "max_nodes") ?? optionalNumber(input, "maxNodes"),
-		}),
+		"graph.tree": (input) =>
+			artifacts.get(string(input, "id"), {
+				tree: true,
+				depth: optionalNumber(input, "depth"),
+				maxNodes: optionalNumber(input, "max_nodes") ?? optionalNumber(input, "maxNodes"),
+			}),
 		"graph.status": (input) => genericWriter.setStatus(string(input, "id"), string(input, "status"), eventContext(input)),
-		"graph.history": (input) => artifacts.events({
-			artifactId: optionalString(input, "id"),
-			actor: optionalString(input, "actor"),
-			sessionId: optionalString(input, "session_id") ?? optionalString(input, "sessionId"),
-			since: optionalString(input, "since"),
-			limit: optionalNumber(input, "limit"),
-			cursor: optionalNumber(input, "cursor"),
-			direction: optionalString(input, "direction") as "asc" | "desc" | undefined,
-		}),
+		"graph.history": (input) =>
+			artifacts.events({
+				artifactId: optionalString(input, "id"),
+				actor: optionalString(input, "actor"),
+				sessionId: optionalString(input, "session_id") ?? optionalString(input, "sessionId"),
+				since: optionalString(input, "since"),
+				limit: optionalNumber(input, "limit"),
+				cursor: optionalNumber(input, "cursor"),
+				direction: optionalString(input, "direction") as "asc" | "desc" | undefined,
+			}),
 		"gates.run": (input) => {
 			const id = string(input, "id");
-			return artifacts.get(id)?.kind === "task"
-				? tasks.runGates(id, eventContextFor(input, "gates-api"))
-				: gates.runAsync(id);
+			return artifacts.get(id)?.kind === "task" ? tasks.runGates(id, eventContextFor(input, "gates-api")) : gates.runAsync(id);
 		},
-		"rules.injectable": (input) => listInjectableRules(artifacts, tasks.active(taskFilter(input))?.id)
-			.map(({ id, title, body, extra }) => ({ id, title, body, extra })),
+		"rules.injectable": (input) =>
+			listInjectableRules(artifacts, tasks.active(taskFilter(input))?.id).map(({ id, title, body, extra }) => ({ id, title, body, extra })),
 		"tasks.create": forwardToModule("tasks.create"),
 		"tasks.update": forwardToModule("tasks.update"),
 		"tasks.list": forwardToModule("tasks.list"),
@@ -453,7 +482,16 @@ export function createPapyrusService(path: string): PapyrusService {
 	const sessionIdentity = new SessionIdentity(new SQLiteSessionIdentityStore(db));
 	const discussions = new Discussions(artifacts, new SQLiteDiscussionRoundStore(db));
 	const authority = createAuthorityRegistry();
-	const vehicle = createPapyrusVehicleRegistry({ artifacts, scopes: artifactScopes, authority, notes, events, taskScopes: scopes, tasks, sessionIdentity });
+	const vehicle = createPapyrusVehicleRegistry({
+		artifacts,
+		scopes: artifactScopes,
+		authority,
+		notes,
+		events,
+		taskScopes: scopes,
+		tasks,
+		sessionIdentity,
+	});
 	const moduleRegistry = new OperationRegistry();
 	moduleRegistry.registerAll(notesOperations(notes));
 	moduleRegistry.registerAll(logsOperations(logs));
@@ -481,8 +519,12 @@ export function createPapyrusService(path: string): PapyrusService {
 			}
 			return handler(input);
 		},
-		checkpoint: () => { db.exec("PRAGMA wal_checkpoint(PASSIVE)"); },
-		optimize: () => { db.exec("PRAGMA optimize"); },
+		checkpoint: () => {
+			db.exec("PRAGMA wal_checkpoint(PASSIVE)");
+		},
+		optimize: () => {
+			db.exec("PRAGMA optimize");
+		},
 		reapStaleFocus: () => tasks.reapStaleFocus(),
 		purgeDueTrash: () => artifacts.purgeDueTrash(),
 		close: () => {
@@ -517,7 +559,10 @@ async function readOperationBody(request: Request): Promise<{ op?: unknown; inpu
 	}
 	const bytes = new Uint8Array(size);
 	let offset = 0;
-	for (const chunk of chunks) { bytes.set(chunk, offset); offset += chunk.byteLength; }
+	for (const chunk of chunks) {
+		bytes.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
 	return JSON.parse(new TextDecoder().decode(bytes)) as { op?: unknown; input?: unknown };
 }
 
@@ -531,9 +576,11 @@ export function createApp(deps: {
 	 * (daemon.ts) wires this to a PushChannel; tests and other embedders can ignore it.
 	 */
 	onOperationExecuted?: (operation: string, input: OperationInput) => void;
+	/** Defaults to a no-op (createVehicleHttpApp's own default) -- daemon.ts wires vehicleLogger() so a failed invocation is actually logged, not silently discarded. */
+	logger?: Logger;
 }): { fetch(request: Request): Promise<Response> } {
 	// Same Bearer token, daemon, and port as the rest of this API -- see ./vehicle/papyrus-vehicle.ts.
-	const vehicleApp = createVehicleHttpApp({ registry: deps.service.vehicle, token: deps.token });
+	const vehicleApp = createVehicleHttpApp({ registry: deps.service.vehicle, token: deps.token, logger: deps.logger });
 	return {
 		async fetch(request: Request): Promise<Response> {
 			if (request.headers.get("authorization") !== `Bearer ${deps.token}`) {
@@ -559,7 +606,14 @@ export function createApp(deps: {
 					deps.onOperationExecuted?.(body.op, input as OperationInput);
 					return json({ result });
 				} catch (error) {
-					const status = error instanceof PayloadTooLargeError ? 413 : error instanceof UnknownOperationError ? 404 : error instanceof InvalidSessionSecretError ? 403 : 400;
+					const status =
+						error instanceof PayloadTooLargeError
+							? 413
+							: error instanceof UnknownOperationError
+								? 404
+								: error instanceof InvalidSessionSecretError
+									? 403
+									: 400;
 					return json({ error: error instanceof Error ? error.message : String(error) }, { status });
 				}
 			}

package/src/session-identity-service.ts

@@ -1,4 +1,9 @@
-import { isSessionRegistered, registerSessionIdentity, releaseSessionIdentity, verifySessionSecret } from "@danypops/vehicle-server/session-identity";
+import {
+	isSessionRegistered,
+	registerSessionIdentity,
+	releaseSessionIdentity,
+	verifySessionSecret,
+} from "@danypops/vehicle-server/session-identity";
 import { assertValidSessionId } from "./domain/session-identity.ts";
 import type { SessionIdentityStore } from "./ports/session-identity-store.ts";
 
@@ -50,6 +55,9 @@ export class SessionIdentity {
 	assertAuthorized(sessionId: string | undefined, secret: string | undefined): void {
 		if (sessionId === undefined) return;
 		if (!this.isRegistered(sessionId)) return;
-		if (!this.verify(sessionId, secret)) throw new InvalidSessionSecretError(`session "${sessionId}" is registered; a valid session_secret is required to mutate its Task Focus`);
+		if (!this.verify(sessionId, secret))
+			throw new InvalidSessionSecretError(
+				`session "${sessionId}" is registered; a valid session_secret is required to mutate its Task Focus`,
+			);
 	}
 }

package/src/task-context.ts

@@ -1,11 +1,7 @@
+import { TASK_CONTEXT_CURRENT_LIMIT, TASK_CONTEXT_REJECTED_LIMIT, TASK_RECONCILIATION_INSTRUCTION } from "./constants.ts";
 import type { Artifact } from "./domain/artifact.ts";
 import { DISCUSSION_SUBTYPE, readDiscussionExtra } from "./domain/discussion.ts";
 import type { ArtifactStore } from "./ports/artifact-store.ts";
-import {
-	TASK_CONTEXT_CURRENT_LIMIT,
-	TASK_CONTEXT_REJECTED_LIMIT,
-	TASK_RECONCILIATION_INSTRUCTION,
-} from "./constants.ts";
 
 interface Gate {
 	type?: unknown;
@@ -14,8 +10,8 @@ interface Gate {
 }
 
 function gatesFrom(task: Artifact): Gate[] {
-	const gates = task.extra["gates"];
-	return Array.isArray(gates) ? gates as Gate[] : [];
+	const gates = task.extra.gates;
+	return Array.isArray(gates) ? (gates as Gate[]) : [];
 }
 
 function renderGate(gate: Gate): string {
@@ -45,14 +41,22 @@ function inScope(taskId: string, activeTaskId: string | undefined, taskIds: Set<
 	return taskIds === undefined || taskIds.has(taskId) || taskId === activeTaskId;
 }
 
-function deferredBlockingDiscussions(artifacts: ArtifactStore, activeTaskId: string | undefined, taskIds: Set<string> | undefined): string[] {
-	const discussions = artifacts.query({ kind: "task", subtype: DISCUSSION_SUBTYPE })
-		.filter((discussion) => {
-			try { return readDiscussionExtra(discussion.extra).state === "deferred"; } catch { return false; }
-		});
+function deferredBlockingDiscussions(
+	artifacts: ArtifactStore,
+	activeTaskId: string | undefined,
+	taskIds: Set<string> | undefined,
+): string[] {
+	const discussions = artifacts.query({ kind: "task", subtype: DISCUSSION_SUBTYPE }).filter((discussion) => {
+		try {
+			return readDiscussionExtra(discussion.extra).state === "deferred";
+		} catch {
+			return false;
+		}
+	});
 	if (discussions.length === 0) return [];
 
-	const blocks = artifacts.relationships({ artifactIds: discussions.map((discussion) => discussion.id) })
+	const blocks = artifacts
+		.relationships({ artifactIds: discussions.map((discussion) => discussion.id) })
 		.filter((edge) => edge.relation === "blocks");
 	const lines: string[] = [];
 	for (const discussion of discussions) {
@@ -76,8 +80,14 @@ export type TaskContextVerbosity = "summary" | "full";
  * exists and that the full plan is one explicit call away -- avoiding repeating the same
  * unchanged prose every single turn for a task that can persist across dozens of turns.
  */
-export function taskContext(artifacts: ArtifactStore, activeTaskId?: string, taskIds?: Set<string>, verbosity: TaskContextVerbosity = "full"): string | null {
-	const tasks = artifacts.query({ kind: "task", excludeSubtype: DISCUSSION_SUBTYPE })
+export function taskContext(
+	artifacts: ArtifactStore,
+	activeTaskId?: string,
+	taskIds?: Set<string>,
+	verbosity: TaskContextVerbosity = "full",
+): string | null {
+	const tasks = artifacts
+		.query({ kind: "task", excludeSubtype: DISCUSSION_SUBTYPE })
 		.filter((task) => taskIds === undefined || taskIds.has(task.id))
 		.sort((left, right) => left.updated_at.localeCompare(right.updated_at));
 	const open = tasks.filter((task) => task.status !== "done" && task.status !== "canceled");
@@ -86,7 +96,9 @@ export function taskContext(artifacts: ArtifactStore, activeTaskId?: string, tas
 
 	const done = tasks.length - open.length;
 	const active = activeTaskId ? open.find((task) => task.id === activeTaskId) : undefined;
-	const current = active ? [active] : open.filter((task) => task.status === "in-progress" || task.status === "review").slice(0, TASK_CONTEXT_CURRENT_LIMIT);
+	const current = active
+		? [active]
+		: open.filter((task) => task.status === "in-progress" || task.status === "review").slice(0, TASK_CONTEXT_CURRENT_LIMIT);
 	const next = open.find((task) => task.status === "todo");
 	const rejected = open.filter((task) => task.status === "rejected").slice(0, TASK_CONTEXT_REJECTED_LIMIT);
 	const lines = tasks.length > 0 ? [`Progress: ${done}/${tasks.length} done`] : [];

package/src/task-execution.ts

@@ -1,16 +1,7 @@
 import { TASK_EXECUTION_MAX_DEGREE, TASK_EXECUTION_MAX_EDGES, TASK_EXECUTION_MAX_NODES } from "./constants.ts";
 import type { TaskGraph } from "./task-service.ts";
 
-export type TaskExecutionState =
-	| "todo"
-	| "in-progress"
-	| "review"
-	| "rejected"
-	| "done"
-	| "canceled"
-	| "ready"
-	| "blocked"
-	| "invalid";
+export type TaskExecutionState = "todo" | "in-progress" | "review" | "rejected" | "done" | "canceled" | "ready" | "blocked" | "invalid";
 
 export interface TaskExecutionNode {
 	id: string;
@@ -56,8 +47,9 @@ function assertBounds(graph: TaskGraph): void {
 /** Build deterministic topological layers ordered by creation time and task ID. */
 export function projectTaskExecution(graph: TaskGraph): TaskExecutionPlan {
 	assertBounds(graph);
-	const orderedNodes = [...graph.nodes].sort((left, right) =>
-		left.task.created_at.localeCompare(right.task.created_at) || left.task.id.localeCompare(right.task.id));
+	const orderedNodes = [...graph.nodes].sort(
+		(left, right) => left.task.created_at.localeCompare(right.task.created_at) || left.task.id.localeCompare(right.task.id),
+	);
 	const byId = new Map(orderedNodes.map((node) => [node.task.id, node]));
 	const order = new Map(orderedNodes.map((node, index) => [node.task.id, index]));
 	const successors = new Map(orderedNodes.map((node) => [node.task.id, [] as string[]]));

package/src/task-graph-view.ts

@@ -36,18 +36,18 @@ export function projectTaskGraph(graph: TaskGraph, view: TaskGraphView): Display
 		}
 	}
 
-	const connected = view === "execution"
-		? new Set(graph.nodes.map((node) => node.task.id))
-		: new Set(edges.flatMap((edge) => [edge.from, edge.to]));
-	const nodes = view === "execution"
-		? projectTaskExecution(graph).nodes.map((node) => ({
-			id: node.id,
-			label: `${node.active ? "▶ " : ""}${EXECUTION_GLYPHS[node.state]} ${node.title} · ${node.layer === null ? "no layer" : `layer ${node.layer + 1}`} · ${node.state}`,
-			status: node.state,
-		}))
-		: graph.nodes
-			.filter((node) => connected.has(node.task.id))
-			.map((node) => ({ id: node.task.id, label: node.task.title, status: node.task.status }));
+	const connected =
+		view === "execution" ? new Set(graph.nodes.map((node) => node.task.id)) : new Set(edges.flatMap((edge) => [edge.from, edge.to]));
+	const nodes =
+		view === "execution"
+			? projectTaskExecution(graph).nodes.map((node) => ({
+					id: node.id,
+					label: `${node.active ? "▶ " : ""}${EXECUTION_GLYPHS[node.state]} ${node.title} · ${node.layer === null ? "no layer" : `layer ${node.layer + 1}`} · ${node.state}`,
+					status: node.state,
+				}))
+			: graph.nodes
+					.filter((node) => connected.has(node.task.id))
+					.map((node) => ({ id: node.task.id, label: node.task.title, status: node.task.status }));
 	return {
 		direction: "TD",
 		nodes,

package/src/task-relationship-view.ts

@@ -32,9 +32,7 @@ export function projectTaskRelationships(task: Artifact, graph?: TaskGraph): Dis
 	}
 	const nodes: DisplayGraphNode[] = [...nodeIds].map((id) => {
 		const artifact = taskNodes.get(id);
-		return artifact
-			? { id, label: artifact.title, status: artifact.status }
-			: { id, label: fallbackLabel(id) };
+		return artifact ? { id, label: artifact.title, status: artifact.status } : { id, label: fallbackLabel(id) };
 	});
 	return { direction: "LR", nodes, edges };
 }