@overdeck/desktop 0.45.24 → 0.46.0

package/server/{teardown-workspace-DeTTImn-.js → teardown-workspace-l2F4_zim.js}

@@ -1,10 +1,10 @@
-import { Vr as init_paths, hr as AGENTS_DIR } from "./config-yaml-DySPNmKN.js";
-import { D as killSession, H as sessionExists, M as listSessionNames, w as init_tmux } from "./tmux-R7N7y-Mh.js";
-import { n as getContainersReferencingWorkspacePath, r as init_workspace_manager } from "./workspace-manager-CBhNdzE4.js";
-import { r as init_devcontainer_renderer, t as DEVCONTAINER_DIRNAME } from "./devcontainer-renderer-_d6XhyND.js";
-import { a as pidsWithCwdUnder } from "./agent-gc-CHcnvonI.js";
-import { i as findWorkspacePath, o as init_archive_planning, r as findAllWorkspacePaths } from "./archive-planning-Du25Jtst.js";
-import { a as stepSkipped, i as stepOk, n as init_types, r as stepFailed } from "./types-5M0lupud.js";
+import { Ir as AGENTS_DIR, ci as init_paths } from "./config-yaml-CmOPzmBb.js";
+import { D as killSession, H as sessionExists, M as listSessionNames, w as init_tmux } from "./tmux-B1Wbxz5o.js";
+import { n as getContainersReferencingWorkspacePath, r as init_workspace_manager } from "./workspace-manager-CwO-Hek7.js";
+import { r as init_devcontainer_renderer, t as DEVCONTAINER_DIRNAME } from "./devcontainer-renderer-68CSCRnu.js";
+import { a as pidsWithCwdUnder } from "./agent-gc-CBULruzm.js";
+import { i as findWorkspacePath, r as findAllWorkspacePaths } from "./archive-planning-C0lAbNB_.js";
+import { a as stepSkipped, i as stepOk, n as init_types, r as stepFailed } from "./types-q67TYYg5.js";
 import { Effect } from "effect";
 import { existsSync } from "fs";
 import { basename, join } from "path";
@@ -26,7 +26,6 @@ import { promisify } from "util";
 init_paths();
 init_tmux();
 init_types();
-init_archive_planning();
 init_workspace_manager();
 init_devcontainer_renderer();
 const execAsync = promisify(exec);
@@ -84,7 +83,7 @@ async function stopTldrDaemonImpl(workspacePath) {
 	const venvPath = join(workspacePath, ".venv");
 	if (!existsSync(venvPath)) return stepSkipped(step, ["No .venv found"]);
 	try {
-		const { getTldrDaemonServiceSync } = await import("./tldr-daemon-BYFkts95.js");
+		const { getTldrDaemonServiceSync } = await import("./tldr-daemon-BKOYB616.js");
 		await getTldrDaemonServiceSync(workspacePath, venvPath).stop();
 		return stepOk(step, ["Stopped TLDR daemon"]);
 	} catch {
@@ -103,7 +102,7 @@ function stopDocker(workspacePath, issueLower) {
 async function stopDockerImpl(workspacePath, issueLower) {
 	const step = "teardown:docker";
 	try {
-		const { stopWorkspaceDocker } = await import("./workspace-manager-CWT55qeI.js");
+		const { stopWorkspaceDocker } = await import("./workspace-manager-CDTKjjdU.js");
 		await Effect.runPromise(stopWorkspaceDocker(workspacePath, issueLower));
 		return stepOk(step, ["Stopped Docker containers"]);
 	} catch {
@@ -407,7 +406,7 @@ function clearShadowState(issueId) {
 async function clearShadowStateImpl(issueId) {
 	const step = "teardown:shadow-state";
 	try {
-		const { removeShadowState } = await import("./shadow-state-DnDyjujH.js");
+		const { removeShadowState } = await import("./shadow-state-FV6PHfEW.js");
 		if (removeShadowState(issueId).success) return stepOk(step, [`Cleared shadow state for ${issueId}`]);
 		return stepSkipped(step, ["No shadow state found"]);
 	} catch {
@@ -457,7 +456,7 @@ function buildPlaceholders(ctx, opts, workspacePath) {
 function removeTunnelConfig(tunnelConfig, placeholders) {
 	return Effect.tryPromise({
 		try: async () => {
-			const { removeTunnelIngress } = await import("./tunnel-DGdUkGoZ.js");
+			const { removeTunnelIngress } = await import("./tunnel-CjSnHdTc.js");
 			return stepOk("teardown:tunnel", (await Effect.runPromise(removeTunnelIngress(tunnelConfig, placeholders))).steps || ["Removed tunnel ingress"]);
 		},
 		catch: (err) => err
@@ -469,7 +468,7 @@ function removeTunnelConfig(tunnelConfig, placeholders) {
 function removeHumeEviConfig(humeConfig, placeholders) {
 	return Effect.tryPromise({
 		try: async () => {
-			const { deleteHumeConfig } = await import("./hume-ccTf4wTX.js");
+			const { deleteHumeConfig } = await import("./hume-Dq--7rOQ.js");
 			return stepOk("teardown:hume", (await Effect.runPromise(deleteHumeConfig(humeConfig, placeholders))).steps || ["Removed Hume EVI config"]);
 		},
 		catch: (err) => err
@@ -514,7 +513,7 @@ function pruneSpecialistRegistry(issueId) {
 	return Effect.tryPromise({
 		try: async () => {
 			const step = "teardown:specialist-registry";
-			const { pruneSpecialistRegistryEntriesForIssue } = await import("./specialists-DM6bWjsi.js");
+			const { pruneSpecialistRegistryEntriesForIssue } = await import("./specialists-Tdezg_6N.js");
 			const removed = pruneSpecialistRegistryEntriesForIssue(issueId);
 			return removed > 0 ? stepOk(step, [`Pruned ${removed} specialist registry entr${removed === 1 ? "y" : "ies"} for ${issueId}`]) : stepSkipped(step, [`No specialist registry entries for ${issueId}`]);
 		},
@@ -525,7 +524,7 @@ function pruneCheckpointRefs(projectPath, issueLower) {
 	return Effect.tryPromise({
 		try: async () => {
 			const step = "teardown:checkpoint-refs";
-			const { pruneCheckpointRefsForAgents } = await import("./checkpoint-manager-DwbQoqrC.js");
+			const { pruneCheckpointRefsForAgents } = await import("./checkpoint-manager-Dxh0FYsv.js");
 			const agentIds = [
 				`agent-${issueLower}`,
 				`planning-${issueLower}`,
@@ -539,4 +538,4 @@ function pruneCheckpointRefs(projectPath, issueLower) {
 //#endregion
 export { teardownWorkspace as t };
 
-//# sourceMappingURL=teardown-workspace-DeTTImn-.js.map
+//# sourceMappingURL=teardown-workspace-l2F4_zim.js.map

package/server/{test-agent-queue-MbxX5vqq.js → test-agent-queue-qakFIIGz.js}

@@ -1,8 +1,8 @@
-import { Tn as init_projects, zn as resolveProjectFromIssueSync } from "./config-yaml-DySPNmKN.js";
-import { b as setReviewStatusSync, l as init_review_status } from "./review-status-kZj_KyCk.js";
-import { b as init_agents, ut as spawnRun } from "./queries-CjNIf-Ub.js";
-import { n as shouldSkipDispatchAsMerged, t as init_merge_verification } from "./merge-verification-BkaOqPsw.js";
-import { r as init_test_verdict, t as clearTestVerdictArtifact } from "./test-verdict-bWYBtqBg.js";
+import { Gn as init_projects, ar as resolveProjectFromIssueSync } from "./config-yaml-CmOPzmBb.js";
+import { S as setReviewStatusSync, f as init_review_status } from "./review-status-yljtTd-q.js";
+import { b as init_agents, dt as spawnRun } from "./queries-DHJm7bTd.js";
+import { n as init_merge_verification, r as shouldSkipDispatchAsMerged } from "./merge-verification-x3JO8Dtz.js";
+import { r as init_test_verdict, t as clearTestVerdictArtifact } from "./test-verdict-BJYDggMm.js";
 import { Data, Effect } from "effect";
 //#region ../../lib/cloister/test-agent-queue.ts
 /**
@@ -163,4 +163,4 @@ const dispatchTestAgentAndNotify = (issueId, workspace, branch, notifyAgent) =>
 //#endregion
 export { buildTestRolePrompt, dispatchTestAgentAndNotify };
 
-//# sourceMappingURL=test-agent-queue-MbxX5vqq.js.map
+//# sourceMappingURL=test-agent-queue-qakFIIGz.js.map

package/server/{test-verdict-bWYBtqBg.js → test-verdict-BJYDggMm.js}

@@ -102,4 +102,4 @@ var init_test_verdict = __esmMin((() => {}));
 //#endregion
 export { testVerdictArtifactPath as a, readTestVerdictArtifact as i, decideUnsignaledTestAction as n, init_test_verdict as r, clearTestVerdictArtifact as t };
 
-//# sourceMappingURL=test-verdict-bWYBtqBg.js.map
+//# sourceMappingURL=test-verdict-BJYDggMm.js.map

package/server/{test-verdict-gscuksPv.js → test-verdict-Gw-btEfb.js}

@@ -1,3 +1,3 @@
-import { i as readTestVerdictArtifact, r as init_test_verdict } from "./test-verdict-bWYBtqBg.js";
+import { i as readTestVerdictArtifact, r as init_test_verdict } from "./test-verdict-BJYDggMm.js";
 init_test_verdict();
 export { readTestVerdictArtifact };

package/server/{tldr-daemon-BYFkts95.js → tldr-daemon-BKOYB616.js}

@@ -1,3 +1,3 @@
-import { n as getTldrDaemonServiceSync, r as init_tldr_daemon } from "./tldr-daemon-C-69c3OI.js";
+import { n as getTldrDaemonServiceSync, r as init_tldr_daemon } from "./tldr-daemon-CBaWkV9k.js";
 init_tldr_daemon();
 export { getTldrDaemonServiceSync };

package/server/{tldr-daemon-C-69c3OI.js → tldr-daemon-CBaWkV9k.js}

@@ -1,5 +1,5 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { mr as init_errors } from "./config-yaml-DySPNmKN.js";
+import { Fr as init_errors } from "./config-yaml-CmOPzmBb.js";
 import "effect";
 import { existsSync, readFileSync, statSync } from "fs";
 import { join } from "path";
@@ -221,4 +221,4 @@ var init_tldr_daemon = __esmMin((() => {
 //#endregion
 export { getTldrDaemonServiceSync as n, init_tldr_daemon as r, TldrDaemonService as t };
 
-//# sourceMappingURL=tldr-daemon-C-69c3OI.js.map
+//# sourceMappingURL=tldr-daemon-CBaWkV9k.js.map

package/server/{tmux-R7N7y-Mh.js → tmux-B1Wbxz5o.js}

@@ -1,5 +1,5 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { Br as getOverdeckHome, Vr as init_paths, dr as TmuxError, f as loadConfigSync, mr as init_errors, t as init_config_yaml } from "./config-yaml-DySPNmKN.js";
+import { Fr as init_errors, Mr as TmuxError, ci as init_paths, f as loadConfigSync, si as getOverdeckHome, t as init_config_yaml } from "./config-yaml-CmOPzmBb.js";
 import { Effect } from "effect";
 import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
 import { join } from "path";
@@ -1250,6 +1250,6 @@ var init_tmux = __esmMin((() => {
 	getAgentSessions = () => listSessions().pipe(Effect.map((sessions) => sessions.filter((s) => s.name.startsWith("agent-"))));
 }));
 //#endregion
-export { init_child_env as $, listPaneValues as A, sendKeysAsync as B, getWindowDimensions as C, killSession as D, isPaneDead as E, parseTmuxPaneRecords as F, paneTreeHasHarnessProcess as G, sessionExists as H, querySessionSync as I, init_ui_theme as J, colorFgBgForTheme as K, resizeWindow as L, listSessionNames as M, listSessions as N, killSessionSync as O, listSessionsSync as P, buildChildEnvWithoutTmuxSync as Q, sendEscapeKeyAsync as R, getTmuxConfigMode as S, isHarnessProcessAlive as T, sessionExistsSync as U, sendRawKeystroke as V, setOption as W, BLANKED_PROVIDER_ENV as X, setUiTheme as Y, buildChildEnvSync as Z, getAgentSessions as _, capturePaneSync as a, getTmuxBaseArgs as b, createSessionSync as c, ensureManagedTmuxContextOnce as d, ensureOverdeckTmuxServerAsync as f, findManagedServerPidSync as g, exactSession as h, capturePane as i, listPaneValuesSync as j, listAllPaneRecords as k, deliveryVerifyLine as l, exactPaneTarget as m, buildTmuxArgs as n, capturePaneText as o, ensureOverdeckTmuxServerSync as p, getUiThemeSync as q, buildTmuxCommandString as r, createSession as s, MessageDeliveryFailed as t, detectTerminalApiErrorSync as u, getManagedTmuxConfigPath as v, init_tmux as w, getTmuxCommand as x, getManagedTmuxSocketName as y, sendKeys as z };
+export { buildChildEnvSync as $, listPaneValues as A, sendKeysAsync as B, getWindowDimensions as C, killSession as D, isPaneDead as E, parseTmuxPaneRecords as F, tmuxExecAsync as G, sessionExists as H, querySessionSync as I, colorFgBgForTheme as J, validateSessionName as K, resizeWindow as L, listSessionNames as M, listSessions as N, killSessionSync as O, listSessionsSync as P, BLANKED_PROVIDER_ENV as Q, sendEscapeKeyAsync as R, getTmuxConfigMode as S, isHarnessProcessAlive as T, sessionExistsSync as U, sendRawKeystroke as V, setOption as W, init_ui_theme as X, getUiThemeSync as Y, setUiTheme as Z, getAgentSessions as _, capturePaneSync as a, getTmuxBaseArgs as b, createSessionSync as c, ensureManagedTmuxContextOnce as d, buildChildEnvWithoutTmuxSync as et, ensureOverdeckTmuxServerAsync as f, findManagedServerPidSync as g, exactSession as h, capturePane as i, listPaneValuesSync as j, listAllPaneRecords as k, deliveryVerifyLine as l, exactPaneTarget as m, buildTmuxArgs as n, capturePaneText as o, ensureOverdeckTmuxServerSync as p, paneTreeHasHarnessProcess as q, buildTmuxCommandString as r, createSession as s, MessageDeliveryFailed as t, init_child_env as tt, detectTerminalApiErrorSync as u, getManagedTmuxConfigPath as v, init_tmux as w, getTmuxCommand as x, getManagedTmuxSocketName as y, sendKeys as z };
 
-//# sourceMappingURL=tmux-R7N7y-Mh.js.map
+//# sourceMappingURL=tmux-B1Wbxz5o.js.map

package/server/{tmux-B6z7h_vZ.js → tmux-DQ6jB76i.js}

@@ -1,3 +1,3 @@
-import { D as killSession, E as isPaneDead, H as sessionExists, M as listSessionNames, k as listAllPaneRecords, w as init_tmux } from "./tmux-R7N7y-Mh.js";
+import { D as killSession, E as isPaneDead, H as sessionExists, M as listSessionNames, k as listAllPaneRecords, w as init_tmux } from "./tmux-B1Wbxz5o.js";
 init_tmux();
 export { isPaneDead, killSession, listAllPaneRecords, listSessionNames, sessionExists };

package/server/{launcher-generator-BBWG_SiS.js → tmux-dedup-DbN6MGzM.js}

@@ -1,11 +1,15 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { Br as getOverdeckHome, H as init_providers, Ur as packageRoot, Vr as init_paths, W as qualifyPiModel } from "./config-yaml-DySPNmKN.js";
-import { J as init_ui_theme, K as colorFgBgForTheme, q as getUiThemeSync } from "./tmux-R7N7y-Mh.js";
-import { o as getHarnessBehavior } from "./src-DtcUOZCq.js";
-import { t as init_behavior } from "./behavior-B3exJ42O.js";
-import { f as toCodexSandboxValue, l as init_codex } from "./codex-BZXGhUVB.js";
+import { H as init_providers, W as qualifyPiModel, ci as init_paths, si as getOverdeckHome, ui as packageRoot } from "./config-yaml-CmOPzmBb.js";
+import { G as tmuxExecAsync, J as colorFgBgForTheme, K as validateSessionName, X as init_ui_theme, Y as getUiThemeSync, w as init_tmux } from "./tmux-B1Wbxz5o.js";
+import { s as getHarnessBehavior } from "./src-CRmCHlma.js";
+import { t as init_behavior } from "./behavior-CfIg6pKp.js";
+import { f as toCodexSandboxValue, l as init_codex } from "./codex-Drlf5Xhf.js";
 import { dirname, join } from "node:path";
 import { Data } from "effect";
+import { join as join$1 } from "path";
+import { tmpdir } from "os";
+import { unlink, writeFile } from "fs/promises";
+import { randomUUID } from "node:crypto";
 //#region ../../lib/model-validation.ts
 function normalizeModelOverrideSync(value) {
 	if (value === void 0 || value === null) return void 0;
@@ -73,10 +77,35 @@ function buildGitGuardLines(agentId) {
 		"}",
 		"_overdeck_git_command=\"\\$(_overdeck_git_find_command \"\\$@\")\"",
 		"case \"\\$_overdeck_git_command\" in",
-		"  rebase|stash)",
-		"    echo \"Overdeck agents must not run git \\$_overdeck_git_command directly. Use pan sync-main to sync main or pan done to submit.\" >&2",
+		"  rebase)",
+		"    echo \"Overdeck agents must not run git rebase directly. Use pan sync-main to sync main or pan done to submit.\" >&2",
 		"    exit 1",
 		"    ;;",
+		"  stash)",
+		"    _overdeck_stash_sub=\"\"",
+		"    _overdeck_after_stash=0",
+		"    for _overdeck_git_arg in \"\\$@\"; do",
+		"      if [ \"\\$_overdeck_after_stash\" = \"1\" ]; then",
+		"        case \"\\$_overdeck_git_arg\" in",
+		"          -*) ;;",
+		"          *)",
+		"            _overdeck_stash_sub=\"\\$_overdeck_git_arg\"",
+		"            break",
+		"            ;;",
+		"        esac",
+		"      elif [ \"\\$_overdeck_git_arg\" = \"stash\" ]; then",
+		"        _overdeck_after_stash=1",
+		"      fi",
+		"    done",
+		"    case \"\\$_overdeck_stash_sub\" in",
+		"      list|show)",
+		"        ;;",
+		"      *)",
+		"        echo \"Overdeck agents must not run git stash directly (read-only stash list/show are allowed). Use pan sync-main to sync main or pan done to submit.\" >&2",
+		"        exit 1",
+		"        ;;",
+		"    esac",
+		"    ;;",
 		"  reset)",
 		"    for _overdeck_git_arg in \"\\$@\"; do",
 		"      if [ \"\\$_overdeck_git_arg\" = \"--hard\" ]; then",
@@ -468,6 +497,396 @@ var init_launcher_generator = __esmMin((() => {
 	];
 }));
 //#endregion
-export { normalizeModelOverrideSync as a, init_model_validation as i, init_launcher_generator as n, requireModelOverrideSync as o, MODEL_ID_PATTERN as r, shellQuoteModelIdSync as s, generateLauncherScriptSync as t };
+//#region ../../lib/tmux-dedup.ts
+/**
+* Keyed, crash-safe tmux delivery (PAN-2997).
+*
+* The dashboard cannot dedupe a tmux paste from its own state — a crash
+* between the paste and the dashboard's acknowledgment bookkeeping would make
+* recovery re-paste. The dedup record therefore lives in the
+* crash-independent component: per-session tmux user options. All
+* check/paste/mark sequences that must not be interrupted are issued as ONE
+* `if-shell` command list, which the tmux SERVER executes — a dashboard exit
+* cannot interrupt it, and a tmux-server exit kills the agent session itself,
+* so a replay after either crash is correct.
+*
+* The protocol is two-phase so the complete paste-settle-submit transaction
+* survives a dashboard crash: the key becomes terminal only as part of the
+* server-owned submission itself.
+*
+*   (none) ──paste──► PENDING ──atomic claim+Enter──► TERMINAL
+*
+* - `sendKeysDedup` atomically pastes and sets the PENDING option only when
+*   neither option is set. A replay that finds PENDING (a prior attempt
+*   crashed before submitting) returns 'submit-pending' WITHOUT re-pasting.
+*   A POISON breadcrumb (a terminal marker that proved false but could not be
+*   rolled back) is repaired first and never honored as a dedup.
+* - `completeKeyedSubmit` issues ONE `if-shell`: only when PENDING is
+*   present, TERMINAL absent, and the pane alive does the tmux server send
+*   the Enter and then flip TERMINAL and clear PENDING — in that order, in a
+*   single server-executed command list. After the command the target is
+*   re-read: if the pane died, was replaced, or cannot be identified around
+*   the Enter, the terminal marker is rolled back under a poison breadcrumb
+*   and the pending claim restored. Exactly one caller can become the
+*   completer; every other concurrent or post-crash caller loses the
+*   server-side condition and sends nothing, so no stray Enter can ever land
+*   in a composer holding unrelated text.
+*/
+/** Set once the keyed message has been SUBMITTED (Enter sent). */
+function dedupTerminalOptionName(dedupKey) {
+	return `@overdeck-dedup-${dedupKey}`;
+}
+/** Set atomically with the paste; cleared when the terminal marker lands. */
+function dedupPendingOptionName(dedupKey) {
+	return `@overdeck-dedup-pending-${dedupKey}`;
+}
+/**
+* Rollback-required breadcrumb (cycle 11). Set when a post-submit check
+* proves a terminal marker FALSE but the rollback could not be verified.
+* While this marker exists the terminal marker must never be honored — the
+* next keyed call repairs the markers before anything else.
+*/
+function dedupPoisonOptionName(dedupKey) {
+	return `@overdeck-dedup-poison-${dedupKey}`;
+}
+/**
+* The pane_pid of the pane that received the keyed paste (cycle 13). Set
+* atomically with the paste (`set-option -F ... '#{pane_pid}'`) and required
+* by the submit condition: recovery may complete an old pending claim with
+* Enter alone ONLY when the current pane IS the pane that holds the pasted
+* content. A replaced pane gets a real re-paste instead.
+*/
+function dedupTargetOptionName(dedupKey) {
+	return `@overdeck-dedup-target-${dedupKey}`;
+}
+function assertValidDedupKey(dedupKey) {
+	if (!DEDUP_KEY_RE.test(dedupKey)) throw new Error(`dedupKey must match [A-Za-z0-9:_-]+, got: ${dedupKey.slice(0, 40)}`);
+}
+/** pane_pid + pane_dead in one read — the identity of the Enter's target. */
+async function readPaneTarget(sessionName) {
+	return tmuxExecAsync([
+		"display-message",
+		"-p",
+		"-t",
+		sessionName,
+		"#{pane_pid} #{pane_dead}"
+	], { encoding: "utf-8" }).then((result) => {
+		const [pid = "", dead = ""] = String(result.stdout).trim().split(/\s+/);
+		return {
+			pid,
+			dead: dead === "1"
+		};
+	}).catch(() => ({
+		pid: "",
+		dead: true
+	}));
+}
+async function readMarker(sessionName, option) {
+	return tmuxExecAsync([
+		"show-option",
+		"-qv",
+		"-t",
+		sessionName,
+		option
+	], { encoding: "utf-8" }).then((result) => String(result.stdout).trim(), () => "");
+}
+/**
+* Fail-CLOSED marker read (cycle 12): `-q` makes an unset user option a clean
+* empty read, so a rejection is always a REAL failure (missing session,
+* unreachable server). Safety-critical markers (the poison breadcrumb) must
+* be read this way — interpreting a failed read as "absent" could honor a
+* false terminal marker or bypass a rollback-required state.
+*/
+async function readMarkerStrict(sessionName, option) {
+	const result = await tmuxExecAsync([
+		"show-option",
+		"-qv",
+		"-t",
+		sessionName,
+		option
+	], { encoding: "utf-8" });
+	return String(result.stdout).trim();
+}
+/**
+* Clear the poison breadcrumb and VERIFY it is gone with a strict read.
+* EVERY failure here — the clear command, the verification read, or a
+* surviving breadcrumb — is a recoverable KeyedMarkerVerificationError
+* (cycle 14): a repair that stops at this boundary has delivered nothing,
+* so the wake outbox must stay pending, never terminal 'failed'.
+*/
+async function clearPoisonVerified(sessionName, poisonOption, context, readStrict = readMarkerStrict) {
+	try {
+		await tmuxExecAsync([
+			"set-option",
+			"-u",
+			"-t",
+			sessionName,
+			poisonOption
+		], { encoding: "utf-8" });
+	} catch (error) {
+		throw new KeyedMarkerVerificationError(sessionName, `poison clear command failed (${context})`, { cause: error });
+	}
+	let remaining;
+	try {
+		remaining = await readStrict(sessionName, poisonOption);
+	} catch (error) {
+		throw new KeyedMarkerVerificationError(sessionName, `post-clear verification read failed (${context})`, { cause: error });
+	}
+	if (remaining !== "") throw new KeyedMarkerVerificationError(sessionName, `poison breadcrumb survived the clear (${context})`);
+}
+/**
+* Repair a poisoned marker set (cycle 11/12): clear the terminal marker,
+* restore a pending claim, verify both, then clear the breadcrumb — verified.
+* A poisoned terminal is PROVISIONAL: it may be a false claim (rollback was
+* interrupted) or a delivered-but-unverified one, and the tmux tier cannot
+* distinguish them — so repair always rolls back to pending and lets the
+* normal recovery re-drive. An empty Enter on the (already-submitted, live)
+* composer is the worst case; a suppressed wake is never acceptable.
+*
+* Returns normally only when the breadcrumb is verifiably gone; throws
+* otherwise (the caller must NOT submit while a stale breadcrumb survives —
+* a later replay would invalidate a legitimate terminal and re-submit).
+*/
+async function repairPoisonedMarkers(sessionName, dedupKey, sendId, readStrict) {
+	const terminalOption = dedupTerminalOptionName(dedupKey);
+	const pendingOption = dedupPendingOptionName(dedupKey);
+	const poisonOption = dedupPoisonOptionName(dedupKey);
+	await tmuxExecAsync([
+		"set-option",
+		"-u",
+		"-t",
+		sessionName,
+		terminalOption,
+		";",
+		"set-option",
+		"-t",
+		sessionName,
+		pendingOption,
+		sendId
+	], { encoding: "utf-8" });
+	let repairedTerminal;
+	let repairedPending;
+	try {
+		[repairedTerminal, repairedPending] = await Promise.all([readStrict(sessionName, terminalOption), readStrict(sessionName, pendingOption)]);
+	} catch {
+		throw new KeyedMarkerVerificationError(sessionName, `repair verification of key "${dedupKey}"`);
+	}
+	if (repairedTerminal !== "" || repairedPending === "") throw new Error(`Keyed tmux markers for ${sessionName} are poisoned and could not be repaired (key "${dedupKey}")`);
+	await clearPoisonVerified(sessionName, poisonOption, `repair of key "${dedupKey}"`, readStrict);
+}
+/**
+* Deduplicated message paste for the tmux fallback path.
+*
+* Returns 'pasted' when this call pasted (caller must complete the submit),
+* 'submit-pending' when a prior attempt's paste is still awaiting submission
+* (caller must complete the submit — crucially WITHOUT pasting again), and
+* 'deduplicated' when the key is already terminal (caller does nothing; no
+* stray Enter, because the composer may hold unrelated operator text).
+*
+* Throws when the keyed paste did not land and no marker explains why —
+* silent loss must surface as a delivery failure, not as a false dedup.
+*/
+async function sendKeysDedup(sessionName, keys, dedupKey, caller, deps = {}) {
+	validateSessionName(sessionName);
+	assertValidDedupKey(dedupKey);
+	const read = deps.readMarker ?? readMarker;
+	const readStrict = deps.readMarkerStrict ?? readMarkerStrict;
+	const terminalOption = dedupTerminalOptionName(dedupKey);
+	const pendingOption = dedupPendingOptionName(dedupKey);
+	const poisonOption = dedupPoisonOptionName(dedupKey);
+	const sendId = randomUUID();
+	let poisonMarker;
+	try {
+		poisonMarker = await readStrict(sessionName, poisonOption);
+	} catch (error) {
+		throw new KeyedMarkerVerificationError(sessionName, `initial poison read (key "${dedupKey}")`, { cause: error });
+	}
+	const repaired = poisonMarker !== "";
+	if (repaired) await repairPoisonedMarkers(sessionName, dedupKey, sendId, readStrict);
+	const targetOption = dedupTargetOptionName(dedupKey);
+	const tmpFile = join$1(tmpdir(), `pan-sendkeys-${sendId}.txt`);
+	const bufferName = `pan-${sendId}`;
+	try {
+		await writeFile(tmpFile, keys, "utf-8");
+		await tmuxExecAsync([
+			"load-buffer",
+			"-b",
+			bufferName,
+			tmpFile
+		], { encoding: "utf-8" });
+		if (!repaired) await tmuxExecAsync([
+			"if-shell",
+			"-t",
+			sessionName,
+			`test -z "$(tmux show-option -qv -t ${sessionName} ${pendingOption})" && test -z "$(tmux show-option -qv -t ${sessionName} ${terminalOption})"`,
+			`paste-buffer -b ${bufferName} -p -t ${sessionName} \; set-option -t ${sessionName} ${pendingOption} ${sendId} \; set-option -F -t ${sessionName} ${targetOption} '#{pane_pid}'`
+		], { encoding: "utf-8" });
+		const [pendingMarker, terminalMarker] = await Promise.all([read(sessionName, pendingOption), read(sessionName, terminalOption)]);
+		if (terminalMarker !== "") return "deduplicated";
+		if (!repaired && pendingMarker === sendId) return "pasted";
+		if (pendingMarker !== "") {
+			const recordedTarget = await read(sessionName, targetOption);
+			const currentPid = (await (deps.readPaneTarget ?? readPaneTarget)(sessionName)).pid;
+			if (recordedTarget !== "" && currentPid !== "" && recordedTarget === currentPid) return "submit-pending";
+			await tmuxExecAsync([
+				"if-shell",
+				"-t",
+				sessionName,
+				`test -n "$(tmux show-option -qv -t ${sessionName} ${pendingOption})" && test -z "$(tmux show-option -qv -t ${sessionName} ${terminalOption})" && ! test "$(tmux display-message -p -t ${sessionName} '#{pane_pid}')" = "$(tmux show-option -qv -t ${sessionName} ${targetOption})"`,
+				`paste-buffer -b ${bufferName} -p -t ${sessionName} \; set-option -t ${sessionName} ${pendingOption} ${sendId} \; set-option -F -t ${sessionName} ${targetOption} '#{pane_pid}'`
+			], { encoding: "utf-8" });
+			const [repastedPending, repastedTerminal, repastedTarget] = await Promise.all([
+				read(sessionName, pendingOption),
+				read(sessionName, terminalOption),
+				read(sessionName, targetOption)
+			]);
+			if (repastedTerminal !== "") return "deduplicated";
+			if (repastedPending === sendId) return "pasted";
+			if (repastedPending !== "") {
+				const nowPid = (await (deps.readPaneTarget ?? readPaneTarget)(sessionName)).pid;
+				if (repastedTarget !== "" && nowPid !== "" && repastedTarget === nowPid) return "submit-pending";
+			}
+		}
+		throw new Error(`Keyed tmux paste for ${sessionName} did not land and no dedup marker was recorded` + (caller ? ` (caller: ${caller})` : ""));
+	} finally {
+		await unlink(tmpFile).catch(() => {});
+		await tmuxExecAsync([
+			"delete-buffer",
+			"-b",
+			bufferName
+		], { encoding: "utf-8" }).catch(() => {});
+	}
+}
+/**
+* Complete the paste-settle-submit transaction for a keyed tmux delivery.
+*
+* After the settle window, the SUBMISSION is one server-owned command: a
+* single `if-shell` whose condition requires the pending claim present, the
+* terminal marker absent, AND the pane alive, and whose command list sends
+* the Enter FIRST and then sets the POISON breadcrumb and the TERMINAL
+* marker and clears pending — the terminal is PROVISIONAL from the moment it
+* exists, so a dashboard crash can never strand an honorable-but-unverified
+* terminal (cycle 12). The tmux server executes the whole sequence:
+*
+* - A pane that died during the settle window fails the liveness condition —
+*   NO marker changes and NO Enter is sent, so the wake is never recorded as
+*   delivered when it never landed. The preserved pending claim lets
+*   recovery retry after the agent resumes.
+* - The pre-branch liveness condition is NOT proof of acceptance (cycle 10):
+*   the pane can die in the shell-to-branch handoff, and tmux reports
+*   send-keys into a remain-on-exit corpse as success. So after the command
+*   the target is re-read — if the pane died, was replaced, or cannot be
+*   identified around the Enter, the terminal marker is ROLLED BACK and the
+*   pending claim restored, and KeyedSubmitTargetDeadError is thrown. The
+*   breadcrumb is lifted only after verification, and clearing it is itself
+*   verified (cycle 12): a stale breadcrumb would let a later replay
+*   invalidate a legitimate terminal and re-submit.
+* - The Enter precedes the terminal transition inside the transaction, so a
+*   failed Enter (which aborts the command list) can never leave the key
+*   terminal.
+* - Exactly one caller becomes the completer; concurrent or post-crash
+*   callers lose the server-side condition and send no stray Enter into a
+*   composer that may hold unrelated operator text.
+*
+* Safe to call for both 'pasted' and 'submit-pending' phases; a call whose
+* key is already terminal is a no-op. Throws KeyedSubmitTargetDeadError when
+* the pane is dead (pending claim preserved), and a generic error when both
+* markers vanished without a submission.
+*/
+async function completeKeyedSubmit(sessionName, dedupKey, deps = {}) {
+	validateSessionName(sessionName);
+	assertValidDedupKey(dedupKey);
+	const read = deps.readMarker ?? readMarker;
+	const readStrict = deps.readMarkerStrict ?? readMarkerStrict;
+	const readTarget = deps.readPaneTarget ?? readPaneTarget;
+	const terminalOption = dedupTerminalOptionName(dedupKey);
+	const pendingOption = dedupPendingOptionName(dedupKey);
+	const poisonOption = dedupPoisonOptionName(dedupKey);
+	const targetOption = dedupTargetOptionName(dedupKey);
+	await new Promise((resolve) => setTimeout(resolve, PASTE_SETTLE_MS));
+	const preTarget = await readTarget(sessionName);
+	const pendingBefore = await read(sessionName, pendingOption);
+	await tmuxExecAsync([
+		"if-shell",
+		"-t",
+		sessionName,
+		`test -z "$(tmux show-option -qv -t ${sessionName} ${terminalOption})" && test -n "$(tmux show-option -qv -t ${sessionName} ${pendingOption})" && test "$(tmux display-message -p -t ${sessionName} '#{pane_dead}')" = "0" && test "$(tmux display-message -p -t ${sessionName} '#{pane_pid}')" = "$(tmux show-option -qv -t ${sessionName} ${targetOption})"`,
+		`send-keys -t ${sessionName} C-m \; set-option -t ${sessionName} ${poisonOption} 1 \; set-option -t ${sessionName} ${terminalOption} 1 \; set-option -u -t ${sessionName} ${pendingOption}`
+	], { encoding: "utf-8" });
+	const [terminalAfter, pendingAfter, postTarget, recordedTarget] = await Promise.all([
+		read(sessionName, terminalOption),
+		read(sessionName, pendingOption),
+		readTarget(sessionName),
+		read(sessionName, targetOption)
+	]);
+	const targetLost = preTarget.dead || preTarget.pid === "" || postTarget.dead || postTarget.pid !== preTarget.pid;
+	if (terminalAfter !== "") {
+		if (!targetLost) {
+			await clearPoisonVerified(sessionName, poisonOption, `verified delivery of key "${dedupKey}"`, readStrict);
+			return;
+		}
+		await tmuxExecAsync(pendingBefore === "" ? [
+			"set-option",
+			"-u",
+			"-t",
+			sessionName,
+			terminalOption,
+			";",
+			"set-option",
+			"-u",
+			"-t",
+			sessionName,
+			pendingOption
+		] : [
+			"set-option",
+			"-u",
+			"-t",
+			sessionName,
+			terminalOption,
+			";",
+			"set-option",
+			"-t",
+			sessionName,
+			pendingOption,
+			pendingBefore
+		], { encoding: "utf-8" }).catch(() => {});
+		let rolledTerminal;
+		let restoredPending;
+		try {
+			[rolledTerminal, restoredPending] = await Promise.all([readStrict(sessionName, terminalOption), readStrict(sessionName, pendingOption)]);
+		} catch {
+			throw new KeyedMarkerVerificationError(sessionName, `rollback verification of key "${dedupKey}"`);
+		}
+		if (rolledTerminal === "" && restoredPending !== "") await clearPoisonVerified(sessionName, poisonOption, `verified rollback of key "${dedupKey}"`, readStrict).catch(() => {});
+		throw new KeyedSubmitTargetDeadError(sessionName, dedupKey);
+	}
+	if (pendingAfter !== "") {
+		const replaced = recordedTarget === "" || postTarget.pid === "" || recordedTarget !== postTarget.pid;
+		if (targetLost || replaced) throw new KeyedSubmitTargetDeadError(sessionName, dedupKey);
+		throw new Error(`Keyed tmux submit for ${sessionName} was rejected with the pending claim intact on a live pane`);
+	}
+	throw new Error(`Keyed tmux submit for ${sessionName} found neither a pending claim nor a terminal marker — the paste vanished without submission`);
+}
+var DEDUP_KEY_RE, PASTE_SETTLE_MS, KeyedSubmitTargetDeadError, KeyedMarkerVerificationError;
+var init_tmux_dedup = __esmMin((() => {
+	init_tmux();
+	DEDUP_KEY_RE = /^[A-Za-z0-9:_-]+$/;
+	PASTE_SETTLE_MS = 300;
+	KeyedSubmitTargetDeadError = class extends Error {
+		constructor(sessionName, dedupKey) {
+			super(`Keyed tmux submit for ${sessionName} found a dead pane — the Enter was NOT accepted by a live harness, the pending claim for key "${dedupKey}" is preserved, and the key is not terminal`);
+			this.name = "KeyedSubmitTargetDeadError";
+		}
+	};
+	KeyedMarkerVerificationError = class extends Error {
+		constructor(sessionName, context, options) {
+			const causeText = options?.cause instanceof Error ? `: ${options.cause.message}` : "";
+			super(`Keyed tmux markers for ${sessionName} could not be verified (${context})${causeText}`, options);
+			this.name = "KeyedMarkerVerificationError";
+		}
+	};
+}));
+//#endregion
+export { shellQuoteModelIdSync as _, dedupPendingOptionName as a, dedupTerminalOptionName as c, generateLauncherScriptSync as d, init_launcher_generator as f, requireModelOverrideSync as g, normalizeModelOverrideSync as h, completeKeyedSubmit as i, init_tmux_dedup as l, init_model_validation as m, KeyedSubmitTargetDeadError as n, dedupPoisonOptionName as o, MODEL_ID_PATTERN as p, assertValidDedupKey as r, dedupTargetOptionName as s, KeyedMarkerVerificationError as t, sendKeysDedup as u };
 
-//# sourceMappingURL=launcher-generator-BBWG_SiS.js.map
+//# sourceMappingURL=tmux-dedup-DbN6MGzM.js.map

package/server/{token-BK6t8BIT.js → token-Cxbk023d.js}

@@ -1,5 +1,5 @@
 import { t as __commonJSMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { r as require_token_error, t as require_token_util } from "./token-util-DxXu-vd1.js";
+import { r as require_token_error, t as require_token_util } from "./token-util-CLq2MmQt.js";
 //#region ../../../node_modules/.bun/@vercel+oidc@3.2.0/node_modules/@vercel/oidc/dist/token.js
 var require_token = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var __defProp = Object.defineProperty;
@@ -54,4 +54,4 @@ var require_token = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 export default require_token();
 export {};
 
-//# sourceMappingURL=token-BK6t8BIT.js.map
+//# sourceMappingURL=token-Cxbk023d.js.map

package/server/{token-util-DxXu-vd1.js → token-util-CLq2MmQt.js}

@@ -432,4 +432,4 @@ var require_token_util = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#endregion
 export { require_auth_errors as n, require_token_error as r, require_token_util as t };
 
-//# sourceMappingURL=token-util-DxXu-vd1.js.map
+//# sourceMappingURL=token-util-CLq2MmQt.js.map