@overdeck/desktop 0.47.0 → 0.48.0

package/server/search-DdtIjAiu.js

@@ -0,0 +1,395 @@
+import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
+import { a as runMemoryFtsTransactionSync, i as runMemoryFtsStatementSync, n as getMemoryFtsDatabaseSync, r as init_fts_operations, t as closeMemoryFtsDatabasesInProcess } from "./fts-operations-DP9R-8Q3.js";
+import { isAbsolute, relative, resolve } from "node:path";
+import { constants } from "node:fs";
+import { open, realpath } from "node:fs/promises";
+import { Worker } from "node:worker_threads";
+//#region ../../lib/memory/pin-path.ts
+/**
+* Lexically resolve a pinned-doc path against the project root, returning
+* the project-relative path when it stays inside it. Returns null when the
+* resolved target escapes the root via an absolute path elsewhere on disk or
+* a `../` traversal.
+*
+* This check alone is NOT sufficient to gate storing or reading a pin: it
+* only inspects the path string, so an in-project symlink (e.g.
+* `docs/private -> ~/.ssh`) passes lexically while actually pointing outside
+* the project. Use `verifyPinPathContainment` for that — this function
+* remains exported for unpin, which only needs to compute the stored lookup
+* key and must keep working even if the underlying file no longer exists.
+*/
+function resolveContainedPinPath(projectRoot, docPath) {
+	const absoluteRoot = resolve(projectRoot);
+	const rel = relative(absoluteRoot, isAbsolute(docPath) ? resolve(docPath) : resolve(absoluteRoot, docPath));
+	if (rel === "" || rel.startsWith("..") || isAbsolute(rel)) return null;
+	return rel;
+}
+/**
+* Symlink-safe containment check AND read, combined into a single verified
+* file descriptor. verifyPinPathContainment (path-in, path-out) still leaves
+* a time-of-check/time-of-use gap for a caller that separately re-opens the
+* path afterward — a concurrent local process could retarget a symlink in
+* between (review fix, cycle 3 non-blocking). This opens the realpath-
+* resolved (symlink-free) target once, verifies it's a regular file via
+* `fstat` on that SAME open handle, and reads from that SAME handle — no
+* second path-based lookup exists for anything to race. Returns null on any
+* escape, missing path, or non-regular-file target, exactly like
+* verifyPinPathContainment.
+*
+* Review fix (cycle 4 non-blocking): `realTarget` is still a pathname, and a
+* concurrent local writer could replace its final component with a symlink
+* between the `realpath()` call and this `open()` call. O_NOFOLLOW makes
+* that race fail closed instead of silently following the swapped-in
+* symlink — `open` errors (caught below, returns null) rather than
+* succeeding on an attacker-controlled target. This does not protect
+* replaceable PARENT directory components (a full openat-style walk would),
+* which is why this remains a narrowed, not eliminated, advisory.
+*/
+async function readVerifiedPinFile(projectRoot, docPath) {
+	const relativePath = resolveContainedPinPath(projectRoot, docPath);
+	if (relativePath === null) return null;
+	let realRoot;
+	let realTarget;
+	try {
+		realRoot = await realpath(resolve(projectRoot));
+		realTarget = await realpath(resolve(projectRoot, relativePath));
+	} catch {
+		return null;
+	}
+	const relFromRealRoot = relative(realRoot, realTarget);
+	if (relFromRealRoot === "" || relFromRealRoot.startsWith("..") || isAbsolute(relFromRealRoot)) return null;
+	let handle;
+	try {
+		handle = await open(realTarget, constants.O_RDONLY | constants.O_NOFOLLOW);
+		if (!(await handle.stat()).isFile()) return null;
+		return await handle.readFile("utf8");
+	} catch {
+		return null;
+	} finally {
+		await handle?.close().catch(() => {});
+	}
+}
+var init_pin_path = __esmMin((() => {}));
+//#endregion
+//#region ../../lib/memory/fts-db.ts
+async function getMemoryFtsDatabase(projectId) {
+	const cached = clients.get(projectId);
+	if (cached) return cached;
+	await postMemoryFtsRequest("initialize", projectId);
+	const client = createClient(projectId);
+	clients.set(projectId, client);
+	return client;
+}
+async function withMemoryFtsDatabase(projectId, operation) {
+	return operation(await getMemoryFtsDatabase(projectId));
+}
+function runMemoryFtsStatement(projectId, statement) {
+	return postMemoryFtsRequest("statement", projectId, { statement });
+}
+function runMemoryFtsTransaction(projectId, statements) {
+	return postMemoryFtsRequest("transaction", projectId, { statements });
+}
+function closeMemoryFtsDatabases() {
+	clients.clear();
+	closeMemoryFtsDatabasesInProcess();
+	if (!worker) return;
+	const closing = worker;
+	worker = null;
+	pendingRequests.forEach((request) => request.reject(/* @__PURE__ */ new Error("Memory FTS worker closed")));
+	pendingRequests.clear();
+	closing.postMessage({
+		id: nextRequestId++,
+		operation: "close"
+	});
+	closing.terminate();
+}
+function createClient(projectId) {
+	return {
+		exec: async (sql) => {
+			await runMemoryFtsStatement(projectId, {
+				sql,
+				method: "exec"
+			});
+		},
+		prepare: (sql) => ({
+			run: (...params) => runMemoryFtsStatement(projectId, {
+				sql,
+				params,
+				method: "run"
+			}),
+			get: (...params) => runMemoryFtsStatement(projectId, {
+				sql,
+				params,
+				method: "get"
+			}),
+			all: (...params) => runMemoryFtsStatement(projectId, {
+				sql,
+				params,
+				method: "all"
+			})
+		})
+	};
+}
+function postMemoryFtsRequest(operation, projectId, payload = {}) {
+	if (shouldRunInline()) return Promise.resolve().then(() => runInline(operation, projectId, payload));
+	const id = nextRequestId++;
+	return new Promise((resolve, reject) => {
+		pendingRequests.set(id, {
+			resolve,
+			reject
+		});
+		const currentWorker = getMemoryFtsWorker();
+		currentWorker.ref();
+		currentWorker.postMessage({
+			id,
+			operation,
+			projectId,
+			...payload
+		});
+	});
+}
+function runInline(operation, projectId, payload = {}) {
+	switch (operation) {
+		case "initialize":
+			getMemoryFtsDatabaseSync(requireProjectId(projectId));
+			return null;
+		case "statement": return runMemoryFtsStatementSync(requireProjectId(projectId), payload.statement);
+		case "transaction": return runMemoryFtsTransactionSync(requireProjectId(projectId), payload.statements);
+		case "close":
+			closeMemoryFtsDatabasesInProcess();
+			return null;
+	}
+}
+function shouldRunInline() {
+	return import.meta.url.endsWith(".ts");
+}
+function requireProjectId(projectId) {
+	if (!projectId) throw new Error("Memory FTS request missing projectId");
+	return projectId;
+}
+function getMemoryFtsWorker() {
+	if (worker) return worker;
+	const nextWorker = new Worker(memoryFtsWorkerUrl(), {
+		type: "module",
+		execArgv: process.execArgv.filter((arg) => !arg.startsWith("--inspect"))
+	});
+	nextWorker.on("message", (message) => {
+		const request = pendingRequests.get(message.id);
+		if (!request) return;
+		pendingRequests.delete(message.id);
+		if (message.ok) request.resolve(message.result);
+		else request.reject(new Error(message.error ?? "Memory FTS worker failed"));
+		if (pendingRequests.size === 0) nextWorker.unref();
+	});
+	nextWorker.on("error", (err) => {
+		failPendingRequests(err);
+		if (worker === nextWorker) worker = null;
+	});
+	nextWorker.on("exit", (code) => {
+		if (worker === nextWorker) worker = null;
+		if (code !== 0) failPendingRequests(/* @__PURE__ */ new Error(`Memory FTS worker exited with code ${code}`));
+	});
+	worker = nextWorker;
+	return worker;
+}
+function failPendingRequests(error) {
+	pendingRequests.forEach((request) => request.reject(error));
+	pendingRequests.clear();
+}
+function memoryFtsWorkerUrl() {
+	if (import.meta.url.endsWith("/dist/cli/index.js")) return new URL("../lib/memory/fts-worker.js", import.meta.url);
+	if (import.meta.url.endsWith("/dist/index.js") || /\/dist\/fts-db-[^/]+\.js$/.test(import.meta.url)) return new URL("./lib/memory/fts-worker.js", import.meta.url);
+	if (import.meta.url.endsWith("/dist/dashboard/server.js") || /\/dist\/dashboard\/fts-db-[^/]+\.js$/.test(import.meta.url)) return new URL("./memory-fts-worker.js", import.meta.url);
+	return import.meta.url.endsWith(".ts") ? new URL("./fts-worker.ts", import.meta.url) : new URL("./fts-worker.js", import.meta.url);
+}
+var worker, nextRequestId, pendingRequests, clients;
+var init_fts_db = __esmMin((() => {
+	init_fts_operations();
+	worker = null;
+	nextRequestId = 1;
+	pendingRequests = /* @__PURE__ */ new Map();
+	clients = /* @__PURE__ */ new Map();
+}));
+//#endregion
+//#region ../../lib/memory/search.ts
+async function searchMemory(input) {
+	const matchQuery = buildMatchQuery(input.query);
+	if (!matchQuery) return [];
+	const limit = normalizeLimit(input.limit);
+	const identityPredicate = buildIdentityPredicate(input);
+	if (!identityPredicate) return [];
+	const rows = await runMemoryFtsStatement(input.projectId, {
+		method: "all",
+		sql: `
+      SELECT
+        rowid,
+        content,
+        display_content,
+        source,
+        branch,
+        entry_date,
+        entry_time,
+        entry_type,
+        files,
+        tags,
+        doc_type,
+        scope,
+        project_id,
+        workspace_id,
+        issue_id,
+        run_id,
+        session_id,
+        agent_role,
+        agent_harness,
+        bm25(memory_fts) AS bm25
+      FROM memory_fts
+      WHERE memory_fts MATCH ?
+        AND project_id = ?
+        ${identityPredicate.sql}
+        ${input.docType ? "AND doc_type = ?" : ""}
+        AND (? = 1 OR (entry_date || 'T' || entry_time) > COALESCE((
+          SELECT MAX(from_timestamp)
+          FROM reset_markers
+          WHERE (scope = 'project' AND scope_id = memory_fts.project_id)
+             OR (scope = 'workspace' AND scope_id = memory_fts.workspace_id)
+             OR (scope = 'issue' AND scope_id = memory_fts.issue_id)
+             OR (scope = 'session' AND scope_id = memory_fts.session_id)
+        ), ''))
+      ORDER BY bm25(memory_fts) ASC
+      LIMIT ?
+    `,
+		params: [
+			matchQuery,
+			input.projectId,
+			...identityPredicate.params,
+			...input.docType ? [input.docType] : [],
+			input.includeArchived ? 1 : 0,
+			limit * OVERFETCH_RATIO
+		]
+	});
+	const tokenBudget = input.sibling || input.crossWorkspace ? normalizeSiblingTokenBudget(input.siblingTokenBudget) : null;
+	const queryTerms = extractQueryTerms(input.query);
+	const now = input.now ?? /* @__PURE__ */ new Date();
+	return rows.map((row) => rowToHit(row, tokenBudget, rankHit(row, queryTerms, now))).filter((hit) => matchesTags(hit, input.tags)).sort((a, b) => b.rankScore - a.rankScore || b.entryDate.localeCompare(a.entryDate) || b.entryTime.localeCompare(a.entryTime)).slice(0, limit);
+}
+function buildMatchQuery(query) {
+	return extractQueryTerms(query).map((term) => `"${term.replaceAll("\"", "\"\"")}"`).join(" ");
+}
+function extractQueryTerms(query) {
+	return query.match(/[\p{L}\p{N}_-]+/gu) ?? [];
+}
+function buildIdentityPredicate(input) {
+	if (input.sibling) {
+		if (!input.workspaceId || !input.issueId) return null;
+		return {
+			sql: "AND workspace_id != ? AND issue_id != ?",
+			params: [input.workspaceId, input.issueId]
+		};
+	}
+	if (input.crossWorkspace) {
+		if (!input.excludeWorkspaceId) return null;
+		return {
+			sql: "AND workspace_id != ?",
+			params: [input.excludeWorkspaceId]
+		};
+	}
+	const clauses = [];
+	const params = [];
+	if (input.workspaceId) {
+		clauses.push("AND workspace_id = ?");
+		params.push(input.workspaceId);
+	}
+	if (input.issueId) {
+		clauses.push("AND issue_id = ?");
+		params.push(input.issueId);
+	}
+	return {
+		sql: clauses.join("\n      "),
+		params
+	};
+}
+function normalizeLimit(limit) {
+	if (limit === void 0) return DEFAULT_LIMIT;
+	if (!Number.isInteger(limit) || limit <= 0) return DEFAULT_LIMIT;
+	return limit;
+}
+function normalizeSiblingTokenBudget(tokenBudget) {
+	if (tokenBudget === void 0) return DEFAULT_SIBLING_TOKEN_BUDGET;
+	if (!Number.isInteger(tokenBudget) || tokenBudget <= 0) return DEFAULT_SIBLING_TOKEN_BUDGET;
+	return tokenBudget;
+}
+function rankHit(row, queryTerms, now) {
+	const tags = splitList(row.tags).map((tag) => tag.toLowerCase());
+	const tagSet = new Set(tags);
+	const matchingTagCount = new Set(queryTerms.map((term) => term.toLowerCase()).filter((term) => tagSet.has(term))).size;
+	const ageDays = ageInDays(`${row.entry_date}T${row.entry_time}`, now);
+	const boostedScore = Math.abs(row.bm25) * Math.exp(-RECENCY_DECAY_RATE * ageDays) + TAG_BOOST * matchingTagCount;
+	if (ageDays < HIGH_SIGNAL_WINDOW_HOURS / 24 && tags.some((tag) => HIGH_SIGNAL_TAGS.has(tag))) return Math.max(boostedScore, HIGH_SIGNAL_SCORE_FLOOR);
+	return boostedScore;
+}
+function ageInDays(timestamp, now) {
+	const parsed = Date.parse(timestamp);
+	if (Number.isNaN(parsed)) return 0;
+	return Math.max(0, (now.getTime() - parsed) / 864e5);
+}
+function rowToHit(row, tokenBudget, rankScore) {
+	return {
+		rowid: row.rowid,
+		content: row.content,
+		displayContent: row.display_content,
+		source: row.source,
+		branch: row.branch,
+		entryDate: row.entry_date,
+		entryTime: row.entry_time,
+		entryType: row.entry_type,
+		files: splitList(row.files),
+		tags: splitList(row.tags),
+		docType: row.doc_type,
+		scope: row.scope,
+		projectId: row.project_id,
+		workspaceId: row.workspace_id,
+		issueId: row.issue_id,
+		runId: row.run_id,
+		sessionId: row.session_id,
+		agentRole: row.agent_role,
+		agentHarness: row.agent_harness,
+		bm25: row.bm25,
+		rankScore,
+		provenance: `${row.workspace_id}:${row.issue_id}`,
+		tokenBudget
+	};
+}
+function splitList(value) {
+	return value.split(",").map((entry) => entry.trim()).filter(Boolean);
+}
+function matchesTags(hit, tags) {
+	if (!tags || tags.length === 0) return true;
+	return tags.every((tag) => hit.tags.includes(tag));
+}
+var DEFAULT_LIMIT, OVERFETCH_RATIO, DEFAULT_SIBLING_TOKEN_BUDGET, RECENCY_DECAY_RATE, TAG_BOOST, HIGH_SIGNAL_SCORE_FLOOR, HIGH_SIGNAL_WINDOW_HOURS, HIGH_SIGNAL_TAGS;
+var init_search = __esmMin((() => {
+	init_fts_db();
+	DEFAULT_LIMIT = 20;
+	OVERFETCH_RATIO = 3;
+	DEFAULT_SIBLING_TOKEN_BUDGET = 1500;
+	RECENCY_DECAY_RATE = .02;
+	TAG_BOOST = .3;
+	HIGH_SIGNAL_SCORE_FLOOR = 1;
+	HIGH_SIGNAL_WINDOW_HOURS = 72;
+	HIGH_SIGNAL_TAGS = new Set([
+		"error",
+		"decision",
+		"blocker",
+		"shipped",
+		"architecture",
+		"review-blocker",
+		"test-failure",
+		"merge-risk",
+		"architecture-decision",
+		"regression"
+	]);
+}));
+//#endregion
+export { init_fts_db as a, withMemoryFtsDatabase as c, closeMemoryFtsDatabases as i, init_pin_path as l, init_search as n, runMemoryFtsStatement as o, searchMemory as r, runMemoryFtsTransaction as s, buildMatchQuery as t, readVerifiedPinFile as u };
+
+//# sourceMappingURL=search-DdtIjAiu.js.map

package/server/{sequence-io-Bmf1EZM5.js → sequence-io-Fw-cLyDs.js}

@@ -1,7 +1,7 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { ln as init_auto_commit, un as queueAutoCommit } from "./config-yaml-CxdwhAIA.js";
-import { d as getReviewStatusSync, p as init_review_status } from "./review-status-CGvlA4o_.js";
-import { M as getProjectPanPaths, S as init_specs } from "./io-B00PBNku.js";
+import { St as init_auto_commit, wt as queueAutoCommit } from "./config-yaml-BSCqwmX0.js";
+import { d as getReviewStatusSync, p as init_review_status } from "./review-status-CKLk5aZ-.js";
+import { C as init_specs, N as getProjectPanPaths } from "./io-mxOWMZ7I.js";
 import { dirname, join } from "node:path";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 //#region ../../lib/backlog/types.ts
@@ -275,4 +275,4 @@ var init_sequence_io = __esmMin((() => {
 //#endregion
 export { parseSequenceMd as n, writeSequenceMd as r, init_sequence_io as t };
 
-//# sourceMappingURL=sequence-io-Bmf1EZM5.js.map
+//# sourceMappingURL=sequence-io-Fw-cLyDs.js.map

package/server/{sequencer-agent-CigMyKh2.js → sequencer-agent-BcpGMt5x.js}

@@ -1,8 +1,9 @@
 import { a as __toCommonJS, n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { d as getReviewStatusSync, p as init_review_status } from "./review-status-CGvlA4o_.js";
-import { On as determineModel, Rr as getAgentRuntimeStateSync, a as listRunningAgentsSync, b as init_agents, dt as spawnRun, pt as stopAgent, rr as getAgentStateSync } from "./queries-C-MUZaIy.js";
-import { n as init_issue_service_singleton, r as issue_service_singleton_exports } from "./issue-service-singleton-C6ZduvuY.js";
-import { n as parseSequenceMd, t as init_sequence_io } from "./sequence-io-Bmf1EZM5.js";
+import { d as getReviewStatusSync, p as init_review_status } from "./review-status-CKLk5aZ-.js";
+import { Et as spawnRun, Gn as determineModel, Ot as stopAgent, a as listRunningAgentsSync, b as init_agents, br as getAgentStateSync, ti as getAgentRuntimeStateSync } from "./queries-DVpl1vsU.js";
+import { n as init_issue_service_singleton, r as issue_service_singleton_exports } from "./issue-service-singleton-BPNEXczv.js";
+import { N as getProjectPanPaths, P as init_paths } from "./io-mxOWMZ7I.js";
+import { n as parseSequenceMd, t as init_sequence_io } from "./sequence-io-Fw-cLyDs.js";
 import { dirname, join } from "node:path";
 import { Effect } from "effect";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
@@ -98,7 +99,8 @@ function detectPartOf(childRef, body) {
 async function collectOpenBacklog(projectRoot, issues, opts) {
 	const now = Date.now();
 	const openIssues = issues.filter((issue) => !CLOSED_STATES.has(issue.state));
-	const specsDir = join(projectRoot, ".pan", "specs");
+	const paths = getProjectPanPaths(projectRoot);
+	const specsDir = paths.specsDir;
 	const workspacesDir = join(projectRoot, "workspaces");
 	const issuesWithSpecs = /* @__PURE__ */ new Set();
 	if (!opts?.hasSpecFn) {
@@ -110,7 +112,7 @@ async function collectOpenBacklog(projectRoot, issues, opts) {
 	const manifest = openIssues.map((issue) => {
 		const reviewStatus = getReviewStatusSync(issue.ref);
 		const inPipeline = reviewStatus !== null && reviewStatus.reviewStatus !== "pending" || existsSync(join(workspacesDir, `feature-${issue.ref.toLowerCase()}`));
-		const hasPrd = opts?.hasPrdFn ? opts.hasPrdFn(issue.ref) : existsSync(join(projectRoot, ".pan", "drafts", `${issue.ref.toUpperCase()}.md`));
+		const hasPrd = opts?.hasPrdFn ? opts.hasPrdFn(issue.ref) : existsSync(join(paths.draftsDir, `${issue.ref.toLowerCase()}.md`)) || existsSync(join(paths.draftsDir, `${issue.ref.toUpperCase()}.md`));
 		const ready = opts?.hasSpecFn ? opts.hasSpecFn(issue.ref) : issuesWithSpecs.has(issue.ref.toUpperCase());
 		const createdMs = issue.createdAt ? new Date(issue.createdAt).getTime() : now;
 		return {
@@ -151,6 +153,7 @@ async function collectOpenBacklog(projectRoot, issues, opts) {
 }
 var SEQUENCE_MD_PATH, CLOSED_STATES, EPIC_TITLE_RE;
 var init_backlog_input = __esmMin((() => {
+	init_paths();
 	init_review_status();
 	init_sequence_io();
 	SEQUENCE_MD_PATH = ".pan/backlog/sequence.md";
@@ -187,16 +190,18 @@ async function spawnSequencerAgent(pass, opts = {}) {
 	const projectRoot = opts.projectRoot ?? process.cwd();
 	const projectKey = opts.projectKey ?? "overdeck";
 	const batchSize = opts.batchSize ?? 20;
-	const seqPath = join(projectRoot, ".pan", "backlog", "sequence.md");
-	const resolvedPass = pass !== "auto" ? pass : existsSync(seqPath) ? "incremental" : "creation";
+	const hasPriorSequence = existsSync(join(projectRoot, ".pan", "backlog", "sequence.md"));
+	const resolvedPass = pass === "auto" ? hasPriorSequence ? "incremental" : "creation" : pass === "incremental" && !hasPriorSequence ? "creation" : pass;
 	let rawIssues = opts.issues;
 	if (!rawIssues) try {
 		const { getSharedIssueService } = (init_issue_service_singleton(), __toCommonJS(issue_service_singleton_exports));
 		rawIssues = getSharedIssueService().getIssues();
-	} catch {
+	} catch (err) {
+		console.warn("[sequencer] issue read model unavailable, falling back to empty issue list:", err);
 		rawIssues = [];
 	}
 	const input = await collectOpenBacklog(projectRoot, normalizeBacklogIssues(rawIssues).filter((issue) => issue.ref.toUpperCase().startsWith("PAN-")));
+	if (input.manifest.length === 0) throw new Error(`Sequencer refusing to spawn: backlog manifest is empty (0 open ${projectKey} issues from ${rawIssues.length} raw read-model issues). An empty manifest usually means the issue read model was unavailable or empty at spawn time, not an empty backlog.`);
 	const manifestPath = join(projectRoot, ".pan", "backlog", "manifest.json");
 	await mkdir(dirname(manifestPath), { recursive: true });
 	await writeFile(manifestPath, JSON.stringify(input.manifest, null, 2), "utf-8");
@@ -325,4 +330,4 @@ var init_sequencer_agent = __esmMin((() => {
 //#endregion
 export { spawnSequencerAgent as a, init_sequencer_agent as i, clearFinishedSequencerRun as n, getSequencerRunStatus as r, SEQUENCER_AGENT_ID as t };
 
-//# sourceMappingURL=sequencer-agent-CigMyKh2.js.map
+//# sourceMappingURL=sequencer-agent-BcpGMt5x.js.map