@overdeck/desktop 0.45.24 → 0.47.0

package/server/{release-engine-Cx48W7z8.js → release-engine-B2X9AfFC.js}

@@ -1,8 +1,8 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { Tn as init_projects, fn as findProjectByPathSync, yn as getProjectSync } from "./config-yaml-DySPNmKN.js";
-import { b as setReviewStatusSync, l as init_review_status } from "./review-status-kZj_KyCk.js";
-import { i as init_merge_set, r as getMergeSetSync } from "./merge-set-DJ8-UErs.js";
-import { i as withComponentStateSync, n as init_release_set, r as upsertReleaseSetSync } from "./release-set-CQfuN9-v.js";
+import { Gn as init_projects, Mn as findProjectByPathSync, zn as getProjectSync } from "./config-yaml-CxdwhAIA.js";
+import { C as setReviewStatusSync, p as init_review_status } from "./review-status-CGvlA4o_.js";
+import { i as init_merge_set, r as getMergeSetSync } from "./merge-set-CBgHfwM0.js";
+import { i as withComponentStateSync, n as init_release_set, r as upsertReleaseSetSync } from "./release-set-G4XKyQ8K.js";
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
 //#region ../../lib/release/release-plan.ts
@@ -303,4 +303,4 @@ __esmMin((() => {
 }))();
 export { runRelease };
 
-//# sourceMappingURL=release-engine-Cx48W7z8.js.map
+//# sourceMappingURL=release-engine-B2X9AfFC.js.map

package/server/{release-set-CQfuN9-v.js → release-set-G4XKyQ8K.js}

@@ -1,6 +1,6 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { $n as resolveIssueIdSync, Yn as init_issue_id } from "./config-yaml-DySPNmKN.js";
-import { d as getOverdeckDatabaseSync, f as init_infra } from "./infra-BEqFxlJc.js";
+import { br as resolveIssueIdSync, gr as init_issue_id } from "./config-yaml-CxdwhAIA.js";
+import { d as getOverdeckDatabaseSync, f as init_infra } from "./infra-BDQDRopn.js";
 import "effect";
 //#region ../../lib/overdeck/release-sync.ts
 function isoFromMillis(value) {
@@ -122,4 +122,4 @@ var init_release_set = __esmMin((() => {
 //#endregion
 export { withComponentStateSync as i, init_release_set as n, upsertReleaseSetSync as r, getReleaseSetSync as t };
 
-//# sourceMappingURL=release-set-CQfuN9-v.js.map
+//# sourceMappingURL=release-set-G4XKyQ8K.js.map

package/server/{remote-C_2hasl7.js → remote-BXarMvqf.js}

@@ -1,5 +1,5 @@
-import "./workspace-metadata-_WygnyoX.js";
-import { C as init_fly_provider, S as createFlyProvider, s as init_remote_agents } from "./remote-agents-By1ige5O.js";
+import "./workspace-metadata-DkO_iTLo.js";
+import { C as createFlyProvider, s as init_remote_agents, w as init_fly_provider } from "./remote-agents-Bba-MgSA.js";
 import { Effect } from "effect";
 //#region ../../lib/remote/index.ts
 init_fly_provider();
@@ -52,4 +52,4 @@ function createFlyProviderFromConfig(remoteConfig, tierOverride) {
 //#endregion
 export { getRemoteProvider as n, isRemoteAvailable as r, createFlyProviderFromConfig as t };
 
-//# sourceMappingURL=remote-C_2hasl7.js.map
+//# sourceMappingURL=remote-BXarMvqf.js.map

package/server/{remote-ChgimyYa.js → remote-CUhyqjXk.js}

@@ -1,4 +1,4 @@
-import { a as loadWorkspaceMetadataSync, i as listWorkspaceMetadataSync, n as deleteWorkspaceMetadataSync, o as saveWorkspaceMetadataSync, r as findRemoteWorkspaceMetadataSync, t as WORKSPACES_DIR } from "./workspace-metadata-_WygnyoX.js";
-import { S as createFlyProvider, d as killRemoteAgent, g as refreshHostHeartbeatForEphemeralVms, h as pollRemoteAgentStatus, m as loadRemoteAgentState, o as getRemoteAgentOutput, p as listRemoteAgents, r as checkRemoteSpendCap, u as isRemoteAgentRunning, v as sendToRemoteAgent, x as FlyProvider, y as spawnRemoteAgent } from "./remote-agents-By1ige5O.js";
-import { n as getRemoteProvider, r as isRemoteAvailable, t as createFlyProviderFromConfig } from "./remote-C_2hasl7.js";
+import { a as loadWorkspaceMetadataSync, i as listWorkspaceMetadataSync, n as deleteWorkspaceMetadataSync, o as saveWorkspaceMetadataSync, r as findRemoteWorkspaceMetadataSync, t as WORKSPACES_DIR } from "./workspace-metadata-DkO_iTLo.js";
+import { C as createFlyProvider, S as FlyProvider, d as killRemoteAgent, g as refreshHostHeartbeatForEphemeralVms, h as pollRemoteAgentStatus, m as loadRemoteAgentState, o as getRemoteAgentOutput, p as listRemoteAgents, r as checkRemoteSpendCap, u as isRemoteAgentRunning, v as sendToRemoteAgent, y as spawnRemoteAgent } from "./remote-agents-Bba-MgSA.js";
+import { n as getRemoteProvider, r as isRemoteAvailable, t as createFlyProviderFromConfig } from "./remote-BXarMvqf.js";
 export { FlyProvider, WORKSPACES_DIR, checkRemoteSpendCap, createFlyProvider, createFlyProviderFromConfig, deleteWorkspaceMetadataSync, findRemoteWorkspaceMetadataSync, getRemoteAgentOutput, getRemoteProvider, isRemoteAgentRunning, isRemoteAvailable, killRemoteAgent, listRemoteAgents, listWorkspaceMetadataSync, loadRemoteAgentState, loadWorkspaceMetadataSync, pollRemoteAgentStatus, refreshHostHeartbeatForEphemeralVms, saveWorkspaceMetadataSync, sendToRemoteAgent, spawnRemoteAgent };

package/server/{remote-agents-By1ige5O.js → remote-agents-Bba-MgSA.js}

@@ -1,15 +1,16 @@
 import { n as __esmMin, o as __toESM } from "./rolldown-runtime-DNCzzKnI.js";
-import { Ft as resolveProjectForIssue, Ot as init_record, er as require_dist, mr as init_errors } from "./config-yaml-DySPNmKN.js";
-import { w as init_tmux, y as getManagedTmuxSocketName } from "./tmux-R7N7y-Mh.js";
-import { n as init_launcher_generator, t as generateLauncherScriptSync } from "./launcher-generator-BBWG_SiS.js";
-import { a as init_claude_permissions, i as getClaudePermissionFlagsSync, n as buildClaudeUserSettingsSync, r as getClaudePermissionFlagsStringSync } from "./claude-permissions-DNWEVV6z.js";
-import { c as isStateMigrated, o as init_state_home } from "./state-home-Cn_Qu8IX.js";
+import { Fr as init_errors, Pt as init_record, Vt as resolveProjectForIssue, xr as require_dist } from "./config-yaml-CxdwhAIA.js";
+import { w as init_tmux, y as getManagedTmuxSocketName } from "./tmux-CfDHob9M.js";
+import { C as init_launcher_generator, S as generateLauncherScriptSync, _ as init_tmux_dedup, b as isOperatorStartedBy, d as assertValidDedupKey, g as dedupTerminalOptionName, h as dedupTargetOptionName, i as init_auto_spawn_consent, l as KeyedMarkerVerificationError, m as dedupPoisonOptionName, p as dedupPendingOptionName, s as withAutoSpawnConsentClaim, u as KeyedSubmitTargetDeadError, y as init_provenance } from "./auto-spawn-consent-CQ9Bi9q6.js";
+import { a as init_claude_permissions, i as getClaudePermissionFlagsSync, n as buildClaudeUserSettingsSync, r as getClaudePermissionFlagsStringSync } from "./claude-permissions-CpbpvUQ2.js";
+import { c as isStateMigrated, o as init_state_home } from "./state-home-722Dkx92.js";
 import { Data, Effect, Stream } from "effect";
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
 import { exec, spawn } from "child_process";
 import { promisify } from "util";
+import { randomUUID } from "node:crypto";
 //#region ../../lib/claude-mcp.ts
 function ensurePlaywrightIsolationSync(mcpConfig) {
 	const playwright = mcpConfig?.mcpServers?.playwright;
@@ -661,6 +662,293 @@ with open(path, "w") as f:
 	};
 }));
 //#endregion
+//#region ../../lib/remote/remote-tmux.ts
+/**
+* Remote tmux/SSH plumbing for Fly-hosted agents.
+*
+* Extracted from remote-agents.ts (file-size ceiling) — the remote tmux
+* server is the crash-independent component for remote sessions, and both
+* remote-agents.ts and remote-keyed-delivery.ts build on these primitives.
+*/
+function shellQuote(value) {
+	return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function getRemoteTmuxBaseArgs() {
+	return [
+		"-L",
+		getManagedTmuxSocketName(),
+		"-f",
+		REMOTE_TMUX_CONFIG_PATH
+	];
+}
+function buildRemoteTmuxCommand(args) {
+	return [
+		"tmux",
+		...getRemoteTmuxBaseArgs(),
+		...args
+	].map(shellQuote).join(" ");
+}
+/** Run a FlyProvider Effect at the async/Promise boundary. */
+function runSsh(provider, vmName, command) {
+	return Effect.runPromise(provider.ssh(vmName, command));
+}
+async function ensureRemoteTmuxContext(provider, vmName) {
+	const configBase64 = Buffer.from(REMOTE_TMUX_CONFIG_CONTENT).toString("base64");
+	await runSsh(provider, vmName, `mkdir -p ${shellQuote(REMOTE_TMUX_DIR)} && echo ${shellQuote(configBase64)} | base64 -d > ${shellQuote(REMOTE_TMUX_CONFIG_PATH)}`);
+}
+var REMOTE_PAN_DIR, REMOTE_TMUX_DIR, REMOTE_TMUX_CONFIG_PATH, REMOTE_TMUX_CONFIG_CONTENT;
+var init_remote_tmux = __esmMin((() => {
+	init_tmux();
+	REMOTE_PAN_DIR = "/workspace/.pan";
+	REMOTE_TMUX_DIR = `${REMOTE_PAN_DIR}/tmux`;
+	REMOTE_TMUX_CONFIG_PATH = `${REMOTE_TMUX_DIR}/overdeck.tmux.conf`;
+	REMOTE_TMUX_CONFIG_CONTENT = [
+		"# Overdeck-managed tmux config",
+		"# Keep this minimal and include only behavior Overdeck intentionally depends on.",
+		"set -g mouse on",
+		""
+	].join("\n");
+}));
+//#endregion
+//#region ../../lib/remote/remote-keyed-delivery.ts
+/**
+* Keyed remote delivery (PAN-2997). The REMOTE tmux server is the
+* crash-independent component for a remote session: it survives both the
+* local dashboard and the remote agent shell, so the same two-phase
+* pending/terminal marker protocol as the local tmux tier
+* (src/lib/tmux-dedup.ts) enforces the dedup key across the complete
+* paste-settle-submit transaction — paste under an atomic pending claim, a
+* liveness-gated Enter-first submit, post-submit target verification with a
+* verified rollback under a poison breadcrumb. A local dashboard crash
+* anywhere in the sequence replays into either a completed pending
+* submission (no second paste) or a terminal-marker dedup — never a lost or
+* duplicated wake.
+*/
+async function sendToRemoteAgentKeyed(agentId, vmName, message, dedupKey, exec) {
+	assertValidDedupKey(dedupKey);
+	let run;
+	if (exec) run = exec;
+	else {
+		const fly = createFlyProvider();
+		await ensureRemoteTmuxContext(fly, vmName);
+		run = async (command) => {
+			const result = await runSsh(fly, vmName, command);
+			if (result.exitCode !== 0) throw new Error(`remote keyed-delivery command failed (exit ${result.exitCode}): ${result.stderr.slice(0, 200)}`);
+			return result.stdout;
+		};
+	}
+	const pendingOption = dedupPendingOptionName(dedupKey);
+	const terminalOption = dedupTerminalOptionName(dedupKey);
+	const poisonOption = dedupPoisonOptionName(dedupKey);
+	const sendId = randomUUID();
+	const bufferName = `pan-keyed-${sendId}`;
+	const promptFile = `${REMOTE_PAN_DIR}/prompts/${agentId}-keyed-${sendId}.txt`;
+	const innerTmux = ["tmux", ...getRemoteTmuxBaseArgs()].map(shellQuote).join(" ");
+	const cleanup = async () => {
+		await run(buildRemoteTmuxCommand([
+			"delete-buffer",
+			"-b",
+			bufferName
+		])).catch(() => "");
+		await run(`rm -f ${shellQuote(promptFile)}`).catch(() => "");
+	};
+	const readMarker = async (option) => run(buildRemoteTmuxCommand([
+		"show-option",
+		"-qv",
+		"-t",
+		agentId,
+		option
+	])).then((stdout) => stdout.trim(), () => "");
+	const readMarkerStrict = async (option) => run(buildRemoteTmuxCommand([
+		"show-option",
+		"-qv",
+		"-t",
+		agentId,
+		option
+	])).then((stdout) => stdout.trim());
+	const clearPoisonVerified = async (context) => {
+		try {
+			await run(buildRemoteTmuxCommand([
+				"set-option",
+				"-u",
+				"-t",
+				agentId,
+				poisonOption
+			]));
+		} catch (error) {
+			throw new KeyedMarkerVerificationError(agentId, `poison clear command failed (${context})`, { cause: error });
+		}
+		let remaining;
+		try {
+			remaining = await readMarkerStrict(poisonOption);
+		} catch (error) {
+			throw new KeyedMarkerVerificationError(agentId, `post-clear verification read failed (${context})`, { cause: error });
+		}
+		if (remaining !== "") throw new KeyedMarkerVerificationError(agentId, `poison breadcrumb survived the clear (${context})`);
+	};
+	const readPaneTarget = async () => run(buildRemoteTmuxCommand([
+		"display-message",
+		"-p",
+		"-t",
+		agentId,
+		"#{pane_pid} #{pane_dead}"
+	])).then((stdout) => {
+		const [pid = "", dead = ""] = stdout.trim().split(/\s+/);
+		return {
+			pid,
+			dead: dead === "1"
+		};
+	}).catch(() => ({
+		pid: "",
+		dead: true
+	}));
+	try {
+		let poisonMarker;
+		try {
+			poisonMarker = await readMarkerStrict(poisonOption);
+		} catch (error) {
+			throw new KeyedMarkerVerificationError(agentId, `initial poison read (key "${dedupKey}")`, { cause: error });
+		}
+		const repaired = poisonMarker !== "";
+		if (repaired) {
+			await run(buildRemoteTmuxCommand([
+				"set-option",
+				"-u",
+				"-t",
+				agentId,
+				terminalOption,
+				";",
+				"set-option",
+				"-t",
+				agentId,
+				pendingOption,
+				sendId
+			]));
+			let repairedTerminal;
+			let repairedPending;
+			try {
+				[repairedTerminal, repairedPending] = await Promise.all([readMarkerStrict(terminalOption), readMarkerStrict(pendingOption)]);
+			} catch {
+				throw new KeyedMarkerVerificationError(agentId, `repair verification of key "${dedupKey}"`);
+			}
+			if (repairedTerminal !== "" || repairedPending === "") throw new Error(`Keyed remote markers for ${agentId} are poisoned and could not be repaired (key "${dedupKey}")`);
+			await clearPoisonVerified(`repair of key "${dedupKey}"`);
+		}
+		const targetOption = dedupTargetOptionName(dedupKey);
+		const messageBase64 = Buffer.from(message).toString("base64");
+		await run(`mkdir -p ${shellQuote(`${REMOTE_PAN_DIR}/prompts`)} && echo ${shellQuote(messageBase64)} | base64 -d > ${shellQuote(promptFile)}`);
+		await run(buildRemoteTmuxCommand([
+			"load-buffer",
+			"-b",
+			bufferName,
+			promptFile
+		]));
+		let pendingMarker;
+		if (repaired) pendingMarker = sendId;
+		else {
+			const condition = `test -z "$(${innerTmux} show-option -qv -t ${agentId} ${pendingOption})" && test -z "$(${innerTmux} show-option -qv -t ${agentId} ${terminalOption})"`;
+			const onTrue = `paste-buffer -b ${bufferName} -p -t ${agentId} \; set-option -t ${agentId} ${pendingOption} ${sendId} \; set-option -F -t ${agentId} ${targetOption} '#{pane_pid}'`;
+			await run(buildRemoteTmuxCommand([
+				"if-shell",
+				"-t",
+				agentId,
+				condition,
+				onTrue
+			]));
+			const terminalMarker = await readMarker(terminalOption);
+			pendingMarker = await readMarker(pendingOption);
+			if (terminalMarker !== "") return "deduplicated";
+			if (pendingMarker === "") throw new Error(`Keyed remote paste for ${agentId} did not land and no dedup marker was recorded`);
+		}
+		const recordedTarget = await readMarker(targetOption);
+		const currentPid = (await readPaneTarget()).pid;
+		if (!(recordedTarget !== "" && currentPid !== "" && recordedTarget === currentPid)) {
+			const repasteCondition = `test -n "$(${innerTmux} show-option -qv -t ${agentId} ${pendingOption})" && test -z "$(${innerTmux} show-option -qv -t ${agentId} ${terminalOption})" && ! test "$(${innerTmux} display-message -p -t ${agentId} '#{pane_pid}')" = "$(${innerTmux} show-option -qv -t ${agentId} ${targetOption})"`;
+			const repasteOnTrue = `paste-buffer -b ${bufferName} -p -t ${agentId} \; set-option -t ${agentId} ${pendingOption} ${sendId} \; set-option -F -t ${agentId} ${targetOption} '#{pane_pid}'`;
+			await run(buildRemoteTmuxCommand([
+				"if-shell",
+				"-t",
+				agentId,
+				repasteCondition,
+				repasteOnTrue
+			]));
+			const [repastedPending, repastedTerminal] = await Promise.all([readMarker(pendingOption), readMarker(terminalOption)]);
+			if (repastedTerminal !== "") return "deduplicated";
+			if (repastedPending === "") throw new Error(`Keyed remote paste for ${agentId} did not land and no dedup marker was recorded`);
+			pendingMarker = repastedPending;
+		}
+		const preTarget = await readPaneTarget();
+		const pendingBefore = pendingMarker;
+		await new Promise((resolve) => setTimeout(resolve, 300));
+		const submitCondition = `test -z "$(${innerTmux} show-option -qv -t ${agentId} ${terminalOption})" && test -n "$(${innerTmux} show-option -qv -t ${agentId} ${pendingOption})" && test "$(${innerTmux} display-message -p -t ${agentId} '#{pane_dead}')" = "0" && test "$(${innerTmux} display-message -p -t ${agentId} '#{pane_pid}')" = "$(${innerTmux} show-option -qv -t ${agentId} ${targetOption})"`;
+		const submitOnTrue = `send-keys -t ${agentId} C-m \; set-option -t ${agentId} ${poisonOption} 1 \; set-option -t ${agentId} ${terminalOption} 1 \; set-option -u -t ${agentId} ${pendingOption}`;
+		await run(buildRemoteTmuxCommand([
+			"if-shell",
+			"-t",
+			agentId,
+			submitCondition,
+			submitOnTrue
+		]));
+		const [terminalAfter, pendingAfter, postTarget, recordedTargetAfter] = await Promise.all([
+			readMarker(terminalOption),
+			readMarker(pendingOption),
+			readPaneTarget(),
+			readMarker(targetOption)
+		]);
+		const targetLost = preTarget.dead || preTarget.pid === "" || postTarget.dead || postTarget.pid !== preTarget.pid;
+		if (terminalAfter === "" && pendingAfter === "") throw new Error(`Keyed remote submit for ${agentId} found neither a pending claim nor a terminal marker — the paste vanished without submission`);
+		if (terminalAfter === "" && (targetLost || recordedTargetAfter === "" || recordedTargetAfter !== postTarget.pid)) throw new KeyedSubmitTargetDeadError(agentId, dedupKey);
+		if (targetLost) {
+			if (terminalAfter !== "") {
+				await run(buildRemoteTmuxCommand(pendingBefore === "" ? [
+					"set-option",
+					"-u",
+					"-t",
+					agentId,
+					terminalOption,
+					";",
+					"set-option",
+					"-u",
+					"-t",
+					agentId,
+					pendingOption
+				] : [
+					"set-option",
+					"-u",
+					"-t",
+					agentId,
+					terminalOption,
+					";",
+					"set-option",
+					"-t",
+					agentId,
+					pendingOption,
+					pendingBefore
+				])).catch(() => "");
+				let rolledTerminal;
+				let restoredPending;
+				try {
+					[rolledTerminal, restoredPending] = await Promise.all([readMarkerStrict(terminalOption), readMarkerStrict(pendingOption)]);
+				} catch {
+					throw new KeyedMarkerVerificationError(agentId, `rollback verification of key "${dedupKey}"`);
+				}
+				if (rolledTerminal === "" && restoredPending !== "") await clearPoisonVerified(`verified rollback of key "${dedupKey}"`).catch(() => "");
+			}
+			throw new KeyedSubmitTargetDeadError(agentId, dedupKey);
+		}
+		if (terminalAfter === "") throw new Error(`Keyed remote submit for ${agentId} was rejected with the pending claim intact on a live pane`);
+		await clearPoisonVerified(`verified delivery of key "${dedupKey}"`);
+		return "delivered";
+	} finally {
+		await cleanup();
+	}
+}
+var init_remote_keyed_delivery = __esmMin((() => {
+	init_tmux_dedup();
+	init_fly_provider();
+	init_remote_tmux();
+}));
+//#endregion
 //#region ../../lib/remote/remote-agents.ts
 /**
 * Remote Agent Management
@@ -680,7 +968,7 @@ with open(path, "w") as f:
 */
 function generatePushDaemonScript(options) {
 	const intervalSeconds = options.intervalSeconds ?? PUSH_DAEMON_INTERVAL_SECONDS;
-	const logFile = options.logFile ?? `${REMOTE_PAN_DIR}/push-daemon.log`;
+	const logFile = options.logFile ?? `/workspace/.pan/push-daemon.log`;
 	const issueIdLiteral = JSON.stringify(options.issueId);
 	const branchLiteral = JSON.stringify(options.branch);
 	return [
@@ -787,7 +1075,7 @@ async function installPushDaemon(provider, vmName, issueId) {
 */
 function generateEphemeralWatchdogScript(options) {
 	const heartbeatPathLiteral = JSON.stringify(options.heartbeatPath);
-	const logFileLiteral = JSON.stringify(options.logFile ?? `${REMOTE_PAN_DIR}/ephemeral-watchdog.log`);
+	const logFileLiteral = JSON.stringify(options.logFile ?? `/workspace/.pan/ephemeral-watchdog.log`);
 	const intervalSeconds = options.intervalSeconds ?? EPHEMERAL_WATCHDOG_INTERVAL_SECONDS;
 	const staleThresholdSeconds = options.staleThresholdSeconds ?? EPHEMERAL_HEARTBEAT_STALE_THRESHOLD_SECONDS;
 	return [
@@ -903,10 +1191,6 @@ function listActiveRemoteAgentStates() {
 	if (!existsSync(AGENTS_DIR)) return [];
 	return readdirSync(AGENTS_DIR).map((agentId) => loadRemoteAgentState(agentId)).filter((state) => state?.location === "remote" && (state.status === "running" || state.status === "starting"));
 }
-/** Run a FlyProvider Effect at the async/Promise boundary. */
-function runSsh(provider, vmName, command) {
-	return Effect.runPromise(provider.ssh(vmName, command));
-}
 /**
 * Refresh the host-heartbeat freshness file on every active ephemeral-tier VM.
 * The deacon patrol calls this each cycle; the VM-side ephemeral watchdog uses
@@ -986,28 +1270,6 @@ async function remoteSessionExists(provider, vmName, sessionName) {
 function assertFlyRemoteStateSupported(issueId, migrated) {
 	if (migrated) throw new Error(`Fly remote spawn blocked for ${issueId.toUpperCase()}: PAN-2541 D14 forbids remote work on migrated projects until PAN-2549 implements overdeck-state synchronization.`);
 }
-function shellQuote(value) {
-	return `'${value.replace(/'/g, `'\\''`)}'`;
-}
-function getRemoteTmuxBaseArgs() {
-	return [
-		"-L",
-		getManagedTmuxSocketName(),
-		"-f",
-		REMOTE_TMUX_CONFIG_PATH
-	];
-}
-function buildRemoteTmuxCommand(args) {
-	return [
-		"tmux",
-		...getRemoteTmuxBaseArgs(),
-		...args
-	].map(shellQuote).join(" ");
-}
-async function ensureRemoteTmuxContext(provider, vmName) {
-	const configBase64 = Buffer.from(REMOTE_TMUX_CONFIG_CONTENT).toString("base64");
-	await runSsh(provider, vmName, `mkdir -p ${shellQuote(REMOTE_TMUX_DIR)} && echo ${shellQuote(configBase64)} | base64 -d > ${shellQuote(REMOTE_TMUX_CONFIG_PATH)}`);
-}
 /**
 * Write a file on the VM via base64 chunks. The Machines exec API rejects
 * payloads somewhere above 4KB (PayloadTooLarge), so large content — agent
@@ -1036,7 +1298,11 @@ async function writeRemoteFile(provider, vmName, remotePath, content) {
 * Spawn a Claude agent on a remote VM
 */
 async function spawnRemoteAgent(options) {
-	const { issueId, workspace, model = "claude-sonnet-4-6", prompt } = options;
+	if (isOperatorStartedBy(options.startedBy) || options.autoSpawnConsentRequired !== true) return spawnRemoteAgentWithoutConsentClaim(options);
+	return withAutoSpawnConsentClaim(options.issueId, (acceptConsent) => spawnRemoteAgentWithoutConsentClaim(options, acceptConsent), { isAccepted: (state) => state.status === "running" });
+}
+async function spawnRemoteAgentWithoutConsentClaim(options, acceptConsent) {
+	const { issueId, workspace, startedBy, model = "claude-sonnet-4-6", prompt } = options;
 	const project = resolveProjectForIssue(issueId);
 	if (project) assertFlyRemoteStateSupported(issueId, await isStateMigrated(project));
 	const tier = options.tier ?? "ephemeral";
@@ -1055,6 +1321,7 @@ async function spawnRemoteAgent(options) {
 		status: "starting",
 		startedAt: (/* @__PURE__ */ new Date()).toISOString(),
 		location: "remote",
+		startedBy,
 		tier
 	};
 	saveRemoteAgentState(state);
@@ -1072,12 +1339,13 @@ async function spawnRemoteAgent(options) {
 			promptFile,
 			baseCommand: "claude",
 			permissionFlags: getClaudePermissionFlagsSync(),
+			extraEnvExports: [`export OVERDECK_AGENT_STARTED_BY=${shellQuote(startedBy)}`],
 			model
 		}));
 		const chmodRes = await runSsh(fly, vmName, `chmod +x ${launcherScript}`);
 		if (chmodRes.exitCode !== 0) throw new Error(`Failed to chmod launcher on ${vmName}: ${chmodRes.stderr}`);
 		claudeCmd = `bash ${launcherScript}`;
-	} else claudeCmd = `claude ${getClaudePermissionFlagsStringSync()} --model ${model}`;
+	} else claudeCmd = `OVERDECK_AGENT_STARTED_BY=${shellQuote(startedBy)} claude ${getClaudePermissionFlagsStringSync()} --model ${model}`;
 	console.log(`[claude-invoke] purpose=remote-agent | model=${model} | source=remote-agents.ts | vm=${vmName} | agent=${agentId} | command="${claudeCmd}"`);
 	await ensureRemoteTmuxContext(fly, vmName);
 	const result = await runSsh(fly, vmName, buildRemoteTmuxCommand([
@@ -1094,6 +1362,7 @@ async function spawnRemoteAgent(options) {
 		saveRemoteAgentState(state);
 		throw new Error(`Failed to start agent: ${result.stderr}`);
 	}
+	await acceptConsent?.();
 	await installPushDaemon(fly, vmName, issueId);
 	if (tier === "ephemeral") await installEphemeralWatchdog(fly, vmName, issueId);
 	state.status = "running";
@@ -1206,30 +1475,24 @@ async function pollRemoteAgentStatus(agentId, vmName) {
 		toolUses
 	};
 }
-var AGENTS_DIR, REMOTE_PAN_DIR, REMOTE_TMUX_DIR, REMOTE_TMUX_CONFIG_PATH, REMOTE_HOST_HEARTBEAT_PATH, REMOTE_TMUX_CONFIG_CONTENT, PUSH_DAEMON_INTERVAL_SECONDS, EPHEMERAL_WATCHDOG_INTERVAL_SECONDS, EPHEMERAL_HEARTBEAT_STALE_THRESHOLD_SECONDS;
+var AGENTS_DIR, REMOTE_HOST_HEARTBEAT_PATH, PUSH_DAEMON_INTERVAL_SECONDS, EPHEMERAL_WATCHDOG_INTERVAL_SECONDS, EPHEMERAL_HEARTBEAT_STALE_THRESHOLD_SECONDS;
 var init_remote_agents = __esmMin((() => {
 	init_fly_provider();
-	init_tmux();
+	init_remote_tmux();
 	init_launcher_generator();
 	init_claude_permissions();
 	init_record();
 	init_state_home();
+	init_auto_spawn_consent();
+	init_provenance();
+	init_remote_keyed_delivery();
 	AGENTS_DIR = join(homedir(), ".overdeck", "agents");
-	REMOTE_PAN_DIR = "/workspace/.pan";
-	REMOTE_TMUX_DIR = `${REMOTE_PAN_DIR}/tmux`;
-	REMOTE_TMUX_CONFIG_PATH = `${REMOTE_TMUX_DIR}/overdeck.tmux.conf`;
 	REMOTE_HOST_HEARTBEAT_PATH = `${REMOTE_PAN_DIR}/host-heartbeat`;
-	REMOTE_TMUX_CONFIG_CONTENT = [
-		"# Overdeck-managed tmux config",
-		"# Keep this minimal and include only behavior Overdeck intentionally depends on.",
-		"set -g mouse on",
-		""
-	].join("\n");
 	PUSH_DAEMON_INTERVAL_SECONDS = 300;
 	EPHEMERAL_WATCHDOG_INTERVAL_SECONDS = 60;
 	EPHEMERAL_HEARTBEAT_STALE_THRESHOLD_SECONDS = 300;
 }));
 //#endregion
-export { init_fly_provider as C, createFlyProvider as S, saveRemoteAgentState as _, generatePushDaemonScript as a, writeRemoteFile as b, installEphemeralWatchdog as c, killRemoteAgent as d, listActiveRemoteAgentStates as f, refreshHostHeartbeatForEphemeralVms as g, pollRemoteAgentStatus as h, generateEphemeralWatchdogScript as i, installPushDaemon as l, loadRemoteAgentState as m, checkRemoteDurabilityPreflight as n, getRemoteAgentOutput as o, listRemoteAgents as p, checkRemoteSpendCap as r, init_remote_agents as s, assertFlyRemoteStateSupported as t, isRemoteAgentRunning as u, sendToRemoteAgent as v, FlyProvider as x, spawnRemoteAgent as y };
+export { createFlyProvider as C, FlyProvider as S, saveRemoteAgentState as _, generatePushDaemonScript as a, writeRemoteFile as b, installEphemeralWatchdog as c, killRemoteAgent as d, listActiveRemoteAgentStates as f, refreshHostHeartbeatForEphemeralVms as g, pollRemoteAgentStatus as h, generateEphemeralWatchdogScript as i, installPushDaemon as l, loadRemoteAgentState as m, checkRemoteDurabilityPreflight as n, getRemoteAgentOutput as o, listRemoteAgents as p, checkRemoteSpendCap as r, init_remote_agents as s, assertFlyRemoteStateSupported as t, isRemoteAgentRunning as u, sendToRemoteAgent as v, init_fly_provider as w, sendToRemoteAgentKeyed as x, spawnRemoteAgent as y };
 
-//# sourceMappingURL=remote-agents-By1ige5O.js.map
+//# sourceMappingURL=remote-agents-Bba-MgSA.js.map

package/server/{remote-agents-CA3Ihlxj.js → remote-agents-CLZB3Coc.js}

@@ -1,3 +1,3 @@
-import { _ as saveRemoteAgentState, a as generatePushDaemonScript, b as writeRemoteFile, c as installEphemeralWatchdog, d as killRemoteAgent, f as listActiveRemoteAgentStates, g as refreshHostHeartbeatForEphemeralVms, h as pollRemoteAgentStatus, i as generateEphemeralWatchdogScript, l as installPushDaemon, m as loadRemoteAgentState, n as checkRemoteDurabilityPreflight, o as getRemoteAgentOutput, p as listRemoteAgents, r as checkRemoteSpendCap, s as init_remote_agents, t as assertFlyRemoteStateSupported, u as isRemoteAgentRunning, v as sendToRemoteAgent, y as spawnRemoteAgent } from "./remote-agents-By1ige5O.js";
+import { _ as saveRemoteAgentState, a as generatePushDaemonScript, b as writeRemoteFile, c as installEphemeralWatchdog, d as killRemoteAgent, f as listActiveRemoteAgentStates, g as refreshHostHeartbeatForEphemeralVms, h as pollRemoteAgentStatus, i as generateEphemeralWatchdogScript, l as installPushDaemon, m as loadRemoteAgentState, n as checkRemoteDurabilityPreflight, o as getRemoteAgentOutput, p as listRemoteAgents, r as checkRemoteSpendCap, s as init_remote_agents, t as assertFlyRemoteStateSupported, u as isRemoteAgentRunning, v as sendToRemoteAgent, x as sendToRemoteAgentKeyed, y as spawnRemoteAgent } from "./remote-agents-Bba-MgSA.js";
 init_remote_agents();
-export { assertFlyRemoteStateSupported, checkRemoteDurabilityPreflight, checkRemoteSpendCap, generateEphemeralWatchdogScript, generatePushDaemonScript, getRemoteAgentOutput, installEphemeralWatchdog, installPushDaemon, isRemoteAgentRunning, killRemoteAgent, listActiveRemoteAgentStates, listRemoteAgents, loadRemoteAgentState, pollRemoteAgentStatus, refreshHostHeartbeatForEphemeralVms, saveRemoteAgentState, sendToRemoteAgent, spawnRemoteAgent, writeRemoteFile };
+export { assertFlyRemoteStateSupported, checkRemoteDurabilityPreflight, checkRemoteSpendCap, generateEphemeralWatchdogScript, generatePushDaemonScript, getRemoteAgentOutput, installEphemeralWatchdog, installPushDaemon, isRemoteAgentRunning, killRemoteAgent, listActiveRemoteAgentStates, listRemoteAgents, loadRemoteAgentState, pollRemoteAgentStatus, refreshHostHeartbeatForEphemeralVms, saveRemoteAgentState, sendToRemoteAgent, sendToRemoteAgentKeyed, spawnRemoteAgent, writeRemoteFile };

package/server/{remote-completion-fVe9e_3u.js → remote-completion-CwAp79EC.js}

@@ -1,10 +1,10 @@
-import { Tn as init_projects, mn as findProjectByTeamSync, un as extractTeamPrefix, zn as resolveProjectFromIssueSync } from "./config-yaml-DySPNmKN.js";
-import { a as PAN_DIRNAME, i as PAN_CONTINUE_FILENAME } from "./types-hraoaQIp.js";
-import { f as init_config, m as loadConfigSync } from "./config-BZ0sHTju.js";
-import { t as init_pan_dir } from "./pan-dir-B0c3w0Ya.js";
-import { r as init_workspace_manager, t as createWorkspace } from "./workspace-manager-CBhNdzE4.js";
-import { _ as saveRemoteAgentState, f as listActiveRemoteAgentStates, m as loadRemoteAgentState, o as getRemoteAgentOutput, s as init_remote_agents, u as isRemoteAgentRunning, v as sendToRemoteAgent } from "./remote-agents-By1ige5O.js";
-import { t as createFlyProviderFromConfig } from "./remote-C_2hasl7.js";
+import { An as extractTeamPrefix, Gn as init_projects, Pn as findProjectByTeamSync, ar as resolveProjectFromIssueSync } from "./config-yaml-CxdwhAIA.js";
+import { a as PAN_DIRNAME, i as PAN_CONTINUE_FILENAME } from "./types-Cm5ASJbq.js";
+import { f as init_config, m as loadConfigSync } from "./config-BvLe652W.js";
+import { t as init_pan_dir } from "./pan-dir-DMzF5wne.js";
+import { r as init_workspace_manager, t as createWorkspace } from "./workspace-manager-BPgTrG66.js";
+import { _ as saveRemoteAgentState, f as listActiveRemoteAgentStates, m as loadRemoteAgentState, o as getRemoteAgentOutput, s as init_remote_agents, u as isRemoteAgentRunning, v as sendToRemoteAgent } from "./remote-agents-Bba-MgSA.js";
+import { t as createFlyProviderFromConfig } from "./remote-BXarMvqf.js";
 import { Effect } from "effect";
 import { existsSync, mkdirSync, statSync, unlinkSync, writeFileSync } from "fs";
 import { basename, join } from "path";
@@ -309,7 +309,7 @@ async function reapCompletedRemoteAgents(opts = {}) {
 			} catch {
 				details.push("No continue.json retrieved from VM (skipped)");
 			}
-			const { getAgentStateSync, saveAgentStateSync } = await import("./agents-wi9NWzs2.js");
+			const { getAgentStateSync, saveAgentStateSync } = await import("./agents-ePFVoZbu.js");
 			const existing = getAgentStateSync(agentId);
 			if (existing) {
 				existing.workspace = existing.workspace || workspacePath;
@@ -327,8 +327,8 @@ async function reapCompletedRemoteAgents(opts = {}) {
 				startedAt: remoteState.startedAt,
 				lastActivity: (/* @__PURE__ */ new Date()).toISOString()
 			});
-			const { createReviewArtifactsForIssue } = await import("./review-artifacts-nRDPuMxd.js");
-			const { setReviewStatusSync } = await import("./review-status-btEYlaxA.js");
+			const { createReviewArtifactsForIssue } = await import("./review-artifacts-BNmw8dWE.js");
+			const { setReviewStatusSync } = await import("./review-status-Dma9SFaN.js");
 			const primaryArtifact = (await Effect.runPromise(createReviewArtifactsForIssue(issueId, workspacePath))).mergeSet?.repos.find((repo) => !!repo.artifactUrl);
 			if (primaryArtifact?.artifactUrl) {
 				setReviewStatusSync(issueId, { prUrl: primaryArtifact.artifactUrl });
@@ -349,7 +349,7 @@ async function reapCompletedRemoteAgents(opts = {}) {
 			try {
 				const fly = createFlyProviderFromConfig(loadConfigSync().remote);
 				if (sessionAlive) {
-					const { killRemoteAgent } = await import("./remote-agents-CA3Ihlxj.js");
+					const { killRemoteAgent } = await import("./remote-agents-CLZB3Coc.js");
 					await killRemoteAgent(agentId, vmName).catch(() => void 0);
 				}
 				await Effect.runPromise(fly.deleteVm(vmName));
@@ -357,7 +357,7 @@ async function reapCompletedRemoteAgents(opts = {}) {
 			} catch (err) {
 				details.push(`Warning: could not destroy machine: ${err.message}`);
 			}
-			const { deleteWorkspaceMetadataSync } = await import("./workspace-metadata-BzHnwwX4.js");
+			const { deleteWorkspaceMetadataSync } = await import("./workspace-metadata-CdjzAP8x.js");
 			deleteWorkspaceMetadataSync(issueId);
 			details.push("Removed remote workspace metadata (pipeline is local from here)");
 			saveRemoteAgentState({
@@ -386,4 +386,4 @@ async function reapCompletedRemoteAgents(opts = {}) {
 //#endregion
 export { reapCompletedRemoteAgents, refreshClaudeCredentialsForActiveRemoteAgents };
 
-//# sourceMappingURL=remote-completion-fVe9e_3u.js.map
+//# sourceMappingURL=remote-completion-CwAp79EC.js.map

package/server/resume-mOREjlYu.js

@@ -0,0 +1,3 @@
+import { G as resumeAgent, W as init_resume } from "./queries-C-MUZaIy.js";
+init_resume();
+export { resumeAgent };