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

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
@@ -950,8 +948,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 +1203,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 +1212,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 +1341,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 +1421,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 +1965,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 +2006,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 +2063,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 +2111,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 +2660,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 +2803,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 +2942,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.
@@ -6353,25 +6303,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 +6501,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 +6528,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 +6770,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 +7158,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 +7186,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;
     }