@danypops/papyrus 0.29.5 → 0.29.7

package/extension/src/index.ts

@@ -95,7 +95,7 @@ export function renderTaskWidgetLines(theme: Theme, projection: TaskWidgetProjec
 	return lines;
 }
 
-class TaskOverlay {
+export class TaskOverlay {
 	private uiCtx: ExtensionUIContext | undefined;
 	private registered = false;
 	private tui: any | undefined;
@@ -116,6 +116,12 @@ class TaskOverlay {
 	// concurrent agent's focused task never shows as active in this session's widget.
 	setSessionId(sessionId: string): void { this.sessionId = sessionId; }
 
+	/**
+	 * Never throws: called from several pi.on(...) handlers, some of which (session_compact,
+	 * session_tree, tool_execution_end) don't wrap it themselves -- Pi's event emitter does not
+	 * guarantee catching a handler's rejection, so an unguarded throw here would become an
+	 * unhandled rejection at the call site instead of a stability issue contained to this widget.
+	 */
 	async refresh(): Promise<void> {
 		if (!this.projectRoot) return;
 		try {
@@ -123,7 +129,11 @@ class TaskOverlay {
 		} catch {
 			this.snapshot = { nodes: [], rootIds: [] };
 		}
-		this.render();
+		try {
+			this.render();
+		} catch {
+			// A rendering bug must not crash the extension host over a best-effort status widget.
+		}
 	}
 
 	private render(): void {
@@ -519,7 +529,7 @@ export default async function (pi: ExtensionAPI) {
 				const usage = ctx.getContextUsage?.();
 				// Real tree (not just the linear current-branch path): surfaces content sitting in an
 				// abandoned /tree branch, which cost real tokens to generate but isn't in context now.
-				const tree = ctx.sessionManager.getTree() as unknown as SessionTreeNodeLike[];
+				const tree = ctx.sessionManager.getTree() as SessionTreeNodeLike[];
 				// buildContextEntries(), NOT getBranch(): getBranch() returns every raw entry on the
 				// current path including everything a real compaction has already summarized away.
 				// A session with 3 real compactions confirmed this made "active" message-history
@@ -528,8 +538,8 @@ export default async function (pi: ExtensionAPI) {
 				// LLM"); buildContextEntries() is the compaction-aware entry list matching what the
 				// LLM actually sees (the latest compaction entry itself, plus kept entries from its
 				// firstKeptEntryId onward, plus everything after -- older summarized entries omitted).
-				const activeEntryIds = new Set((ctx.sessionManager.buildContextEntries() as unknown as SessionEntryLike[]).map((entry) => entry.id));
-				const branchEntryIds = new Set((ctx.sessionManager.getBranch() as unknown as SessionEntryLike[]).map((entry) => entry.id));
+				const activeEntryIds = new Set((ctx.sessionManager.buildContextEntries() as SessionEntryLike[]).map((entry) => entry.id));
+				const branchEntryIds = new Set((ctx.sessionManager.getBranch() as SessionEntryLike[]).map((entry) => entry.id));
 				const messageHistory = buildMessageHistoryTree(tree, activeEntryIds, branchEntryIds);
 				const breakdown = buildContextBreakdown({
 					totalTokens: usage?.tokens ?? null,

package/extension/src/tasks.ts

@@ -120,7 +120,8 @@ export async function showTasks(ctx: ExtensionCommandContext): Promise<void> {
 		if (action.type === "graph") { await showTaskGraph(ctx, graph); continue; }
 		if (action.type !== "action" || !action.row) continue;
 
-		const node = graph.nodes.find((entry) => entry.task.id === action.row!.id);
+		const rowId = action.row.id;
+		const node = graph.nodes.find((entry) => entry.task.id === rowId);
 		const active = node?.active === true;
 		const focusStatus = node?.focusStatus;
 		const choices = [
@@ -136,8 +137,8 @@ export async function showTasks(ctx: ExtensionCommandContext): Promise<void> {
 		const choice = await ctx.ui.select(action.row.title, choices);
 		if (!choice) continue;
 
-		if (choice === "Remove dependency" || choice === "Remove from parent") {
-			const relatedIds = choice === "Remove dependency" ? node!.dependencyIds : node!.parentIds;
+		if ((choice === "Remove dependency" || choice === "Remove from parent") && node) {
+			const relatedIds = choice === "Remove dependency" ? node.dependencyIds : node.parentIds;
 			const relatedTasks = relatedIds.map((relatedId) => graph.nodes.find((entry) => entry.task.id === relatedId)?.task).filter((task): task is Artifact => task !== undefined);
 			const relatedTitles = taskChoiceLabels(relatedTasks);
 			const selected = await ctx.ui.select(choice === "Remove dependency" ? "Remove which dependency?" : "Remove from which parent?", relatedTitles);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/papyrus",
-  "version": "0.29.5",
+  "version": "0.29.7",
   "description": "Daemon-backed graph artifacts, evidence-bearing tasks, rules, skills, and native TUI workflows for Pi",
   "type": "module",
   "keywords": ["pi-package"],

package/src/daemon.ts

@@ -52,7 +52,11 @@ export function serveMain(): void {
 		clearInterval(purgeTrashTimer);
 		clearDaemonPort(stateDir);
 		service.close();
-		void server.stop(true).finally(() => process.exit(0));
+		// .finally() re-throws rather than handling a rejection -- catching it first turns a bare
+		// unhandled-rejection warning into a real, queryable shutdown-failure log line.
+		void server.stop(true)
+			.catch((error) => logEvent("error", "server_stop_failed", { message: error instanceof Error ? error.message : String(error) }))
+			.finally(() => process.exit(0));
 	};
 	process.on("SIGINT", shutdown);
 	process.on("SIGTERM", shutdown);

package/src/db.ts

@@ -12,13 +12,23 @@ import { SQLITE_BUSY_TIMEOUT_MS, SQLITE_SCHEMA_VERSION } from "./constants.ts";
 
 const require_ = createRequire(import.meta.url);
 const IS_BUN = typeof (globalThis as { Bun?: unknown }).Bun !== "undefined";
-const backend = IS_BUN
-	? (require_("bun:sqlite") as typeof import("bun:sqlite"))
-	: (require_("node:sqlite") as unknown as typeof import("bun:sqlite"));
 
-const DatabaseCtor = (
-	"DatabaseSync" in backend ? (backend as { DatabaseSync: unknown }).DatabaseSync : backend.Database
-) as new (path: string, opts?: { create?: boolean }) => Db;
+/** Bun's bun:sqlite exports Database; Node's node:sqlite exports DatabaseSync -- neither module is
+ * actually the other, but both satisfy this shape at the methods Papyrus calls through Db/DbStatement. */
+interface SqliteBackendModule {
+	Database?: new (path: string, opts?: { create?: boolean }) => Db;
+	DatabaseSync?: new (path: string, opts?: { create?: boolean }) => Db;
+}
+
+const backend = require_(IS_BUN ? "bun:sqlite" : "node:sqlite") as SqliteBackendModule;
+// IIFE + explicit return type, not a bare `const DatabaseCtor = backend.DatabaseSync ?? backend.Database`
+// with a following throw-guard: that guard's narrowing wouldn't propagate into openDb() below, a
+// separate function closing over this module-level binding.
+const DatabaseCtor: new (path: string, opts?: { create?: boolean }) => Db = (() => {
+	const ctor = backend.DatabaseSync ?? backend.Database;
+	if (!ctor) throw new Error("no compatible sqlite backend found (expected bun:sqlite's Database or node:sqlite's DatabaseSync)");
+	return ctor;
+})();
 
 export interface DbStatement {
 	/** changes: number of rows the statement affected. Both bun:sqlite and node:sqlite's real run() return this at runtime; declared here so callers (e.g. reapStale) can rely on it without an unsafe cast. */

package/src/ops.ts

@@ -507,53 +507,38 @@ function readBoundedGateFile(path: string): string {
 	return readFileSync(path, "utf-8") as string;
 }
 
+/** Shared by the sync and async process-gate runners so "test" is never a second, independently
+ * maintained copy of "command"'s own command-template/timeout selection. */
+function processGateCommand(gate: Gate): { command: string; timeout: number } {
+	if (gate.type === "test") return { command: `npx vitest run ${gate.target} --reporter=dot`, timeout: GATE_TEST_TIMEOUT_MS };
+	return { command: gate.target, timeout: GATE_COMMAND_TIMEOUT_MS };
+}
+
+/**
+ * spawnSync + manual stdout/stderr concatenation, not execSync: execSync's return value is stdout
+ * only. Many real commands (bun test's own per-test lines and its pass/fail summary among them, and
+ * vitest's own "test" gate output) write their actual output to stderr, so an execSync-based match
+ * against gate.expect saw only the first line of a banner and never the result -- every such gate
+ * failed regardless of whether the command actually passed. This one function now serves both
+ * "command" and "test" gates; previously "test" was a second, separately-maintained execSync path
+ * that never checked gate.expect at all.
+ */
+function runProcessGateSync(gate: Gate, cwd?: string): GateResult {
+	const { spawnSync } = require_("node:child_process");
+	const { command, timeout } = processGateCommand(gate);
+	const result = spawnSync(command, { shell: true, encoding: "utf-8", timeout, ...(cwd ? { cwd } : {}) });
+	if (result.error) return { gate, passed: false, output: result.error.message.slice(0, GATE_OUTPUT_LIMIT) };
+	const combined = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
+	const passed = result.status === 0 && (gate.expect ? combined.includes(gate.expect) : true);
+	return { gate, passed, output: combined.slice(0, GATE_OUTPUT_LIMIT) || (result.status === 0 ? "ok" : `command exited with code ${result.status}`) };
+}
+
 export function runGates(db: Db, artifactId: string, options: GateRunOptions = {}): GateResult[] {
 	const art = getArtifact(db, artifactId);
 	if (!art) throw new Error("artifact not found");
 	const gates = (art.extra["gates"] as Gate[]) ?? [];
 	const cwd = options.cwd;
-	return gates.map((gate) => {
-		switch (gate.type) {
-			case "file-exists": {
-				const { existsSync } = require_("node:fs");
-				const exists = existsSync(gate.target);
-				return { gate, passed: exists, output: exists ? "exists" : "not found" };
-			}
-			case "contains": {
-				try {
-					const content = readBoundedGateFile(gate.target);
-					const found = gate.expect ? content.includes(gate.expect) : content.length > 0;
-					return { gate, passed: found, output: found ? "found" : `"${gate.expect ?? ""}" not found` };
-				} catch {
-					return { gate, passed: false, output: "file not readable" };
-				}
-			}
-			case "command": {
-				// spawnSync + manual stdout/stderr concatenation, not execSync: execSync's return value is
-				// stdout only. Many real commands (bun test's own per-test lines and its pass/fail summary
-				// among them) write their actual output to stderr, so an execSync-based match against
-				// gate.expect saw only the first line of a banner and never the result -- every such gate
-				// failed regardless of whether the command actually passed.
-				const { spawnSync } = require_("node:child_process");
-				const result = spawnSync(gate.target, { shell: true, encoding: "utf-8", timeout: GATE_COMMAND_TIMEOUT_MS, ...(cwd ? { cwd } : {}) });
-				if (result.error) return { gate, passed: false, output: result.error.message.slice(0, GATE_OUTPUT_LIMIT) };
-				const combined = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
-				const passed = result.status === 0 && (gate.expect ? combined.includes(gate.expect) : true);
-				return { gate, passed, output: combined.slice(0, GATE_OUTPUT_LIMIT) || (result.status === 0 ? "ok" : `command exited with code ${result.status}`) };
-			}
-			case "test": {
-				const { execSync } = require_("node:child_process");
-				try {
-					execSync(`npx vitest run ${gate.target} --reporter=dot`, { encoding: "utf-8", timeout: GATE_TEST_TIMEOUT_MS, stdio: ["pipe", "pipe", "pipe"], ...(cwd ? { cwd } : {}) });
-					return { gate, passed: true, output: "tests passed" };
-				} catch (e) {
-					return { gate, passed: false, output: e instanceof Error ? e.message.slice(0, GATE_OUTPUT_LIMIT) : "tests failed" };
-				}
-			}
-			default:
-				return { gate, passed: false, output: `unknown gate type: ${String(gate.type)}` };
-		}
-	});
+	return gates.map((gate) => (gate.type === "command" || gate.type === "test") ? runProcessGateSync(gate, cwd) : runNonProcessGate(gate));
 }
 
 /**
@@ -652,8 +637,7 @@ export async function runGatesAsync(db: Db, artifactId: string, options: GateRun
 			continue;
 		}
 		if (gate.type === "command" || gate.type === "test") {
-			const command = gate.type === "test" ? `npx vitest run ${gate.target} --reporter=dot` : gate.target;
-			const configuredTimeout = gate.type === "test" ? GATE_TEST_TIMEOUT_MS : GATE_COMMAND_TIMEOUT_MS;
+			const { command, timeout: configuredTimeout } = processGateCommand(gate);
 			const timeout = remainingMs === undefined ? configuredTimeout : Math.max(1, Math.min(configuredTimeout, remainingMs));
 			const executed = await executeGateCommand(command, timeout, options.cwd);
 			results.push({

package/src/task-service.ts

@@ -286,10 +286,11 @@ export class Tasks {
 		const byId = new Map(tasks.map((task) => [task.id, task]));
 		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: focus!.status } : {}),
+			...(task.id === focusedId ? { focusStatus } : {}),
 			parentIds: [] as string[],
 			childIds: [] as string[],
 			dependencyIds: [] as string[],