@danypops/papyrus 0.41.0 → 0.42.1

package/src/service.ts

@@ -1,68 +1,77 @@
-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 { instantiateSkillOrTemplate, skillsOperations, SKILLS_OPERATION_NAMES } from "./modules/skills.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
  * (artifact create/query/show, graph link/unlink/tree/status/history, gates run --
  * no domain owns creation/linking/traversal for every kind, the same way system.migrate
- * has no owning module) and two permanent composition-root exceptions (rules.injectable
- * needs tasks.active(); skills.instantiate branches into tasks.create()) -- see
- * src/modules/rules.ts and src/modules/skills.ts's module comments. Discourse's own
+ * has no owning module) and one permanent composition-root exception (rules.injectable
+ * needs tasks.active()) -- see src/modules/rules.ts's own module comment. Discourse's own
  * Papyrus-embedded storage (discourse.store) was removed entirely -- zero real callers
  * were ever confirmed against it; Discourse's real home is the standalone
  * @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",
-	"rules.injectable", "skills.instantiate",
+	"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;
 
 /**
@@ -80,7 +89,6 @@ export const EXPECTED_OPERATION_NAMES = [
 	...DOCS_OPERATION_NAMES,
 	...NOTES_OPERATION_NAMES,
 	...RULES_OPERATION_NAMES,
-	...SKILLS_OPERATION_NAMES,
 	...PLAYBOOKS_OPERATION_NAMES,
 	...GRAPH_PROJECTION_OPERATION_NAMES,
 	...LOGS_OPERATION_NAMES,
@@ -88,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;
 
@@ -110,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`);
@@ -131,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;
 }
 
@@ -170,11 +178,11 @@ const tasksAuthorityClaim: AuthorityClaim = {
 
 /**
  * The same status-bypass protection Tasks and Notes already have, extended to every other kind
- * with its own validated transition set (Doc's draft/active/archived, Rule/Skill/Playbook's
+ * with its own validated transition set (Doc's draft/active/archived, Rule/Playbook's
  * active/deprecated) -- graph.status previously let a caller jump straight to any status string,
  * skipping e.g. Doc's draft-must-go-through-active-before-archived rule entirely.
  */
-function lifecycleAuthorityClaim(owner: "docs" | "rules" | "skills" | "playbooks", kind: string): AuthorityClaim {
+function lifecycleAuthorityClaim(owner: "docs" | "rules" | "playbooks", kind: string): AuthorityClaim {
 	return {
 		owner,
 		matchesArtifact: (candidateKind, subtype) => candidateKind === kind && !(kind === "doc" && subtype === NOTE_SUBTYPE),
@@ -190,7 +198,6 @@ export function createAuthorityRegistry(): AuthorityRegistry {
 		tasksAuthorityClaim,
 		lifecycleAuthorityClaim("docs", "doc"),
 		lifecycleAuthorityClaim("rules", "rule"),
-		lifecycleAuthorityClaim("skills", "skill"),
 		lifecycleAuthorityClaim("playbooks", "playbook"),
 	]);
 	return authority;
@@ -229,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,
@@ -241,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"),
@@ -268,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(),
@@ -314,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 {
@@ -322,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"),
@@ -408,16 +433,6 @@ function handlers(
 		"rules.gate": forwardToModule("rules.gate"),
 		"rules.assign_project": forwardToModule("rules.assign_project"),
 		"rules.update": forwardToModule("rules.update"),
-		"skills.create": forwardToModule("skills.create"),
-		"skills.create_template": forwardToModule("skills.create_template"),
-		"skills.list": forwardToModule("skills.list"),
-		"skills.show": forwardToModule("skills.show"),
-		"skills.invoke": forwardToModule("skills.invoke"),
-		"skills.run": forwardToModule("skills.run"),
-		"skills.enable": forwardToModule("skills.enable"),
-		"skills.disable": forwardToModule("skills.disable"),
-		"skills.assign_project": forwardToModule("skills.assign_project"),
-		"skills.update": forwardToModule("skills.update"),
 		"playbooks.create": forwardToModule("playbooks.create"),
 		"playbooks.list": forwardToModule("playbooks.list"),
 		"playbooks.show": forwardToModule("playbooks.show"),
@@ -431,7 +446,6 @@ function handlers(
 		"playbooks.uncontain": forwardToModule("playbooks.uncontain"),
 		"playbooks.depend": forwardToModule("playbooks.depend"),
 		"playbooks.undepend": forwardToModule("playbooks.undepend"),
-		"skills.instantiate": (input) => instantiateSkillOrTemplate({ artifacts, tasks, authority }, input, eventContextFor(input, "template-instantiation")),
 		"graph_projection.apply": forwardToModule("graph_projection.apply"),
 		"graph_projection.checkpoint": forwardToModule("graph_projection.checkpoint"),
 		"logs.append": forwardToModule("logs.append"),
@@ -468,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));
@@ -477,7 +500,6 @@ export function createPapyrusService(path: string): PapyrusService {
 	moduleRegistry.registerAll(tasksOperations(tasks, artifacts, sessionIdentity));
 	moduleRegistry.registerAll(docsOperations(artifacts, artifactScopes, authority));
 	moduleRegistry.registerAll(rulesOperations(artifacts, artifactScopes));
-	moduleRegistry.registerAll(skillsOperations({ artifacts, events, scopes, artifactScopes, authority }));
 	moduleRegistry.registerAll(playbooksOperations({ artifacts, events, scopes, artifactScopes, tasks, sessionIdentity }));
 	moduleRegistry.registerAll(graphProjectionOperations(artifacts, projections, authority));
 	const registry = handlers(artifacts, gates, tasks, notes, events, scopes, () => migrateDb(db), moduleRegistry, authority);
@@ -497,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: () => {
@@ -533,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 };
 }
 
@@ -547,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}`) {
@@ -575,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 };
 }