@overdeck/desktop 0.49.1 → 0.49.2

package/server/specialists-registry-1y6Rt_F1.js

@@ -0,0 +1,3 @@
+import { d as isReviewSessionForIssue, l as init_specialists_registry } from "./specialists-registry-BYjs04iK.js";
+init_specialists_registry();
+export { isReviewSessionForIssue };

package/server/specialists-registry-BYjs04iK.js

@@ -0,0 +1,277 @@
+import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
+import { Ri as init_paths, vi as OVERDECK_HOME } from "./config-yaml-D9nfpEx1.js";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import "crypto";
+//#region ../../lib/cloister/specialists-registry.ts
+/**
+* Cloister Specialist Registry
+*
+* Manages specialist metadata, registry persistence, and session naming.
+*/
+/**
+* Get the directory for a project's specialist
+*/
+function getProjectSpecialistDir(projectKey, specialistType) {
+	return join(SPECIALISTS_DIR, projectKey, specialistType);
+}
+/**
+* Ensure per-project specialist directory structure exists
+*/
+function ensureProjectSpecialistDir(projectKey, specialistType) {
+	const specialistDir = getProjectSpecialistDir(projectKey, specialistType);
+	const runsDir = join(specialistDir, "runs");
+	const contextDir = join(specialistDir, "context");
+	if (!existsSync(runsDir)) mkdirSync(runsDir, { recursive: true });
+	if (!existsSync(contextDir)) mkdirSync(contextDir, { recursive: true });
+}
+function isProjectSpecialistActivelyRunning(runtimeState, fallbackRunning = false) {
+	if (runtimeState?.state === "active") return true;
+	if (runtimeState?.state === "idle" || runtimeState?.state === "suspended" || runtimeState?.state === "stopped" || runtimeState?.state === "waiting-on-human") return false;
+	return fallbackRunning;
+}
+/**
+* PAN-1048 review feedback 003 (REQ-16): initSpecialistsDirectory is a no-op.
+*
+* The cleanup at Cloister startup (service.ts cleanupLegacySpecialistsDirectory)
+* removes ~/.overdeck/specialists/ on every boot. The previous body of this
+* function would unconditionally re-create the directory and seed
+* registry.json from DEFAULT_SPECIALISTS the next time anything called
+* loadRegistry(), undoing the cleanup and resurrecting the legacy identity
+* model. The stub keeps the call sites alive (callers that still loadRegistry
+* get an in-memory default registry) without recreating any disk artifacts.
+*/
+function initSpecialistsDirectory() {}
+/**
+* Load the specialist registry
+*
+* @returns Specialist registry
+*/
+function loadRegistry() {
+	if (!existsSync(REGISTRY_FILE)) return {
+		version: "3.0",
+		defaults: {
+			contextRuns: 5,
+			digestModel: null,
+			retention: {
+				maxDays: 30,
+				maxRuns: 50
+			}
+		},
+		projects: {},
+		specialists: DEFAULT_SPECIALISTS,
+		lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	try {
+		const content = readFileSync(REGISTRY_FILE, "utf-8");
+		return JSON.parse(content);
+	} catch (error) {
+		console.error("Failed to load specialist registry:", error);
+		return {
+			version: "3.0",
+			defaults: {
+				contextRuns: 5,
+				digestModel: null,
+				retention: {
+					maxDays: 30,
+					maxRuns: 50
+				}
+			},
+			projects: {},
+			specialists: DEFAULT_SPECIALISTS,
+			lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+		};
+	}
+}
+/**
+* Save the specialist registry
+*
+* @param registry - Registry to save
+*/
+function saveRegistry(registry) {
+	if (!existsSync(SPECIALISTS_DIR)) return;
+	registry.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+	try {
+		writeFileSync(REGISTRY_FILE, JSON.stringify(registry, null, 2), "utf-8");
+	} catch (error) {
+		console.error("Failed to save specialist registry:", error);
+		throw error;
+	}
+}
+/**
+* Get metadata for a specific specialist
+*
+* @param name - Specialist name
+* @returns Specialist metadata or null if not found
+*/
+function getSpecialistMetadata(name) {
+	return (loadRegistry().specialists ?? []).find((s) => s.name === name) || null;
+}
+/**
+* Update specialist metadata
+*
+* @param name - Specialist name
+* @param updates - Partial metadata to update
+*/
+function updateSpecialistMetadata(name, updates) {
+	const registry = loadRegistry();
+	const specialists = registry.specialists ?? [];
+	const index = specialists.findIndex((s) => s.name === name);
+	if (index === -1) throw new Error(`Specialist ${name} not found in registry`);
+	specialists[index] = {
+		...specialists[index],
+		...updates,
+		name
+	};
+	registry.specialists = specialists;
+	saveRegistry(registry);
+}
+/**
+* Get all specialist metadata
+*
+* @returns Array of all specialists
+*/
+function getAllSpecialists() {
+	return loadRegistry().specialists ?? [];
+}
+/**
+* Get tmux session name for a specialist
+*
+* @param name - Specialist name
+* @param projectKey - Optional project key for per-project specialists
+* @returns Expected tmux session name
+*/
+function getTmuxSessionName(name, projectKey, issueId) {
+	if (projectKey && issueId) return `specialist-${projectKey}-${issueId}-${name}`;
+	if (projectKey) return `specialist-${projectKey}-${name}`;
+	return `specialist-${name}`;
+}
+/**
+* Get the canonical reviewer tmux session name (PAN-830 / PAN-1048).
+*
+* Pattern: `agent-<issueId>-review-<role>`. One tmux session per role per
+* issue — sessions are reused across review rounds via the agent message delivery path.
+* resumption. Round 2 of `review-correctness` does NOT spawn a new session;
+* it injects a follow-up prompt into the existing pane.
+*
+* @param role - One of the canonical reviewer roles
+* @param _projectKey - Unused (kept for signature compatibility with existing callers)
+* @param issueId - Issue identifier (e.g. `pan-540` or `PAN-540`)
+* @returns Canonical tmux session name
+*/
+function getReviewerSessionName(role, _projectKey, issueId) {
+	return `agent-${issueId.toLowerCase()}-review-${role}`;
+}
+/**
+* Parse a canonical reviewer session name back into role + issue.
+* Returns null if the name does not match either pattern.
+* Supports both current `agent-*` format and legacy `specialist-*` format.
+*/
+function parseReviewerSessionName(name) {
+	const agentMatch = name.match(/^agent-([a-z0-9]+-\d+)-review-(correctness|security|performance|requirements|synthesis)$/i);
+	if (agentMatch) return {
+		issueId: agentMatch[1].toUpperCase(),
+		role: agentMatch[2]
+	};
+	const legacyMatch = name.match(/^specialist-([\w.-]+?)-([\w.-]+?)-review-(correctness|security|performance|requirements|synthesis)$/);
+	if (legacyMatch) return {
+		issueId: legacyMatch[2],
+		role: legacyMatch[3]
+	};
+	return null;
+}
+/**
+* Construct the compound registry key for a per-issue specialist (PAN-754).
+* Format: `${specialistType}:${issueId}` or `${specialistType}:${issueId}:${role}` for convoy.
+*/
+function makeSpecialistRegistryKey(specialistType, issueId, role) {
+	return role ? `${specialistType}:${issueId}:${role}` : `${specialistType}:${issueId}`;
+}
+/**
+* Remove every project-specialist registry entry whose compound key references
+* the given issueId (case-insensitive match on the second segment). Returns
+* the number of entries removed. Called from teardown so closed issues do not
+* leave behind metadata that the deacon keeps inspecting and force-killing.
+*/
+function pruneSpecialistRegistryEntriesForIssue(issueId) {
+	const issueLower = issueId.toLowerCase();
+	const issueUpper = issueId.toUpperCase();
+	const registry = loadRegistry();
+	let removed = 0;
+	for (const projectKey of Object.keys(registry.projects ?? {})) {
+		const bucket = registry.projects[projectKey] ?? {};
+		for (const key of Object.keys(bucket)) {
+			const { issueId: keyIssue } = parseSpecialistRegistryKey(key);
+			if (!keyIssue) continue;
+			if (keyIssue === issueLower || keyIssue === issueUpper) {
+				delete bucket[key];
+				removed++;
+			}
+		}
+	}
+	if (removed > 0) saveRegistry(registry);
+	return removed;
+}
+/**
+* Parse a compound registry key back into its parts.
+*/
+function parseSpecialistRegistryKey(key) {
+	const parts = key.split(":");
+	if (parts.length === 1) return { specialistType: parts[0] };
+	if (parts.length === 2) return {
+		specialistType: parts[0],
+		issueId: parts[1]
+	};
+	return {
+		specialistType: parts[0],
+		issueId: parts[1],
+		role: parts[2]
+	};
+}
+/**
+* Record wake event in metadata
+*
+* @param name - Specialist name
+* @param sessionId - New session ID (if changed)
+*/
+function recordWake(name, sessionId) {
+	const updates = { lastWake: (/* @__PURE__ */ new Date()).toISOString() };
+	if (sessionId) updates.sessionId = sessionId;
+	updateSpecialistMetadata(name, updates);
+}
+/**
+* True when a tmux session name belongs to any review phase of this issue —
+* the parent review role, convoy children, and legacy coordinator sessions —
+* so callers do not need to know which review phase has started. Lives in this
+* leaf module (not review-agent.ts) so the review-status read door can classify
+* sessions without closing an import cycle (PAN-3674).
+*/
+function isReviewSessionForIssue(sessionName, projectKey, issueId) {
+	const session = sessionName.toLowerCase();
+	const issue = issueId.toLowerCase();
+	const project = projectKey?.toLowerCase();
+	if (session.startsWith("conv-")) return false;
+	if (session === `agent-${issue}-review` || session.startsWith(`agent-${issue}-review-`)) return true;
+	if (session.startsWith(`review-${issue}-`) || session.startsWith(`review-coordinator-${issue}-`)) return true;
+	if (!project) return false;
+	if (session === `specialist-${project}-${issue}-review-agent`) return true;
+	return session.startsWith(`specialist-${project}-${issue}-review-`);
+}
+var SPECIALISTS_DIR, REGISTRY_FILE, DEFAULT_SPECIALISTS, REVIEWER_ROLES;
+var init_specialists_registry = __esmMin((() => {
+	init_paths();
+	SPECIALISTS_DIR = join(OVERDECK_HOME, "specialists");
+	REGISTRY_FILE = join(SPECIALISTS_DIR, "registry.json");
+	DEFAULT_SPECIALISTS = [];
+	REVIEWER_ROLES = [
+		"correctness",
+		"security",
+		"performance",
+		"requirements",
+		"synthesis"
+	];
+}));
+//#endregion
+export { recordWake as _, getReviewerSessionName as a, initSpecialistsDirectory as c, isReviewSessionForIssue as d, loadRegistry as f, pruneSpecialistRegistryEntriesForIssue as g, parseSpecialistRegistryKey as h, getProjectSpecialistDir as i, init_specialists_registry as l, parseReviewerSessionName as m, ensureProjectSpecialistDir as n, getSpecialistMetadata as o, makeSpecialistRegistryKey as p, getAllSpecialists as r, getTmuxSessionName as s, REVIEWER_ROLES as t, isProjectSpecialistActivelyRunning as u, saveRegistry as v, updateSpecialistMetadata as y };
+
+//# sourceMappingURL=specialists-registry-BYjs04iK.js.map

package/server/specialists-x-kPMhrL.js

@@ -0,0 +1,4 @@
+import { A as findSessionFile, C as listSpecialistsForProject, D as updateRunMetadata, E as updateProjectSpecialistMetadata, F as isInitialized, I as isRunning, L as buildSpecialistBaseCommand, M as getSpecialistState, N as getSpecialistStatus, O as updateRunStatus, P as initializeEnabledSpecialists, R as buildSpecialistCavemanExports, S as listProjectsWithSpecialists, T as updateContextTokens, _ as getEnabledSpecialists, a as sendFeedbackToAgent, b as incrementProjectRunCount, c as getGracePeriodState, d as signalSpecialistCompletion, f as startGracePeriod, g as getAllProjectSpecialistStatuses, h as enableSpecialist, i as getPendingFeedback, j as getAllSpecialistStatus, k as countContextTokens, l as pauseGracePeriod, m as disableSpecialist, o as exitGracePeriod, p as terminateSpecialist, r as getFeedbackStats, s as findActiveRegistryKey, t as init_specialists, u as resumeGracePeriod, v as getProjectSpecialistMetadata, w as setCurrentRun, x as isEnabled, y as getRunMetadata } from "./specialists-CuDWiNdB.js";
+import { _ as recordWake, a as getReviewerSessionName, c as initSpecialistsDirectory, f as loadRegistry, g as pruneSpecialistRegistryEntriesForIssue, h as parseSpecialistRegistryKey, i as getProjectSpecialistDir, m as parseReviewerSessionName, n as ensureProjectSpecialistDir, o as getSpecialistMetadata, p as makeSpecialistRegistryKey, r as getAllSpecialists, s as getTmuxSessionName, t as REVIEWER_ROLES, u as isProjectSpecialistActivelyRunning, v as saveRegistry, y as updateSpecialistMetadata } from "./specialists-registry-BYjs04iK.js";
+init_specialists();
+export { REVIEWER_ROLES, buildSpecialistBaseCommand, buildSpecialistCavemanExports, countContextTokens, disableSpecialist, enableSpecialist, ensureProjectSpecialistDir, exitGracePeriod, findActiveRegistryKey, findSessionFile, getAllProjectSpecialistStatuses, getAllSpecialistStatus, getAllSpecialists, getEnabledSpecialists, getFeedbackStats, getGracePeriodState, getPendingFeedback, getProjectSpecialistDir, getProjectSpecialistMetadata, getReviewerSessionName, getRunMetadata, getSpecialistMetadata, getSpecialistState, getSpecialistStatus, getTmuxSessionName, incrementProjectRunCount, initSpecialistsDirectory, initializeEnabledSpecialists, isEnabled, isInitialized, isProjectSpecialistActivelyRunning, isRunning, listProjectsWithSpecialists, listSpecialistsForProject, loadRegistry, makeSpecialistRegistryKey, parseReviewerSessionName, parseSpecialistRegistryKey, pauseGracePeriod, pruneSpecialistRegistryEntriesForIssue, recordWake, resumeGracePeriod, saveRegistry, sendFeedbackToAgent, setCurrentRun, signalSpecialistCompletion, startGracePeriod, terminateSpecialist, updateContextTokens, updateProjectSpecialistMetadata, updateRunMetadata, updateRunStatus, updateSpecialistMetadata };

package/server/specs-IYsFlM-L.js

@@ -0,0 +1,3 @@
+import { C as init_specs, S as findSpecByIssue } from "./io-DKrWd3gX.js";
+init_specs();
+export { findSpecByIssue };