@danypops/papyrus 0.54.2 → 0.54.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/papyrus",
-  "version": "0.54.2",
+  "version": "0.54.3",
   "description": "Daemon-backed graph artifacts, evidence-bearing tasks, rules, skills, and native TUI workflows for Pi",
   "type": "module",
   "main": "./src/index.ts",

package/src/daemon/daemon.ts

@@ -6,7 +6,7 @@ import { diagnoseDaemon, openDaemonLifecycleLog } from "@danypops/vehicle-server
 import { acquireDaemonLock, releaseDaemonLock } from "@danypops/vehicle-server/paths";
 import { PushChannel } from "@danypops/vehicle-server/push-channel";
 import { DAEMON_HOST, DB_OPTIMIZE_INTERVAL_MS, dbPath, WAL_CHECKPOINT_INTERVAL_MS } from "../constants.ts";
-import { logEvent, vehicleLogger } from "../log/log.ts";
+import { logEvent, logger } from "../log/log.ts";
 import { createApp, createPapyrusService } from "../service.ts";
 import {
 	clearDaemonPort,
@@ -78,7 +78,7 @@ export async function serveMain(): Promise<void> {
 				pushChannel.publish("tasks", { operation });
 			}
 		},
-		logger: vehicleLogger(),
+		logger,
 		diagnose: () => diagnoseDaemon({ lifecycleLog, current: { instanceId, pid: process.pid, startedAt, provenance } }),
 	});
 	const server = Bun.serve({

package/src/log/log.ts

@@ -1,25 +1,36 @@
-import type { Logger } from "@danypops/vehicle-server/logging";
+/**
+ * Structured daemon logging, now backed by `@danypops/vehicle-server/logging` (pino) instead of a
+ * hand-rolled `console.error(JSON.stringify(...))` -- gains real level filtering (including a real
+ * debug level this daemon previously had no way to emit at all) and a destination injectable for
+ * tests, matching jittor/src/log.ts's already-migrated shape exactly. One deliberate, disclosed
+ * shape change from the old bespoke format: the event name is now pino's `msg` field rather than a
+ * separate `event` field, matching daemon-kit's shared convention across every migrated daemon.
+ * `component`/`level`/`timestamp` and credential-safety (callers still must pass only bounded,
+ * non-sensitive fields; @danypops/vehicle-server/logging's own default redact list also catches any
+ * credential-shaped field that slips in regardless) are unchanged.
+ */
+import { createLogger, type Logger, type LogLevel as VehicleLogLevel } 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 }));
-}
+export type LogLevel = Extract<VehicleLogLevel, "info" | "warn" | "error">;
 
 /**
- * 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.
+ * Pinned to `console.error` -- rather than `createLogger`'s own default of a raw fd 2 write via
+ * `pino.destination(2)`, which bypasses `console.error` entirely -- so existing tooling/tests that
+ * intercept `console.error` keep working unchanged (matches jittor/src/log.ts's own reasoning).
+ * Also satisfies @danypops/vehicle-server's own `Logger` port directly wherever one is needed (e.g.
+ * `createVehicleHttpApp`'s failure logging in daemon.ts), replacing the old `vehicleLogger()`
+ * adapter now that this logger already natively implements the full debug/info/warn/error surface.
  */
-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),
-	};
+export const logger: Logger = createLogger("papyrus-daemon", {
+	destination: {
+		write: (chunk: string) => {
+			console.error(chunk.replace(/\n$/, ""));
+			return true;
+		},
+	},
+});
+
+/** Credential-safe structured daemon event. Callers must pass bounded, non-sensitive fields. */
+export function logEvent(level: LogLevel, event: string, fields: Record<string, unknown> = {}): void {
+	logger[level](event, fields);
 }

package/src/service.ts

@@ -594,7 +594,7 @@ 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. */
+	/** Defaults to a no-op (createVehicleHttpApp's own default) -- daemon.ts wires log/log.ts's own `logger` so a failed invocation is actually logged, not silently discarded. */
 	logger?: Logger;
 	/**
 	 * Backs GET /daemon/diagnose -- "who am I, and what happened recently" (see

package/src/stores/task-mutation-request-store.ts

@@ -56,6 +56,10 @@ export class InMemoryTaskMutationRequestStore implements TaskMutationRequestStor
 	}
 
 	put(record: TaskMutationRequestRecord): void {
+		// Checked in the same order sqlite-task-mutation-request-store.ts's own catch-and-reclassify
+		// does: a still-pending (taskId, operation) always becomes the more specific
+		// TaskMutationPendingError first, regardless of which underlying constraint actually
+		// collided (SQLite's partial unique pending index, or the PRIMARY KEY check below).
 		if (record.state === "pending" && record.taskId) {
 			const existing = this.findPending(record.taskId, record.operation, record.createdAt);
 			if (existing) {
@@ -66,7 +70,18 @@ export class InMemoryTaskMutationRequestStore implements TaskMutationRequestStor
 				);
 			}
 		}
-		this.records.set(this.recordKey(record.scope, record.key), { ...record });
+		// Mirror SQLite's own PRIMARY KEY (request_scope, idempotency_key): a genuine duplicate
+		// (scope, key) is always rejected, never silently overwritten -- SQLite throws on any such
+		// collision regardless of whether the colliding row's other columns match, so this does too,
+		// rather than only checking receiptId. Every real write path already dedupes via
+		// mutationRequests.get() before ever calling put() twice for the same (scope, key)
+		// (task-service.ts's prepareMutation()), so this is unreachable through normal application
+		// flow today -- it only guards a caller that talks to the store interface directly.
+		const recordKey = this.recordKey(record.scope, record.key);
+		if (this.records.has(recordKey)) {
+			throw new Error(`task mutation request already exists for scope "${record.scope}" key "${record.key}"`);
+		}
+		this.records.set(recordKey, { ...record });
 	}
 
 	complete(scope: string, key: string, responseJson: string, updatedAt: string): void {