@danypops/papyrus 0.42.0 → 0.42.2

package/src/task-service.ts

@@ -4,24 +4,38 @@ import {
 	TASK_EXECUTION_MAX_DEGREE,
 	TASK_EXECUTION_MAX_EDGES,
 	TASK_EXECUTION_MAX_NODES,
+	TASK_FOCUS_STALE_AFTER_MS,
 	TASK_LABEL_MAX_COUNT,
 	TASK_LABEL_MAX_LENGTH,
-	TASK_FOCUS_STALE_AFTER_MS,
 	TASK_SCOPE_MAX_TASKS,
 	TASK_TITLE_MAX_LENGTH,
 } from "./constants.ts";
 import type { Artifact } from "./domain/artifact.ts";
-import { checklistEntries, validateChecklist, type Checklist, type ProofReference } from "./domain/checklist.ts";
+import { type Checklist, checklistEntries, type ProofReference, validateChecklist } from "./domain/checklist.ts";
 import { DISCUSSION_SUBTYPE, isDiscussionArtifact, readDiscussionExtra } from "./domain/discussion.ts";
-import { validateGates, type Gate, type GateResult } from "./domain/gate.ts";
-import type { AppendTaskEvent, TaskEventContext, TaskEventFeedPage, TaskEventFeedQuery, TaskHistoryPage, TaskHistoryQuery, TaskLifecycleStatus } from "./domain/task-event.ts";
-import { normalizeProjectRoot, taskScopeLabel, type TaskScopeSource, type TaskViewMode, type TaskViewSelection } from "./domain/task-scope.ts";
+import { type Gate, type GateResult, validateGates } from "./domain/gate.ts";
+import type {
+	AppendTaskEvent,
+	TaskEventContext,
+	TaskEventFeedPage,
+	TaskEventFeedQuery,
+	TaskHistoryPage,
+	TaskHistoryQuery,
+	TaskLifecycleStatus,
+} from "./domain/task-event.ts";
+import type { TaskLease } from "./domain/task-lease.ts";
+import {
+	normalizeProjectRoot,
+	type TaskScopeSource,
+	type TaskViewMode,
+	type TaskViewSelection,
+	taskScopeLabel,
+} from "./domain/task-scope.ts";
 import type { ArtifactStore } from "./ports/artifact-store.ts";
 import type { GateRunner } from "./ports/gate-runner.ts";
-import { InMemoryTaskFocusStore, type TaskFocusStatus, type TaskFocusStore } from "./ports/task-focus-store.ts";
 import { InMemoryTaskEventStore, type TaskEventStore } from "./ports/task-event-store.ts";
+import { InMemoryTaskFocusStore, type TaskFocusStatus, type TaskFocusStore } from "./ports/task-focus-store.ts";
 import { InMemoryTaskLeaseStore, type TaskLeaseStore } from "./ports/task-lease-store.ts";
-import type { TaskLease } from "./domain/task-lease.ts";
 import { InMemoryTaskScopeStore, type TaskScopeStore } from "./ports/task-scope-store.ts";
 import { assertDependencyEdgeAllowed } from "./task-execution.ts";
 
@@ -147,8 +161,8 @@ export class Tasks {
 			if (input.parentId) this.require(input.parentId);
 			for (const dependency of input.dependsOn ?? []) this.require(dependency);
 			const extra: Record<string, unknown> = { ...(input.extra ?? {}) };
-			if (input.gates !== undefined) extra["gates"] = validateGates(input.gates);
-			if (input.checklist !== undefined) extra["checklist"] = validateChecklist(input.checklist);
+			if (input.gates !== undefined) extra.gates = validateGates(input.gates);
+			if (input.checklist !== undefined) extra.checklist = validateChecklist(input.checklist);
 			const projectRoot = input.projectRoot === undefined ? undefined : normalizeProjectRoot(input.projectRoot);
 			if (input.parentId && this.scopes.get(input.parentId)?.projectRoot !== projectRoot) {
 				throw new Error(`parent task "${input.parentId}" is outside project scope`);
@@ -179,18 +193,26 @@ export class Tasks {
 			if (task.status !== "done" && task.status !== "canceled") throw new Error(`cannot recover task creation from ${task.status}`);
 			const history = this.events.history(id, { direction: "asc", limit: 2 });
 			const created = history.events[0];
-			if (history.events.length !== 1 || history.nextCursor !== undefined || created?.type !== "created" || created.toStatus !== task.status) {
+			if (
+				history.events.length !== 1 ||
+				history.nextCursor !== undefined ||
+				created?.type !== "created" ||
+				created.toStatus !== task.status
+			) {
 				throw new Error("task was not terminal at creation");
 			}
 			const recovered = this.artifacts.setStatus(id, "todo");
 			if (!recovered) throw new Error(`task "${id}" not found`);
-			this.appendEvent({
-				taskId: id,
-				type: "creation_recovered",
-				fromStatus: task.status as TaskStatus,
-				toStatus: "todo",
-				evidence: { result: "terminal-at-creation" },
-			}, context);
+			this.appendEvent(
+				{
+					taskId: id,
+					type: "creation_recovered",
+					fromStatus: task.status as TaskStatus,
+					toStatus: "todo",
+					evidence: { result: "terminal-at-creation" },
+				},
+				context,
+			);
 			return recovered;
 		});
 	}
@@ -204,11 +226,13 @@ export class Tasks {
 			return this.recoverCreation(id, context);
 		}
 		const fields = (["title", "body", "labels"] as const).filter((field) => input[field] !== undefined);
-		if (fields.length === 0) throw new Error("task update requires title, body, or labels; status todo is only valid for creation recovery");
+		if (fields.length === 0)
+			throw new Error("task update requires title, body, or labels; status todo is only valid for creation recovery");
 		if (input.title !== undefined && (input.title.trim().length === 0 || input.title.length > TASK_TITLE_MAX_LENGTH)) {
 			throw new Error(`title must be between 1 and ${TASK_TITLE_MAX_LENGTH} characters`);
 		}
-		if (input.body !== undefined && input.body.length > TASK_BODY_MAX_LENGTH) throw new Error(`body cannot exceed ${TASK_BODY_MAX_LENGTH} characters`);
+		if (input.body !== undefined && input.body.length > TASK_BODY_MAX_LENGTH)
+			throw new Error(`body cannot exceed ${TASK_BODY_MAX_LENGTH} characters`);
 		if (input.labels !== undefined) {
 			if (input.labels.length > TASK_LABEL_MAX_COUNT) throw new Error(`labels cannot exceed ${TASK_LABEL_MAX_COUNT} entries`);
 			if (input.labels.some((label) => label.length === 0 || label.length > TASK_LABEL_MAX_LENGTH)) {
@@ -231,7 +255,14 @@ export class Tasks {
 			throw new Error(`task list limit must be between 1 and ${TASK_SCOPE_MAX_TASKS + 1}`);
 		}
 		if (selection.mode === "all") {
-			return this.artifacts.query({ kind: "task", excludeSubtype: DISCUSSION_SUBTYPE, status: filter.status, text: filter.text, labels: filter.labels, limit });
+			return this.artifacts.query({
+				kind: "task",
+				excludeSubtype: DISCUSSION_SUBTYPE,
+				status: filter.status,
+				text: filter.text,
+				labels: filter.labels,
+				limit,
+			});
 		}
 		const ids = this.scopes.taskIds(selection.projectRoot, TASK_SCOPE_MAX_TASKS + 1);
 		if (ids.length > TASK_SCOPE_MAX_TASKS) throw new Error(`task project scope exceeds ${TASK_SCOPE_MAX_TASKS} tasks`);
@@ -244,7 +275,9 @@ export class Tasks {
 		// leak a trashed task back into list results for the entire grace period. Scoped by ids
 		// rather than a bare kind query, so this stays bounded to exactly the already-bounded
 		// selectedIds set instead of scanning every task in the database.
-		const notTrashed = new Map(this.artifacts.query({ kind: "task", excludeSubtype: DISCUSSION_SUBTYPE, ids: [...selectedIds] }).map((task) => [task.id, task]));
+		const notTrashed = new Map(
+			this.artifacts.query({ kind: "task", excludeSubtype: DISCUSSION_SUBTYPE, ids: [...selectedIds] }).map((task) => [task.id, task]),
+		);
 		return [...selectedIds]
 			.map((id) => notTrashed.get(id))
 			.filter((task): task is Artifact => task !== undefined)
@@ -256,7 +289,8 @@ export class Tasks {
 	}
 
 	scopeSelection(projectRoot?: string, mode?: TaskViewMode, rootTaskId?: string): TaskViewSelection {
-		if (mode !== undefined && mode !== "project" && mode !== "graph" && mode !== "all") throw new Error("task scope must be project, graph, or all");
+		if (mode !== undefined && mode !== "project" && mode !== "graph" && mode !== "all")
+			throw new Error("task scope must be project, graph, or all");
 		if (projectRoot === undefined) return { mode: "all", label: taskScopeLabel("all") };
 		const normalized = normalizeProjectRoot(projectRoot);
 		const persisted = this.scopes.view(normalized);
@@ -302,14 +336,19 @@ export class Tasks {
 		const focus = this.focusStore.get(filter.sessionId);
 		const focusedId = focus?.taskId;
 		const focusStatus = focus?.status;
-		const nodes = new Map(tasks.map((task) => [task.id, {
-			task,
-			active: task.id === focusedId,
-			...(task.id === focusedId ? { focusStatus } : {}),
-			parentIds: [] as string[],
-			childIds: [] as string[],
-			dependencyIds: [] as string[],
-		}]));
+		const nodes = new Map(
+			tasks.map((task) => [
+				task.id,
+				{
+					task,
+					active: task.id === focusedId,
+					...(task.id === focusedId ? { focusStatus } : {}),
+					parentIds: [] as string[],
+					childIds: [] as string[],
+					dependencyIds: [] as string[],
+				},
+			]),
+		);
 		const relationships = this.artifacts.relationships({
 			kind: "task",
 			artifactIds: [...byId.keys()],
@@ -349,12 +388,17 @@ export class Tasks {
 		const focus = this.focusStore.get(filter?.sessionId);
 		if (!focus) return null;
 		const task = this.artifacts.get(focus.taskId);
-		if (!task || task.kind !== "task" || task.status === "done" || task.status === "canceled") {
+		if (task?.kind !== "task" || task.status === "done" || task.status === "canceled") {
 			this.focusStore.clear(focus.taskId, filter?.sessionId);
 			return null;
 		}
 		if (filter?.projectRoot && !this.list(filter).some((candidate) => candidate.id === task.id)) return null;
-		return { artifact: task, status: focus.status, updatedAt: focus.updatedAt, ...(focus.pauseReason ? { pauseReason: focus.pauseReason } : {}) };
+		return {
+			artifact: task,
+			status: focus.status,
+			updatedAt: focus.updatedAt,
+			...(focus.pauseReason ? { pauseReason: focus.pauseReason } : {}),
+		};
 	}
 
 	active(filter?: TaskFilter): Artifact | null {
@@ -378,7 +422,12 @@ export class Tasks {
 			if (!focus) throw new Error("no focused task");
 			const state = this.focusStore.pause(focus.artifact.id, context.reason, context.sessionId);
 			this.appendEvent({ taskId: focus.artifact.id, type: "focus_paused" }, context);
-			return { artifact: focus.artifact, status: state.status, updatedAt: state.updatedAt, ...(state.pauseReason ? { pauseReason: state.pauseReason } : {}) };
+			return {
+				artifact: focus.artifact,
+				status: state.status,
+				updatedAt: state.updatedAt,
+				...(state.pauseReason ? { pauseReason: state.pauseReason } : {}),
+			};
 		});
 	}
 
@@ -446,12 +495,19 @@ export class Tasks {
 			const transition = TASK_TRANSITIONS[action];
 			if (!transition.from.includes(task.status as TaskStatus)) throw new Error(`cannot ${action} task from ${task.status}`);
 			if (action === "start") {
-				const blocking = this.dependencyIds(id).map((dependencyId) => this.require(dependencyId)).filter((dependency) => dependency.status !== "done");
-				if (blocking.length > 0) throw new Error(`task "${task.title}" is blocked by dependencies: ${blocking.map((dependency) => `"${dependency.title}"`).join(", ")}`);
+				const blocking = this.dependencyIds(id)
+					.map((dependencyId) => this.require(dependencyId))
+					.filter((dependency) => dependency.status !== "done");
+				if (blocking.length > 0)
+					throw new Error(
+						`task "${task.title}" is blocked by dependencies: ${blocking.map((dependency) => `"${dependency.title}"`).join(", ")}`,
+					);
 				this.focusStore.set(id, context.sessionId);
 			}
 			const updated = this.artifacts.setStatus(id, transition.to)!;
-			const eventType = { start: "started", submit: "submitted", reject: "review_rejected", retry: "retried", cancel: "canceled" }[action] as AppendTaskEvent["type"];
+			const eventType = { start: "started", submit: "submitted", reject: "review_rejected", retry: "retried", cancel: "canceled" }[
+				action
+			] as AppendTaskEvent["type"];
 			this.appendEvent({ taskId: id, type: eventType, fromStatus: task.status as TaskStatus, toStatus: transition.to }, context);
 			if (action === "start" || action === "retry") this.propagateProgressToAncestors(id, context);
 			if (action === "retry") this.focusStore.set(id, context.sessionId);
@@ -480,8 +536,9 @@ export class Tasks {
 			visited.add(current);
 			if (visited.size > TASK_CANCEL_SUBTREE_MAX_NODES) throw new Error(`cancelSubtree exceeds ${TASK_CANCEL_SUBTREE_MAX_NODES} tasks`);
 			const task = this.artifacts.get(current);
-			if (!task || task.kind !== "task") continue;
-			const childIds = this.artifacts.relationships({ artifactIds: [current] })
+			if (task?.kind !== "task") continue;
+			const childIds = this.artifacts
+				.relationships({ artifactIds: [current] })
 				.filter((edge) => edge.from === current && edge.relation === "contains")
 				.map((edge) => edge.to);
 			queue.push(...childIds);
@@ -499,7 +556,9 @@ export class Tasks {
 		const task = this.requireReview(id);
 		this.requireNotBlocked(task);
 		const attemptId = crypto.randomUUID();
-		this.events.atomic(() => this.appendEvent({ taskId: id, type: "completion_attempted", fromStatus: "review", toStatus: "review", attemptId }, context));
+		this.events.atomic(() =>
+			this.appendEvent({ taskId: id, type: "completion_attempted", fromStatus: "review", toStatus: "review", attemptId }, context),
+		);
 		const checklist = this.reviewChecklist(task);
 		const results = this.gates.run(id, { cwd: this.scopes.get(id)?.projectRoot });
 		return this.resolveCompletion(id, attemptId, results, checklist, context, options);
@@ -509,7 +568,9 @@ export class Tasks {
 		const task = this.requireReview(id);
 		this.requireNotBlocked(task);
 		const attemptId = crypto.randomUUID();
-		this.events.atomic(() => this.appendEvent({ taskId: id, type: "completion_attempted", fromStatus: "review", toStatus: "review", attemptId }, context));
+		this.events.atomic(() =>
+			this.appendEvent({ taskId: id, type: "completion_attempted", fromStatus: "review", toStatus: "review", attemptId }, context),
+		);
 		const checklist = this.reviewChecklist(task);
 		// project_root, never the daemon's own inherited process cwd -- see GateRunOptions.cwd's doc
 		// comment for the real incident this fixes (a command gate once tested the daemon's entire
@@ -522,7 +583,16 @@ export class Tasks {
 	async runGates(id: string, context: TaskEventContext = {}): Promise<GateResult[]> {
 		this.require(id);
 		const results = await this.gates.runAsync(id, { cwd: this.scopes.get(id)?.projectRoot });
-		this.events.atomic(() => this.appendEvent({ taskId: id, type: "gates_evaluated", evidence: { gates: results, result: results.every((gate) => gate.passed) ? "passed" : "failed" } }, context));
+		this.events.atomic(() =>
+			this.appendEvent(
+				{
+					taskId: id,
+					type: "gates_evaluated",
+					evidence: { gates: results, result: results.every((gate) => gate.passed) ? "passed" : "failed" },
+				},
+				context,
+			),
+		);
 		return results;
 	}
 
@@ -593,7 +663,9 @@ export class Tasks {
 		return this.events.atomic(() => {
 			this.require(parentId);
 			this.require(childId);
-			const alreadyContained = this.relationships(parentId).some((edge) => edge.relation === "contains" && edge.from === parentId && edge.to === childId);
+			const alreadyContained = this.relationships(parentId).some(
+				(edge) => edge.relation === "contains" && edge.from === parentId && edge.to === childId,
+			);
 			this.artifacts.link({ from: parentId, relation: "contains", to: childId }, context);
 			this.artifacts.link({ from: childId, relation: "part_of", to: parentId }, context);
 			if (!alreadyContained) this.appendEvent({ taskId: parentId, type: "containment_added", reason: context.reason }, context);
@@ -621,7 +693,8 @@ export class Tasks {
 			artifactIds: projectTaskIds,
 			limit: TASK_EXECUTION_MAX_EDGES + 1,
 		});
-		if (relationships.length > TASK_EXECUTION_MAX_EDGES) throw new Error(`task project scope exceeds ${TASK_EXECUTION_MAX_EDGES} relationships`);
+		if (relationships.length > TASK_EXECUTION_MAX_EDGES)
+			throw new Error(`task project scope exceeds ${TASK_EXECUTION_MAX_EDGES} relationships`);
 		const children = new Map<string, string[]>();
 		for (const edge of relationships) {
 			const parentId = edge.relation === "contains" ? edge.from : edge.relation === "part_of" ? edge.to : undefined;
@@ -676,22 +749,25 @@ export class Tasks {
 			const parent = this.require(parentId);
 			if (parent.status === "todo") {
 				this.artifacts.setStatus(parentId, "in-progress");
-				this.appendEvent({ taskId: parentId, type: "started", fromStatus: "todo", toStatus: "in-progress" }, {
-					...context,
-					source: "task-ancestry",
-					reason: `nested task ${id} entered progress`,
-				});
+				this.appendEvent(
+					{ taskId: parentId, type: "started", fromStatus: "todo", toStatus: "in-progress" },
+					{
+						...context,
+						source: "task-ancestry",
+						reason: `nested task ${id} entered progress`,
+					},
+				);
 			}
 			pending.push(...this.parentIds(parentId));
 		}
 	}
 
 	private reviewChecklist(task: Artifact): ChecklistReview[] {
-		return checklistEntries(task.extra["checklist"]).map((entry) => ({
+		return checklistEntries(task.extra.checklist).map((entry) => ({
 			item: entry.item,
 			proof: entry.proof,
 			accepted: !entry.legacy && entry.proof.length > 0,
-			...((entry.legacy || entry.proof.length === 0) ? { reason: "typed proof reference required" } : {}),
+			...(entry.legacy || entry.proof.length === 0 ? { reason: "typed proof reference required" } : {}),
 		}));
 	}
 
@@ -717,21 +793,31 @@ export class Tasks {
 		if (failed) {
 			return this.events.atomic(() => {
 				const artifact = this.artifacts.setStatus(id, "rejected")!;
-				this.appendEvent({
-					taskId: id,
-					type: "review_rejected",
-					fromStatus: "review",
-					toStatus: "rejected",
-					attemptId,
-					evidence: { gates, checklist, result: "rejected" },
-				}, context);
+				this.appendEvent(
+					{
+						taskId: id,
+						type: "review_rejected",
+						fromStatus: "review",
+						toStatus: "rejected",
+						attemptId,
+						evidence: { gates, checklist, result: "rejected" },
+					},
+					context,
+				);
 				return { artifact, gates, checklist, completed: false, focused: this.active({ sessionId: context.sessionId }), blocked: [] };
 			});
 		}
 		return this.events.atomic(() => this.finish(id, attemptId, gates, checklist, context, options));
 	}
 
-	private finish(id: string, attemptId: string, gates: GateResult[], checklist: ChecklistReview[], context: TaskEventContext, options: TaskCompletionOptions): TaskCompletion {
+	private finish(
+		id: string,
+		attemptId: string,
+		gates: GateResult[],
+		checklist: ChecklistReview[],
+		context: TaskEventContext,
+		options: TaskCompletionOptions,
+	): TaskCompletion {
 		const successorIds = this.relationships(id)
 			.filter((edge) => edge.relation === "depends_on" && edge.to === id)
 			.map((edge) => edge.from);
@@ -739,22 +825,24 @@ export class Tasks {
 			throw new Error(`task "${id}" exceeds ${TASK_EXECUTION_MAX_DEGREE} successors`);
 		}
 		const artifact = this.artifacts.setStatus(id, "done")!;
-		this.appendEvent({
-			taskId: id,
-			type: "completed",
-			fromStatus: "review",
-			toStatus: "done",
-			attemptId,
-			evidence: { gates, checklist, result: "completed" },
-		}, context);
+		this.appendEvent(
+			{
+				taskId: id,
+				type: "completed",
+				fromStatus: "review",
+				toStatus: "done",
+				attemptId,
+				evidence: { gates, checklist, result: "completed" },
+			},
+			context,
+		);
 		this.focusStore.clearEverywhere(id);
 		const blocked: TaskBlockage[] = [];
 		let focused: Artifact | null = null;
 		for (const successorId of [...successorIds].sort()) {
 			const successor = this.require(successorId);
 			if (successor.status === "done" || successor.status === "canceled") continue;
-			const dependencyIds = this.dependencyIds(successorId)
-				.filter((dependencyId) => this.require(dependencyId).status !== "done");
+			const dependencyIds = this.dependencyIds(successorId).filter((dependencyId) => this.require(dependencyId).status !== "done");
 			if (dependencyIds.length > 0) {
 				blocked.push({ artifact: successor, dependencyIds });
 				continue;
@@ -794,19 +882,26 @@ export class Tasks {
 	 * unrecognized shape.
 	 */
 	private blockingDiscussions(id: string): Artifact[] {
-		return this.artifacts.relationships({ artifactIds: [id] })
+		return this.artifacts
+			.relationships({ artifactIds: [id] })
 			.filter((edge) => edge.relation === "blocks" && edge.to === id)
 			.map((edge) => this.artifacts.get(edge.from))
 			.filter((source): source is Artifact => source !== null && isDiscussionArtifact(source))
 			.filter((discussion) => {
-				try { return readDiscussionExtra(discussion.extra).state === "active"; } catch { return false; }
+				try {
+					return readDiscussionExtra(discussion.extra).state === "active";
+				} catch {
+					return false;
+				}
 			});
 	}
 
 	private requireNotBlocked(task: Artifact): void {
 		const blockers = this.blockingDiscussions(task.id);
 		if (blockers.length > 0) {
-			throw new Error(`task "${task.title}" is blocked by ${blockers.length} active Discussion(s): ${blockers.map((discussion) => `"${discussion.title}"`).join(", ")}`);
+			throw new Error(
+				`task "${task.title}" is blocked by ${blockers.length} active Discussion(s): ${blockers.map((discussion) => `"${discussion.title}"`).join(", ")}`,
+			);
 		}
 	}
 }

package/src/vehicle/artifact-trash-vehicle.ts

@@ -3,7 +3,7 @@
  * artifact's kind. Registered once here, shared by every domain, instead of
  * duplicated as rules.remove/docs.remove/etc.
  */
-import { defineVehicleOperation, bindVehicleOperation } from "@danypops/vehicle-core";
+import { bindVehicleOperation, defineVehicleOperation } from "@danypops/vehicle-core";
 import type { VehicleRegistry } from "@danypops/vehicle-server";
 import { removeArtifactSubtree } from "../artifact-subtree.ts";
 import type { ArtifactStore } from "../ports/artifact-store.ts";
@@ -14,9 +14,9 @@ const OWNER = "artifact";
 const LIMITS = { defaultTimeoutMs: 5_000, maxTimeoutMs: 30_000, maxRequestBytes: 65_536, maxResponseBytes: 262_144 };
 
 function eventContext(input: Record<string, unknown>): { actor?: string; source?: string; sessionId?: string } {
-	const actor = input["actor"];
-	const source = input["source"];
-	const sessionId = input["session_id"] ?? input["sessionId"];
+	const actor = input.actor;
+	const source = input.source;
+	const sessionId = input.session_id ?? input.sessionId;
 	return {
 		actor: typeof actor === "string" ? actor : undefined,
 		source: typeof source === "string" ? source : undefined,
@@ -25,7 +25,7 @@ function eventContext(input: Record<string, unknown>): { actor?: string; source?
 }
 
 function requireId(input: Record<string, unknown>): string {
-	const id = input["id"];
+	const id = input.id;
 	if (typeof id !== "string" || id.length === 0) throw new Error("id is required");
 	return id;
 }
@@ -50,7 +50,10 @@ export function registerArtifactTrashOperations(registry: VehicleRegistry, artif
 			idempotency: { mode: effect === "read" ? "safe" : "unsafe" },
 			limits: LIMITS,
 		});
-		registry.register(OWNER, bindVehicleOperation(operation, () => async (context) => execute(context.input)));
+		registry.register(
+			OWNER,
+			bindVehicleOperation(operation, () => async (context) => execute(context.input)),
+		);
 	};
 
 	define(
@@ -59,11 +62,12 @@ export function registerArtifactTrashOperations(registry: VehicleRegistry, artif
 		"read",
 		{ id: stringProp, tree: { type: "boolean" } as unknown as { type: string }, depth: numberProp, max_nodes: numberProp },
 		["id"],
-		(input) => artifacts.get(requireId(input), {
-			tree: input["tree"] === true,
-			depth: typeof input["depth"] === "number" ? input["depth"] : undefined,
-			maxNodes: typeof input["max_nodes"] === "number" ? input["max_nodes"] : undefined,
-		}),
+		(input) =>
+			artifacts.get(requireId(input), {
+				tree: input.tree === true,
+				depth: typeof input.depth === "number" ? input.depth : undefined,
+				maxNodes: typeof input.max_nodes === "number" ? input.max_nodes : undefined,
+			}),
 	);
 
 	define(
@@ -72,7 +76,11 @@ export function registerArtifactTrashOperations(registry: VehicleRegistry, artif
 		"local-write",
 		{ id: stringProp, reason: stringProp, actor: stringProp, source: stringProp, session_id: stringProp },
 		["id"],
-		(input) => artifacts.trash(requireId(input), { reason: typeof input["reason"] === "string" ? input["reason"] : undefined, context: eventContext(input) }),
+		(input) =>
+			artifacts.trash(requireId(input), {
+				reason: typeof input.reason === "string" ? input.reason : undefined,
+				context: eventContext(input),
+			}),
 	);
 
 	define(
@@ -81,7 +89,11 @@ export function registerArtifactTrashOperations(registry: VehicleRegistry, artif
 		"local-write",
 		{ id: stringProp, reason: stringProp, actor: stringProp, source: stringProp, session_id: stringProp },
 		["id"],
-		(input) => removeArtifactSubtree(artifacts, requireId(input), { reason: typeof input["reason"] === "string" ? input["reason"] : undefined, context: eventContext(input) }),
+		(input) =>
+			removeArtifactSubtree(artifacts, requireId(input), {
+				reason: typeof input.reason === "string" ? input.reason : undefined,
+				context: eventContext(input),
+			}),
 	);
 
 	define(

package/src/vehicle/artifact-vehicle-shared.ts

@@ -3,7 +3,7 @@
  * VehicleRegistry projection (notes-vehicle.ts, rules-vehicle.ts, docs-vehicle.ts,
  * artifact-trash-vehicle.ts).
  */
-import { defineVehicleSchema, type VehicleSchemaCodec, type VehicleContentBlock } from "@danypops/vehicle-core";
+import { defineVehicleSchema, type VehicleContentBlock, type VehicleSchemaCodec } from "@danypops/vehicle-core";
 import type { Artifact } from "../domain/artifact.ts";
 import type { ArtifactStore } from "../ports/artifact-store.ts";
 import type { TaskExecutionPlan } from "../task-execution.ts";
@@ -14,7 +14,10 @@ import type { TaskExecutionPlan } from "../task-execution.ts";
  * enforced at runtime -- so a declared `enum` has to be checked here for
  * real, or it's a documentation gesture, not an honest contract.
  */
-export function looseObjectSchema(properties: Record<string, { type: string; enum?: readonly string[] }>, required: readonly string[] = []): VehicleSchemaCodec<Record<string, unknown>> {
+export function looseObjectSchema(
+	properties: Record<string, { type: string; enum?: readonly string[] }>,
+	required: readonly string[] = [],
+): VehicleSchemaCodec<Record<string, unknown>> {
 	return defineVehicleSchema<Record<string, unknown>>({
 		jsonSchema: { type: "object", properties, required: [...required], additionalProperties: false },
 		safeParse(value) {
@@ -61,7 +64,9 @@ export function matchArtifactByName(candidates: readonly Artifact[], name: strin
 	const matches = candidates.filter((artifact) => artifact.title.trim().toLowerCase() === needle);
 	if (matches.length === 0) throw new Error(`no artifact named "${name}" found in this scope`);
 	if (matches.length > 1) {
-		throw new Error(`${matches.length} artifacts are named "${name}": ${matches.map((a) => `${a.title} (${a.id})`).join(", ")} -- use id to disambiguate`);
+		throw new Error(
+			`${matches.length} artifacts are named "${name}": ${matches.map((a) => `${a.title} (${a.id})`).join(", ")} -- use id to disambiguate`,
+		);
 	}
 	return matches[0]!.id;
 }
@@ -72,7 +77,11 @@ export function matchArtifactByName(candidates: readonly Artifact[], name: strin
  * flow only -- the caller supplies its own scoped/widened list calls, since scoping
  * differs per domain. Omit `fetchWidened` when there is no wider scope to retry.
  */
-export function resolveArtifactIdWidened(name: string, fetchCandidates: () => readonly Artifact[], fetchWidened?: () => readonly Artifact[]): string {
+export function resolveArtifactIdWidened(
+	name: string,
+	fetchCandidates: () => readonly Artifact[],
+	fetchWidened?: () => readonly Artifact[],
+): string {
 	try {
 		return matchArtifactByName(fetchCandidates(), name);
 	} catch (error) {
@@ -87,7 +96,12 @@ export function labelsById(artifacts: ArtifactStore, ids: readonly string[]): Ma
 	const resolved = uniqueIds.map((id) => artifacts.get(id)).filter((artifact): artifact is Artifact => artifact !== null);
 	const titleCounts = new Map<string, number>();
 	for (const artifact of resolved) titleCounts.set(artifact.title, (titleCounts.get(artifact.title) ?? 0) + 1);
-	return new Map(resolved.map((artifact) => [artifact.id, (titleCounts.get(artifact.title) ?? 0) > 1 ? `${artifact.title} (${artifact.id})` : artifact.title]));
+	return new Map(
+		resolved.map((artifact) => [
+			artifact.id,
+			(titleCounts.get(artifact.title) ?? 0) > 1 ? `${artifact.title} (${artifact.id})` : artifact.title,
+		]),
+	);
 }
 
 export interface WorkflowRunNarrativeInput {
@@ -103,14 +117,21 @@ export interface WorkflowRunNarrativeInput {
  * execution DAG -- the same shape pi-papyrus's own hand-rolled playbooks tool built
  * client-side, now built once here where the run result is actually produced.
  */
-export function buildWorkflowRunContent(artifacts: ArtifactStore, headline: string, input: WorkflowRunNarrativeInput, extraLines: readonly string[] = []): VehicleContentBlock {
+export function buildWorkflowRunContent(
+	artifacts: ArtifactStore,
+	headline: string,
+	input: WorkflowRunNarrativeInput,
+	extraLines: readonly string[] = [],
+): VehicleContentBlock {
 	const nodeById = new Map(input.execution.nodes.map((node) => [node.id, node]));
 	const rootLabels = input.rootTaskIds.map((id) => nodeById.get(id)?.title ?? "unknown task");
 	const createdLabels = labelsById(artifacts, [...input.created.docs, ...input.created.rules]);
 	const titleCounts = new Map<string, number>();
 	for (const node of input.execution.nodes) titleCounts.set(node.title, (titleCounts.get(node.title) ?? 0) + 1);
 	const executionLines = input.execution.nodes
-		.map((node) => ((titleCounts.get(node.title) ?? 0) > 1 ? `  [${node.state}] ${node.title} (${node.id})` : `  [${node.state}] ${node.title}`))
+		.map((node) =>
+			(titleCounts.get(node.title) ?? 0) > 1 ? `  [${node.state}] ${node.title} (${node.id})` : `  [${node.state}] ${node.title}`,
+		)
 		.join("\n");
 	const text = [
 		headline,