nolo-cli 0.100.0-alpha.1 → 0.100.0

package/{chunk-6OZ36FXI.js → chunk-27ONFIEY.js}

@@ -3,7 +3,7 @@ import {
   resolvePlatformChatCompletionsEndpoint,
   resolvePlatformHostedCredentialProvider,
   resolvePlatformResponsesEndpoint
-} from "./chunk-GQBOR3G6.js";
+} from "./chunk-7KVZ5LDQ.js";
 import {
   CLI_PROVIDER_VALUES
 } from "./chunk-W7XHHYWM.js";
@@ -11,7 +11,7 @@ import {
   CLIENT_VERSION_TOO_OLD_CODE,
   buildClientVersionGateErrorDetail,
   evaluatePlatformHostedClientVersionGate
-} from "./chunk-Q67DOFOO.js";
+} from "./chunk-Y3PMXGLH.js";
 import {
   asTrimmedLowercaseString
 } from "./chunk-QSJ3HFEF.js";
@@ -164,10 +164,28 @@ function resolveProviderAuthHeaderName(args) {
   if (/xiaomimimo\.com/i.test(args.endpoint)) return "api-key";
   return "Authorization";
 }
+var OPENCODE_GO_ENDPOINT_RE = /^https?:\/\/opencode\.ai\/zen\/go\//i;
+var OPENCODE_SESSION_HEADER = "x-opencode-session";
+var OPENCODE_USER_AGENT = "nolo-agent/1.0";
+var PROCESS_FALLBACK_SESSION_ID = `nolo-${Math.random().toString(36).slice(2)}${Date.now().toString(36)}`;
+function isOpenCodeGoEndpoint(endpoint) {
+  return typeof endpoint === "string" && OPENCODE_GO_ENDPOINT_RE.test(endpoint.trim());
+}
+function buildProviderSessionHeaders(args) {
+  if (!isOpenCodeGoEndpoint(args.endpoint)) return {};
+  return {
+    [OPENCODE_SESSION_HEADER]: args.sessionId?.trim() || PROCESS_FALLBACK_SESSION_ID,
+    "User-Agent": OPENCODE_USER_AGENT
+  };
+}
 function buildProviderAuthHeaders(args) {
-  if (!args.apiKey) return {};
+  const sessionHeaders = buildProviderSessionHeaders(args);
+  if (!args.apiKey) return sessionHeaders;
   const headerName = resolveProviderAuthHeaderName(args);
-  return headerName.toLowerCase() === "authorization" ? { Authorization: `Bearer ${args.apiKey}` } : { [headerName]: args.apiKey };
+  return {
+    ...sessionHeaders,
+    ...headerName.toLowerCase() === "authorization" ? { Authorization: `Bearer ${args.apiKey}` } : { [headerName]: args.apiKey }
+  };
 }
 async function buildProviderExecutionPlan(args) {
   const { agentConfig, env } = args;

package/{chunk-JEDZAO7L.js → chunk-2SYTUTLI.js}

@@ -1,15 +1,15 @@
-import {
-  loadProfileConfig
-} from "./chunk-BYMV6QZG.js";
-import {
-  resolveDefaultSpawn
-} from "./chunk-X7HHHIOZ.js";
 import {
   isCompiledBinary
 } from "./chunk-A7GB5UGH.js";
 import {
   DEFAULT_NOLO_SERVER_URL
 } from "./chunk-OLZBQWZU.js";
+import {
+  loadProfileConfig
+} from "./chunk-TNIX77YM.js";
+import {
+  resolveDefaultSpawn
+} from "./chunk-Y6ROFCZO.js";
 import {
   normalizeServerOrigin
 } from "./chunk-CF7PE763.js";
@@ -30,6 +30,7 @@ import {
   readFileSync,
   renameSync,
   rmSync,
+  statSync,
   writeSync,
   writeFileSync
 } from "node:fs";
@@ -38,6 +39,7 @@ import { dirname, isAbsolute, join, normalize } from "node:path";
 import { randomUUID } from "node:crypto";
 var UPDATE_STATE_FILE = "update-result.json";
 var UPDATE_STALE_MS = 15 * 60 * 1e3;
+var UPDATE_CORRUPT_MAX_AGE_MS = 30 * 60 * 1e3;
 var UPDATE_LOCK_FILE = "update.lock";
 function resolveNoloHome(env, homeDir = homedir()) {
   return env.NOLO_HOME?.trim() || join(homeDir, ".nolo");
@@ -101,6 +103,39 @@ function readWindowsUpdateState(env = process.env, homeDir = homedir()) {
     return null;
   }
 }
+function assessWindowsUpdatePending(state, now, statePath) {
+  const startedAtMs = Date.parse(state.startedAt);
+  const MAX_CLOCK_SKEW_MS = 5 * 60 * 1e3;
+  if (Number.isFinite(startedAtMs) && startedAtMs - now <= MAX_CLOCK_SKEW_MS) {
+    const ageMs = now - startedAtMs;
+    const stale = ageMs >= UPDATE_STALE_MS;
+    return {
+      classification: stale ? "stale" : "active",
+      ageMs,
+      startedAtUsable: true,
+      blocksStartup: !stale
+    };
+  }
+  let mtimeAge = Number.NaN;
+  try {
+    mtimeAge = now - statSync(statePath).mtimeMs;
+  } catch {
+  }
+  if (!Number.isFinite(mtimeAge) || mtimeAge < UPDATE_CORRUPT_MAX_AGE_MS) {
+    return {
+      classification: "corrupt-unageable",
+      ageMs: mtimeAge,
+      startedAtUsable: false,
+      blocksStartup: true
+    };
+  }
+  return {
+    classification: "stale",
+    ageMs: mtimeAge,
+    startedAtUsable: false,
+    blocksStartup: false
+  };
+}
 function consumeWindowsUpdateStartupNotice(env = process.env, options = {}) {
   const homeDir = options.homeDir ?? homedir();
   const statePath = resolveWindowsUpdateStatePath(env, homeDir);
@@ -110,26 +145,35 @@ function consumeWindowsUpdateStartupNotice(env = process.env, options = {}) {
     if (options.ownerUpdateId && state.updateId && options.ownerUpdateId === state.updateId) {
       return null;
     }
-    const startedAt = Date.parse(state.startedAt);
-    const age = (options.now ?? Date.now()) - startedAt;
-    if (!Number.isFinite(age) || age < UPDATE_STALE_MS) {
+    const now = options.now ?? Date.now();
+    const assessment = assessWindowsUpdatePending(state, now, statePath);
+    if (assessment.blocksStartup) {
       return {
         blocking: true,
-        text: `Nolo update is still running. Try again shortly.
+        text: `A Nolo update may still be in progress (${describeUpdatePhase(state)}). Run "nolo update status" for details, or retry shortly.
 Log: ${state.logPath}`
       };
     }
     if (state.lockPath && state.updateId) {
       removeOwnedLock(state.lockPath, state.updateId);
     }
-    rmSync(statePath, { force: true });
     return {
       blocking: false,
-      text: `The previous Nolo update helper stopped unexpectedly. Verify with "nolo -v"; a manual npm repair may be required.
+      text: `The previous Nolo update helper stopped unexpectedly and its lock was released. Verify with "nolo -v" / "nolo update status"; a manual npm repair may be required.
 Log: ${state.logPath}`
     };
   }
-  rmSync(statePath, { force: true });
+  if (state.noticeAcknowledgedAt) {
+    return null;
+  }
+  const acknowledged = {
+    ...state,
+    noticeAcknowledgedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  try {
+    writeJsonAtomic(statePath, acknowledged);
+  } catch {
+  }
   if (state.status === "success") {
     return {
       blocking: false,
@@ -144,6 +188,82 @@ ${state.message}` : ""}
 Log: ${state.logPath}`
   };
 }
+function describeUpdatePhase(state) {
+  if (state.phase) {
+    return `phase: ${state.phase}`;
+  }
+  return "helper running";
+}
+function getWindowsUpdateStatus(env = process.env, options = {}) {
+  const homeDir = options.homeDir ?? homedir();
+  const state = readWindowsUpdateState(env, homeDir);
+  const now = options.now ?? Date.now();
+  const version = options.currentVersion ?? "unknown";
+  if (!state) {
+    return {
+      status: "none",
+      alive: false,
+      text: `No recorded Nolo update.
+Installed version: ${version}`
+    };
+  }
+  const lines = [];
+  lines.push(`Update status: ${state.status}`);
+  lines.push(`Installed version: ${version}`);
+  lines.push(`Channel: ${state.channel}`);
+  lines.push(`From version: ${state.currentVersion}`);
+  if (state.targetVersion) lines.push(`Target version: ${state.targetVersion}`);
+  if (state.phase) lines.push(`Phase: ${state.phase}`);
+  lines.push(`Started: ${state.startedAt}`);
+  if (state.phaseStartedAt) lines.push(`Phase started: ${state.phaseStartedAt}`);
+  if (state.phaseDeadline) lines.push(`Phase deadline: ${state.phaseDeadline}`);
+  if (state.finishedAt) lines.push(`Finished: ${state.finishedAt}`);
+  if (state.helperPid) lines.push(`Helper pid: ${state.helperPid}`);
+  if (state.message) lines.push(`Message: ${state.message}`);
+  lines.push(`Log: ${state.logPath}`);
+  if (state.status === "pending") {
+    const statePath = resolveWindowsUpdateStatePath(env, homeDir);
+    const assessment = assessWindowsUpdatePending(state, now, statePath);
+    const deadline = state.phaseDeadline ? Date.parse(state.phaseDeadline) : NaN;
+    const pastDeadline = Number.isFinite(deadline) && now > deadline;
+    if (pastDeadline) {
+      lines.push(
+        `Phase deadline elapsed: the recorded phase has run past its soft ceiling. This can be a hung helper, but it can also be a slow install \u2014 the lock is NOT auto-released on this evidence alone.`
+      );
+    }
+    switch (assessment.classification) {
+      case "active":
+        lines.push(
+          `Diagnosis: update record is fresh (${describeUpdatePhase(state)}). The helper process has not been verified alive; the record simply has not outlived its bound, so startup is still blocked.`
+        );
+        break;
+      case "corrupt-unageable":
+        lines.push(
+          `Diagnosis: update record has an unreadable start time and cannot be aged reliably. Startup stays conservatively blocked until the record outlives its hard bound; inspect the log to tell a hung helper from a live one.`
+        );
+        break;
+      case "stale":
+        lines.push(
+          `Diagnosis: update record has outlived its bound; the helper is presumed stopped. The startup guard releases the stale lock on next start, then this record remains here for diagnosis.`
+        );
+        break;
+    }
+    return {
+      status: "pending",
+      alive: assessment.blocksStartup,
+      pendingClassification: assessment.classification,
+      text: lines.join("\n")
+    };
+  }
+  if (state.status === "success") {
+    lines.push(
+      state.noticeAcknowledgedAt ? `Diagnosis: update applied and already acknowledged.` : `Diagnosis: update applied; notice pending on next start.`
+    );
+  } else {
+    lines.push(`Diagnosis: update failed; see the log above.`);
+  }
+  return { status: state.status, alive: false, text: lines.join("\n") };
+}
 function defaultLaunchWindowsUpdateHelper(input) {
   const child = spawn(input.execPath, [input.helperPath, input.payload], {
     detached: true,
@@ -172,6 +292,19 @@ const writeState = (next) => {
   writeFileSync(temp, JSON.stringify(next, null, 2) + "\n", "utf8");
   renameSync(temp, payload.statePath);
 };
+// Record the current helper step with a bounded wall-clock deadline so the
+// startup guard can tell a live phase from a hung one. Deadline is a soft
+// ceiling: a phase that overruns it is reported stale, not killed.
+const setPhase = (base, phase, budgetMs) => {
+  const phaseStartedAt = new Date().toISOString();
+  const phaseDeadline = new Date(Date.now() + budgetMs).toISOString();
+  try {
+    writeState({ ...base, status: "pending", phase, phaseStartedAt, phaseDeadline });
+  } catch (error) {
+    log("Could not persist phase " + phase + ": " + (error && error.message ? error.message : String(error)));
+  }
+  return { ...base, status: "pending", phase, phaseStartedAt, phaseDeadline };
+};
 const runNpm = (args) => {
   const command = [payload.nodePath, payload.npmCliPath, ...args].join(" ");
   log("> " + command);
@@ -229,6 +362,27 @@ const isWithin = (root, candidate) => {
 const quoteCmd = (value) => '"' + String(value).replace(/"/g, '""') + '"';
 const quotePowerShell = (value) => "'" + String(value).replace(/'/g, "''") + "'";
 const quoteSh = (value) => "'" + String(value).replace(/'/g, "'\\''") + "'";
+
+let stagedDirReferenced = false;
+let lockOwnershipLost = false;
+let shimLeftUnrestored = false;
+
+const assertLockOwnership = () => {
+  try {
+    if (!existsSync(payload.lockPath)) {
+      throw new Error("Update lock was released or removed; aborting to avoid racing another process");
+    }
+    const raw = readFileSync(payload.lockPath, "utf8").trim();
+    const owner = raw.startsWith("{") ? JSON.parse(raw).updateId : raw;
+    if (owner !== payload.updateId) {
+      throw new Error("Update lock was reclaimed by " + owner + "; aborting to avoid racing another updater");
+    }
+  } catch (e) {
+    lockOwnershipLost = true;
+    throw new Error("Lock ownership check failed: " + (e && e.message ? e.message : String(e)));
+  }
+};
+
 const switchWindowsShims = (shimDir, entrypoint) => {
   const shims = [
     { path: join(shimDir, "nolo.cmd"), content: "@ECHO off\r\n" + quoteCmd(payload.nodePath) + " " + quoteCmd(entrypoint) + " %*\r\n" },
@@ -243,14 +397,45 @@ const switchWindowsShims = (shimDir, entrypoint) => {
     return { ...shim, temp, backup, existed: existsSync(shim.path) };
   });
   const activated = [];
+  const attemptRollback = () => {
+    let allRestored = true;
+    for (const shim of [...activated].reverse()) {
+      try { rmSync(shim.path, { force: true }); } catch (e) {
+        log("CRITICAL: Failed to remove new shim " + shim.path + ": " + (e && e.message ? e.message : String(e)));
+      }
+      if (shim.existed) {
+        try {
+          renameSync(shim.backup, shim.path);
+        } catch (e) {
+          allRestored = false;
+          log("CRITICAL: Failed to restore backup shim for " + shim.path + ": " + (e && e.message ? e.message : String(e)));
+        }
+      } else if (existsSync(shim.path)) {
+        // The delete above did not remove this shim (locked file, ACL, ...).
+        // It still points at the staged directory, so the rollback is NOT clean.
+        allRestored = false;
+        log("CRITICAL: New shim still present after rollback attempt: " + shim.path);
+      }
+    }
+    for (const shim of prepared) try { rmSync(shim.temp, { force: true }); } catch {}
+    stagedDirReferenced = !allRestored;
+    return allRestored;
+  };
+
   try {
     for (const shim of prepared) {
       if (shim.existed) renameSync(shim.path, shim.backup);
       try {
         renameSync(shim.temp, shim.path);
+        stagedDirReferenced = true;
       } catch (error) {
         if (shim.existed) {
-          try { renameSync(shim.backup, shim.path); } catch {}
+          try {
+            renameSync(shim.backup, shim.path);
+          } catch (restoreErr) {
+            shimLeftUnrestored = true;
+            log("CRITICAL: Failed to restore backup shim for " + shim.path + ": " + (restoreErr && restoreErr.message ? restoreErr.message : String(restoreErr)));
+          }
         }
         throw error;
       }
@@ -258,22 +443,19 @@ const switchWindowsShims = (shimDir, entrypoint) => {
       activated.push(shim);
     }
   } catch (error) {
-    for (const shim of [...activated].reverse()) {
-      try { rmSync(shim.path, { force: true }); } catch {}
-      if (shim.existed) {
-        try { renameSync(shim.backup, shim.path); } catch {}
+    if (!attemptRollback() || shimLeftUnrestored) {
+      if (error && typeof error === "object") {
+        error.message = (error.message ? error.message : String(error)) + "; rollback incomplete";
       }
+      log("CRITICAL: Rollback incomplete while switching launch shims");
     }
-    for (const shim of prepared) try { rmSync(shim.temp, { force: true }); } catch {}
     throw error;
   }
   return {
     rollback: () => {
-      for (const shim of [...activated].reverse()) {
-        try { rmSync(shim.path, { force: true }); } catch {}
-        if (shim.existed) {
-          try { renameSync(shim.backup, shim.path); } catch {}
-        }
+      const restored = attemptRollback();
+      if (!restored) {
+        throw new Error("Rollback incomplete: one or more launch shims could not be restored or removed");
       }
     },
     commit: () => {
@@ -296,7 +478,9 @@ const switchWindowsShims = (shimDir, entrypoint) => {
     updateId: payload.updateId,
     lockPath: payload.lockPath,
   };
+  let progress = base;
   try {
+    progress = setPhase(base, "wait-parent-exit", 480 * 250 + 60 * 1000);
     log("Waiting for parent process " + payload.parentPid + " to exit");
     let parentExited = false;
     for (let waited = 0; waited < 480; waited++) {
@@ -306,6 +490,7 @@ const switchWindowsShims = (shimDir, entrypoint) => {
     if (!parentExited) throw new Error("Timed out waiting for the current Nolo process to exit");
     await delay(250);
 
+    progress = setPhase(progress, "wait-other-windows", 120 * 1000 + 30 * 1000);
     const otherProcessDeadline = Date.now() + 120 * 1000;
     let otherPids = listOtherNoloPids();
     let checks = 0;
@@ -319,6 +504,7 @@ const switchWindowsShims = (shimDir, entrypoint) => {
       throw new Error("Other Nolo processes are still running: " + otherPids.join(", "));
     }
 
+    progress = setPhase(progress, "resolve-prefix", 30 * 1000);
     const prefixResult = runNpm(["prefix", "-g"]);
     if (prefixResult.code !== 0 || !prefixResult.stdout) throw new Error("Could not resolve npm global prefix");
     const prefix = prefixResult.stdout.split(/\r?\n/).at(-1).trim();
@@ -329,6 +515,7 @@ const switchWindowsShims = (shimDir, entrypoint) => {
       throw new Error("Refusing to update a different npm prefix. Current entrypoint: " + payload.entrypointPath + "; npm prefix: " + prefix);
     }
 
+    progress = setPhase(progress, "resolve-target-version", 30 * 1000);
     const targetResult = runNpm(["view", "nolo-cli@" + payload.channel, "version"]);
     if (targetResult.code !== 0 || !parseVersion(targetResult.stdout)) {
       throw new Error("Could not resolve nolo-cli@" + payload.channel + " target version");
@@ -339,10 +526,13 @@ const switchWindowsShims = (shimDir, entrypoint) => {
     }
 
     if (compare(targetVersion, payload.currentVersion) > 0) {
+      progress = setPhase(progress, "install-target", 5 * 60 * 1000 + 30 * 1000);
       const versionPrefix = join(payload.managedRoot, targetVersion + "-" + payload.updateId);
       uncommittedVersionPrefix = versionPrefix;
       mkdirSync(versionPrefix, { recursive: true });
-      const install = runNpm(["install", "-g", "--prefix", versionPrefix, "nolo-cli@" + payload.channel, "--force", "--progress"]);
+      // Install the exact version resolved from the dist-tag above — never the
+      // floating channel tag — so the staged package is the verified one.
+      const install = runNpm(["install", "-g", "--prefix", versionPrefix, "nolo-cli@" + targetVersion, "--force", "--progress"]);
       if (install.code !== 0) throw new Error("npm install exited with code " + install.code);
       const stagedPackagePath = join(versionPrefix, "node_modules", "nolo-cli", "package.json");
       const staged = JSON.parse(readFileSync(stagedPackagePath, "utf8"));
@@ -351,6 +541,8 @@ const switchWindowsShims = (shimDir, entrypoint) => {
       }
       const stagedEntrypoint = join(versionPrefix, "node_modules", "nolo-cli", "index.js");
       if (!existsSync(stagedEntrypoint)) throw new Error("Staged nolo entrypoint is missing");
+      assertLockOwnership();
+      progress = setPhase(progress, "switch-shims", 60 * 1000);
       const switchedShims = switchWindowsShims(prefix, stagedEntrypoint);
       const verify = spawnSync(payload.nodePath, [stagedEntrypoint, "-v"], {
         encoding: "utf8",
@@ -360,29 +552,51 @@ const switchWindowsShims = (shimDir, entrypoint) => {
         timeout: 30 * 1000,
       });
       if (verify.error || verify.status !== 0 || !String(verify.stdout || "").includes(targetVersion)) {
-        switchedShims.rollback();
+        let rollbackError = null;
+        try {
+          switchedShims.rollback();
+        } catch (e) {
+          rollbackError = e;
+        }
+        if (rollbackError) {
+          throw new Error(
+            "The staged CLI failed its post-switch version check; " +
+              (rollbackError && rollbackError.message ? rollbackError.message : String(rollbackError)),
+          );
+        }
         throw new Error("The staged CLI failed its post-switch version check; the previous launch shims were restored");
       }
+      // The lock could have been reclaimed (stale timeout / competing updater)
+      // during the verify window. Re-check before committing so we never claim
+      // success for an update we no longer own. We deliberately do not roll the
+      // shims back here: a competing updater may be mid-switch, and nothing is
+      // deleted, so leaving our shims in place is recoverable (last writer wins).
+      assertLockOwnership();
       switchedShims.commit();
       uncommittedVersionPrefix = null;
-      for (const entry of readdirSync(payload.managedRoot)) {
-        const candidate = join(payload.managedRoot, entry);
-        if (normalize(candidate) !== normalize(versionPrefix)) {
-          try { rmSync(candidate, { recursive: true, force: true }); } catch {}
-        }
-      }
+      // Previous versions are intentionally retained (unbounded until a
+      // reference-aware cleanup exists) because deleting them risks removing a
+      // directory that a shim or a rolled-back update still references.
       log("Verified nolo-cli " + targetVersion + " at " + stagedEntrypoint);
     } else {
       log("Already current at " + targetVersion);
     }
-    writeState({ ...base, status: "success", targetVersion, finishedAt: new Date().toISOString() });
+    writeState({ ...progress, status: "success", phase: "done", targetVersion, finishedAt: new Date().toISOString() });
   } catch (error) {
     const message = error && error.message ? error.message : String(error);
     log("ERROR: " + message);
     if (uncommittedVersionPrefix) {
-      try { rmSync(uncommittedVersionPrefix, { recursive: true, force: true }); } catch {}
+      if (stagedDirReferenced) {
+        log("PRESERVING staged directory " + uncommittedVersionPrefix + " because launch shims may still reference it; deleting it would cause MODULE_NOT_FOUND");
+      } else {
+        try { rmSync(uncommittedVersionPrefix, { recursive: true, force: true }); } catch {}
+      }
+    }
+    if (lockOwnershipLost) {
+      log("Not writing a failed status record: the update lock belongs to another updater");
+    } else {
+      writeState({ ...progress, status: "failed", finishedAt: new Date().toISOString(), message });
     }
-    writeState({ ...base, status: "failed", finishedAt: new Date().toISOString(), message });
     process.exitCode = 1;
   } finally {
     try {
@@ -679,7 +893,11 @@ async function runShellScript(script, {
   const proc = spawn2({
     cmd: ["sh", "-c", script],
     cwd,
-    stdin: "inherit",
+    // Capture mode (TUI sink): ignore stdin — the TUI's own decoder is
+    // reading the tty, and a child that reads stdin would race it for keys.
+    // The inherit branch is unreachable inside the TUI (useCustomSink is
+    // always true there) and stays the correct choice for `nolo update`.
+    stdin: useCustomSink ? "ignore" : "inherit",
     stdout: useCustomSink ? "pipe" : "inherit",
     stderr: useCustomSink ? "pipe" : "inherit",
     env
@@ -900,7 +1118,8 @@ Nolo Agent CLI Installer & Updater
   const useCustomSink = options.output !== void 0;
   const proc = spawn2({
     cmd: command,
-    stdin: "inherit",
+    // Capture mode (TUI sink): ignore stdin — see runShellScript.
+    stdin: useCustomSink ? "ignore" : "inherit",
     stdout: useCustomSink ? "pipe" : "inherit",
     stderr: useCustomSink ? "pipe" : "inherit",
     env
@@ -936,6 +1155,7 @@ async function runSelfUpdate(outputOrOptions) {
 
 export {
   consumeWindowsUpdateStartupNotice,
+  getWindowsUpdateStatus,
   getCliInstallChannel,
   renderProgressBar,
   buildNpmSelfUpdateCommand,

package/{chunk-53HEEOTT.js → chunk-2WJ57RJA.js}

@@ -1,3 +1,6 @@
+import {
+  writeOAuthCredential
+} from "./chunk-HNGRBWYF.js";
 import {
   ANTIGRAVITY_AUTH_URL,
   ANTIGRAVITY_CALLBACK_PATH,
@@ -11,19 +14,16 @@ import {
   getAntigravityUserAgent,
   normalizeAntigravityTokenPayload,
   refreshAntigravityToken
-} from "./chunk-UZGQNTVW.js";
-import {
-  writeOAuthCredential
-} from "./chunk-ONXOABJR.js";
+} from "./chunk-UA324D4O.js";
 import {
   toErrorMessage
 } from "./chunk-HNMXYYJR.js";
-import {
-  asOptionalFiniteNumber
-} from "./chunk-WWC7I6TA.js";
 import {
   isRecord
 } from "./chunk-KUG52IAP.js";
+import {
+  asOptionalFiniteNumber
+} from "./chunk-WWC7I6TA.js";
 import {
   asTrimmedString
 } from "./chunk-3EUW3WEO.js";
@@ -367,6 +367,77 @@ async function refreshAntigravityOAuthToken(credential, deps = {}) {
 // packages/cli/oauth/flows/openai-codex.ts
 import { createHash as createHash2 } from "node:crypto";
 
+// packages/agent-runtime/oauthRefreshError.ts
+var PERMANENT_REFRESH_CODES = /* @__PURE__ */ new Set([
+  "invalid_grant",
+  // OpenAI 令牌端点对失效/不存在的 refresh token 返回 401
+  // {"error":{"code":"invalid_refresh_token",...}}（2026-10-01 用必然无效的
+  // token 实测）。线上 chatgpt 凭据正是因为没认出它，被当成临时的
+  // "unauthorized"、每 15 分钟重试一次且永远不提示重新授权。
+  "invalid_refresh_token",
+  "refresh_token_reused",
+  "invalid_client"
+]);
+var SAFE_MESSAGES = {
+  invalid_grant: "refresh token \u5DF2\u5931\u6548\uFF0C\u8BF7\u91CD\u65B0\u6388\u6743",
+  invalid_refresh_token: "refresh token \u5DF2\u5931\u6548\uFF0C\u8BF7\u91CD\u65B0\u6388\u6743",
+  refresh_token_reused: "refresh token \u5DF2\u88AB\u5176\u4ED6\u526F\u672C\u4F7F\u7528\uFF0C\u8BF7\u91CD\u65B0\u6388\u6743",
+  invalid_client: "OAuth \u5BA2\u6237\u7AEF\u88AB\u62D2\u7EDD\uFF0C\u8BF7\u91CD\u65B0\u6388\u6743",
+  unauthorized: "\u4E0A\u6E38\u62D2\u7EDD\u4E86\u5237\u65B0\u8BF7\u6C42\uFF08401/403\uFF09",
+  rate_limited: "\u4E0A\u6E38\u9650\u6D41\uFF0C\u7A0D\u540E\u91CD\u8BD5",
+  http_5xx: "\u4E0A\u6E38\u670D\u52A1\u6682\u65F6\u4E0D\u53EF\u7528",
+  network: "\u65E0\u6CD5\u8FDE\u63A5\u4E0A\u6E38",
+  bad_response: "\u4E0A\u6E38\u8FD4\u56DE\u4E86\u65E0\u6CD5\u8BC6\u522B\u7684\u54CD\u5E94",
+  unknown: "\u5237\u65B0\u5931\u8D25"
+};
+var OAuthRefreshError = class extends Error {
+  code;
+  status;
+  retryAfterMs;
+  constructor(code, opts = {}) {
+    super(SAFE_MESSAGES[code]);
+    this.name = "OAuthRefreshError";
+    this.code = code;
+    if (opts.status !== void 0) this.status = opts.status;
+    if (opts.retryAfterMs !== void 0) this.retryAfterMs = opts.retryAfterMs;
+  }
+  get permanent() {
+    return PERMANENT_REFRESH_CODES.has(this.code);
+  }
+};
+function readErrorCode(payload) {
+  if (!payload || typeof payload !== "object") return void 0;
+  const err = payload.error;
+  if (typeof err === "string") return err;
+  if (err && typeof err === "object") {
+    const code = err.code;
+    if (typeof code === "string") return code;
+  }
+  return void 0;
+}
+function classifyOAuthRefreshHttpFailure(status, payload, headers) {
+  const raw = readErrorCode(payload)?.toLowerCase();
+  if (raw === "invalid_grant") return new OAuthRefreshError("invalid_grant", { status });
+  if (raw === "invalid_refresh_token") {
+    return new OAuthRefreshError("invalid_refresh_token", { status });
+  }
+  if (raw === "refresh_token_reused") {
+    return new OAuthRefreshError("refresh_token_reused", { status });
+  }
+  if (raw === "invalid_client") return new OAuthRefreshError("invalid_client", { status });
+  if (status === 429) {
+    const seconds = Number(headers?.get("retry-after"));
+    return new OAuthRefreshError("rate_limited", {
+      status,
+      ...Number.isFinite(seconds) && seconds > 0 ? { retryAfterMs: seconds * 1e3 } : {}
+    });
+  }
+  if (status === 401 || status === 403) return new OAuthRefreshError("unauthorized", { status });
+  if (status >= 500) return new OAuthRefreshError("http_5xx", { status });
+  return new OAuthRefreshError("unknown", { status });
+}
+var TRANSIENT_MAX_MS = 15 * 6e4;
+
 // packages/agent-runtime/openaiCodexOAuth.ts
 var OPENAI_CODEX_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
 var OPENAI_CODEX_SCOPES = [
@@ -463,17 +534,14 @@ async function refreshOpenAiCodexToken(credential, deps = {}) {
       signal: AbortSignal.timeout(OPENAI_CODEX_TOKEN_REQUEST_TIMEOUT_MS)
     });
   } catch (error) {
-    throw new Error(
-      `OpenAI Codex token refresh failed: ${toErrorMessage(error)}`
-    );
+    throw new OAuthRefreshError("network");
   }
   const payload = await response.json().catch(() => ({}));
   if (!response.ok) {
-    const detail = typeof payload.error_description === "string" && payload.error_description ? payload.error_description : typeof payload.error === "string" && payload.error ? payload.error : `HTTP ${response.status}`;
-    throw new Error(`OpenAI Codex token refresh failed: ${detail}`);
+    throw classifyOAuthRefreshHttpFailure(response.status, payload, response.headers);
   }
   if (typeof payload.access_token !== "string" || !payload.access_token.trim()) {
-    throw new Error("OpenAI Codex token refresh response missing access_token");
+    throw new OAuthRefreshError("bad_response");
   }
   const now = deps.now?.() ?? Date.now();
   return normalizeOpenAiCodexTokenPayload({
@@ -1047,11 +1115,10 @@ async function refreshAnthropicToken(credential, deps = {}) {
   });
   const payload = await response.json().catch(() => ({}));
   if (!response.ok) {
-    const detail = typeof payload.error_description === "string" ? payload.error_description : typeof payload.error === "string" ? payload.error : `HTTP ${response.status}`;
-    throw new Error(`Claude token refresh failed: ${detail}`);
+    throw classifyOAuthRefreshHttpFailure(response.status, payload, response.headers);
   }
   if (typeof payload.access_token !== "string" || !payload.access_token.trim()) {
-    throw new Error("Claude token refresh response missing access_token");
+    throw new OAuthRefreshError("bad_response");
   }
   const now = deps.now?.() ?? Date.now();
   return normalizeAnthropicTokenPayload({