@overdeck/desktop 0.49.1 → 0.49.2

package/server/issue-title-fallback-DTSCQVu0.js

@@ -0,0 +1,120 @@
+import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
+import { r as init_factory, t as createTracker } from "./factory-BrdqXBeK.js";
+import { n as resolveGitHubIssueSync, r as resolveTrackerTypeSync, t as init_tracker_utils } from "./tracker-utils-DJAOAuMN.js";
+import { Effect } from "effect";
+//#region services/issue-title-fallback.ts
+/**
+* Fallback resolution for issues that have aged out of the tracker sync
+* window.
+*
+* The resource tree surfaces any issue that still owns local resources
+* (workspaces, agent sessions, records, planning artifacts) — including
+* issues closed long ago, which the shared issue service no longer syncs.
+* Without a tracker row, discovery falls back to the bare identifier as the
+* row title, so the tree renders "MIN-852 — MIN-852" (PAN-3337). The issue
+* view (drawer/cockpit) has the same hole: its header reads the read-model
+* issue list, which drops closed issues older than `closedWindowDays`, so
+* the header falls back to "Issue details" (PAN-3659).
+*
+* Resolve those issues per issue on demand through the tracker's own
+* getIssue door. Successes are memoized for the process lifetime (rows of
+* closed issues do not churn); failures are memoized briefly so a broken or
+* unconfigured tracker cannot be hammered by the discovery refresh loop.
+*/
+/**
+* Build a tracker bound to the repo/project the issue belongs to.
+* createTracker({ type }) alone is not enough for trackers whose config is
+* per-repo: GitHub needs owner/repo (resolved from the issue prefix), and
+* without them the factory throws — which silently broke this fallback for
+* every GitHub-tracked issue (PAN-3659).
+*/
+function trackerForIssue(issueId) {
+	const trackerType = resolveTrackerTypeSync(issueId);
+	if (!trackerType) return null;
+	if (trackerType === "github") {
+		const resolution = resolveGitHubIssueSync(issueId);
+		if (!resolution.isGitHub) return null;
+		return createTracker({
+			type: "github",
+			owner: resolution.owner,
+			repo: resolution.repo
+		});
+	}
+	return createTracker({ type: trackerType });
+}
+async function lookupIssue(issueId) {
+	const tracker = trackerForIssue(issueId);
+	if (!tracker) return null;
+	return Effect.runPromise(tracker.getIssue(issueId).pipe(Effect.timeout(LOOKUP_TIMEOUT)));
+}
+/**
+* Resolve one issue through its tracker door, memoized: successes for the
+* process lifetime, failures for FAILURE_RETRY_MS, concurrent callers share
+* one in-flight request. Returns null when the issue cannot be resolved.
+*/
+async function resolveMissingIssue(issueId) {
+	const key = issueId.toUpperCase();
+	const memoized = resolvedIssues.get(key);
+	if (memoized) return memoized;
+	const failedAt = failedLookupsAt.get(key);
+	if (failedAt !== void 0 && Date.now() - failedAt < FAILURE_RETRY_MS) return null;
+	let pending = inFlight.get(key);
+	if (!pending) {
+		pending = lookupIssue(key).catch(() => null).finally(() => inFlight.delete(key));
+		inFlight.set(key, pending);
+	}
+	const issue = await pending;
+	if (issue) {
+		resolvedIssues.set(key, issue);
+		failedLookupsAt.delete(key);
+		return issue;
+	}
+	failedLookupsAt.set(key, Date.now());
+	return null;
+}
+function usableTitle(issue, issueId) {
+	const title = issue.title?.trim();
+	return title && title.toUpperCase() !== issueId.toUpperCase() ? title : null;
+}
+/**
+* Resolve titles for issues the tracker snapshot missed. Returns only the
+* identifiers that resolved to a real title (memoized or freshly fetched).
+*/
+async function resolveMissingIssueTitles(issueIds) {
+	const result = /* @__PURE__ */ new Map();
+	const toFetch = [];
+	const now = Date.now();
+	for (const raw of issueIds) {
+		const issueId = raw.toUpperCase();
+		const memoized = resolvedIssues.get(issueId);
+		if (memoized) {
+			const title = usableTitle(memoized, issueId);
+			if (title) result.set(issueId, title);
+			continue;
+		}
+		const failedAt = failedLookupsAt.get(issueId);
+		if (failedAt !== void 0 && now - failedAt < FAILURE_RETRY_MS) continue;
+		if (toFetch.length < MAX_LOOKUPS_PER_PASS) toFetch.push(issueId);
+	}
+	await Promise.all(toFetch.map(async (issueId) => {
+		const issue = await resolveMissingIssue(issueId);
+		const title = issue ? usableTitle(issue, issueId) : null;
+		if (title) result.set(issueId, title);
+	}));
+	return result;
+}
+var FAILURE_RETRY_MS, LOOKUP_TIMEOUT, MAX_LOOKUPS_PER_PASS, resolvedIssues, failedLookupsAt, inFlight;
+var init_issue_title_fallback = __esmMin((() => {
+	init_tracker_utils();
+	init_factory();
+	FAILURE_RETRY_MS = 600 * 1e3;
+	LOOKUP_TIMEOUT = "10 seconds";
+	MAX_LOOKUPS_PER_PASS = 8;
+	resolvedIssues = /* @__PURE__ */ new Map();
+	failedLookupsAt = /* @__PURE__ */ new Map();
+	inFlight = /* @__PURE__ */ new Map();
+}));
+//#endregion
+export { resolveMissingIssue as n, resolveMissingIssueTitles as r, init_issue_title_fallback as t };
+
+//# sourceMappingURL=issue-title-fallback-DTSCQVu0.js.map

package/server/{issues-CkvUoAnq.js → issues-e_Ck1Ln2.js}

@@ -1,5 +1,5 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { _ as integer, a as EventBus, c as Records, f as init_infra, h as text, m as sqliteTable, p as init_sqlite_core, r as Db, v as init_drizzle_orm, x as eq } from "./infra-KTp9KV9u.js";
+import { _ as integer, a as EventBus, c as Records, f as init_infra, h as text, m as sqliteTable, p as init_sqlite_core, r as Db, v as init_drizzle_orm, x as eq } from "./infra-CHIvOb9q.js";
 import { Context, Effect, Layer, Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
 //#region ../../lib/overdeck/issues.ts
@@ -350,4 +350,4 @@ var init_issues = __esmMin((() => {
 //#endregion
 export { init_issues as n, IssueId as t };
 
-//# sourceMappingURL=issues-CkvUoAnq.js.map
+//# sourceMappingURL=issues-e_Ck1Ln2.js.map

package/server/{jsonl-parser-CrEb2PWr.js → jsonl-parser-DqxVCZ1k.js}

@@ -1,6 +1,6 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { Di as encodeClaudeProjectDir, Fi as init_paths, oi as init_errors } from "./config-yaml-BwOEANMr.js";
-import { o as getPricingSync, s as init_cost, t as calculateCostSync } from "./cost-CQKI6OCu.js";
+import { Ri as init_paths, ci as init_errors, ki as encodeClaudeProjectDir } from "./config-yaml-D9nfpEx1.js";
+import { o as getPricingSync, s as init_cost, t as calculateCostSync } from "./cost-CiIwxH1D.js";
 import "effect";
 import { existsSync, readFileSync, readdirSync, statSync } from "fs";
 import { basename, join } from "path";
@@ -247,4 +247,4 @@ var init_jsonl_parser = __esmMin((() => {
 //#endregion
 export { init_jsonl_parser as a, getSessionFilesSync as i, getAllSessionFilesSync as n, normalizeModelName as o, getProjectDirsSync as r, parseClaudeSessionSync as s, getActiveSessionModelSync as t };
 
-//# sourceMappingURL=jsonl-parser-CrEb2PWr.js.map
+//# sourceMappingURL=jsonl-parser-DqxVCZ1k.js.map

package/server/jsonl-resolver-07OS3qOr.js

@@ -0,0 +1,324 @@
+import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
+import { Li as getOverdeckHome, Ri as init_paths, ki as encodeClaudeProjectDir } from "./config-yaml-D9nfpEx1.js";
+import { s as getHarnessBehavior } from "./src-CY2Wl8IX.js";
+import { g as logAgentLifecycleSync, h as init_persistent_logger } from "./agents-jXgqpHca.js";
+import { Ct as getAgentWorkspace, U as getAgentRuntimeState, g as getAgentStateSync, q as init_agents, wt as init_agent_enrichment } from "./agent-state-BJhGIJZe.js";
+import { t as init_behavior } from "./behavior-BiCQzqyT.js";
+import { join } from "node:path";
+import { Effect } from "effect";
+import { homedir } from "node:os";
+import { access, readFile, readdir, stat } from "node:fs/promises";
+//#region routes/jsonl-resolver.ts
+/**
+* JSONL transcript resolver for the Command Deck (PAN-830).
+*
+* Maps an agent ID (e.g. `agent-pan-830`, `planning-pan-830`, or a canonical
+* specialist tmux session name) to the agent's JSONL transcript file on disk.
+*
+* Codex agents (PAN-1805) write rollout JSONLs under the per-agent
+* `codex-home/sessions/` tree — resolution dispatches on the harness recorded
+* in state.json (thread-id fast path, then latest-rollout fallback).
+*
+* For claude-code agents the JSONL filename is the *Claude session ID* (a UUID
+* written by Claude Code itself), NOT the agent/tmux name. Lookup order:
+*   1. session.id     — UUID pinned before fresh work-agent launch and updated
+*                       by auto-suspend/resume flows
+*   2. sessions.json  — array of UUIDs the agent has used; the heartbeat hook
+*                       APPENDS new IDs and dedupes, so once a session has been
+*                       seen its array index never moves. After a `pan resume`
+*                       brings an older session back as the live one, the array
+*                       order no longer reflects time-recency. We disambiguate
+*                       across all listed IDs by JSONL mtime.
+*   3. runtime state  — in-process mirror, populated by hooks
+*   4. agents registry — the DB row's session_id recorded at spawn; survives
+*                        janitor removal of the agent directory
+*
+* Async-only (fs/promises) because this code path runs inside the dashboard
+* server's event loop.
+*/
+function logTranscriptResolution(agentId, signature, message, opts) {
+	const signatureKey = `${agentId}:${opts.agentsDirOverride ?? "live"}`;
+	if (transcriptResolutionSignatures.get(signatureKey) === signature) return;
+	transcriptResolutionSignatures.set(signatureKey, signature);
+	(opts.logDiagnostic ?? (opts.agentsDirOverride ? void 0 : logAgentLifecycleSync))?.(agentId, `transcript resolution: ${message}`);
+}
+async function pathExists(p) {
+	return access(p).then(() => true, () => false);
+}
+async function readOptional(p) {
+	return readFile(p, "utf-8").catch(() => null);
+}
+function behaviorForHarness(harness) {
+	return getHarnessBehavior(harness);
+}
+/**
+* Pick the candidate UUID whose JSONL transcript has the most recent mtime.
+*
+* The heartbeat hook appends to sessions.json and dedupes — so once an ID is
+* recorded, its array index never moves even if a later resume makes it the
+* current session again. Choosing by JSONL mtime is the only reliable signal
+* for "which session is actually live right now."
+*
+* Returns null if no candidate has a corresponding JSONL on disk. Falls back
+* to scanning every project dir if the workspace path can't be resolved
+* (covers specialist sessions whose workspace lives elsewhere).
+*/
+async function pickFreshestSessionId(candidates, agentId, opts) {
+	if (candidates.length === 0) return null;
+	if (candidates.length === 1) return candidates[0];
+	const projectsRoot = opts.claudeProjectsDirOverride ?? join(homedir(), ".claude", "projects");
+	let candidatePaths = [];
+	try {
+		const workspace = await Effect.runPromise(getAgentWorkspace(agentId));
+		if (workspace) {
+			const projectDir = join(projectsRoot, encodeClaudeProjectDir(workspace));
+			candidatePaths = candidates.map((id) => ({
+				id,
+				path: join(projectDir, `${id}.jsonl`)
+			}));
+		}
+	} catch {}
+	if (candidatePaths.length === 0) try {
+		const dirs = await readdir(projectsRoot);
+		const SAFE_DIR = /^[a-zA-Z0-9_.-]+$/;
+		for (const id of candidates) for (const dir of dirs) {
+			if (!SAFE_DIR.test(dir)) continue;
+			candidatePaths.push({
+				id,
+				path: join(projectsRoot, dir, `${id}.jsonl`)
+			});
+		}
+	} catch {}
+	let best = null;
+	for (const { id, path } of candidatePaths) try {
+		const s = await stat(path);
+		if (!best || s.mtimeMs > best.mtimeMs) best = {
+			id,
+			mtimeMs: s.mtimeMs
+		};
+	} catch {}
+	return best ? best.id : candidates[candidates.length - 1] ?? null;
+}
+/** Async equivalent of getLatestSessionId from lib/agents.ts. */
+async function resolveClaudeSessionId(agentId, opts = {}) {
+	const agentDir = join(opts.agentsDirOverride ?? join(getOverdeckHome(), "agents"), agentId);
+	const sessionIdTrimmed = (await readOptional(join(agentDir, "session.id")))?.trim();
+	if (sessionIdTrimmed) return sessionIdTrimmed;
+	const sessionsRaw = await readOptional(join(agentDir, "sessions.json"));
+	if (sessionsRaw) try {
+		const parsed = JSON.parse(sessionsRaw);
+		if (Array.isArray(parsed)) {
+			const fresh = await pickFreshestSessionId(parsed.filter((v) => typeof v === "string" && v.trim().length > 0), agentId, opts);
+			if (fresh) return fresh;
+		}
+	} catch {}
+	try {
+		const runtimeState = await (opts.getRuntimeStateAsync ?? ((id) => Effect.runPromise(getAgentRuntimeState(id))))(agentId);
+		if (runtimeState?.claudeSessionId) return runtimeState.claudeSessionId;
+	} catch {}
+	if (!opts.agentsDirOverride) {
+		const registrySessionId = getAgentStateSync(agentId)?.sessionId?.trim();
+		if (registrySessionId) return registrySessionId;
+	}
+	return null;
+}
+async function readLauncherPinnedSessionId(tmuxSession, opts = {}) {
+	const home = opts.overdeckHomeOverride ?? getOverdeckHome();
+	const candidates = [join(home, "conversations", tmuxSession, "launcher.sh"), join(home, "agents", tmuxSession, "launcher.sh")];
+	for (const path of candidates) {
+		const text = await readOptional(path);
+		if (!text) continue;
+		const match = LAUNCHER_SESSION_ID_RE.exec(text) ?? LAUNCHER_RESUME_RE.exec(text);
+		if (match) return match[1];
+	}
+	return null;
+}
+/**
+* Read the harness + workspace recorded for an agent, honoring the test
+* override dir. Used by resolveAgentHarness / agentHasClaudeTranscript so the
+* stale-harness self-correction runs identically in prod and under test.
+*/
+async function readRecordedState(agentId, opts) {
+	if (opts.agentsDirOverride) try {
+		const raw = await readFile(join(opts.agentsDirOverride, agentId, "state.json"), "utf8");
+		const s = JSON.parse(raw);
+		return {
+			harness: typeof s.harness === "string" ? s.harness : null,
+			workspace: typeof s.workspace === "string" ? s.workspace : void 0
+		};
+	} catch {
+		return { harness: null };
+	}
+	const st = getAgentStateSync(agentId);
+	return {
+		harness: st?.harness ?? null,
+		workspace: st?.workspace
+	};
+}
+/**
+* Resolve the harness for transcript routing. Reads state.json, then
+* self-corrects when the recorded value is stale.
+*
+* Trust an explicit non-default harness (codex / pi / ohmypi / acp) — it was chosen
+* by resolveHarness at spawn time and is not the generic fallback. The
+* 'claude-code' default, however, goes stale in one observed case: a
+* wipe-and-respawn that changed the provider-default harness left state.json
+* carrying the pre-respawn 'claude-code' while the fresh launch was
+* codex/ohmypi. The resolver then took the claude-code branch, found no
+* claudeSessionId, and the dashboard showed "No conversation data available"
+* for a live agent whose real transcript sat untouched under codex-home.
+*
+* Self-correction (claude-code/null recorded only): if the agent has NO
+* claude-code transcript on disk but DOES have a codex rollout / pi session,
+* the on-disk runtime wins — those artifacts are written only by that runtime,
+* so this cannot surface a wrong transcript. When a claude-code transcript IS
+* present it always wins, so a past codex run's codex-home can't shadow a
+* current claude-code session.
+*/
+async function resolveAgentHarness(agentId, opts = {}) {
+	const recorded = (await readRecordedState(agentId, opts)).harness;
+	if (recorded === "codex" || recorded === "pi" || recorded === "ohmypi" || recorded === "acp" || recorded === "kimi-code") return recorded;
+	if (await agentHasClaudeTranscript(agentId, opts)) return recorded ?? "claude-code";
+	if (await resolveAcpTranscriptPath(agentId, opts)) return "acp";
+	if (await resolveCodexRolloutPath(agentId, opts)) return "codex";
+	if (await resolvePiSessionPath(agentId, opts)) return "ohmypi";
+	if (await resolveKimiWirePath(agentId, opts)) return "kimi-code";
+	return recorded;
+}
+/**
+* Whether the agent has a resolvable claude-code transcript on disk. Used by
+* resolveAgentHarness to decide if a claude-code recording is still live
+* (vs. a stale default that should be corrected to codex/ohmypi).
+*/
+async function agentHasClaudeTranscript(agentId, opts = {}) {
+	const sessionId = await resolveClaudeSessionId(agentId, opts);
+	if (!sessionId) return false;
+	const workspace = (await readRecordedState(agentId, opts)).workspace;
+	if (!workspace) return false;
+	return pathExists(join(opts.claudeProjectsDirOverride ?? join(homedir(), ".claude", "projects"), encodeClaudeProjectDir(workspace), `${sessionId}.jsonl`));
+}
+/**
+* Resolve the Codex rollout JSONL for a codex-harness agent (PAN-1805).
+*
+* Fast path: the persisted codex-thread-id maps directly to its rollout file.
+* Lazy fallback (same shape as the conversation panel's PAN-1690 fix): codex
+* writes the rollout only on the first turn, so a spawn-time thread-id capture
+* can miss it — the per-agent CODEX_HOME holds only this agent's rollouts, so
+* the newest one is its current thread.
+*/
+async function resolveCodexRolloutPath(agentId, opts = {}) {
+	const agentDir = join(opts.agentsDirOverride ?? join(getOverdeckHome(), "agents"), agentId);
+	const codexHome = join(agentDir, "codex-home");
+	if (!await pathExists(codexHome)) return null;
+	const { findRolloutPath, findLatestRollout } = await import("./codex-DZhFfcWu.js");
+	const threadId = (await readOptional(join(agentDir, "codex-thread-id")))?.trim();
+	if (threadId) {
+		const rollout = findRolloutPath(codexHome, threadId);
+		if (rollout) return rollout;
+	}
+	return findLatestRollout(codexHome);
+}
+/** Resolve the normalized transcript written by the persistent ACP host. */
+async function resolveAcpTranscriptPath(agentId, opts = {}) {
+	const transcriptPath = join(opts.agentsDirOverride ?? join(getOverdeckHome(), "agents"), agentId, "acp-session.jsonl");
+	return await pathExists(transcriptPath) ? transcriptPath : null;
+}
+/**
+* Resolve the native Kimi Code CLI wire.jsonl for a kimi-code-harness agent
+* (PAN-1837 wi8a). Fast path: the per-agent kimi-session-id (persisted by
+* wi5's spawnAgent) maps directly to
+* `<kimiHome>/sessions/<workDirKey>/<sessionId>/agents/main/wire.jsonl`.
+* Fallback (no captured id): the newest session directory by wire.jsonl mtime
+* under the workspace's workDirKey bucket — same shape as the codex/pi lazy
+* fallbacks above, since Kimi may not have finished writing its first turn
+* when the id was captured.
+*/
+async function resolveKimiWirePath(agentId, opts = {}) {
+	const workspace = opts.workspaceOverride ?? (await readRecordedState(agentId, opts)).workspace;
+	if (!workspace) return null;
+	const sessionId = (await readOptional(join(opts.agentsDirOverride ?? join(getOverdeckHome(), "agents"), agentId, "kimi-session-id")))?.trim() || null;
+	const kimiHome = opts.kimiHomeOverride ?? join(homedir(), ".kimi-code");
+	const { findKimiWirePathAsync } = await import("./kimi-code-vtXl2DR5.js");
+	return findKimiWirePathAsync(kimiHome, workspace, sessionId);
+}
+/**
+* Resolve the pi/kimi session JSONL (PAN-1908). Pi writes its session transcript
+* as `<iso-ts>_<session-id>.jsonl` either in the agent dir's `sessions/` subdir
+* (conversations) OR in the agent dir root (work agents) — so check both. The dir
+* also holds `cost-events.jsonl` / `activity.jsonl`, which are NOT transcripts.
+* Return the freshest transcript by mtime, or null if pi hasn't written one yet.
+*/
+async function resolvePiSessionPath(agentId, opts = {}) {
+	const agentDir = join(opts.agentsDirOverride ?? join(getOverdeckHome(), "agents"), agentId);
+	const NON_TRANSCRIPT = new Set([
+		"acp-session.jsonl",
+		"cost-events.jsonl",
+		"activity.jsonl",
+		"pending-events.jsonl"
+	]);
+	let best = null;
+	for (const dir of [join(agentDir, "sessions"), agentDir]) {
+		let entries;
+		try {
+			entries = await readdir(dir);
+		} catch {
+			continue;
+		}
+		for (const name of entries) {
+			if (!name.endsWith(".jsonl") || NON_TRANSCRIPT.has(name)) continue;
+			const p = join(dir, name);
+			try {
+				const m = (await stat(p)).mtimeMs;
+				if (!best || m > best.mtime) best = {
+					path: p,
+					mtime: m
+				};
+			} catch {}
+		}
+	}
+	return best?.path ?? null;
+}
+/**
+* Resolve the JSONL transcript for an agent.
+*
+* Codex agents resolve to their rollout JSONL (PAN-1805). For claude-code
+* agents, returns the absolute path if both the claudeSessionId is known AND
+* the corresponding JSONL file exists; otherwise null.
+*/
+async function resolveJsonlPath(agentId, workspacePath, opts = {}) {
+	const harness = await resolveAgentHarness(agentId, opts);
+	const behavior = behaviorForHarness(harness);
+	if (behavior.transcriptKind === "codex-rollout-jsonl") return resolveCodexRolloutPath(agentId, opts);
+	if (behavior.transcriptKind === "ohmypi-jsonl") return resolvePiSessionPath(agentId, opts);
+	if (behavior.transcriptKind === "acp-jsonl") return resolveAcpTranscriptPath(agentId, opts);
+	if (behavior.transcriptKind === "kimi-wire-jsonl") return resolveKimiWirePath(agentId, opts);
+	const claudeSessionId = await resolveClaudeSessionId(agentId, opts);
+	if (!claudeSessionId) {
+		logTranscriptResolution(agentId, `missing-session-id:${harness ?? "unknown"}`, `failed harness=${harness ?? "unknown"} reason=no-session-id checked=session.id,sessions.json,runtime-state`, opts);
+		return null;
+	}
+	const effectiveWorkspacePath = (await readRecordedState(agentId, opts)).workspace ?? workspacePath;
+	const jsonlPath = join(opts.claudeProjectsDirOverride ?? join(homedir(), ".claude", "projects"), encodeClaudeProjectDir(effectiveWorkspacePath), `${claudeSessionId}.jsonl`);
+	if (await pathExists(jsonlPath)) {
+		logTranscriptResolution(agentId, `resolved:${jsonlPath}`, `resolved harness=${harness ?? "claude-code"} sessionId=${claudeSessionId} path=${jsonlPath}`, opts);
+		return jsonlPath;
+	}
+	logTranscriptResolution(agentId, `missing-jsonl:${jsonlPath}`, `failed harness=${harness ?? "claude-code"} reason=jsonl-missing sessionId=${claudeSessionId} workspace=${effectiveWorkspacePath} expectedPath=${jsonlPath}`, opts);
+	return null;
+}
+var transcriptResolutionSignatures, LAUNCHER_UUID, LAUNCHER_SESSION_ID_RE, LAUNCHER_RESUME_RE;
+var init_jsonl_resolver = __esmMin((() => {
+	init_agents();
+	init_paths();
+	init_agent_enrichment();
+	init_behavior();
+	init_persistent_logger();
+	transcriptResolutionSignatures = /* @__PURE__ */ new Map();
+	LAUNCHER_UUID = "[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}";
+	LAUNCHER_SESSION_ID_RE = new RegExp(`--session-id\\s+'?(${LAUNCHER_UUID})'?`);
+	LAUNCHER_RESUME_RE = new RegExp(`--resume\\s+'?(${LAUNCHER_UUID})'?`);
+}));
+//#endregion
+export { resolveClaudeSessionId as a, resolveKimiWirePath as c, resolveAgentHarness as i, resolvePiSessionPath as l, readLauncherPinnedSessionId as n, resolveCodexRolloutPath as o, resolveAcpTranscriptPath as r, resolveJsonlPath as s, init_jsonl_resolver as t };
+
+//# sourceMappingURL=jsonl-resolver-07OS3qOr.js.map

package/server/{kimi-code-C26gmGxM.js → kimi-code-BjtAHIz1.js}

@@ -1,13 +1,14 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { Fi as init_paths, Pi as getOverdeckHome } from "./config-yaml-BwOEANMr.js";
-import { n as init_fs_lock, r as isPidDead } from "./fs-lock-cw25uO_E.js";
-import { c as getRuntimeBehavior } from "./src-DudQNYVw.js";
-import { O as saveAgentStateSync, Xn as deliverAgentMessage, _i as init_pty_token, bi as resolvePtySupervisorScriptPath, cn as listAgentStates, er as init_delivery, h as init_agent_state, m as getAgentStateSync, sn as init_queries, vi as writePtyToken, yi as init_pty_supervisor_locate } from "./agent-state-Bb3UUxQm.js";
-import { t as init_behavior } from "./behavior-Bitko0mD.js";
-import { C as generateLauncherScriptSync, w as init_launcher_generator } from "./auto-spawn-consent-BDfe4qz0.js";
-import { _ as tmuxKillSession, g as tmuxCreateSession, h as init_tmux_cli, v as tmuxSessionExists } from "./codex-OOea7lXs.js";
-import { i as prepareHarnessLaunch, r as init_harness_binary } from "./harness-binary-BgXYDo2Z.js";
-import { n as parseKimiSessionSync, t as init_kimi_parser } from "./kimi-parser-Dmhy3UlR.js";
+import { Li as getOverdeckHome, Ri as init_paths } from "./config-yaml-D9nfpEx1.js";
+import { n as init_fs_lock, r as isPidDead } from "./fs-lock-C7J-ugIf.js";
+import { C as init_tmux, v as getManagedTmuxSocketName } from "./tmux-DWEc4Ld9.js";
+import { c as getRuntimeBehavior } from "./src-CY2Wl8IX.js";
+import { A as saveAgentStateSync, Di as writePtyToken, Ei as init_pty_token, Oi as init_pty_supervisor_locate, _ as init_agent_state, _n as listAgentStates, ar as deliverAgentMessage, g as getAgentStateSync, gn as init_queries, ki as resolvePtySupervisorScriptPath, lr as init_delivery } from "./agent-state-BJhGIJZe.js";
+import { t as init_behavior } from "./behavior-BiCQzqyT.js";
+import { C as generateLauncherScriptSync, w as init_launcher_generator } from "./auto-spawn-consent-Dc4mtM-B.js";
+import { _ as tmuxKillSession, g as tmuxCreateSession, h as init_tmux_cli, v as tmuxSessionExists } from "./codex-KaSKE-R3.js";
+import { i as prepareHarnessLaunch, r as init_harness_binary } from "./harness-binary-tMmgJfC1.js";
+import { n as parseKimiSessionSync, t as init_kimi_parser } from "./kimi-parser-B1lgy2Vt.js";
 import { basename, dirname, join } from "node:path";
 import { homedir } from "node:os";
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
@@ -337,6 +338,7 @@ function createKimiCodeRuntimeSync(options = {}) {
 }
 var execAsync, SPAWN_READY_TIMEOUT_MS, POLL_INTERVAL_MS, KimiCodeSpawnTimeout, KIMI_CAPTURE_LOCK_POLL_MS, KIMI_CAPTURE_LOCK_MAX_WAIT_MS, KIMI_CAPTURE_LOCK_STALE_AGE_MS, KimiCaptureLockTimeoutError, KimiCodeRuntimeSync;
 var init_kimi_code = __esmMin((() => {
+	init_tmux();
 	init_agent_state();
 	init_queries();
 	init_delivery();
@@ -440,12 +442,12 @@ var init_kimi_code = __esmMin((() => {
 		}
 		async killAgent(agentId) {
 			try {
-				await this.execCommand(`tmux -L overdeck send-keys -t ${shellQuote(agentId)} C-c 2>/dev/null || true`);
+				await this.execCommand(`tmux -L ${shellQuote(getManagedTmuxSocketName())} send-keys -t ${shellQuote(agentId)} C-c 2>/dev/null || true`);
 			} catch {}
 			if (await pollUntilSessionGone(agentId, 2e3)) return;
 			let panePid = null;
 			try {
-				const { stdout } = await this.execCommand(`tmux -L overdeck list-panes -t ${shellQuote(agentId)} -F '#{pane_pid}' 2>/dev/null`);
+				const { stdout } = await this.execCommand(`tmux -L ${shellQuote(getManagedTmuxSocketName())} list-panes -t ${shellQuote(agentId)} -F '#{pane_pid}' 2>/dev/null`);
 				panePid = stdout.trim() || null;
 				if (panePid) await this.execCommand(`kill -TERM -- -${panePid} 2>/dev/null || kill -TERM ${panePid} 2>/dev/null || true`);
 			} catch {}
@@ -576,4 +578,4 @@ var init_kimi_code = __esmMin((() => {
 //#endregion
 export { findKimiWirePath as a, findLatestKimiSessionAsync as c, kimiSessionsRoot as d, kimiWorkDirKey as f, writeKimiSessionId as g, withKimiSessionCaptureLock as h, createKimiCodeRuntimeSync as i, init_kimi_code as l, waitForNewKimiSessionAsync as m, KimiCodeRuntimeSync as n, findKimiWirePathAsync as o, waitForNewKimiSession as p, KimiCodeSpawnTimeout as r, findLatestKimiSession as s, KimiCaptureLockTimeoutError as t, kimiCaptureLockPath as u };
 
-//# sourceMappingURL=kimi-code-C26gmGxM.js.map
+//# sourceMappingURL=kimi-code-BjtAHIz1.js.map

package/server/{kimi-code-DoMoGqIu.js → kimi-code-vtXl2DR5.js}

@@ -1,3 +1,3 @@
-import { d as kimiSessionsRoot, g as writeKimiSessionId, h as withKimiSessionCaptureLock, l as init_kimi_code, m as waitForNewKimiSessionAsync, o as findKimiWirePathAsync } from "./kimi-code-C26gmGxM.js";
+import { d as kimiSessionsRoot, g as writeKimiSessionId, h as withKimiSessionCaptureLock, l as init_kimi_code, m as waitForNewKimiSessionAsync, o as findKimiWirePathAsync } from "./kimi-code-BjtAHIz1.js";
 init_kimi_code();
 export { findKimiWirePathAsync, kimiSessionsRoot, waitForNewKimiSessionAsync, withKimiSessionCaptureLock, writeKimiSessionId };

package/server/{kimi-parser-Dmhy3UlR.js → kimi-parser-B1lgy2Vt.js}

@@ -1,5 +1,5 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { o as getPricingSync, s as init_cost } from "./cost-CQKI6OCu.js";
+import { o as getPricingSync, s as init_cost } from "./cost-CiIwxH1D.js";
 import { basename, dirname } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 //#region ../../lib/cost-parsers/kimi-parser.ts
@@ -144,4 +144,4 @@ var init_kimi_parser = __esmMin((() => {
 //#endregion
 export { parseKimiSessionSync as n, summarizeKimiEntries as r, init_kimi_parser as t };
 
-//# sourceMappingURL=kimi-parser-Dmhy3UlR.js.map
+//# sourceMappingURL=kimi-parser-B1lgy2Vt.js.map

package/server/{label-cleanup-X2lWfghH.js → label-cleanup-D2zUMasf.js}

@@ -1,5 +1,5 @@
-import { Gn as init_issue_id, Un as extractNumberSync, Wn as extractPrefixSync } from "./config-yaml-BwOEANMr.js";
-import { a as stepSkipped, i as stepOk, n as init_types, r as stepFailed, t as getLinearApiKey } from "./types-DjpLVpsj.js";
+import { Gn as extractNumberSync, Kn as extractPrefixSync, qn as init_issue_id } from "./config-yaml-D9nfpEx1.js";
+import { a as stepSkipped, i as stepOk, n as init_types, r as stepFailed, t as getLinearApiKey } from "./types-fzBp9cYi.js";
 import { Effect } from "effect";
 import { exec } from "child_process";
 import { promisify } from "util";
@@ -102,4 +102,4 @@ async function cleanupLabelsLinear(ctx, apiKey) {
 //#endregion
 export { cleanupMergedLabels };
 
-//# sourceMappingURL=label-cleanup-X2lWfghH.js.map
+//# sourceMappingURL=label-cleanup-D2zUMasf.js.map

package/server/{lifecycle-Bg44O-9x.js → lifecycle-0NOEzomy.js}

@@ -1,5 +1,5 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { oi as init_errors } from "./config-yaml-BwOEANMr.js";
+import { ci as init_errors } from "./config-yaml-D9nfpEx1.js";
 import "effect";
 import { mkdirSync } from "fs";
 import { join } from "path";
@@ -118,4 +118,4 @@ var init_lifecycle = __esmMin((() => {
 //#endregion
 export { generateXBriefFilename as a, parseXBriefFilename as c, ensureXBriefDirsSync as i, resolveXBriefDir as l, LEGACY_VBRIEF_LIFECYCLE_DIRS as n, init_lifecycle as o, XBRIEF_FILENAME_SUFFIX as r, isXBriefFilename as s, LEGACY_VBRIEF_FILENAME_SUFFIX as t, slugify as u };
 
-//# sourceMappingURL=lifecycle-Bg44O-9x.js.map
+//# sourceMappingURL=lifecycle-0NOEzomy.js.map

package/server/{lifecycle-B0rL38D3.js → lifecycle-DaCovZwn.js}

@@ -1,11 +1,11 @@
-import { t as archivePlanning } from "./archive-planning-BwEhu9Oq.js";
-import { a as stepSkipped, i as stepOk, n as init_types, r as stepFailed } from "./types-DjpLVpsj.js";
-import { t as closeIssue } from "./close-issue-J0_eWYT1.js";
-import { t as teardownWorkspace } from "./teardown-workspace-CYend-KY.js";
-import { a as deepWipe, i as closeOut, n as cancelIssueWorkflow, o as resetToTodo, r as close, t as approve } from "./workflows-BYwR2aIN.js";
+import { a as stepSkipped, i as stepOk, n as init_types, r as stepFailed } from "./types-fzBp9cYi.js";
+import { t as archivePlanning } from "./archive-planning-CGkU6UeL.js";
+import { t as closeIssue } from "./close-issue-CxvRD0UI.js";
+import { t as teardownWorkspace } from "./teardown-workspace-cJea1OLo.js";
+import { a as deepWipe, i as closeOut, n as cancelIssueWorkflow, o as resetToTodo, r as close, t as approve } from "./workflows-AgFul1xc.js";
 //#region ../../lib/lifecycle/index.ts
 init_types();
 //#endregion
 export { approve, archivePlanning, cancelIssueWorkflow, close, closeIssue, closeOut, deepWipe, resetToTodo, stepFailed, stepOk, stepSkipped, teardownWorkspace };
 
-//# sourceMappingURL=lifecycle-B0rL38D3.js.map
+//# sourceMappingURL=lifecycle-DaCovZwn.js.map

package/server/{lifecycle-io-CCBpRv5m.js → lifecycle-io-6WL46dsB.js}

@@ -1,8 +1,8 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { Dt as queueAutoCommit, I as appendSessionEntrySync, P as appendFeedbackEntrySync, Tt as init_auto_commit, V as clearRecordFeedbackSync, Y as init_record, Yr as FsError, nt as readRecordContinueViewSync, oi as init_errors, wt as flushAutoCommits } from "./config-yaml-BwOEANMr.js";
-import { a as generateXBriefFilename, c as parseXBriefFilename, i as ensureXBriefDirsSync, l as resolveXBriefDir, n as LEGACY_VBRIEF_LIFECYCLE_DIRS, o as init_lifecycle, u as slugify } from "./lifecycle-Bg44O-9x.js";
-import { A as init_xbrief_index, C as init_specs, N as getProjectPanPaths, _ as serializeXBriefDocument, f as readPlanSync, j as invalidateXBriefIndex, s as init_io, u as normalizeXBriefEnvelope } from "./io-DfvO2xyh.js";
-import { t as init_pan_dir } from "./pan-dir-DDd91kMb.js";
+import { Dt as queueAutoCommit, I as appendSessionEntrySync, P as appendFeedbackEntrySync, Tt as init_auto_commit, V as clearRecordFeedbackSync, Y as init_record, Zr as FsError, ci as init_errors, nt as readRecordContinueViewSync, wt as flushAutoCommits } from "./config-yaml-D9nfpEx1.js";
+import { a as generateXBriefFilename, c as parseXBriefFilename, i as ensureXBriefDirsSync, l as resolveXBriefDir, n as LEGACY_VBRIEF_LIFECYCLE_DIRS, o as init_lifecycle, u as slugify } from "./lifecycle-0NOEzomy.js";
+import { A as init_xbrief_index, C as init_specs, N as getProjectPanPaths, _ as serializeXBriefDocument, f as readPlanSync, j as invalidateXBriefIndex, s as init_io, u as normalizeXBriefEnvelope } from "./io-DKrWd3gX.js";
+import { t as init_pan_dir } from "./pan-dir-BMda7tQj.js";
 import { Effect } from "effect";
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, unlinkSync, writeFileSync } from "fs";
 import { basename, join } from "path";
@@ -264,4 +264,4 @@ var init_lifecycle_io = __esmMin((() => {
 //#endregion
 export { init_lifecycle_io as a, updatePlanStatus as c, findXBriefByIssueSync as i, appendFeedbackEntryForIssue as n, readContinueStateForIssue as o, clearFeedbackForIssue as r, transitionXBriefOnMain as s, appendContinueSessionEntryForIssue as t };
 
-//# sourceMappingURL=lifecycle-io-CCBpRv5m.js.map
+//# sourceMappingURL=lifecycle-io-6WL46dsB.js.map

package/server/{lifecycle-io-DQDU0apV.js → lifecycle-io-BBMTaP7S.js}

@@ -1,3 +1,3 @@
-import { a as init_lifecycle_io, s as transitionXBriefOnMain } from "./lifecycle-io-CCBpRv5m.js";
+import { a as init_lifecycle_io, s as transitionXBriefOnMain } from "./lifecycle-io-6WL46dsB.js";
 init_lifecycle_io();
 export { transitionXBriefOnMain };

package/server/{linear-client-B0cIkTs4.js → linear-client-7fQThJTc.js}

@@ -1,5 +1,5 @@
-import { a as init_tracker_config, n as getLinearApiKey } from "./tracker-config-DVzhaUxO.js";
-import { a as RateLimited, c as TrackerNotConfigured, r as IssueNotFound, s as TrackerApiError } from "./typed-errors-DzC4zXbI.js";
+import { a as init_tracker_config, n as getLinearApiKey } from "./tracker-config-CJzPhSHv.js";
+import { a as RateLimited, c as TrackerNotConfigured, r as IssueNotFound, s as TrackerApiError } from "./typed-errors-DXqf3RnP.js";
 import { Context, Duration, Effect, Layer, Schedule } from "effect";
 import { LinearClient } from "@linear/sdk";
 //#region services/linear-client.ts
@@ -195,4 +195,4 @@ const LinearClientOptionalLive = Layer.effect(LinearClient$1, Effect.succeed({
 //#endregion
 export { LinearClientLive as n, LinearClientOptionalLive as r, LinearClient$1 as t };
 
-//# sourceMappingURL=linear-client-B0cIkTs4.js.map
+//# sourceMappingURL=linear-client-7fQThJTc.js.map

package/server/{linear-client-6V2E-DSa.js → linear-client-BTGApNLo.js}

@@ -1,2 +1,2 @@
-import { n as LinearClientLive, r as LinearClientOptionalLive, t as LinearClient } from "./linear-client-B0cIkTs4.js";
+import { n as LinearClientLive, r as LinearClientOptionalLive, t as LinearClient } from "./linear-client-7fQThJTc.js";
 export { LinearClient, LinearClientLive, LinearClientOptionalLive };

package/server/{linear-mcp-auth-LCo9AWUd.js → linear-mcp-auth-B8pYRsiU.js}

@@ -1,2 +1,2 @@
-import { l as processLinearMcpAuthWake } from "./linear-mcp-auth-Dsu9Io9r.js";
+import { l as processLinearMcpAuthWake } from "./linear-mcp-auth-Nk5s3L9M.js";
 export { processLinearMcpAuthWake };