@songsid/agend 2.3.4-beta.1 → 2.3.4-beta.11

package/dist/backend/codex-speed.d.ts

@@ -0,0 +1,14 @@
+export declare const CODEX_SPEEDS: readonly ["fast", "standard"];
+export type CodexSpeed = typeof CODEX_SPEEDS[number];
+/** The catalog's id for Codex's Fast tier. */
+export declare const CODEX_FAST_TIER = "priority";
+export declare function isCodexSpeed(value: unknown): value is CodexSpeed;
+/** The flags to append (with a leading space) for the configured speed, or why none (a quiet launch note). */
+export declare function codexSpeed(speed: unknown, catalog: {
+    model: string | null;
+    tiers: string[] | null;
+    unproven?: boolean;
+}): {
+    arg: string | null;
+    note: string | null;
+};

package/dist/backend/codex-speed.js

@@ -0,0 +1,35 @@
+/**
+ * M-2446: a per-agent Codex speed (`backend_options.codex.speed`), as launch flags. Unset launches as before.
+ *  - "fast"     → `-c service_tier="fast" -c features.fast_mode=true`, only when the catalog entry of the model that
+ *                 will run advertises the "priority" tier (Codex's Fast). Codex sends `service_tier: "priority"` then
+ *                 (verified on 0.165.0 against a mock Responses API). Otherwise no flag and a quiet note: codex would
+ *                 drop the tier itself with a warning row, and an unproven model may not take it.
+ *  - "standard" → `-c service_tier="default"`: no tier on the wire, overriding a Fast default saved by `/fast`.
+ * Codex accepts any string here and silently omits an unknown one, so the value is allow-listed (here and in
+ * config-validator.ts). Fast uses ChatGPT plan limits at 2.5× the Standard rate (OpenAI's Codex Speed page).
+ */
+import { t } from "../locale.js";
+import { shellQuote } from "./types.js";
+export const CODEX_SPEEDS = ["fast", "standard"];
+/** The catalog's id for Codex's Fast tier. */
+export const CODEX_FAST_TIER = "priority";
+export function isCodexSpeed(value) {
+    return typeof value === "string" && CODEX_SPEEDS.includes(value);
+}
+/** The flags to append (with a leading space) for the configured speed, or why none (a quiet launch note). */
+export function codexSpeed(speed, catalog) {
+    if (speed === undefined || speed === null || speed === "")
+        return { arg: null, note: null };
+    if (!isCodexSpeed(speed))
+        return { arg: null, note: t("codex.speed_skipped", String(speed), t("codex.speed_not_a_speed", CODEX_SPEEDS.join(", "))) };
+    if (speed === "standard")
+        return { arg: ` -c ${shellQuote(`service_tier="default"`)}`, note: null };
+    if (catalog.unproven)
+        return { arg: null, note: t("codex.speed_skipped", speed, t("effort.launch_codex_model_unproven")) };
+    if (!catalog.tiers)
+        return { arg: null, note: t("codex.speed_skipped", speed, t("codex.speed_unknown_model", catalog.model ?? "—")) };
+    if (!catalog.tiers.includes(CODEX_FAST_TIER))
+        return { arg: null, note: t("codex.speed_skipped", speed, t("codex.speed_not_offered", catalog.model ?? "—")) };
+    return { arg: ` -c ${shellQuote(`service_tier="fast"`)} -c features.fast_mode=true`, note: null };
+}
+//# sourceMappingURL=codex-speed.js.map

package/dist/backend/codex-speed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex-speed.js","sourceRoot":"","sources":["../../src/backend/codex-speed.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,cAAc,CAAC;AACjC,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,MAAM,EAAE,UAAU,CAAU,CAAC;AAE1D,8CAA8C;AAC9C,MAAM,CAAC,MAAM,eAAe,GAAG,UAAU,CAAC;AAE1C,MAAM,UAAU,YAAY,CAAC,KAAc;IACzC,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAK,YAAkC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AAC1F,CAAC;AAED,8GAA8G;AAC9G,MAAM,UAAU,UAAU,CACxB,KAAc,EAAE,OAA6E;IAE7F,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,EAAE;QAAE,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;IAC5F,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC;QAAE,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,qBAAqB,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,yBAAyB,EAAE,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;IACrJ,IAAI,KAAK,KAAK,UAAU;QAAE,OAAO,EAAE,GAAG,EAAE,OAAO,UAAU,CAAC,wBAAwB,CAAC,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;IACpG,IAAI,OAAO,CAAC,QAAQ;QAAE,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,qBAAqB,EAAE,KAAK,EAAE,CAAC,CAAC,oCAAoC,CAAC,CAAC,EAAE,CAAC;IAC3H,IAAI,CAAC,OAAO,CAAC,KAAK;QAAE,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,qBAAqB,EAAE,KAAK,EAAE,CAAC,CAAC,2BAA2B,EAAE,OAAO,CAAC,KAAK,IAAI,GAAG,CAAC,CAAC,EAAE,CAAC;IACtI,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,eAAe,CAAC;QAAE,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,qBAAqB,EAAE,KAAK,EAAE,CAAC,CAAC,yBAAyB,EAAE,OAAO,CAAC,KAAK,IAAI,GAAG,CAAC,CAAC,EAAE,CAAC;IAC9J,OAAO,EAAE,GAAG,EAAE,OAAO,UAAU,CAAC,qBAAqB,CAAC,6BAA6B,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;AACpG,CAAC"}

package/dist/backend/codex.d.ts

@@ -20,6 +20,21 @@ export declare const CODEX_STATUS_GLYPH: string;
  */
 export declare function codexLiveRowMatches(pane: string, rowPattern: RegExp): boolean;
 export declare function codexAppServerDisconnected(pane: string): boolean;
+/**
+ * M-2266: a one-shot "resume this conversation" for the next launch, written by the fleet (restart_instance with
+ * resume_session_id, validated there) into the instance directory and consumed by that launch.
+ */
+export declare const CODEX_RESUME_NEXT_FILE = "codex-resume-next.json";
+/**
+ * M-2266: the conversation the last launch was told to resume (auto or one-shot). The next launch asks codex's
+ * database whether that resume took (codex records the thread as it opens it); if it did not, that launch starts
+ * fresh once and says so — never the same failing resume again.
+ */
+export declare const CODEX_RESUME_ATTEMPT_FILE = "codex-resume-attempt.json";
+/** M-2266: conversations an auto-resume could not open (codex refused the id); skipped by later auto-resumes. */
+export declare const CODEX_RESUME_FAILED_FILE = "codex-resume-failed.json";
+/** Above this, a resumed rollout carries a note that codex may compact it first. */
+export declare const CODEX_RESUME_LARGE_BYTES: number;
 export declare class CodexBackend implements CliBackend {
     private instanceDir;
     /**
@@ -290,6 +305,18 @@ export declare class CodexBackend implements CliBackend {
     getInputUnavailableTransients(): InputUnavailableTransient[];
     getContextUsage(): number | null;
     getSessionId(): string | null;
+    /** The launch as the database plans it — and, when it has no conversation for this directory, an auto-resume (M-2266). */
+    private plannedCommand;
+    /** The database this instance's codex writes (see planResume). */
+    private stateDbPath;
+    /** M-2266: read and remove a JSON `{ id }` file in the instance directory; the id, or null. */
+    private takeIdFile;
+    private takeResumeAttempt;
+    private takeResumeNext;
+    /** M-2266: conversations an auto-resume tried and codex could not open; never auto-picked again. */
+    private failedResumes;
+    private rememberFailedResume;
+    private writeResumeAttempt;
     /** Which Codex session this launch resumes (#984). Reads, never writes, Codex state. */
     private planResume;
     /** Only a resume paints "Resuming session…"; a fresh launch never does. */

package/dist/backend/codex.js

@@ -4,15 +4,17 @@ import { execFileSync } from "node:child_process";
 import { execFile } from "../child-process.js";
 import { promisify } from "node:util";
 import { basename, dirname, join, resolve } from "node:path";
+import { stripCodexPassiveHintRow, withCodexPassiveHintTail } from "./codex-footer-hints.js";
 import { codexPackageWarning } from "./codex-package.js";
 import { probeCliVersion, resolveBinary, shellQuote, validateModel, validateProvider, warnIfModelMismatch } from "./types.js";
 import { credentialHomeSpec, credentialProfileHome, prepareCredentialProfileHome, resolveCredentialProfile, } from "./credential-profile.js";
 import { getAgendHome } from "../paths.js";
-import { CODEX_MODELS_CACHE_MAX_BYTES, codexShortHomeFor, readCodexEffortLevels, readCodexModelEffortLevels, resolveCodexLaunchModel } from "./codex-metadata.js";
+import { CODEX_MODELS_CACHE_MAX_BYTES, codexShortHomeFor, readCodexEffortLevels, readCodexModelEffortLevels, readCodexModelServiceTiers, resolveCodexLaunchModel } from "./codex-metadata.js";
 import { EFFORT_CAPABILITIES } from "./effort-metadata.js";
 import { codexEffort } from "./launch-effort.js";
+import { codexSpeed } from "./codex-speed.js";
 import { appendWithMarker, removeMarker } from "./marker-utils.js";
-import { codexSiblingState, codexStateDbAbsent, cwdRolloutsProvenAbsent, findExactCwdCodexSession, planCodexResume, newestMissedCwdRollout } from "./codex-session-lookup.js";
+import { checkResumeId, codexSiblingState, codexStateDbAbsent, codexThreadRowExists, cwdRolloutsProvenAbsent, findExactCwdCodexSession, planCodexResume, newestResumableRollout } from "./codex-session-lookup.js";
 import { t } from "../locale.js";
 import { quotaLine, quotaLowLine, quotaPausedLine } from "../quota-notice.js";
 import { parse as parseToml } from "smol-toml";
@@ -968,6 +970,21 @@ function codexUnboxedResumeLoading(rows) {
         return false;
     return after.slice(composer + 1).every(row => row === "");
 }
+/**
+ * M-2266: a one-shot "resume this conversation" for the next launch, written by the fleet (restart_instance with
+ * resume_session_id, validated there) into the instance directory and consumed by that launch.
+ */
+export const CODEX_RESUME_NEXT_FILE = "codex-resume-next.json";
+/**
+ * M-2266: the conversation the last launch was told to resume (auto or one-shot). The next launch asks codex's
+ * database whether that resume took (codex records the thread as it opens it); if it did not, that launch starts
+ * fresh once and says so — never the same failing resume again.
+ */
+export const CODEX_RESUME_ATTEMPT_FILE = "codex-resume-attempt.json";
+/** M-2266: conversations an auto-resume could not open (codex refused the id); skipped by later auto-resumes. */
+export const CODEX_RESUME_FAILED_FILE = "codex-resume-failed.json";
+/** Above this, a resumed rollout carries a note that codex may compact it first. */
+export const CODEX_RESUME_LARGE_BYTES = 20 * 1024 * 1024;
 export class CodexBackend {
     instanceDir;
     /**
@@ -1123,6 +1140,7 @@ export class CodexBackend {
         const rows = pane.replace(/\r/g, "").split("\n");
         while (rows.length && !rows[rows.length - 1].trim())
             rows.pop();
+        stripCodexPassiveHintRow(rows);
         const footer = rows.pop() ?? "";
         // Codex preserves other configured status-line items after the context
         // meter (observed on 0.156.0: "Context 100% left · GPT-6-Astra"). They
@@ -1193,6 +1211,9 @@ export class CodexBackend {
         // idle chrome.  Remove only that observed decorative glyph; broader
         // punctuation stripping could turn real tool output into a false prompt.
         const rows = pane.replace(/\r/g, "").split("\n").map(row => row.replace(/⋆/gu, ""));
+        while (rows.length && !rows.at(-1).trim())
+            rows.pop();
+        stripCodexPassiveHintRow(rows);
         let prompt = -1;
         for (let i = rows.length - 1; i >= 0; i--) {
             if (/^[>›]\s*Ask Codex to do anything\s*$/.test(rows[i])) {
@@ -1256,27 +1277,39 @@ export class CodexBackend {
             cmd = `${this.binaryPath} ${approvalFlag}`;
         }
         else {
-            const plan = this.planResume(config);
-            this.lastLaunchResumes = plan.mode === "resume" || plan.mode === "last";
-            if (plan.mode === "resume")
-                cmd = `${this.binaryPath} resume ${shellQuote(plan.id)} ${approvalFlag}`;
-            else if (plan.mode === "last")
-                cmd = `${this.binaryPath} resume --last ${approvalFlag}`;
-            else
+            const resumeBy = (id, why, bytes) => {
+                this.lastLaunchResumes = true;
+                this.writeResumeAttempt(id);
+                const large = bytes !== null && bytes > CODEX_RESUME_LARGE_BYTES ? ` ${t("codex.resume_large", String(Math.round(bytes / (1024 * 1024))))}` : "";
+                this.launchWarning = why + large;
+                return `${this.binaryPath} resume ${shellQuote(id)} ${approvalFlag}`;
+            };
+            const sessionsDir = join(this.isolatedCodexHome, "sessions");
+            // M-2266: the previous launch was told to resume a conversation by id. Codex records a thread as it opens it,
+            // so a resume that did not take (codex exited with "No saved session found…") left no row: this launch starts
+            // fresh, once, and says so. A database that cannot be read proves nothing, and planning goes on as usual.
+            // A new one-shot ask comes first: it is the person's explicit choice for this launch.
+            const oneShot = this.takeResumeNext();
+            const attempt = this.takeResumeAttempt();
+            const failed = !oneShot && attempt !== null && codexThreadRowExists(this.stateDbPath(), attempt) === false;
+            if (failed) {
+                // Remembered, so the auto-resume never picks this conversation again on a later launch.
+                this.rememberFailedResume(attempt);
                 cmd = `${this.binaryPath} ${approvalFlag}`;
-            if (plan.mode === "last")
-                this.launchWarning = t("codex.resume_db_unreadable_last", plan.cause);
-            else if (plan.mode === "fresh" && plan.reason === "unreadable-with-siblings") {
-                this.launchWarning = t("codex.resume_db_unreadable_fresh", plan.cause);
+                this.launchWarning = t("codex.resume_failed", config.workingDirectory, attempt);
+            }
+            else if (oneShot) {
+                // M-2266: validated when it was asked for (restart_instance); checked again now, as the rollout may have moved.
+                const check = checkResumeId(sessionsDir, config.workingDirectory, oneShot);
+                if (check.ok)
+                    cmd = resumeBy(check.rollout.id, t("codex.resume_oneshot", config.workingDirectory, check.rollout.id), check.rollout.bytes);
+                else {
+                    cmd = this.plannedCommand(config, approvalFlag, sessionsDir, resumeBy);
+                    this.launchWarning = [t("codex.resume_oneshot_invalid", config.workingDirectory, oneShot, check.reason), this.launchWarning].filter(Boolean).join("\n");
+                }
             }
-            else if (plan.mode === "fresh") {
-                // #1053: "none" is also what a lookup that missed looks like (#1028
-                // was a silent new session per restart). A workspace that never had
-                // a conversation stays quiet; one whose rollout shows a turn is told
-                // which conversation to resume by hand.
-                const missed = newestMissedCwdRollout(join(this.isolatedCodexHome, "sessions"), config.workingDirectory);
-                if (missed)
-                    this.launchWarning = t("codex.resume_none_but_history", config.workingDirectory, missed.id);
+            else {
+                cmd = this.plannedCommand(config, approvalFlag, sessionsDir, resumeBy);
             }
         }
         if (config.model) {
@@ -1299,7 +1332,13 @@ export class CodexBackend {
             : { model: runs.model, levels: null, unproven: true });
         if (effort.arg)
             cmd += effort.arg;
-        this.quietLaunchNotes = effort.note ? [effort.note] : [];
+        // M-2446: the per-agent speed (codex-speed.ts) — Fast only where the running model's catalog entry offers it.
+        const speed = codexSpeed(config.backendOptions?.speed, runs.proven
+            ? readCodexModelServiceTiers({ isolatedHome: this.isolatedCodexHome, sharedHome: this.sharedCodexHome, model: runs.model })
+            : { model: runs.model, tiers: null, unproven: true });
+        if (speed.arg)
+            cmd += speed.arg;
+        this.quietLaunchNotes = [effort.note, speed.note].filter((n) => !!n);
         // AgEnD instances are unattended processes: an interactive self-update
         // picker blocks delivery and must never be enabled by a copied global or
         // managed config layer. Keep this last so the CLI override is authoritative.
@@ -1827,7 +1866,7 @@ export class CodexBackend {
         // U+22C6 is Codex's observed cosmetic starfield; it can be drawn in the
         // prompt, between prompt/footer, and below the footer. A drafted composer
         // is also idle once this same bottom footer proves it owns the screen.
-        const contextReady = /(?:^|\n)[>›][ \t⋆]+(?!\d+\.)\S[^\r\n]*\r?\n(?:[ \t⋆]*\r?\n){0,3}[ \t⋆]+(?:[0-9a-f-]{36}[ \t]+·[ \t]+)?Context[ \t]+(?:\d+%[ \t]+(?:left|used)|\d+…|…)[^\r\n]*(?:\r?\n[ \t⋆]*)*$/i;
+        const contextReady = withCodexPassiveHintTail(/(?:^|\n)[>›][ \t⋆]+(?!\d+\.)\S[^\r\n]*\r?\n(?:[ \t⋆]*\r?\n){0,3}[ \t⋆]+(?:[0-9a-f-]{36}[ \t]+·[ \t]+)?Context[ \t]+(?:\d+%[ \t]+(?:left|used)|\d+…|…)[^\r\n]*(?:\r?\n[ \t⋆]*)*$/i);
         const footerPattern = this.configuredStatusLineFooterPattern();
         if (!footerPattern)
             return contextReady;
@@ -1836,13 +1875,13 @@ export class CodexBackend {
         // configured, that value must specifically be Ready. This is positive
         // structural proof, never a deny-list of known dialogs.
         const footerSource = footerPattern.source.slice(1, -1);
-        const noContextReady = new RegExp(String.raw `(?:^|\n)[>›][ \t⋆]*Ask Codex to do anything[ \t⋆]*\r?\n(?:[ \t⋆]*\r?\n){0,3}${footerSource}(?:\r?\n[ \t⋆]*)*$`, "iu");
+        const noContextReady = withCodexPassiveHintTail(new RegExp(String.raw `(?:^|\n)[>›][ \t⋆]*Ask Codex to do anything[ \t⋆]*\r?\n(?:[ \t⋆]*\r?\n){0,3}${footerSource}(?:\r?\n[ \t⋆]*)*$`, "iu"));
         // #978: a configured footer that carries a Context item in any position
         // is the Context footer: same drafted-composer rule as Context-first. The
         // whole row must match the configured item grammar, so an arbitrary
         // indented line that merely contains `Context N% left` cannot pass.
         const configuredContextReady = this.configuredHasContextItem()
-            ? new RegExp(String.raw `(?:^|\n)[>›][ \t⋆]+(?!\d+\.)\S[^\r\n]*\r?\n(?:[ \t⋆]*\r?\n){0,3}(?=[^\r\n]*${CODEX_CONTEXT_ITEM})${footerSource}(?:\r?\n[ \t⋆]*)*$`, "iu")
+            ? withCodexPassiveHintTail(new RegExp(String.raw `(?:^|\n)[>›][ \t⋆]+(?!\d+\.)\S[^\r\n]*\r?\n(?:[ \t⋆]*\r?\n){0,3}(?=[^\r\n]*${CODEX_CONTEXT_ITEM})${footerSource}(?:\r?\n[ \t⋆]*)*$`, "iu"))
             : null;
         return new RegExp([contextReady.source, noContextReady.source, configuredContextReady?.source]
             .filter((source) => !!source)
@@ -2376,6 +2415,75 @@ export class CodexBackend {
         // (planResume); AgEnD persists no session id of its own (#913 was reverted).
         return null;
     }
+    /** The launch as the database plans it — and, when it has no conversation for this directory, an auto-resume (M-2266). */
+    plannedCommand(config, approvalFlag, sessionsDir, resumeBy) {
+        const plan = this.planResume(config);
+        this.lastLaunchResumes = plan.mode === "resume" || plan.mode === "last";
+        if (plan.mode === "resume")
+            return `${this.binaryPath} resume ${shellQuote(plan.id)} ${approvalFlag}`;
+        if (plan.mode === "last") {
+            this.launchWarning = t("codex.resume_db_unreadable_last", plan.cause);
+            return `${this.binaryPath} resume --last ${approvalFlag}`;
+        }
+        if (plan.reason === "unreadable-with-siblings") {
+            this.launchWarning = t("codex.resume_db_unreadable_fresh", plan.cause);
+            return `${this.binaryPath} ${approvalFlag}`;
+        }
+        // #1053 found these and only told the person; M-2266 (the user's choice) resumes it: codex's database has no
+        // conversation for this directory, but its newest CLI rollout of exactly this directory, with a turn, is still
+        // there — `codex resume <id>` reads it.
+        const found = newestResumableRollout(sessionsDir, config.workingDirectory, undefined, this.failedResumes());
+        if (found)
+            return resumeBy(found.id, t("codex.resume_auto", config.workingDirectory, found.id), found.bytes);
+        return `${this.binaryPath} ${approvalFlag}`;
+    }
+    /** The database this instance's codex writes (see planResume). */
+    stateDbPath() {
+        const instanceDb = join(this.isolatedCodexHome, "state_5.sqlite");
+        const sharedDb = join(this.sharedCodexHome, "state_5.sqlite");
+        return existsSync(instanceDb) || sharedDb === instanceDb ? instanceDb : sharedDb;
+    }
+    /** M-2266: read and remove a JSON `{ id }` file in the instance directory; the id, or null. */
+    takeIdFile(name) {
+        const path = join(this.instanceDir, name);
+        let id = null;
+        try {
+            const v = JSON.parse(readFileSync(path, "utf-8"));
+            if (typeof v.id === "string" && /^[0-9a-f-]{36}$/i.test(v.id))
+                id = v.id;
+        }
+        catch { /* absent or unreadable */ }
+        try {
+            unlinkSync(path);
+        }
+        catch { /* absent */ }
+        return id;
+    }
+    takeResumeAttempt() { return this.takeIdFile(CODEX_RESUME_ATTEMPT_FILE); }
+    takeResumeNext() { return this.takeIdFile(CODEX_RESUME_NEXT_FILE); }
+    /** M-2266: conversations an auto-resume tried and codex could not open; never auto-picked again. */
+    failedResumes() {
+        try {
+            const v = JSON.parse(readFileSync(join(this.instanceDir, CODEX_RESUME_FAILED_FILE), "utf-8"));
+            return new Set(Array.isArray(v.ids) ? v.ids.filter((x) => typeof x === "string") : []);
+        }
+        catch {
+            return new Set();
+        }
+    }
+    rememberFailedResume(id) {
+        const ids = [...this.failedResumes(), id].slice(-50);
+        try {
+            writeFileSync(join(this.instanceDir, CODEX_RESUME_FAILED_FILE), JSON.stringify({ ids: [...new Set(ids)] }), { mode: 0o600 });
+        }
+        catch { /* best effort: then the next launch may try it once more, and fall back again */ }
+    }
+    writeResumeAttempt(id) {
+        try {
+            writeFileSync(join(this.instanceDir, CODEX_RESUME_ATTEMPT_FILE), JSON.stringify({ id, at: new Date().toISOString() }), { mode: 0o600 });
+        }
+        catch { /* without it a failed resume is only retried, as any failed launch is */ }
+    }
     /** Which Codex session this launch resumes (#984). Reads, never writes, Codex state. */
     planResume(config) {
         // Read the database Codex actually writes: the one in this instance's