@danypops/papyrus 0.41.0 → 0.42.1

package/src/graph-projection-service.ts

@@ -3,12 +3,17 @@
  * contexts. See src/domain/graph-projection.ts for the batch/checkpoint shapes and the
  * documented, deliberate scope limits of this first walking-skeleton slice.
  */
-import { GRAPH_PROJECTION_ID_MAX_LENGTH, GRAPH_PROJECTION_MAX_ARTIFACTS_PER_BATCH, GRAPH_PROJECTION_MAX_EDGES_PER_BATCH } from "./constants.ts";
+
+import type { AuthorityRegistry } from "./authority-registry.ts";
+import {
+	GRAPH_PROJECTION_ID_MAX_LENGTH,
+	GRAPH_PROJECTION_MAX_ARTIFACTS_PER_BATCH,
+	GRAPH_PROJECTION_MAX_EDGES_PER_BATCH,
+} from "./constants.ts";
 import { GRAPH_PROJECTION_SCHEMA_VERSION, type GraphProjectionBatch, type GraphProjectionResult } from "./domain/graph-projection.ts";
 import type { ArtifactStore } from "./ports/artifact-store.ts";
 import { requireAtomicArtifactStore } from "./ports/atomic-artifact-store.ts";
 import type { GraphProjectionStore } from "./ports/graph-projection-store.ts";
-import type { AuthorityRegistry } from "./authority-registry.ts";
 
 function boundedId(value: string, label: string): string {
 	if (!value || value.length === 0) throw new Error(`${label} is required`);
@@ -29,7 +34,9 @@ export class GraphProjection {
 
 	apply(batch: GraphProjectionBatch): GraphProjectionResult {
 		if (batch.schemaVersion !== GRAPH_PROJECTION_SCHEMA_VERSION) {
-			throw new Error(`unsupported graph projection schema version "${batch.schemaVersion}", expected "${GRAPH_PROJECTION_SCHEMA_VERSION}"`);
+			throw new Error(
+				`unsupported graph projection schema version "${batch.schemaVersion}", expected "${GRAPH_PROJECTION_SCHEMA_VERSION}"`,
+			);
 		}
 		const producerId = boundedId(batch.producerId, "producer_id");
 		const batchId = boundedId(batch.batchId, "batch_id");
@@ -41,20 +48,35 @@ export class GraphProjection {
 			throw new Error(`batch is bounded to ${GRAPH_PROJECTION_MAX_EDGES_PER_BATCH} edges; got ${batch.edges.length}`);
 		}
 		for (const artifact of batch.artifacts) boundedId(artifact.externalId, "artifact externalId");
-		for (const edge of batch.edges) { boundedId(edge.from, "edge from"); boundedId(edge.to, "edge to"); }
+		for (const edge of batch.edges) {
+			boundedId(edge.from, "edge from");
+			boundedId(edge.to, "edge to");
+		}
 
 		const existingCheckpoint = this.store.getCheckpoint(producerId);
 		if (existingCheckpoint?.lastBatchId === batchId && existingCheckpoint.lastSequence === batch.sequence) {
-			return { producerId, batchId, sequence: batch.sequence, artifactsUpserted: 0, artifactsCreated: 0, edgesUpserted: 0, alreadyApplied: true };
+			return {
+				producerId,
+				batchId,
+				sequence: batch.sequence,
+				artifactsUpserted: 0,
+				artifactsCreated: 0,
+				edgesUpserted: 0,
+				alreadyApplied: true,
+			};
 		}
 		if (existingCheckpoint === null) {
 			if (batch.sequence !== 1) throw new Error(`first batch for producer "${producerId}" must have sequence 1, got ${batch.sequence}`);
 		} else {
 			if (batch.sequence <= existingCheckpoint.lastSequence) {
-				throw new Error(`stale batch: sequence ${batch.sequence} is not after checkpoint sequence ${existingCheckpoint.lastSequence} for producer "${producerId}"`);
+				throw new Error(
+					`stale batch: sequence ${batch.sequence} is not after checkpoint sequence ${existingCheckpoint.lastSequence} for producer "${producerId}"`,
+				);
 			}
 			if (batch.sequence > existingCheckpoint.lastSequence + 1) {
-				throw new Error(`sequence gap for producer "${producerId}": expected ${existingCheckpoint.lastSequence + 1}, got ${batch.sequence}`);
+				throw new Error(
+					`sequence gap for producer "${producerId}": expected ${existingCheckpoint.lastSequence + 1}, got ${batch.sequence}`,
+				);
 			}
 		}
 
@@ -71,7 +93,11 @@ export class GraphProjection {
 			for (const projected of batch.artifacts) {
 				const existingId = this.store.resolveIdentity(producerId, projected.externalId);
 				if (existingId) {
-					this.artifacts.updateContent(existingId, { title: projected.title, body: projected.body, labels: projected.labels ? [...projected.labels] : undefined });
+					this.artifacts.updateContent(existingId, {
+						title: projected.title,
+						body: projected.body,
+						labels: projected.labels ? [...projected.labels] : undefined,
+					});
 					if (projected.extra !== undefined) this.artifacts.setExtra(existingId, projected.extra);
 				} else {
 					const created = this.artifacts.create({

package/src/id-migration.ts

@@ -71,7 +71,12 @@ const TEXT_SCAN_COLUMNS: ReadonlyArray<{ table: string; column: string }> = [
 ];
 
 /** Audit tables whose append-only guard must be suspended for exactly this migration's duration. */
-const APPEND_ONLY_GUARD_TRIGGERS = ["task_events_no_update", "task_events_no_delete", "artifact_events_no_update", "artifact_events_no_delete"];
+const APPEND_ONLY_GUARD_TRIGGERS = [
+	"task_events_no_update",
+	"task_events_no_delete",
+	"artifact_events_no_update",
+	"artifact_events_no_delete",
+];
 
 function tableExists(db: Db, table: string): boolean {
 	return db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?").get(table) != null;
@@ -102,8 +107,13 @@ export function applyIdMigration(db: Db, plan: IdMigrationPlan): IdMigrationRepo
 		return inTransaction(db, () => {
 			const triggerDdl = new Map<string, string>();
 			for (const name of APPEND_ONLY_GUARD_TRIGGERS) {
-				const row = db.prepare("SELECT sql FROM sqlite_master WHERE type = 'trigger' AND name = ?").get(name) as { sql: string } | undefined;
-				if (row) { triggerDdl.set(name, row.sql); db.exec(`DROP TRIGGER ${name}`); }
+				const row = db.prepare("SELECT sql FROM sqlite_master WHERE type = 'trigger' AND name = ?").get(name) as
+					| { sql: string }
+					| undefined;
+				if (row) {
+					triggerDdl.set(name, row.sql);
+					db.exec(`DROP TRIGGER ${name}`);
+				}
 			}
 			try {
 				let edgesRemapped = 0;
@@ -123,7 +133,10 @@ export function applyIdMigration(db: Db, plan: IdMigrationPlan): IdMigrationRepo
 				let textOccurrencesRemapped = 0;
 				for (const { table, column } of TEXT_SCAN_COLUMNS) {
 					if (!tableExists(db, table)) continue;
-					const rows = db.prepare(`SELECT rowid AS rowid, ${column} AS value FROM ${table} WHERE ${column} IS NOT NULL`).all() as Array<{ rowid: number; value: string }>;
+					const rows = db.prepare(`SELECT rowid AS rowid, ${column} AS value FROM ${table} WHERE ${column} IS NOT NULL`).all() as Array<{
+						rowid: number;
+						value: string;
+					}>;
 					const updateStmt = db.prepare(`UPDATE ${table} SET ${column} = ? WHERE rowid = ?`);
 					for (const row of rows) {
 						let value = row.value;

package/src/index.ts

@@ -4,30 +4,35 @@
  * than a blanket `export *` on service-heavy modules -- matches ports-and-adapters practice of a
  * purposeful API, not "everything happens to be reachable."
  */
-export * from "./constants.ts";
 
+export { projectArtifactRelationships } from "./artifact-relationship-view.ts";
+export {
+	connectPapyrusClient,
+	type PapyrusClient,
+	type PushChannelTarget,
+	resolvePushChannelTarget,
+	resolveVehicleClientTarget,
+	type VehicleClientTarget,
+} from "./client.ts";
+export * from "./constants.ts";
+export type { DiscussionAndRounds } from "./discussion-service.ts";
 export type { Artifact, ArtifactEdge } from "./domain/artifact.ts";
-export { PROOF_TYPES, checklistEntries, type ProofReference } from "./domain/checklist.ts";
-export { DISCUSSION_SUBTYPE, readDiscussionExtra, type DiscussionRound } from "./domain/discussion.ts";
+export { checklistEntries, PROOF_TYPES, type ProofReference } from "./domain/checklist.ts";
+export { DISCUSSION_SUBTYPE, type DiscussionRound, readDiscussionExtra } from "./domain/discussion.ts";
 export type { DisplayGraph, DisplayGraphEdge, DisplayGraphNode, RenderedGraph } from "./domain/display-graph.ts";
 export type { GateResult } from "./domain/gate.ts";
 export type { NoteHistoryPage } from "./domain/note-event.ts";
 export type { TaskEvent, TaskHistoryPage } from "./domain/task-event.ts";
 export type { TaskLease } from "./domain/task-lease.ts";
 export type { TaskViewSelection } from "./domain/task-scope.ts";
-
+export { NOTE_DISPOSITIONS } from "./note-service.ts";
+export type { PlaybookInvocationResult, PlaybookMissingArguments } from "./playbook-execution.ts";
 export type { ArtifactStore } from "./ports/artifact-store.ts";
 export type { GraphRenderer } from "./ports/graph-renderer.ts";
-
-export { connectPapyrusClient, resolvePushChannelTarget, resolveVehicleClientTarget, type PapyrusClient, type PushChannelTarget, type VehicleClientTarget } from "./client.ts";
-export type { DiscussionAndRounds } from "./discussion-service.ts";
-export { NOTE_DISPOSITIONS } from "./note-service.ts";
 export type { OperationName, SchemaState } from "./service.ts";
-export type { WorkflowRunResult } from "./workflow-execution.ts";
-export type { PlaybookInvocationResult, PlaybookMissingArguments } from "./playbook-execution.ts";
-export { projectArtifactRelationships } from "./artifact-relationship-view.ts";
 export { taskContext } from "./task-context.ts";
 export { projectTaskExecution, type TaskExecutionPlan, type TaskExecutionState } from "./task-execution.ts";
 export { projectTaskGraph, type TaskGraphView } from "./task-graph-view.ts";
 export { fallbackLabel, projectTaskRelationships } from "./task-relationship-view.ts";
 export type { TaskCompletion, TaskGraph, TaskNode, TaskStatus } from "./task-service.ts";
+export type { WorkflowRunResult } from "./workflow-execution.ts";

package/src/log-service.ts

@@ -1,14 +1,14 @@
 import { randomUUID } from "node:crypto";
 import {
+	type AppendLogEntryCommand,
+	type AppendLogEntryResult,
 	boundMessage,
 	LOG_QUERY_MAX_ENTRIES,
 	LOG_RETENTION_MAX_ENTRIES_PER_SOURCE,
-	meetsLevel,
-	validateAppendLogEntryCommand,
-	type AppendLogEntryCommand,
-	type AppendLogEntryResult,
 	type LogEntryPage,
 	type LogQuery,
+	meetsLevel,
+	validateAppendLogEntryCommand,
 } from "./domain/log-entry.ts";
 import type { LogStore } from "./ports/log-store.ts";
 
@@ -47,7 +47,8 @@ export class Logs {
 	 */
 	query(query: LogQuery): LogEntryPage {
 		const limit = Math.min(query.limit ?? LOG_QUERY_MAX_ENTRIES, LOG_QUERY_MAX_ENTRIES);
-		const matching = this.store.entriesForSource(query.sourceId)
+		const matching = this.store
+			.entriesForSource(query.sourceId)
 			.filter((entry) => query.since === undefined || entry.occurredAt > query.since)
 			.filter((entry) => query.level === undefined || meetsLevel(entry.level, query.level));
 

package/src/log.ts

@@ -1,6 +1,25 @@
+import type { Logger } from "@danypops/vehicle-server/logging";
+
 export type LogLevel = "info" | "warn" | "error";
 
 /** Credential-safe structured daemon event. Callers must pass bounded, non-sensitive fields. */
 export function logEvent(level: LogLevel, event: string, fields: Record<string, unknown> = {}): void {
 	console.error(JSON.stringify({ timestamp: new Date().toISOString(), level, component: "papyrus-daemon", event, ...fields }));
 }
+
+/**
+ * Adapts logEvent to @danypops/vehicle-server's Logger interface (debug/
+ * info/warn/error), so createVehicleHttpApp's own failure logging lands
+ * through this daemon's one existing structured-log sink instead of
+ * introducing a second logging system. debug is a no-op -- this daemon's
+ * own logEvent never had a debug level, and none of its existing output
+ * needs one.
+ */
+export function vehicleLogger(): Logger {
+	return {
+		debug() {},
+		info: (msg, fields) => logEvent("info", msg, fields),
+		warn: (msg, fields) => logEvent("warn", msg, fields),
+		error: (msg, fields) => logEvent("error", msg, fields),
+	};
+}

package/src/modules/discuss.ts

@@ -2,8 +2,9 @@
  * modules/discuss.ts — Discuss as a Papyrus-native registered module. See
  * domain/discussion.ts and discussion-service.ts for the full design.
  */
-import type { ArtifactEventContext } from "../domain/artifact-event.ts";
+
 import type { Discussions } from "../discussion-service.ts";
+import type { ArtifactEventContext } from "../domain/artifact-event.ts";
 import type { OperationDefinition } from "../module-registry.ts";
 
 const MODULE_ID = "discuss";
@@ -12,7 +13,8 @@ type OperationInput = Record<string, unknown>;
 
 function string(input: OperationInput, key: string): string {
 	const value = input[key];
-	if (typeof value !== "string" || value.length === 0) throw new Error(`${key} is required${REQUIRED_FIELD_HINTS[key] ? ` (${REQUIRED_FIELD_HINTS[key]})` : ""}`);
+	if (typeof value !== "string" || value.length === 0)
+		throw new Error(`${key} is required${REQUIRED_FIELD_HINTS[key] ? ` (${REQUIRED_FIELD_HINTS[key]})` : ""}`);
 	return value;
 }
 
@@ -63,38 +65,63 @@ function optionsMode(input: OperationInput): "single" | "multi" | undefined {
 
 /** This module's own operation names, the single source of truth src/service.ts's EXPECTED_OPERATION_NAMES spreads in rather than re-listing by hand. */
 export const DISCUSS_OPERATION_NAMES = [
-	"discuss.open", "discuss.reply", "discuss.defer", "discuss.resume", "discuss.settle",
-	"discuss.block", "discuss.unblock", "discuss.show", "discuss.rounds", "discuss.list",
+	"discuss.open",
+	"discuss.reply",
+	"discuss.defer",
+	"discuss.resume",
+	"discuss.settle",
+	"discuss.block",
+	"discuss.unblock",
+	"discuss.show",
+	"discuss.rounds",
+	"discuss.list",
 ] as const;
 
 /** Registers every discuss.* operation against one Discussions instance. */
 export function discussOperations(discussions: Discussions): OperationDefinition[] {
 	const define = <Input, Output>(name: string, execute: (input: Input) => Output): OperationDefinition<Input, Output> => ({
-		name, moduleId: MODULE_ID, execute,
+		name,
+		moduleId: MODULE_ID,
+		execute,
 	});
 	return [
-		define("discuss.open", (input: OperationInput) => discussions.open({
-			title: string(input, "title"),
-			actor: string(input, "actor"),
-			content: string(input, "content"),
-			body: optionalString(input, "body"),
-			labels: optionalStringArray(input, "labels"),
-			blocksTaskIds: optionalStringArray(input, "blocks_task_ids") ?? optionalStringArray(input, "blocksTaskIds"),
-			options: optionalStringArray(input, "options"),
-			optionsMode: optionsMode(input),
-			optionDescriptions: optionalStringArray(input, "option_descriptions") ?? optionalStringArray(input, "optionDescriptions"),
-		}, eventContext(input))),
-		define("discuss.reply", (input: OperationInput) => discussions.reply(string(input, "id"), {
-			actor: string(input, "actor"),
-			content: string(input, "content"),
-			selected: optionalStringArray(input, "selected"),
-			options: optionalStringArray(input, "options"),
-			optionsMode: optionsMode(input),
-			optionDescriptions: optionalStringArray(input, "option_descriptions") ?? optionalStringArray(input, "optionDescriptions"),
-		}, eventContext(input))),
-		define("discuss.defer", (input: OperationInput) => discussions.defer(string(input, "id"), optionalString(input, "reason"), eventContext(input))),
+		define("discuss.open", (input: OperationInput) =>
+			discussions.open(
+				{
+					title: string(input, "title"),
+					actor: string(input, "actor"),
+					content: string(input, "content"),
+					body: optionalString(input, "body"),
+					labels: optionalStringArray(input, "labels"),
+					blocksTaskIds: optionalStringArray(input, "blocks_task_ids") ?? optionalStringArray(input, "blocksTaskIds"),
+					options: optionalStringArray(input, "options"),
+					optionsMode: optionsMode(input),
+					optionDescriptions: optionalStringArray(input, "option_descriptions") ?? optionalStringArray(input, "optionDescriptions"),
+				},
+				eventContext(input),
+			),
+		),
+		define("discuss.reply", (input: OperationInput) =>
+			discussions.reply(
+				string(input, "id"),
+				{
+					actor: string(input, "actor"),
+					content: string(input, "content"),
+					selected: optionalStringArray(input, "selected"),
+					options: optionalStringArray(input, "options"),
+					optionsMode: optionsMode(input),
+					optionDescriptions: optionalStringArray(input, "option_descriptions") ?? optionalStringArray(input, "optionDescriptions"),
+				},
+				eventContext(input),
+			),
+		),
+		define("discuss.defer", (input: OperationInput) =>
+			discussions.defer(string(input, "id"), optionalString(input, "reason"), eventContext(input)),
+		),
 		define("discuss.resume", (input: OperationInput) => discussions.resume(string(input, "id"), eventContext(input))),
-		define("discuss.settle", (input: OperationInput) => discussions.settle(string(input, "id"), string(input, "settlement"), eventContext(input))),
+		define("discuss.settle", (input: OperationInput) =>
+			discussions.settle(string(input, "id"), string(input, "settlement"), eventContext(input)),
+		),
 		define("discuss.block", (input: OperationInput) => {
 			discussions.block(string(input, "id"), taskId(input), eventContext(input));
 			return { blocked: true };
@@ -103,7 +130,15 @@ export function discussOperations(discussions: Discussions): OperationDefinition
 			unblocked: discussions.unblock(string(input, "id"), taskId(input), eventContext(input)),
 		})),
 		define("discuss.show", (input: OperationInput) => discussions.show(string(input, "id"))),
-		define("discuss.rounds", (input: OperationInput) => discussions.listRounds(string(input, "id"), optionalNumber(input, "after_round") ?? optionalNumber(input, "afterRound"), optionalNumber(input, "limit"))),
-		define("discuss.list", (input: OperationInput) => discussions.list({ state: optionalString(input, "state"), limit: optionalNumber(input, "limit") })),
+		define("discuss.rounds", (input: OperationInput) =>
+			discussions.listRounds(
+				string(input, "id"),
+				optionalNumber(input, "after_round") ?? optionalNumber(input, "afterRound"),
+				optionalNumber(input, "limit"),
+			),
+		),
+		define("discuss.list", (input: OperationInput) =>
+			discussions.list({ state: optionalString(input, "state"), limit: optionalNumber(input, "limit") }),
+		),
 	];
 }

package/src/modules/docs.ts

@@ -7,7 +7,16 @@
  * ArtifactStore-based with no other module's concrete class dependency.
  */
 import type { AuthorityRegistry } from "../authority-registry.ts";
-import { assignDocumentProject, createDocument, linkDocument, listDocuments, showDocument, transitionDocument, updateDocument, type DocumentRelation } from "../domain-services.ts";
+import {
+	assignDocumentProject,
+	createDocument,
+	type DocumentRelation,
+	linkDocument,
+	listDocuments,
+	showDocument,
+	transitionDocument,
+	updateDocument,
+} from "../domain-services.ts";
 import type { OperationDefinition } from "../module-registry.ts";
 import type { ArtifactScopeStore } from "../ports/artifact-scope-store.ts";
 import type { ArtifactStore } from "../ports/artifact-store.ts";
@@ -52,29 +61,77 @@ const artifactFilter = (input: OperationInput) => ({
 /** Registers every docs.* operation against the shared ArtifactStore port. Behavior is unchanged from the prior inline handlers in src/service.ts. */
 /** This module's own operation names, the single source of truth src/service.ts's EXPECTED_OPERATION_NAMES spreads in rather than re-listing by hand. */
 export const DOCS_OPERATION_NAMES = [
-	"docs.create", "docs.list", "docs.show", "docs.activate", "docs.archive", "docs.reopen", "docs.link", "docs.assign_project", "docs.update",
+	"docs.create",
+	"docs.list",
+	"docs.show",
+	"docs.activate",
+	"docs.archive",
+	"docs.reopen",
+	"docs.link",
+	"docs.assign_project",
+	"docs.update",
 ] as const;
 
 export function docsOperations(artifacts: ArtifactStore, scopes: ArtifactScopeStore, authority: AuthorityRegistry): OperationDefinition[] {
 	const define = <Input, Output>(name: string, execute: (input: Input) => Output): OperationDefinition<Input, Output> => ({
-		name, moduleId: MODULE_ID, execute,
+		name,
+		moduleId: MODULE_ID,
+		execute,
 	});
 	return [
-		define("docs.create", (input: OperationInput) => createDocument(artifacts, scopes, {
-			title: string(input, "title"), body: optionalString(input, "body"), subtype: optionalString(input, "subtype"),
-			labels: input["labels"] as string[] | undefined, extra: input["extra"] as Record<string, unknown> | undefined,
-			templateId: optionalString(input, "template_id") ?? optionalString(input, "templateId"),
-			projectRoot: optionalString(input, "project_root"),
-		}, authority, eventContext(input))),
+		define("docs.create", (input: OperationInput) =>
+			createDocument(
+				artifacts,
+				scopes,
+				{
+					title: string(input, "title"),
+					body: optionalString(input, "body"),
+					subtype: optionalString(input, "subtype"),
+					labels: input.labels as string[] | undefined,
+					extra: input.extra as Record<string, unknown> | undefined,
+					templateId: optionalString(input, "template_id") ?? optionalString(input, "templateId"),
+					projectRoot: optionalString(input, "project_root"),
+				},
+				authority,
+				eventContext(input),
+			),
+		),
 		define("docs.list", (input: OperationInput) => listDocuments(artifacts, scopes, artifactFilter(input))),
 		define("docs.show", (input: OperationInput) => showDocument(artifacts, string(input, "id"))),
-		define("docs.activate", (input: OperationInput) => transitionDocument(artifacts, string(input, "id"), "activate", authority, eventContext(input))),
-		define("docs.archive", (input: OperationInput) => transitionDocument(artifacts, string(input, "id"), "archive", authority, eventContext(input))),
-		define("docs.reopen", (input: OperationInput) => transitionDocument(artifacts, string(input, "id"), "reopen", authority, eventContext(input))),
-		define("docs.link", (input: OperationInput) => linkDocument(artifacts, string(input, "id"), string(input, "relation") as DocumentRelation, string(input, "target_id"), authority, eventContext(input))),
-		define("docs.assign_project", (input: OperationInput) => assignDocumentProject(artifacts, scopes, string(input, "id"), optionalString(input, "project_root"))),
-		define("docs.update", (input: OperationInput) => updateDocument(artifacts, string(input, "id"), {
-			title: optionalString(input, "title"), body: optionalString(input, "body"), labels: input["labels"] as string[] | undefined,
-		}, authority, eventContext(input))),
+		define("docs.activate", (input: OperationInput) =>
+			transitionDocument(artifacts, string(input, "id"), "activate", authority, eventContext(input)),
+		),
+		define("docs.archive", (input: OperationInput) =>
+			transitionDocument(artifacts, string(input, "id"), "archive", authority, eventContext(input)),
+		),
+		define("docs.reopen", (input: OperationInput) =>
+			transitionDocument(artifacts, string(input, "id"), "reopen", authority, eventContext(input)),
+		),
+		define("docs.link", (input: OperationInput) =>
+			linkDocument(
+				artifacts,
+				string(input, "id"),
+				string(input, "relation") as DocumentRelation,
+				string(input, "target_id"),
+				authority,
+				eventContext(input),
+			),
+		),
+		define("docs.assign_project", (input: OperationInput) =>
+			assignDocumentProject(artifacts, scopes, string(input, "id"), optionalString(input, "project_root")),
+		),
+		define("docs.update", (input: OperationInput) =>
+			updateDocument(
+				artifacts,
+				string(input, "id"),
+				{
+					title: optionalString(input, "title"),
+					body: optionalString(input, "body"),
+					labels: input.labels as string[] | undefined,
+				},
+				authority,
+				eventContext(input),
+			),
+		),
 	];
 }

package/src/modules/graph-projection.ts

@@ -6,7 +6,12 @@
  * itself; this file only parses/validates raw operation input into that typed shape.
  */
 import type { AuthorityRegistry } from "../authority-registry.ts";
-import { GRAPH_PROJECTION_SCHEMA_VERSION, type GraphProjectionBatch, type ProjectedArtifact, type ProjectedEdge } from "../domain/graph-projection.ts";
+import type {
+	GRAPH_PROJECTION_SCHEMA_VERSION,
+	GraphProjectionBatch,
+	ProjectedArtifact,
+	ProjectedEdge,
+} from "../domain/graph-projection.ts";
 import { GraphProjection } from "../graph-projection-service.ts";
 import type { OperationDefinition } from "../module-registry.ts";
 import type { ArtifactStore } from "../ports/artifact-store.ts";
@@ -37,11 +42,11 @@ function parseArtifact(raw: unknown, index: number): ProjectedArtifact {
 	return {
 		externalId: string(raw, "external_id"),
 		kind: string(raw, "kind"),
-		...(typeof raw["subtype"] === "string" ? { subtype: raw["subtype"] } : {}),
+		...(typeof raw.subtype === "string" ? { subtype: raw.subtype } : {}),
 		title: string(raw, "title"),
-		...(typeof raw["body"] === "string" ? { body: raw["body"] } : {}),
-		...(Array.isArray(raw["labels"]) ? { labels: raw["labels"] as string[] } : {}),
-		...(isRecord(raw["extra"]) ? { extra: raw["extra"] } : {}),
+		...(typeof raw.body === "string" ? { body: raw.body } : {}),
+		...(Array.isArray(raw.labels) ? { labels: raw.labels as string[] } : {}),
+		...(isRecord(raw.extra) ? { extra: raw.extra } : {}),
 	};
 }
 
@@ -52,8 +57,8 @@ function parseEdge(raw: unknown, index: number): ProjectedEdge {
 
 function parseBatch(input: OperationInput): GraphProjectionBatch {
 	const schemaVersion = string(input, "schema_version");
-	const rawArtifacts = input["artifacts"];
-	const rawEdges = input["edges"] ?? [];
+	const rawArtifacts = input.artifacts;
+	const rawEdges = input.edges ?? [];
 	if (!Array.isArray(rawArtifacts)) throw new Error("artifacts must be an array");
 	if (!Array.isArray(rawEdges)) throw new Error("edges must be an array");
 	return {
@@ -70,10 +75,16 @@ function parseBatch(input: OperationInput): GraphProjectionBatch {
 /** This module's own operation names, the single source of truth src/service.ts's EXPECTED_OPERATION_NAMES spreads in rather than re-listing by hand. */
 export const GRAPH_PROJECTION_OPERATION_NAMES = ["graph_projection.apply", "graph_projection.checkpoint"] as const;
 
-export function graphProjectionOperations(artifacts: ArtifactStore, store: GraphProjectionStore, authority: AuthorityRegistry): OperationDefinition[] {
+export function graphProjectionOperations(
+	artifacts: ArtifactStore,
+	store: GraphProjectionStore,
+	authority: AuthorityRegistry,
+): OperationDefinition[] {
 	const projection = new GraphProjection(artifacts, store, authority);
 	const define = <Input, Output>(name: string, execute: (input: Input) => Output): OperationDefinition<Input, Output> => ({
-		name, moduleId: MODULE_ID, execute,
+		name,
+		moduleId: MODULE_ID,
+		execute,
 	});
 	return [
 		define("graph_projection.apply", (input: OperationInput) => projection.apply(parseBatch(input))),

package/src/modules/logs.ts

@@ -1,13 +1,13 @@
 /**
  * modules/logs.ts — the `log` domain as a registered Papyrus-native module.
  *
- * Deliberately self-contained: does not import artifact/task/rule/skill infrastructure --
+ * Deliberately self-contained: does not import artifact/task/rule/playbook infrastructure --
  * logs never touch the Artifact graph directly (see src/domain/log-entry.ts's own module
  * comment on why `log` is not an Artifact kind).
  */
 import type { JsonValue, LogLevel } from "../domain/log-entry.ts";
-import type { OperationDefinition } from "../module-registry.ts";
 import type { Logs } from "../log-service.ts";
+import type { OperationDefinition } from "../module-registry.ts";
 
 const MODULE_ID = "logs";
 
@@ -34,8 +34,14 @@ function optionalNumber(input: OperationInput, key: string): number | undefined
 }
 
 function isJsonValue(value: unknown): value is JsonValue {
-	return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean"
-		|| Array.isArray(value) || (typeof value === "object");
+	return (
+		value === null ||
+		typeof value === "string" ||
+		typeof value === "number" ||
+		typeof value === "boolean" ||
+		Array.isArray(value) ||
+		typeof value === "object"
+	);
 }
 
 function optionalFields(input: OperationInput, key: string): JsonValue | undefined {
@@ -51,25 +57,31 @@ export const LOGS_OPERATION_NAMES = ["logs.append", "logs.query"] as const;
 /** Registers every logs.* operation against one Logs instance. */
 export function logsOperations(logs: Logs): OperationDefinition[] {
 	const define = <Input, Output>(name: string, execute: (input: Input) => Output): OperationDefinition<Input, Output> => ({
-		name, moduleId: MODULE_ID, execute,
+		name,
+		moduleId: MODULE_ID,
+		execute,
 	});
 	return [
-		define("logs.append", (input: OperationInput) => logs.append({
-			sourceId: string(input, "source_id"),
-			sourceLabel: optionalString(input, "source_label"),
-			projectRoot: optionalString(input, "project_root") ?? null,
-			level: string(input, "level") as LogLevel,
-			message: string(input, "message"),
-			fields: optionalFields(input, "fields"),
-			operationId: string(input, "operation_id"),
-			sessionId: optionalString(input, "session_id"),
-			occurredAt: optionalString(input, "occurred_at"),
-		})),
-		define("logs.query", (input: OperationInput) => logs.query({
-			sourceId: string(input, "source_id"),
-			since: optionalString(input, "since"),
-			level: optionalString(input, "level") as LogLevel | undefined,
-			limit: optionalNumber(input, "limit"),
-		})),
+		define("logs.append", (input: OperationInput) =>
+			logs.append({
+				sourceId: string(input, "source_id"),
+				sourceLabel: optionalString(input, "source_label"),
+				projectRoot: optionalString(input, "project_root") ?? null,
+				level: string(input, "level") as LogLevel,
+				message: string(input, "message"),
+				fields: optionalFields(input, "fields"),
+				operationId: string(input, "operation_id"),
+				sessionId: optionalString(input, "session_id"),
+				occurredAt: optionalString(input, "occurred_at"),
+			}),
+		),
+		define("logs.query", (input: OperationInput) =>
+			logs.query({
+				sourceId: string(input, "source_id"),
+				since: optionalString(input, "since"),
+				level: optionalString(input, "level") as LogLevel | undefined,
+				limit: optionalNumber(input, "limit"),
+			}),
+		),
 	];
 }