@danypops/papyrus 0.44.3 → 0.44.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/papyrus",
-  "version": "0.44.3",
+  "version": "0.44.5",
   "description": "Daemon-backed graph artifacts, evidence-bearing tasks, rules, skills, and native TUI workflows for Pi",
   "type": "module",
   "keywords": ["pi-package"],
@@ -34,8 +34,8 @@
   },
   "files": ["src", "README.md"],
   "dependencies": {
-    "@danypops/vehicle-core": "^0.10.0",
-    "@danypops/vehicle-client": "^0.6.0",
-    "@danypops/vehicle-server": "^0.13.0"
+    "@danypops/vehicle-client": "^0.6.1",
+    "@danypops/vehicle-core": "^0.12.3",
+    "@danypops/vehicle-server": "^0.18.1"
   }
 }

package/src/cli.ts

@@ -1,18 +1,18 @@
 #!/usr/bin/env bun
 import { execFileSync } from "node:child_process";
 import { copyFileSync, existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createNodeServiceInstallDeps, generateSystemdUnit, installUserService, type ServiceSpec } from "@danypops/vehicle-server/service";
 import { connectPapyrusClient, type PapyrusClient } from "./client.ts";
 import { DAEMON_UNIT_NAME, dbPath, TASK_EXECUTION_MAX_NODES } from "./constants.ts";
 import { serveMain } from "./daemon.ts";
+import { daemonStateDir, vehicleHandlePath } from "./daemon-state.ts";
 import { openDb } from "./db.ts";
 import type { GateResult } from "./domain/gate.ts";
 import { applyIdMigration, type IdMigrationPlan, mirrorDatabase, planIdMigration, verifyIdMigration } from "./id-migration.ts";
 import type { TaskExecutionPlan } from "./task-execution.ts";
 import type { TaskBlockage, TaskCompletion } from "./task-service.ts";
+import { VERSION } from "./version.ts";
 
 export interface SystemdUnitOptions {
 	bunBin: string;
@@ -26,20 +26,23 @@ export interface SystemdUnitOptions {
  *
  * Papyrus's own daemon.ts does not (yet) use vehicle-server's startDaemon/runDaemonProcess -- it's
  * a bespoke Bun.serve() with its own state-file layout (daemon-state.ts) and maintenance-timer
- * scheduling, predating that shared substrate. Only unit *generation* is migrated here; unitPath()
- * stays a manual XDG_CONFIG_HOME construction rather than pulling in resolveDaemonPaths() for a
- * database/token/handle layout Papyrus doesn't actually use. DAEMON_KIT_LAUNCH_PROVENANCE=service
- * is emitted (generateSystemdUnit always adds it) but is currently inert -- Papyrus's daemon never
- * reads it, since it has no idle-shutdown concept of its own. Migrating daemon.ts's own substrate
- * is tracked separately.
+ * scheduling, predating that shared substrate. handlePath points at the real {host,port,pid} file
+ * daemon.ts writes on startup (writeVehicleHandle), so Armada's readiness probe works once Papyrus
+ * is service-installed. DAEMON_KIT_LAUNCH_PROVENANCE=service is emitted (generateSystemdUnit always
+ * adds it) but is currently inert -- Papyrus's daemon never reads it, since it has no idle-shutdown
+ * concept of its own. Migrating daemon.ts's own substrate onto vehicle-server's shared daemon
+ * runtime entirely is tracked separately.
  */
-function papyrusServiceSpec(options: SystemdUnitOptions): ServiceSpec {
+export function papyrusServiceSpec(options: SystemdUnitOptions): ServiceSpec {
 	return {
 		name: "papyrus",
 		displayName: "Papyrus graph artifact service",
+		version: VERSION,
 		binPath: options.bunBin,
 		args: [options.cliPath, "serve"],
-		descriptorPath: unitPath(),
+		// The real {host,port,pid} file daemon.ts writes on startup (writeVehicleHandle) --
+		// Armada's readiness probe polls exactly this path once Papyrus is service-installed.
+		handlePath: vehicleHandlePath(daemonStateDir()),
 		// Restart=always/RestartSec=2 already unconditional in the prior hand-rolled unit --
 		// preserved exactly, not a new opt-in.
 		restartOnFailure: true,
@@ -51,11 +54,6 @@ export function renderSystemdUnit(options: SystemdUnitOptions): string {
 	return generateSystemdUnit(papyrusServiceSpec(options));
 }
 
-function unitPath(): string {
-	const configHome = process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config");
-	return join(configHome, "systemd", "user", DAEMON_UNIT_NAME);
-}
-
 function systemctl(...args: string[]): void {
 	execFileSync("systemctl", ["--user", ...args], { stdio: "inherit" });
 }

package/src/constants.ts

@@ -2,6 +2,8 @@
 export const DAEMON_HOST = "127.0.0.1";
 export const DAEMON_PORT_FILE = "port";
 export const DAEMON_TOKEN_FILE = "token";
+/** vehicle-server's own {host,port,pid} handle format -- read by Armada's readiness probe once Papyrus is service-installed, see cli.ts's papyrusServiceSpec. */
+export const DAEMON_HANDLE_FILE = "vehicle-handle.json";
 export const DAEMON_CLIENT_TIMEOUT_MS = 15_000;
 export const DAEMON_PROBE_TIMEOUT_MS = 800;
 export const DAEMON_UNIT_NAME = "papyrus.service";

package/src/daemon-state.ts

@@ -2,7 +2,8 @@ import { randomBytes } from "node:crypto";
 import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { DAEMON_DIR_ENV, DAEMON_HOST, DAEMON_PORT_FILE, DAEMON_TOKEN_FILE } from "./constants.ts";
+import { LOOPBACK_HOST, removeDaemonHandle, writeDaemonHandle } from "@danypops/vehicle-server/paths";
+import { DAEMON_DIR_ENV, DAEMON_HANDLE_FILE, DAEMON_HOST, DAEMON_PORT_FILE, DAEMON_TOKEN_FILE } from "./constants.ts";
 
 export interface DaemonHandle {
 	baseUrl: string;
@@ -42,6 +43,20 @@ export function clearDaemonPort(dir: string): void {
 	rmSync(join(dir, DAEMON_PORT_FILE), { force: true });
 }
 
+/** Where Armada's readiness probe looks once Papyrus is service-installed -- see cli.ts's papyrusServiceSpec. */
+export function vehicleHandlePath(dir: string): string {
+	return join(dir, DAEMON_HANDLE_FILE);
+}
+
+/** vehicle-server's own {host,port,pid} handle format, distinct from this file's port/token pair -- Armada's readiness probe (createHandleReadinessProbe) reads exactly this shape. */
+export function writeVehicleHandle(dir: string, port: number, pid: number = process.pid): void {
+	writeDaemonHandle(vehicleHandlePath(dir), { host: LOOPBACK_HOST, port, pid });
+}
+
+export function clearVehicleHandle(dir: string): void {
+	removeDaemonHandle(vehicleHandlePath(dir));
+}
+
 export function readDaemonHandle(dir: string): DaemonHandle | undefined {
 	try {
 		const token = readFileSync(join(dir, DAEMON_TOKEN_FILE), "utf8").trim();

package/src/daemon.ts

@@ -2,7 +2,14 @@ import { join } from "node:path";
 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 { clearDaemonPort, daemonStateDir, loadOrCreateToken, writeDaemonPort } from "./daemon-state.ts";
+import {
+	clearDaemonPort,
+	clearVehicleHandle,
+	daemonStateDir,
+	loadOrCreateToken,
+	writeDaemonPort,
+	writeVehicleHandle,
+} from "./daemon-state.ts";
 import { logEvent, vehicleLogger } from "./log.ts";
 import { createApp, createPapyrusService } from "./service.ts";
 
@@ -66,6 +73,7 @@ export function serveMain(): void {
 		throw new Error("Papyrus daemon failed to bind a listener");
 	}
 	writeDaemonPort(stateDir, server.port);
+	writeVehicleHandle(stateDir, server.port);
 	const checkpointTimer = setInterval(() => {
 		try {
 			service.checkpoint();
@@ -110,6 +118,7 @@ export function serveMain(): void {
 		clearInterval(reapFocusTimer);
 		clearInterval(purgeTrashTimer);
 		clearDaemonPort(stateDir);
+		clearVehicleHandle(stateDir);
 		releaseDaemonLock(lockPath);
 		service.close();
 		// .finally() re-throws rather than handling a rejection -- catching it first turns a bare

package/src/task-service.ts

@@ -329,11 +329,17 @@ export class Tasks {
 			throw new Error(`task graph limit must be between 1 and ${TASK_EXECUTION_MAX_NODES + 1}`);
 		}
 		const tasks = this.list({ ...filter, limit: requestedLimit });
+		return this.buildGraph(tasks, scope, filter.sessionId);
+	}
+
+	/** Shared by graph() and dependencyCheckGraph() -- the latter builds a graph from an
+	 * explicitly assembled task list (a union of two projects) rather than one filter's own scope. */
+	private buildGraph(tasks: Artifact[], scope: TaskViewSelection, sessionId?: string): TaskGraph {
 		if (tasks.length > TASK_EXECUTION_MAX_NODES) {
-			throw new Error(`task execution graph exceeds ${TASK_EXECUTION_MAX_NODES} nodes`);
+			throw new TaskExecutionBoundExceededError(`task execution graph exceeds ${TASK_EXECUTION_MAX_NODES} nodes`);
 		}
 		const byId = new Map(tasks.map((task) => [task.id, task]));
-		const focus = this.focusStore.get(filter.sessionId);
+		const focus = this.focusStore.get(sessionId);
 		const focusedId = focus?.taskId;
 		const focusStatus = focus?.status;
 		const nodes = new Map(
@@ -355,7 +361,7 @@ export class Tasks {
 			limit: TASK_EXECUTION_MAX_EDGES + 1,
 		});
 		if (relationships.length > TASK_EXECUTION_MAX_EDGES) {
-			throw new Error(`task execution graph exceeds ${TASK_EXECUTION_MAX_EDGES} relationships`);
+			throw new TaskExecutionBoundExceededError(`task execution graph exceeds ${TASK_EXECUTION_MAX_EDGES} relationships`);
 		}
 		for (const edge of relationships) {
 			if (!byId.has(edge.from) || !byId.has(edge.to)) continue;
@@ -656,6 +662,18 @@ export class Tasks {
 		if (sourceProject !== undefined && sourceProject === targetProject) {
 			return this.graph({ projectRoot: sourceProject, scope: "project" });
 		}
+		if (sourceProject !== undefined && targetProject !== undefined) {
+			// A genuine cross-project pair: the union of both endpoints' own project scopes
+			// covers every prerequisite/successor edge relevant to THIS pair's own cycle check,
+			// without pulling in every unrelated project's tasks -- those can push the daemon-wide
+			// total over TASK_EXECUTION_MAX_NODES for reasons that have nothing to do with these
+			// two tasks. A cycle threading through a third, uninvolved project is not covered by
+			// this union; falls back to the fully unscoped graph only when a project is unknown.
+			const limit = TASK_EXECUTION_MAX_NODES + 1;
+			const merged = new Map(this.list({ projectRoot: sourceProject, scope: "project", limit }).map((task) => [task.id, task]));
+			for (const task of this.list({ projectRoot: targetProject, scope: "project", limit })) merged.set(task.id, task);
+			return this.buildGraph([...merged.values()], { mode: "all", label: taskScopeLabel("all") });
+		}
 		return this.graph();
 	}