@songsid/agend 2.1.6-beta.13 → 2.1.6-beta.15

package/dist/daemon.js

@@ -30,8 +30,6 @@ import { bottomRowIsReady, inputAreaText, inputShowsPastedText, pastedTextSignat
 import { TurnReplyGuard } from "./turn-reply-guard.js";
 import { t } from "./locale.js";
 import { MuseUsageRelay, clearMuseUsageSnapshot } from "./muse-usage-relay.js";
-import { CodexResumeConflictError, CodexResumeIdentityError, CodexResumeUnavailableError } from "./backend/codex-session.js";
-import { codexResumeLockVisible } from "./backend/codex.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 // Tool routing sets — module-level to avoid re-creation on every handleToolCall
@@ -451,6 +449,10 @@ export class BackendUnreachableStartupError extends Error {
 }
 /** Bounded wait (under the pane lock) for the prompt to return before retrying a dropped Enter. */
 const STRANDED_RETRY_READY_WAIT_MS = 30_000;
+/** A pasted Kiro message may be processing for longer than the retry window. */
+const KIRO_SUBMISSION_OBSERVE_MS = 10 * 60_000;
+const KIRO_SUBMISSION_POLL_MS = 1_000;
+const KIRO_SUBMISSION_UNREADABLE_POLLS = 40;
 /** A passive startup phase must clear within this bound before an Enter is sent. */
 /**
  * How long a passive startup/resume transient may sit WITHOUT REPAINTING before
@@ -950,8 +952,6 @@ export class Daemon extends EventEmitter {
     instanceStateBusyPattern = null;
     instanceStateMonitorActive = false;
     sessionCheckpointWarningEmitted = false;
-    codexSessionIdentityHoldNotified = false;
-    recoveredLegacyCodexSessionId = null;
     statePollInFlight = false;
     // One generation-scoped source of truth for human-turn reply completion.
     // It also supplies the older dead-MCP/malformed-call recovery paths, so those
@@ -1207,11 +1207,6 @@ export class Daemon extends EventEmitter {
         this.autoPauseController = new AutoPauseController(Math.max(0, autoPauseMinutes) * 60_000, readLastInboundAt(instanceDir) ?? Date.now());
     }
     async start() {
-        // Do this before touching daemon.pid or a pre-existing window. An unknown
-        // rollout format with an owned marker must not become a fresh session.
-        if (this.backend?.hasInvalidSessionIdentity?.(this.config.working_directory)) {
-            throw new CodexResumeIdentityError();
-        }
         mkdirSync(this.instanceDir, { recursive: true });
         writeFileSync(join(this.instanceDir, "daemon.pid"), String(process.pid));
         this.logger.info(`Starting ${this.name}`);
@@ -1221,16 +1216,8 @@ export class Daemon extends EventEmitter {
             if (existsSync(crashStatePath)) {
                 const state = JSON.parse(readFileSync(crashStatePath, "utf-8"));
                 if (state.resumeDisabled) {
-                    if (this.backend?.binaryName === "codex" && this.backend.canResume?.(this.config.working_directory)) {
-                        // A crash-loop heuristic cannot silently discard an explicitly
-                        // owned Codex conversation. Try once, then hold with a visible
-                        // reason rather than cycling or choosing a new session.
-                        this.logger.warn("Previous crash loop detected — preserving explicit Codex resume");
-                    }
-                    else {
-                        this.skipResume = true;
-                        this.logger.warn("Previous crash loop detected — starting without resume");
-                    }
+                    this.skipResume = true;
+                    this.logger.warn("Previous crash loop detected — starting without resume");
                 }
                 unlinkSync(crashStatePath);
             }
@@ -1358,12 +1345,7 @@ export class Daemon extends EventEmitter {
             if (savedId) {
                 const oldTmux = new TmuxManager(this.tmuxSessionName, savedId);
                 if (await oldTmux.isWindowAlive()) {
-                    this.backend?.setActivePanePid?.(await TmuxManager.getPanePid(this.tmuxSessionName, savedId));
-                    const recoveredPane = this.backend?.binaryName === "codex"
-                        ? await oldTmux.capturePane().catch(() => undefined) : undefined;
-                    const recoveredId = this.checkpointLivePaneBeforeReplacement(recoveredPane);
-                    if (this.backend?.binaryName === "codex")
-                        this.recoveredLegacyCodexSessionId = recoveredId;
+                    this.saveSessionId();
                     await oldTmux.killWindow();
                     this.logger.info({ savedId }, "Killed old tmux window for fresh start");
                 }
@@ -1443,10 +1425,7 @@ export class Daemon extends EventEmitter {
             this.guardian = new ContextGuardian(this.config.context_guardian, this.logger, statusFile);
             this.guardian.startWatching();
             this.guardian.on("status_update", () => {
-                // Codex's /new can leave multiple writer locks in one PID. A status
-                // callback has no pane footer, so it cannot attest the current chat.
-                if (this.backend?.binaryName !== "codex")
-                    this.saveSessionId();
+                this.saveSessionId();
             });
             // Context rotation removed: all CLI backends have built-in auto-compact.
             // Crash recovery (health check + respawn with snapshot) is retained below.
@@ -1990,8 +1969,7 @@ export class Daemon extends EventEmitter {
                         await this.tmux.killWindow();
                     }
                     // Detect claude-code background session conflict — recover without counting as crash
-                    if (this.backend?.binaryName !== "codex" && lastOutput
-                        && (lastOutput.includes("background agent") || lastOutput.includes("Session is currently running"))) {
+                    if (lastOutput && (lastOutput.includes("background agent") || lastOutput.includes("Session is currently running"))) {
                         if (!this.backgroundSessionRecoveryAttempted) {
                             this.backgroundSessionRecoveryAttempted = true;
                             this.logger.warn("Detected lingering background agent session — starting fresh (no resume)");
@@ -2032,14 +2010,6 @@ export class Daemon extends EventEmitter {
                     // and skip resume so the next spawn starts fresh. (skipResume also stops
                     // saveSessionId below from resurrecting the id from statusline.json.)
                     if (this.paneSaysNoConversation(lastOutput)) {
-                        if (this.backend?.binaryName === "codex" && this.backend.hasSessionIdentity?.()) {
-                            // Codex may have changed its rollout format or emitted an error
-                            // that only resembles this generic pattern. A persisted UUID is
-                            // never discarded by a text heuristic; preserve and hold.
-                            this.healthCheckPaused = true;
-                            this.emitSupervisionEnded("Codex could not resume its owned session", "Inspect the preserved session ID/rollout and restart this instance manually.");
-                            return;
-                        }
                         this.setSessionAside("cli_reported_no_conversation");
                         this.skipResume = true;
                     }
@@ -2097,10 +2067,7 @@ export class Daemon extends EventEmitter {
                     this.logger.warn({ crashCount: this.crashCount, delay }, `${cliLabel} window died — respawning after backoff`);
                     await new Promise(r => setTimeout(r, delay));
                     try {
-                        // The dead Codex pane cannot supply current-session evidence.
-                        // Its last verified checkpoint stays as-is (or held if ambiguous).
-                        if (this.backend?.binaryName !== "codex")
-                            this.saveSessionId();
+                        this.saveSessionId();
                         this.transcriptMonitor?.resetOffset();
                         // Kill orphan MCP server from the crashed CLI session.
                         // MCP server writes its PID to channel.mcp.pid on startup.
@@ -2148,16 +2115,7 @@ export class Daemon extends EventEmitter {
                             this.stormWindow?.markRecovered(this.name);
                     }
                     catch (err) {
-                        if (err instanceof CodexResumeConflictError || err instanceof CodexResumeUnavailableError) {
-                            // A live owner is not a broken conversation. Stop automatic
-                            // respawns and preserve the explicit session for a human retry.
-                            this.healthCheckPaused = true;
-                            this.logger.warn({ ownerPid: err instanceof CodexResumeConflictError ? err.ownerPid : null }, "Codex resume cannot continue — supervision stopped");
-                            this.emitSupervisionEnded(err.message, err instanceof CodexResumeConflictError
-                                ? "Close the other Codex owner, then restart this instance."
-                                : "Inspect the Codex pane and restart this instance after resolving the startup failure.");
-                        }
-                        else if (!this.handOffBackendUnreachableRespawn(err)) {
+                        if (!this.handOffBackendUnreachableRespawn(err)) {
                             this.logger.error({ err }, `Failed to respawn ${cliLabel} window`);
                         }
                     }
@@ -2706,9 +2664,7 @@ export class Daemon extends EventEmitter {
         // Quit CLI FIRST — this kills MCP server child processes cleanly.
         // IPC must stay open during quit so MCP servers receive the shutdown message.
         if (this.tmux) {
-            const codexPane = this.backend?.binaryName === "codex"
-                ? await this.tmux.capturePane().catch(() => undefined) : undefined;
-            this.saveSessionId(codexPane);
+            this.saveSessionId();
             this.healthCheckPaused = true;
             let killed = false;
             const quitSent = await this.sendQuitSequence();
@@ -2851,9 +2807,7 @@ export class Daemon extends EventEmitter {
         this.freezeRuntimeMonitors();
         const transition = (async () => {
             try {
-                const codexPane = this.backend?.binaryName === "codex"
-                    ? await this.tmux?.capturePane().catch(() => undefined) : undefined;
-                this.saveSessionId(codexPane);
+                this.saveSessionId();
                 await this.sendQuitSequence();
                 let exited = false;
                 for (let i = 0; i < 15; i++) {
@@ -2992,13 +2946,13 @@ export class Daemon extends EventEmitter {
             return;
         }
         this.instanceState = snapshot.state;
-        // OpenCode and Codex create their session lazily on the first submitted message.
+        // OpenCode creates its session lazily on the first submitted message.
         // Waiting until stop/pause to persist that id loses resume state when the
         // fleet is SIGKILLed or the host reboots.
         // Idle observations are safe checkpoints; the 60s safety sweep also gives
         // us a bounded retry if session creation produced no visible state edge.
-        if (snapshot.state === "idle" && (this.backend?.binaryName === "opencode" || this.backend?.binaryName === "codex")) {
-            this.saveSessionId(pane);
+        if (snapshot.state === "idle" && this.backend?.binaryName === "opencode") {
+            this.saveSessionId();
         }
         // Only a transition back to idle completes pending work. Repeated idle
         // observations between enqueue and paste must not clear a newer inbound.
@@ -4294,6 +4248,8 @@ export class Daemon extends EventEmitter {
         // A false return means the cap expired with a spawn STILL running — the
         // generation captured below is in-progress evidence, not settled evidence,
         // so the critical section must still back out (see settledClean).
+        if (this.spawnSettled && status)
+            this.emit("message_queued", status);
         const settledClean = await this.waitForSpawnToSettle();
         // Everything captured below (window id, readiness verdicts) belongs to
         // this spawn generation. A spawn that starts afterwards is detected inside
@@ -4435,6 +4391,9 @@ export class Daemon extends EventEmitter {
                 }
                 return this.deliverMessage(formatted, status, { ...opts, spawnRetry: retries });
             }
+            if (typeof outcome === "object") {
+                return this.observeKiroSubmission(formatted, outcome, status, verdict, cancelled);
+            }
             if (outcome !== "dialog")
                 return outcome;
             // Wait OUTSIDE the lock (holding it would starve the runtime dismisser),
@@ -4963,6 +4922,126 @@ export class Daemon extends EventEmitter {
             this.logger.warn("Could not read the pane after Enter — not confirming the submission");
         return sawOutput && residue === "absent";
     }
+    /** Once Kiro returns to its prompt, its unique envelope id in history proves submission. */
+    async kiroSubmissionEvidence(windowId, formatted, signature) {
+        if (!this.tmux)
+            return "unreadable";
+        let pane;
+        try {
+            pane = await this.tmux.capturePane();
+        }
+        catch {
+            return "unreadable";
+        }
+        const prompt = this.backend?.getBottomReadyPattern?.();
+        if (prompt && bottomRowIsReady(pane, prompt)
+            && inputShowsPastedText(inputAreaText(pane, prompt) ?? "", signature.value))
+            return "stranded";
+        if (prompt && pasteLeftInInput(pane, prompt, formatted))
+            return "stranded";
+        // During generation the same text can still be typeahead for an older
+        // turn. A history hit is safe only after this pane returns to its prompt.
+        if (!signature.unique || !this.tmux.capturePaneWithHistory
+            || !(await this.isPaneReadyForDelivery(windowId)))
+            return "unknown";
+        try {
+            const history = await this.tmux.capturePaneWithHistory(300);
+            // History includes the CURRENT input row. The earlier viewport capture
+            // and readiness probe may belong to an older frame: Kiro can finish a
+            // turn and expose our unsent typeahead between those reads. Judge both
+            // readiness and input residue on this same, final snapshot before its
+            // message id can count as a submitted transcript echo.
+            if (!prompt || !bottomRowIsReady(history, prompt))
+                return "unknown";
+            if (inputShowsPastedText(inputAreaText(history, prompt) ?? "", signature.value)
+                || pasteLeftInInput(history, prompt, formatted))
+                return "stranded";
+            if (countOccurrences(history.replace(/\s+/g, ""), signature.value) > 0)
+                return "submitted";
+        }
+        catch { /* missing history cannot establish a verdict */ }
+        return "unknown";
+    }
+    /** Observe the Kiro paste outside paneWriteLock; a long agent turn must not block dialog handling. */
+    async observeKiroSubmission(formatted, pending, status, verdict, cancelled) {
+        const deadline = Date.now() + KIRO_SUBMISSION_OBSERVE_MS;
+        let retriedStrand = false;
+        let unreadable = 0;
+        const current = () => !cancelled()
+            && !this.spawning
+            && this.spawnGeneration === pending.spawnGeneration
+            && this.getWindowId() === pending.windowId
+            && this.tmux?.getWindowId() === pending.windowId;
+        for (;;) {
+            if (!current())
+                return false;
+            const evidence = await this.kiroSubmissionEvidence(pending.windowId, formatted, pending.signature);
+            if (!current())
+                return false;
+            if (evidence === "submitted") {
+                if (status)
+                    this.emit("message_confirmed", status);
+                return true;
+            }
+            unreadable = evidence === "unreadable" ? unreadable + 1 : 0;
+            if (unreadable >= KIRO_SUBMISSION_UNREADABLE_POLLS) {
+                return this.failDelivery(verdict, status, "post-submit-proof", "pane-unreadable");
+            }
+            if (evidence === "stranded" && await this.isPaneReadyForDelivery(pending.windowId)) {
+                if (!current())
+                    return false;
+                if (retriedStrand)
+                    return this.failDelivery(verdict, status, "stranded-text-retry", "stranded");
+                const retry = await this.paneWriteLock.run(async () => {
+                    if (!current())
+                        return "cancelled";
+                    const fresh = await this.kiroSubmissionEvidence(pending.windowId, formatted, pending.signature);
+                    if (!current())
+                        return "cancelled";
+                    if (fresh === "submitted")
+                        return "submitted";
+                    if (fresh !== "stranded" || !(await this.isPaneReadyForDelivery(pending.windowId)))
+                        return "changed";
+                    if (!current())
+                        return "cancelled";
+                    const sent = await this.sendDeliveryEnter("stranded-text-retry", current);
+                    if (!current())
+                        return "cancelled";
+                    return sent ? "sent" : "failed";
+                });
+                if (!current())
+                    return false;
+                if (retry === "cancelled")
+                    return false;
+                if (retry === "submitted") {
+                    if (status)
+                        this.emit("message_confirmed", status);
+                    return true;
+                }
+                if (retry === "failed")
+                    return this.failDelivery(verdict, status, "stranded-text-retry", "tmux-send-keys-failed");
+                if (retry === "sent") {
+                    retriedStrand = true;
+                    await new Promise(r => setTimeout(r, POST_ENTER_PROOF_WINDOW_MS));
+                    continue;
+                }
+            }
+            const alive = await this.tmux?.isWindowAlive().catch(() => false);
+            if (!current())
+                return false;
+            if (!alive)
+                return this.failDelivery(verdict, status, "post-submit-proof", "window-gone");
+            if (Date.now() >= deadline) {
+                // A live, busy pane and no positive strand are still ambiguous. The
+                // hang detector owns hung CLI recovery; elapsed time alone is not ❌.
+                this.logger.warn("Kiro submission remains unproven; keeping the delivery queued without a false failure");
+                verdict.phase = "post-submit-proof";
+                verdict.proof = "unproven";
+                return false;
+            }
+            await new Promise(r => setTimeout(r, KIRO_SUBMISSION_POLL_MS));
+        }
+    }
     /**
      * While the CLI is parked on a fatal startup screen (see fatalStartupBlocked),
      * no pane write may happen: paste+Enter into the corrupt-config modal would
@@ -5042,9 +5121,13 @@ export class Daemon extends EventEmitter {
      * precisely so the lock's scope is visible at the call site rather than being
      * an invariant maintained by comments.
      */
-    async sendDeliveryEnter(phase) {
+    async sendDeliveryEnter(phase, stillCurrent) {
         if (!(await this.waitForInputTransientToClear(phase)))
             return false;
+        // A recovery Enter may have waited for a transient while cancel or spawn
+        // replaced the delivery. Check at the last point before the tmux write.
+        if (stillCurrent && !stillCurrent())
+            return false;
         const sent = await this.tmux.sendSpecialKey("Enter");
         if (!sent) {
             this.logger.error({
@@ -5269,10 +5352,20 @@ export class Daemon extends EventEmitter {
                 // F2: output after Enter is necessary but not sufficient — the paste
                 // must also have LEFT the input row.
                 let submitted = await this.confirmSubmittedAfterEnter(windowId, enterAt, formatted);
+                if (!submitted && signature.unique) {
+                    submitted = await this.kiroSubmissionEvidence(windowId, formatted, signature) === "submitted";
+                    if (!submitted) {
+                        // No output edge is not proof of a lost message. Leave the pane
+                        // lock before waiting through a long Kiro turn, so runtime dialog
+                        // handling can still make progress.
+                        if (status)
+                            this.emit("message_queued", status);
+                        return { kind: "kiro-pending", windowId, spawnGeneration: this.spawnGeneration, signature };
+                    }
+                }
                 if (!submitted) {
-                    // The Enter landed while the TUI was still busy (it kept the text but
-                    // dropped the key). A retry is only useful once the prompt is back —
-                    // bounded, since we hold the pane lock here.
+                    // Legacy system pastes have no unique envelope id. Preserve their
+                    // existing bounded retry until they can be tied to a specific turn.
                     this.logger.warn("Message not submitted after Enter — waiting for the prompt, then re-sending Enter once");
                     const promptBack = await this.waitForPaneReadyForDelivery(windowId, STRANDED_RETRY_READY_WAIT_MS);
                     const retryAt = Date.now();
@@ -6353,25 +6446,11 @@ export class Daemon extends EventEmitter {
             if (!this.backend) {
                 throw new Error("No backend configured — cannot spawn CLI window");
             }
-            const attemptedResume = !this.skipResume
-                && (this.backend.canResume?.(this.config.working_directory) ?? true);
+            const attemptedResume = !this.skipResume;
             // A resume launch may get a longer budget than a fresh one (kiro: the
             // conversation must come back from the backend before anything paints).
             const resumeBudget = attemptedResume ? this.startupBudgetFor(true) : undefined;
             let alive = await this.trySpawn(false, resumeBudget);
-            if (!alive && attemptedResume && this.backend.binaryName === "codex") {
-                const status = await this.tmux?.getPaneStatus().catch(() => null);
-                if (status?.exitCode === 75)
-                    throw new CodexResumeConflictError(null);
-                const pane = await this.tmux?.capturePane().catch(() => "");
-                if (pane?.includes("[agend:codex-session-held]"))
-                    throw new CodexResumeConflictError(null);
-                if (pane && codexResumeLockVisible(pane))
-                    throw new CodexResumeConflictError(null);
-                // A failed explicit resume is not evidence that the conversation is
-                // unusable. Never enter the generic abandon/--fresh recovery path.
-                throw new CodexResumeUnavailableError();
-            }
             if (!alive && attemptedResume) {
                 // Resume failed. Before abandoning the session:
                 //  1. If the backend is unreachable (fleet-level memory, or this very pane
@@ -6565,9 +6644,7 @@ export class Daemon extends EventEmitter {
             this.logger.debug({ err }, "IPC server close failed during startup abort");
         }
         this.ipcServer = null;
-        // A rejection before tmux setup did not create a replacement window; its
-        // pre-existing window-id still belongs to the old pane and must survive.
-        for (const file of this.tmux ? ["daemon.pid", "window-id"] : ["daemon.pid"]) {
+        for (const file of ["daemon.pid", "window-id"]) {
             try {
                 unlinkSync(join(this.instanceDir, file));
             }
@@ -6594,21 +6671,13 @@ export class Daemon extends EventEmitter {
      * Returns true if CLI is ready, false if it failed or got stuck.
      */
     async trySpawn(reuseWindow = false, startupTimeoutMs) {
-        const ready = !this.spawnGate
-            ? await this.trySpawnInsideGate(reuseWindow, startupTimeoutMs)
-            : await this.spawnGate.run({
-                instanceName: this.name,
-                workingDirectory: this.config.working_directory,
-                reason: reuseWindow ? "wake" : this.lastSpawnAt > 0 ? "recovery" : "startup",
-            }, () => this.trySpawnInsideGate(reuseWindow, startupTimeoutMs));
-        // All successful launches, including wake's trySpawn(true), cross this
-        // point. The previous checkpoint in spawnClaudeWindow missed wake and
-        // kept reading the dead pane PID after a resumed session changed.
-        if (ready && !this.fatalStartupBlocked && this.backend?.binaryName === "codex" && this.tmux) {
-            this.backend.setActivePanePid?.(await TmuxManager.getPanePid(this.tmuxSessionName, this.tmux.getWindowId()));
-            this.saveSessionId(await this.tmux.capturePane().catch(() => undefined));
-        }
-        return ready;
+        if (!this.spawnGate)
+            return this.trySpawnInsideGate(reuseWindow, startupTimeoutMs);
+        return this.spawnGate.run({
+            instanceName: this.name,
+            workingDirectory: this.config.working_directory,
+            reason: reuseWindow ? "wake" : this.lastSpawnAt > 0 ? "recovery" : "startup",
+        }, () => this.trySpawnInsideGate(reuseWindow, startupTimeoutMs));
     }
     /**
      * One fresh pane capture judged as ready && !busy && !dialog. Transcript
@@ -6844,21 +6913,6 @@ export class Daemon extends EventEmitter {
         }
         this.backend.writeConfig(backendConfig);
         this.backend.preTrust?.(this.config.working_directory);
-        // Bounded preflight for an owner left by a restart or another app. Codex
-        // must not be launched as a competing resumer. The command's flock is the
-        // atomic second fence for a race after this observation.
-        if (!backendConfig.skipResume && this.backend.resumeOwner) {
-            let owner = null;
-            for (let attempt = 0; attempt < 3; attempt++) {
-                owner = this.backend.resumeOwner(this.config.working_directory);
-                if (owner === null)
-                    break;
-                if (attempt < 2)
-                    await new Promise(r => setTimeout(r, 1_000));
-            }
-            if (owner !== null)
-                throw new CodexResumeConflictError(owner);
-        }
         // Resolve working directory (e.g. symlink for hidden paths)
         const resolvedCwd = this.backend.resolveWorkingDirectory?.(this.config.working_directory, this.name) ?? this.config.working_directory;
         // Generate a fresh per-instance agent token each spawn. agent-cli reads
@@ -7247,34 +7301,26 @@ export class Daemon extends EventEmitter {
         }
         catch { /* best effort */ }
     }
-    /** The returned ID was durably checkpointed or already matched on disk. */
-    saveSessionId(pane) {
+    saveSessionId() {
         // When a resume failure has forced a fresh start, don't persist the stale id
         // back from statusline.json — that would re-arm --continue and re-loop.
         if (this.skipResume)
-            return null;
+            return;
         try {
-            const sid = this.backend?.getSessionId(pane);
-            if (!sid) {
-                if (this.backend?.hasUnconfirmedSessionIdentity?.() && !this.codexSessionIdentityHoldNotified) {
-                    this.codexSessionIdentityHoldNotified = true;
-                    this.emit("codex_session_identity_unconfirmed", { name: this.name });
-                }
-                return null;
-            }
-            this.codexSessionIdentityHoldNotified = false;
+            const sid = this.backend?.getSessionId();
+            if (!sid)
+                return;
             const path = join(this.instanceDir, "session-id");
             // Idle observations happen after turns. Avoid needless writes (and mtime
             // churn) while still updating the marker when /new changes the session.
             try {
                 if (readFileSync(path, "utf-8").trim() === sid)
-                    return sid;
+                    return;
             }
             catch { /* first checkpoint */ }
             writeFileSync(path, sid);
             this.sessionCheckpointWarningEmitted = false;
             this.logger.debug("Session id checkpointed");
-            return sid;
         }
         catch (err) {
             // Session discovery is best-effort and must never break the pane state
@@ -7283,24 +7329,8 @@ export class Daemon extends EventEmitter {
                 this.sessionCheckpointWarningEmitted = true;
                 this.logger.warn({ err: err.message }, "Session id checkpoint failed");
             }
-            return null;
         }
     }
-    checkpointLivePaneBeforeReplacement(pane) {
-        // A pre-upgrade Codex pane can provide stronger, exact ownership
-        // evidence than an old crash-loop heuristic. Discover it before
-        // saveSessionId's skip-resume guard, then arm resume only if the
-        // checkpoint was actually durable. Never fall back to --last.
-        const exactCodexId = this.backend?.binaryName === "codex" ? this.backend.getSessionId(pane) : null;
-        if (exactCodexId)
-            this.skipResume = false;
-        const recoveredId = this.saveSessionId(pane);
-        if (exactCodexId && !recoveredId)
-            this.skipResume = true;
-        return recoveredId;
-    }
-    /** Only a live pre-upgrade pane can provide this positive migration proof. */
-    getRecoveredLegacyCodexSessionId() { return this.recoveredLegacyCodexSessionId; }
     readContextPercentage() {
         return this.backend?.getContextUsage() ?? 0;
     }