@textcortex/zenocode 0.1.14 → 0.1.16

package/scripts/run-zenocode.test.mjs

@@ -1,14 +1,10 @@
-import assert from "node:assert/strict";
-import http from "node:http";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { spawn } from "node:child_process";
-import test from "node:test";
-import {
-  buildPaddedLogoSnippet,
-  patchLogoSnippetText,
-} from "./branding-patch.mjs";
+import assert from 'node:assert/strict';
+import http from 'node:http';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import test from 'node:test';
 import {
   buildOpenCodeConfig,
   buildPackageLauncherInvocation,
@@ -17,248 +13,402 @@ import {
   buildZenocodeBanner,
   chooseDefaults,
   hasLocalBaseUrlFlag,
-  packageNameFromSpecifier,
+  isRecoverableSessionError,
+  resolveLaunchPackage,
+  resolvePackageRunners,
+  resolveConfiguredRuntimePackage,
   resolveLoginBaseUrl,
   resolveLoginSuccessIdentifier,
   resolveTextCortexBaseUrl,
   runRuntimeWithSessionRecovery,
   shouldBypassZenocodePreparation,
   shouldFallbackLoginToCloud,
+  zenocodeOwnedCommandMessage,
   writePrivateJsonFile,
-} from "./run-zenocode.mjs";
+} from './run-zenocode.mjs';
+
+test('Zenocode launches the pinned TextCortex-owned runtime by default', () => {
+  assert.equal(
+    resolveLaunchPackage(),
+    '@textcortex/zenocode-ai@1.18.10-zenocode.2'
+  );
+});
+
+test('Zenocode ignores generic OpenCode package overrides', () => {
+  assert.equal(
+    resolveConfiguredRuntimePackage({ OPENCODE_PACKAGE: 'opencode-ai' }),
+    null
+  );
+  assert.equal(
+    resolveConfiguredRuntimePackage({
+      ZENOCODE_OPENCODE_PACKAGE: '@textcortex/zenocode-ai@dev',
+    }),
+    '@textcortex/zenocode-ai@dev'
+  );
+});
+
+test('Zenocode owns runtime upgrades instead of forwarding them to OpenCode', () => {
+  assert.match(
+    zenocodeOwnedCommandMessage(['upgrade']),
+    /npm install -g @textcortex\/zenocode@latest/
+  );
+  assert.match(
+    zenocodeOwnedCommandMessage(['uninstall']),
+    /npm uninstall -g @textcortex\/zenocode/
+  );
+  assert.equal(
+    zenocodeOwnedCommandMessage(['run', 'upgrade dependencies']),
+    null
+  );
+});
+
+test('chooseDefaults prefers GPT-6 Luna as the Zenocode default', () => {
+  const defaults = chooseDefaults({
+    'gpt-6-sol': {},
+    'claude-sonnet-5-5': {},
+    'glm-5-3': {},
+    'kimi-k3-non-thinking': {},
+    'gpt-6-luna': {},
+    'gpt-5-6-luna': {},
+  });
+
+  assert.deepEqual(defaults, {
+    model: 'gpt-6-luna',
+    smallModel: 'gpt-6-luna',
+  });
+});
 
-test("chooseDefaults prefers GPT-5.6 Luna as the Zenocode default", () => {
+test('chooseDefaults ranks GLM 5.3 and Claude 5.5 above their predecessors', () => {
+  assert.equal(
+    chooseDefaults({ 'glm-5-2-non-thinking': {}, 'glm-5-3': {} }).model,
+    'glm-5-3'
+  );
+  assert.equal(
+    chooseDefaults({ 'claude-5-sonnet': {}, 'claude-sonnet-5-5': {} }).model,
+    'claude-sonnet-5-5'
+  );
+});
+
+test('chooseDefaults falls back to GPT-5.6 Luna when GPT-6 Luna is unavailable', () => {
   const defaults = chooseDefaults({
-    "kimi-k2p7-code-non-thinking": {},
-    "gpt-5-6-luna": {},
-    "glm-5-2-non-thinking": {},
-    "minimax-m3-thinking": {},
-    "gpt-5-2": {},
+    'kimi-k2p7-code-non-thinking': {},
+    'gpt-5-6-luna': {},
+    'glm-5-2-non-thinking': {},
+    'minimax-m3-thinking': {},
+    'gpt-5-2': {},
   });
 
   assert.deepEqual(defaults, {
-    model: "gpt-5-6-luna",
-    smallModel: "gpt-5-6-luna",
+    model: 'gpt-5-6-luna',
+    smallModel: 'gpt-5-6-luna',
   });
 });
 
-test("chooseDefaults falls back to Kimi K2.7 Code when GPT-5.6 Luna is unavailable", () => {
+test('chooseDefaults falls back to Kimi K2.7 Code when GPT-5.6 Luna is unavailable', () => {
   const defaults = chooseDefaults({
-    "kimi-k2p7-code-non-thinking": {},
-    "glm-5-2-non-thinking": {},
-    "glm-5-1-non-thinking": {},
-    "kimi-k2-6-non-thinking": {},
-    "minimax-m3-thinking": {},
-    "gpt-5-2": {},
+    'kimi-k2p7-code-non-thinking': {},
+    'glm-5-2-non-thinking': {},
+    'glm-5-1-non-thinking': {},
+    'kimi-k2-6-non-thinking': {},
+    'minimax-m3-thinking': {},
+    'gpt-5-2': {},
   });
 
   assert.deepEqual(defaults, {
-    model: "kimi-k2p7-code-non-thinking",
-    smallModel: "kimi-k2p7-code-non-thinking",
+    model: 'kimi-k2p7-code-non-thinking',
+    smallModel: 'kimi-k2p7-code-non-thinking',
   });
 });
 
-test("chooseDefaults prefers GLM 5.2 over GLM 5.1 for Zenocode fallback", () => {
+test('chooseDefaults never selects deprecated GLM 5.1 for Zenocode fallback', () => {
   const defaults = chooseDefaults({
-    "glm-5-1-non-thinking": {},
-    "glm-5-2-non-thinking": {},
-    "gpt-5-mini": {},
+    'glm-5-1-non-thinking': {},
+    'future-model': {},
   });
 
   assert.deepEqual(defaults, {
-    model: "glm-5-2-non-thinking",
-    smallModel: "gpt-5-mini",
+    model: 'future-model',
+    smallModel: 'future-model',
   });
 });
 
-test("chooseDefaults falls back to explicit thinking variants when base models are absent", () => {
+test('chooseDefaults falls back to explicit thinking variants when base models are absent', () => {
   const defaults = chooseDefaults({
-    "kimi-k2p7-code-thinking": {},
-    "glm-5-2-non-thinking": {},
-    "kimi-k2-6-thinking": {},
+    'kimi-k2p7-code-thinking': {},
+    'glm-5-2-non-thinking': {},
+    'kimi-k2-6-thinking': {},
   });
 
   assert.deepEqual(defaults, {
-    model: "kimi-k2p7-code-thinking",
-    smallModel: "kimi-k2p7-code-thinking",
+    model: 'kimi-k2p7-code-thinking',
+    smallModel: 'kimi-k2p7-code-thinking',
   });
 });
 
-test("packageNameFromSpecifier strips npm versions without breaking scopes", () => {
-  assert.equal(packageNameFromSpecifier("opencode-ai@1.17.6"), "opencode-ai");
-  assert.equal(
-    packageNameFromSpecifier("@textcortex/zenocode-ai@1.17.6"),
-    "@textcortex/zenocode-ai",
-  );
-  assert.equal(
-    packageNameFromSpecifier("@textcortex/zenocode-ai"),
-    "@textcortex/zenocode-ai",
-  );
+test('chooseDefaults prefers Kimi K3 over older Kimi generations', () => {
+  const defaults = chooseDefaults({
+    'kimi-k2p7-code-non-thinking': {},
+    'kimi-k3-non-thinking': {},
+    'kimi-k2-6-non-thinking': {},
+    'minimax-m3-thinking': {},
+  });
+
+  assert.deepEqual(defaults, {
+    model: 'kimi-k3-non-thinking',
+    smallModel: 'kimi-k3-non-thinking',
+  });
 });
 
-test("shouldBypassZenocodePreparation skips auth for runtime metadata commands", () => {
-  assert.equal(shouldBypassZenocodePreparation(["--version"]), true);
-  assert.equal(shouldBypassZenocodePreparation(["completion", "zsh"]), true);
-  assert.equal(shouldBypassZenocodePreparation(["run"]), false);
-  assert.equal(shouldBypassZenocodePreparation(["run", "implement", "completion"]), false);
-  assert.equal(shouldBypassZenocodePreparation(["run", "--help"]), false);
+test('chooseDefaults ranks Claude 5 below the coding-first models', () => {
+  const defaults = chooseDefaults({
+    'claude-opus-5': {},
+    'claude-5-sonnet': {},
+    'kimi-k3-thinking': {},
+  });
+
+  assert.deepEqual(defaults, {
+    model: 'kimi-k3-thinking',
+    smallModel: 'kimi-k3-thinking',
+  });
 });
 
-test("resolveTextCortexBaseUrl defaults to the cloud API for packaged usage", () => {
+test('chooseDefaults selects Claude 5 when it is the only catalog entry', () => {
+  const defaults = chooseDefaults({
+    'claude-5-sonnet': {},
+    'claude-opus-5': {},
+  });
+
+  assert.deepEqual(defaults, {
+    model: 'claude-5-sonnet',
+    smallModel: 'claude-5-sonnet',
+  });
+});
+
+test('shouldBypassZenocodePreparation skips auth for runtime metadata commands', () => {
+  assert.equal(shouldBypassZenocodePreparation(['--version']), true);
+  assert.equal(shouldBypassZenocodePreparation(['completion', 'zsh']), true);
+  assert.equal(shouldBypassZenocodePreparation(['run']), false);
+  assert.equal(
+    shouldBypassZenocodePreparation(['run', 'implement', 'completion']),
+    false
+  );
+  assert.equal(shouldBypassZenocodePreparation(['run', '--help']), false);
+});
+
+test('resolveTextCortexBaseUrl defaults to the cloud API for packaged usage', () => {
   assert.equal(
     resolveTextCortexBaseUrl({
-      envBaseUrl: "",
+      envBaseUrl: '',
       storedBaseUrl: null,
     }),
-    "https://api.textcortex.com",
+    'https://api.textcortex.com'
   );
 });
 
-test("resolveTextCortexBaseUrl prefers the explicit env var over stored credentials", () => {
+test('resolveTextCortexBaseUrl prefers the explicit env var over stored credentials', () => {
   assert.equal(
     resolveTextCortexBaseUrl({
-      envBaseUrl: "https://staging.textcortex.com",
-      storedBaseUrl: "http://127.0.0.1:8080",
+      envBaseUrl: 'https://staging.textcortex.com',
+      storedBaseUrl: 'http://127.0.0.1:8080',
     }),
-    "https://staging.textcortex.com",
+    'https://staging.textcortex.com'
   );
 });
 
-test("resolveTextCortexBaseUrl prefers localhost when the local flag is enabled", () => {
+test('resolveTextCortexBaseUrl prefers localhost when the local flag is enabled', () => {
   assert.equal(
     resolveTextCortexBaseUrl({
-      envBaseUrl: "https://staging.textcortex.com",
-      storedBaseUrl: "https://api.textcortex.com",
+      envBaseUrl: 'https://staging.textcortex.com',
+      storedBaseUrl: 'https://api.textcortex.com',
       preferLocalhost: true,
     }),
-    "http://127.0.0.1:8080",
+    'http://127.0.0.1:8080'
   );
 });
 
-test("resolveLoginBaseUrl ignores stored credentials and defaults explicit login to cloud", () => {
+test('resolveLoginBaseUrl ignores stored credentials and defaults explicit login to cloud', () => {
   assert.equal(
     resolveLoginBaseUrl({
-      envBaseUrl: "",
+      envBaseUrl: '',
     }),
-    "https://api.textcortex.com",
+    'https://api.textcortex.com'
   );
 });
 
-test("resolveLoginBaseUrl still respects explicit env overrides", () => {
+test('resolveLoginBaseUrl still respects explicit env overrides', () => {
   assert.equal(
     resolveLoginBaseUrl({
-      envBaseUrl: "https://staging.textcortex.com",
+      envBaseUrl: 'https://staging.textcortex.com',
     }),
-    "https://staging.textcortex.com",
+    'https://staging.textcortex.com'
   );
 });
 
-test("resolveLoginBaseUrl prefers localhost when the local flag is enabled", () => {
+test('resolveLoginBaseUrl prefers localhost when the local flag is enabled', () => {
   assert.equal(
     resolveLoginBaseUrl({
-      envBaseUrl: "https://staging.textcortex.com",
+      envBaseUrl: 'https://staging.textcortex.com',
       preferLocalhost: true,
     }),
-    "http://127.0.0.1:8080",
+    'http://127.0.0.1:8080'
   );
 });
 
-test("hasLocalBaseUrlFlag detects localhost flags", () => {
-  assert.equal(hasLocalBaseUrlFlag(["login", "--local"]), true);
-  assert.equal(hasLocalBaseUrlFlag(["--localhost", "run"]), true);
-  assert.equal(hasLocalBaseUrlFlag(["run", "--help"]), false);
+test('hasLocalBaseUrlFlag detects localhost flags', () => {
+  assert.equal(hasLocalBaseUrlFlag(['login', '--local']), true);
+  assert.equal(hasLocalBaseUrlFlag(['--localhost', 'run']), true);
+  assert.equal(hasLocalBaseUrlFlag(['run', '--help']), false);
 });
 
-test("shouldFallbackLoginToCloud retries the cloud API when the local auth route returns 404", () => {
+test('shouldFallbackLoginToCloud retries the cloud API when the local auth route returns 404', () => {
   assert.equal(
     shouldFallbackLoginToCloud({
-      baseUrl: "http://127.0.0.1:8080",
+      baseUrl: 'http://127.0.0.1:8080',
       hasExplicitBaseUrl: false,
-      error: new Error("Login initiate failed (404): not found"),
+      error: new Error('Login initiate failed (404): not found'),
     }),
-    true,
+    true
   );
 });
 
-test("shouldFallbackLoginToCloud does not override an explicit base URL", () => {
+test('shouldFallbackLoginToCloud does not override an explicit base URL', () => {
   assert.equal(
     shouldFallbackLoginToCloud({
-      baseUrl: "http://127.0.0.1:8080",
+      baseUrl: 'http://127.0.0.1:8080',
       hasExplicitBaseUrl: true,
-      error: new Error("fetch failed"),
+      error: new Error('fetch failed'),
     }),
-    false,
+    false
   );
 });
 
-test("buildOpenCodeConfig includes an openai stub for fallback runtime auth plugins", () => {
+test('buildOpenCodeConfig includes an openai stub for fallback runtime auth plugins', () => {
   const config = buildOpenCodeConfig({
-    baseUrl: "http://127.0.0.1:8080",
-    providerID: "textcortex",
-    model: "minimax-m3-thinking",
-    smallModel: "gpt-5-2",
+    baseUrl: 'http://127.0.0.1:8080',
+    providerID: 'textcortex',
+    model: 'minimax-m3-thinking',
+    smallModel: 'gpt-5-2',
   });
 
-  assert.deepEqual(config.enabled_providers, ["textcortex"]);
-  assert.equal(config.model, "textcortex/minimax-m3-thinking");
-  assert.equal(config.small_model, "textcortex/gpt-5-2");
-  assert.equal(config.theme, "system");
+  assert.deepEqual(config.enabled_providers, ['textcortex']);
+  assert.equal(config.model, 'textcortex/minimax-m3-thinking');
+  assert.equal(config.small_model, 'textcortex/gpt-5-2');
+  assert.equal(config.theme, 'system');
+  assert.equal(config.autoupdate, false);
   assert.ok(config.provider.openai);
   assert.deepEqual(config.provider.openai.models, {});
 });
 
-test("buildPackageLauncherChildOptions keeps fallback package launchers attached to the terminal", () => {
-  const childOptions = buildPackageLauncherChildOptions(
-    {
-      cwd: "/tmp/zenocode",
-      env: { TEXTCORTEX_API_KEY: "token-1" },
-    },
-    "/tmp/zenocode-runtime",
-  );
+test('buildPackageLauncherChildOptions keeps fallback package launchers attached to the terminal', () => {
+  const childOptions = buildPackageLauncherChildOptions({
+    cwd: '/tmp/zenocode',
+    env: { TEXTCORTEX_API_KEY: 'token-1' },
+  });
 
-  assert.equal(childOptions.stdio, "inherit");
-  assert.equal(childOptions.cwd, "/tmp/zenocode");
+  assert.equal(childOptions.stdio, 'inherit');
+  assert.equal(childOptions.cwd, '/tmp/zenocode');
   assert.deepEqual(childOptions.env, {
-    TEXTCORTEX_API_KEY: "token-1",
-    OPENCODE_BIN_PATH: "/tmp/zenocode-runtime",
+    TEXTCORTEX_API_KEY: 'token-1',
   });
 });
 
-test("buildPackageLauncherInvocation runs pinned runtimes directly", () => {
+test('buildPackageLauncherInvocation launches the owned runtime package unchanged', () => {
   const invocation = buildPackageLauncherInvocation({
     runner: {
-      command: "npx",
-      args: ["--yes", "opencode-ai@1.17.6", "--version"],
+      command: 'pnpm',
+      args: ['dlx', '@textcortex/zenocode-ai@1.18.10-zenocode.2', '--version'],
     },
-    args: ["--version"],
-    pinnedRuntimePath: "/tmp/zenocode-runtime",
   });
 
   assert.deepEqual(invocation, {
-    command: "/tmp/zenocode-runtime",
-    args: ["--version"],
-    usePinnedRuntime: true,
+    command: 'pnpm',
+    args: ['dlx', '@textcortex/zenocode-ai@1.18.10-zenocode.2', '--version'],
   });
 });
 
-test("buildPackageLauncherInvocation uses package runners without a pinned runtime", () => {
-  const invocation = buildPackageLauncherInvocation({
-    runner: {
-      command: "pnpm",
-      args: ["dlx", "opencode-ai@1.17.6", "--version"],
+test('resolvePackageRunners keeps pnpm then npx on POSIX platforms', () => {
+  const runners = resolvePackageRunners(
+    '@textcortex/zenocode-ai@1.0.0',
+    ['run'],
+    {
+      platform: 'linux',
+      execPath: '/usr/bin/node',
+      env: {},
+      fileExists: () => true,
+    }
+  );
+
+  assert.deepEqual(runners, [
+    { command: 'pnpm', args: ['dlx', '@textcortex/zenocode-ai@1.0.0', 'run'] },
+    { command: 'npx', args: ['--yes', '@textcortex/zenocode-ai@1.0.0', 'run'] },
+  ]);
+});
+
+test('resolvePackageRunners never spawns .cmd/.bat shims on Windows', () => {
+  // Node >= 18.20.2 / 20.12.2 rejects spawning batch files without a shell
+  // (CVE-2024-27980) with `spawn EINVAL`, so Windows runners must be executables.
+  const execPath = 'C:\\Program Files\\nodejs\\node.exe';
+  const npxCli = path.win32.join(
+    'C:\\Program Files\\nodejs',
+    'node_modules',
+    'npm',
+    'bin',
+    'npx-cli.js'
+  );
+  const runners = resolvePackageRunners(
+    '@textcortex/zenocode-ai@1.0.0',
+    ['run'],
+    {
+      platform: 'win32',
+      execPath,
+      env: {},
+      fileExists: (candidate) => candidate === npxCli,
+    }
+  );
+
+  for (const runner of runners) {
+    assert.doesNotMatch(runner.command, /\.(cmd|bat)$/i);
+  }
+  assert.deepEqual(runners, [
+    {
+      command: 'pnpm.exe',
+      args: ['dlx', '@textcortex/zenocode-ai@1.0.0', 'run'],
     },
-    args: ["--version"],
-    pinnedRuntimePath: null,
+    {
+      command: execPath,
+      args: [npxCli, '--yes', '@textcortex/zenocode-ai@1.0.0', 'run'],
+    },
+  ]);
+});
+
+test('resolvePackageRunners finds npx beside npm_execpath on Windows', () => {
+  const npmCli = 'D:\\tools\\npm\\bin\\npm-cli.js';
+  const npxCli = 'D:\\tools\\npm\\bin\\npx-cli.js';
+  const runners = resolvePackageRunners('pkg@1', [], {
+    platform: 'win32',
+    execPath: 'D:\\volta\\node.exe',
+    env: { npm_execpath: npmCli },
+    fileExists: (candidate) => candidate === npxCli,
   });
 
-  assert.deepEqual(invocation, {
-    command: "pnpm",
-    args: ["dlx", "opencode-ai@1.17.6", "--version"],
-    usePinnedRuntime: false,
+  assert.deepEqual(runners.at(-1), {
+    command: 'D:\\volta\\node.exe',
+    args: [npxCli, '--yes', 'pkg@1'],
   });
 });
 
-test("buildZenocodeBanner renders block logo art instead of plain text", () => {
+test('resolvePackageRunners omits npx on Windows when npm is not beside node', () => {
+  const runners = resolvePackageRunners('pkg@1', [], {
+    platform: 'win32',
+    execPath: 'C:\\node\\node.exe',
+    env: {},
+    fileExists: () => false,
+  });
+
+  assert.deepEqual(runners, [{ command: 'pnpm.exe', args: ['dlx', 'pkg@1'] }]);
+});
+
+test('buildZenocodeBanner renders block logo art instead of plain text', () => {
   const banner = buildZenocodeBanner();
 
   assert.match(banner, /▀▀█/);
@@ -267,51 +417,20 @@ test("buildZenocodeBanner renders block logo art instead of plain text", () => {
   assert.doesNotMatch(banner, /\bZenocode\b/);
 });
 
-test("patchLogoSnippetText upgrades previously branded Zenocode logos", () => {
-  const legacyTextLogoSnippet = `var logo = {
-  left: ["                   ", "   Zenocode        ", "   Zenocode        ", "                   "],
-  right: ["                   ", "                   ", "                   ", "                   "]
-};
-var marks = "_^~";`;
-
-  const result = patchLogoSnippetText(buildPaddedLogoSnippet(legacyTextLogoSnippet));
-
-  assert.equal(result.patched, true);
-  assert.match(result.text, /\\u2580\\u2580\\u2588/);
-  assert.match(result.text, /\\u2588\\u2580\\u2580/);
-  assert.doesNotMatch(result.text, /\\\\u2580/);
-  assert.doesNotMatch(result.text, /Zenocode/);
-});
-
-test("patchLogoSnippetText upgrades double-escaped Zenocode glyph logos", () => {
-  const brokenGlyphLogoSnippet = String.raw`var logo = {
-  left: ["                   "," \\u2580\\u2580\\u2588 \\u2588\\u2580\\u2580 \\u2588\\u2584 \\u2588 \\u2588\\u2580\\u2588"," \\u2588\\u2584\\u2584 \\u2588\\u2588\\u2584 \\u2588 \\u2580\\u2588 \\u2588\\u2584\\u2588","                   "],
-  right: ["                   "," \\u2588\\u2580\\u2580 \\u2588\\u2580\\u2588 \\u2588\\u2580\\u2584 \\u2588\\u2580\\u2580"," \\u2588\\u2584\\u2584 \\u2588\\u2584\\u2588 \\u2588\\u2584\\u2580 \\u2588\\u2588\\u2584","                   "]
-};
-var marks = "_^~";`;
-
-  const result = patchLogoSnippetText(buildPaddedLogoSnippet(brokenGlyphLogoSnippet));
-
-  assert.equal(result.patched, true);
-  assert.match(result.text, /\\u2580\\u2580\\u2588/);
-  assert.match(result.text, /\\u2588\\u2580\\u2580/);
-  assert.doesNotMatch(result.text, /\\\\u2580/);
-});
-
-test("writePrivateJsonFile stores credentials with private permissions", async (t) => {
-  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "zenocode-runtime-"));
-  const credentialsPath = path.join(tempDir, "runtime", "credentials.json");
+test('writePrivateJsonFile stores credentials with private permissions', async (t) => {
+  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'zenocode-runtime-'));
+  const credentialsPath = path.join(tempDir, 'runtime', 'credentials.json');
 
   t.after(async () => {
     await fs.rm(tempDir, { recursive: true, force: true });
   });
 
-  await writePrivateJsonFile(credentialsPath, { access_token: "secret-token" });
+  await writePrivateJsonFile(credentialsPath, { access_token: 'secret-token' });
 
-  const saved = JSON.parse(await fs.readFile(credentialsPath, "utf-8"));
-  assert.equal(saved.access_token, "secret-token");
+  const saved = JSON.parse(await fs.readFile(credentialsPath, 'utf-8'));
+  assert.equal(saved.access_token, 'secret-token');
 
-  if (process.platform !== "win32") {
+  if (process.platform !== 'win32') {
     const dirMode = (await fs.stat(path.dirname(credentialsPath))).mode & 0o777;
     const fileMode = (await fs.stat(credentialsPath)).mode & 0o777;
 
@@ -320,68 +439,89 @@ test("writePrivateJsonFile stores credentials with private permissions", async (
   }
 });
 
-test("canRecoverRuntimeSessionFromTranscript detects expired session output", () => {
+test('canRecoverRuntimeSessionFromTranscript detects expired session output', () => {
   const transcript = [
-    "\u001b[2J\u001b[H",
-    "cool, is there anything about zenocode?",
-    "",
+    '\u001b[2J\u001b[H',
+    'cool, is there anything about zenocode?',
+    '',
     'Unauthorized: {"detail":"Token has expired"}',
-  ].join("\n");
+  ].join('\n');
 
   assert.equal(canRecoverRuntimeSessionFromTranscript(transcript), true);
 });
 
-test("resolveLoginSuccessIdentifier avoids email fallback", () => {
+test('isRecoverableSessionError accepts expired and malformed model tokens', () => {
+  assert.equal(
+    isRecoverableSessionError(
+      new Error('Models fetch failed (401): Token has expired')
+    ),
+    true
+  );
+  assert.equal(
+    isRecoverableSessionError(
+      new Error('Models fetch failed (401): Invalid token format')
+    ),
+    true
+  );
+  assert.equal(
+    isRecoverableSessionError(
+      new Error('Models fetch failed (401): forbidden')
+    ),
+    false
+  );
+});
+
+test('resolveLoginSuccessIdentifier avoids email fallback', () => {
   assert.equal(
     resolveLoginSuccessIdentifier({
-      auth_id: "auth_123",
-      email: "user@example.com",
+      auth_id: 'auth_123',
+      email: 'user@example.com',
     }),
-    "auth_123",
+    'auth_123'
   );
   assert.equal(
     resolveLoginSuccessIdentifier({
-      email: "user@example.com",
+      email: 'user@example.com',
     }),
-    "unknown",
+    'unknown'
   );
 });
 
-test("runRuntimeWithSessionRecovery reruns login after runtime session expiry", async () => {
+test('runRuntimeWithSessionRecovery reruns login after runtime session expiry', async () => {
   const events = [];
   let launchCount = 0;
 
   const result = await runRuntimeWithSessionRecovery({
-    args: ["run"],
-    baseUrl: "http://127.0.0.1:8080",
-    token: "token-1",
+    args: ['run'],
+    baseUrl: 'http://127.0.0.1:8080',
+    token: 'token-1',
     childOptions: {
       cwd: process.cwd(),
       env: {},
     },
     canAutoLoginRuntime: true,
     refreshTokenFn: async (baseUrl) => {
-      events.push(["refresh", baseUrl]);
-      throw new Error("refresh failed");
+      events.push(['refresh', baseUrl]);
+      throw new Error('refresh failed');
     },
     runLogin: async (baseUrl, loginArgs) => {
-      events.push(["login", baseUrl, loginArgs]);
+      events.push(['login', baseUrl, loginArgs]);
     },
     resolveTokenFn: async () => {
-      events.push(["resolve-token"]);
-      return "token-2";
+      events.push(['resolve-token']);
+      return 'token-2';
     },
     resolveStoredBaseUrlFn: async () => {
-      events.push(["resolve-base-url"]);
-      return "https://api.textcortex.com";
+      events.push(['resolve-base-url']);
+      return 'https://api.textcortex.com';
     },
     prepareRuntimeFn: async (baseUrl, token) => {
-      events.push(["prepare", baseUrl, token]);
-      return "kimi-k2-5-thinking";
+      events.push(['prepare', baseUrl, token]);
+      return 'kimi-k2-5-thinking';
     },
     launchRuntimeFn: async ({ childOptions }) => {
       launchCount += 1;
-      events.push(["launch", launchCount, childOptions.env.TEXTCORTEX_API_KEY]);
+      events.push(['launch', launchCount, childOptions.env.TEXTCORTEX_API_KEY]);
       if (launchCount === 1) {
         return { expiredSession: true };
       }
@@ -390,47 +530,47 @@ test("runRuntimeWithSessionRecovery reruns login after runtime session expiry",
   });
 
   assert.deepEqual(events, [
-    ["launch", 1, "token-1"],
-    ["refresh", "http://127.0.0.1:8080"],
-    ["login", "http://127.0.0.1:8080", []],
-    ["resolve-token"],
-    ["resolve-base-url"],
-    ["prepare", "https://api.textcortex.com", "token-2"],
-    ["launch", 2, "token-2"],
+    ['launch', 1, 'token-1'],
+    ['refresh', 'http://127.0.0.1:8080'],
+    ['login', 'http://127.0.0.1:8080', []],
+    ['resolve-token'],
+    ['resolve-base-url'],
+    ['prepare', 'https://api.textcortex.com', 'token-2'],
+    ['launch', 2, 'token-2'],
   ]);
   assert.deepEqual(result, { code: 0, signal: null, expiredSession: false });
 });
 
-test("runRuntimeWithSessionRecovery refreshes stored credentials before forcing login", async () => {
+test('runRuntimeWithSessionRecovery refreshes stored credentials before forcing login', async () => {
   const events = [];
   let launchCount = 0;
 
   const result = await runRuntimeWithSessionRecovery({
-    args: ["run"],
-    baseUrl: "http://127.0.0.1:8080",
-    token: "token-1",
+    args: ['run'],
+    baseUrl: 'http://127.0.0.1:8080',
+    token: 'token-1',
     childOptions: {
       cwd: process.cwd(),
       env: {},
     },
     canAutoLoginRuntime: true,
     refreshTokenFn: async (baseUrl) => {
-      events.push(["refresh", baseUrl]);
+      events.push(['refresh', baseUrl]);
       return {
-        token: "token-2",
-        baseUrl: "https://api.textcortex.com",
+        token: 'token-2',
+        baseUrl: 'https://api.textcortex.com',
       };
     },
     runLogin: async () => {
-      throw new Error("login should not be called");
+      throw new Error('login should not be called');
     },
     prepareRuntimeFn: async (baseUrl, token) => {
-      events.push(["prepare", baseUrl, token]);
-      return "kimi-k2-5-thinking";
+      events.push(['prepare', baseUrl, token]);
+      return 'kimi-k2-5-thinking';
     },
     launchRuntimeFn: async ({ childOptions }) => {
       launchCount += 1;
-      events.push(["launch", launchCount, childOptions.env.TEXTCORTEX_API_KEY]);
+      events.push(['launch', launchCount, childOptions.env.TEXTCORTEX_API_KEY]);
       if (launchCount === 1) {
         return { expiredSession: true };
       }
@@ -439,22 +579,22 @@ test("runRuntimeWithSessionRecovery refreshes stored credentials before forcing
   });
 
   assert.deepEqual(events, [
-    ["launch", 1, "token-1"],
-    ["refresh", "http://127.0.0.1:8080"],
-    ["prepare", "https://api.textcortex.com", "token-2"],
-    ["launch", 2, "token-2"],
+    ['launch', 1, 'token-1'],
+    ['refresh', 'http://127.0.0.1:8080'],
+    ['prepare', 'https://api.textcortex.com', 'token-2'],
+    ['launch', 2, 'token-2'],
   ]);
   assert.deepEqual(result, { code: 0, signal: null, expiredSession: false });
 });
 
-test("runRuntimeWithSessionRecovery preserves explicit localhost preference during login recovery", async () => {
+test('runRuntimeWithSessionRecovery preserves explicit localhost preference during login recovery', async () => {
   const events = [];
   let launchCount = 0;
 
   const result = await runRuntimeWithSessionRecovery({
-    args: ["run"],
-    baseUrl: "http://127.0.0.1:8080",
-    token: "token-1",
+    args: ['run'],
+    baseUrl: 'http://127.0.0.1:8080',
+    token: 'token-1',
     childOptions: {
       cwd: process.cwd(),
       env: {},
@@ -462,27 +602,27 @@ test("runRuntimeWithSessionRecovery preserves explicit localhost preference duri
     canAutoLoginRuntime: true,
     preferLocalhost: true,
     refreshTokenFn: async (baseUrl) => {
-      events.push(["refresh", baseUrl]);
-      throw new Error("refresh failed");
+      events.push(['refresh', baseUrl]);
+      throw new Error('refresh failed');
     },
     runLogin: async (baseUrl, loginArgs, options) => {
-      events.push(["login", baseUrl, loginArgs, options]);
+      events.push(['login', baseUrl, loginArgs, options]);
     },
     resolveTokenFn: async () => {
-      events.push(["resolve-token"]);
-      return "token-2";
+      events.push(['resolve-token']);
+      return 'token-2';
     },
     resolveStoredBaseUrlFn: async () => {
-      events.push(["resolve-base-url"]);
-      return "https://api.textcortex.com";
+      events.push(['resolve-base-url']);
+      return 'https://api.textcortex.com';
     },
     prepareRuntimeFn: async (baseUrl, token) => {
-      events.push(["prepare", baseUrl, token]);
-      return "kimi-k2-5-thinking";
+      events.push(['prepare', baseUrl, token]);
+      return 'kimi-k2-5-thinking';
     },
     launchRuntimeFn: async ({ childOptions }) => {
       launchCount += 1;
-      events.push(["launch", launchCount, childOptions.env.TEXTCORTEX_API_KEY]);
+      events.push(['launch', launchCount, childOptions.env.TEXTCORTEX_API_KEY]);
       if (launchCount === 1) {
         return { expiredSession: true };
       }
@@ -491,27 +631,27 @@ test("runRuntimeWithSessionRecovery preserves explicit localhost preference duri
   });
 
   assert.deepEqual(events, [
-    ["launch", 1, "token-1"],
-    ["refresh", "http://127.0.0.1:8080"],
-    ["login", "http://127.0.0.1:8080", ["--local"], { preferLocalhost: true }],
-    ["resolve-token"],
-    ["resolve-base-url"],
-    ["prepare", "http://127.0.0.1:8080", "token-2"],
-    ["launch", 2, "token-2"],
+    ['launch', 1, 'token-1'],
+    ['refresh', 'http://127.0.0.1:8080'],
+    ['login', 'http://127.0.0.1:8080', ['--local'], { preferLocalhost: true }],
+    ['resolve-token'],
+    ['resolve-base-url'],
+    ['prepare', 'http://127.0.0.1:8080', 'token-2'],
+    ['launch', 2, 'token-2'],
   ]);
   assert.deepEqual(result, { code: 0, signal: null, expiredSession: false });
 });
 
-test("runRuntimeWithSessionRecovery stops after repeated recovery failures", async () => {
+test('runRuntimeWithSessionRecovery stops after repeated recovery failures', async () => {
   const events = [];
   let launchCount = 0;
 
   await assert.rejects(
     () =>
       runRuntimeWithSessionRecovery({
-        args: ["run"],
-        baseUrl: "http://127.0.0.1:8080",
-        token: "token-1",
+        args: ['run'],
+        baseUrl: 'http://127.0.0.1:8080',
+        token: 'token-1',
         childOptions: {
           cwd: process.cwd(),
           env: {},
@@ -519,60 +659,64 @@ test("runRuntimeWithSessionRecovery stops after repeated recovery failures", asy
         canAutoLoginRuntime: true,
         maxRecoveryAttempts: 2,
         sleepFn: async () => {
-          events.push(["sleep"]);
+          events.push(['sleep']);
         },
         refreshTokenFn: async (baseUrl) => {
-          events.push(["refresh", baseUrl]);
-          throw new Error("refresh failed");
+          events.push(['refresh', baseUrl]);
+          throw new Error('refresh failed');
         },
         runLogin: async (baseUrl, loginArgs) => {
-          events.push(["login", baseUrl, loginArgs]);
+          events.push(['login', baseUrl, loginArgs]);
         },
         resolveTokenFn: async () => {
-          events.push(["resolve-token"]);
-          return "token-2";
+          events.push(['resolve-token']);
+          return 'token-2';
         },
         resolveStoredBaseUrlFn: async () => {
-          events.push(["resolve-base-url"]);
-          return "https://api.textcortex.com";
+          events.push(['resolve-base-url']);
+          return 'https://api.textcortex.com';
         },
         prepareRuntimeFn: async (baseUrl, token) => {
-          events.push(["prepare", baseUrl, token]);
-          return "kimi-k2-5-thinking";
+          events.push(['prepare', baseUrl, token]);
+          return 'kimi-k2-5-thinking';
         },
         launchRuntimeFn: async ({ childOptions }) => {
           launchCount += 1;
-          events.push(["launch", launchCount, childOptions.env.TEXTCORTEX_API_KEY]);
+          events.push([
+            'launch',
+            launchCount,
+            childOptions.env.TEXTCORTEX_API_KEY,
+          ]);
           return { expiredSession: true };
         },
       }),
-    /Zenocode session recovery failed after 2 attempts/,
+    /Zenocode session recovery failed after 2 attempts/
   );
 
   assert.deepEqual(events, [
-    ["launch", 1, "token-1"],
-    ["refresh", "http://127.0.0.1:8080"],
-    ["login", "http://127.0.0.1:8080", []],
-    ["resolve-token"],
-    ["resolve-base-url"],
-    ["prepare", "https://api.textcortex.com", "token-2"],
-    ["sleep"],
-    ["launch", 2, "token-2"],
-    ["refresh", "https://api.textcortex.com"],
-    ["login", "https://api.textcortex.com", []],
-    ["resolve-token"],
-    ["resolve-base-url"],
-    ["prepare", "https://api.textcortex.com", "token-2"],
-    ["sleep"],
-    ["launch", 3, "token-2"],
+    ['launch', 1, 'token-1'],
+    ['refresh', 'http://127.0.0.1:8080'],
+    ['login', 'http://127.0.0.1:8080', []],
+    ['resolve-token'],
+    ['resolve-base-url'],
+    ['prepare', 'https://api.textcortex.com', 'token-2'],
+    ['sleep'],
+    ['launch', 2, 'token-2'],
+    ['refresh', 'https://api.textcortex.com'],
+    ['login', 'https://api.textcortex.com', []],
+    ['resolve-token'],
+    ['resolve-base-url'],
+    ['prepare', 'https://api.textcortex.com', 'token-2'],
+    ['sleep'],
+    ['launch', 3, 'token-2'],
   ]);
 });
 
-test("prepare-only refreshes stored Zenocode credentials when the access token has expired", async (t) => {
-  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "zenocode-refresh-"));
-  const zenocodeHome = path.join(tempDir, ".zenocode");
-  const credentialsPath = path.join(zenocodeHome, "credentials.json");
-  const scriptPath = new URL("./run-zenocode.mjs", import.meta.url);
+test('prepare-only refreshes stored Zenocode credentials when the selected token is invalid', async (t) => {
+  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'zenocode-refresh-'));
+  const zenocodeHome = path.join(tempDir, '.zenocode');
+  const credentialsPath = path.join(zenocodeHome, 'credentials.json');
+  const scriptPath = new URL('./run-zenocode.mjs', import.meta.url);
   let refreshCalls = 0;
   let refreshedAuthHeader = null;
   let modelAuthHeader = null;
@@ -586,127 +730,142 @@ test("prepare-only refreshes stored Zenocode credentials when the access token h
     credentialsPath,
     JSON.stringify(
       {
-        base_url: "http://127.0.0.1:1",
-        access_token: "expired-access",
-        refresh_token: "refresh-token",
+        base_url: 'http://127.0.0.1:1',
+        access_token: 'expired-access',
+        refresh_token: 'refresh-token',
         expires_at: new Date(Date.now() - 60_000).toISOString(),
       },
       null,
-      2,
-    ),
+      2
+    )
   );
 
   const server = http.createServer((req, res) => {
-    if (req.method === "POST" && req.url === "/auth/token/refresh/") {
+    if (req.method === 'POST' && req.url === '/auth/token/refresh/') {
       refreshCalls += 1;
       refreshedAuthHeader = req.headers.authorization || null;
-      res.writeHead(200, { "Content-Type": "application/json" });
+      res.writeHead(200, { 'Content-Type': 'application/json' });
       res.end(
         JSON.stringify({
-          access_token: "fresh-access",
-          refresh_token: "fresh-refresh",
-        }),
+          access_token: 'fresh-access',
+          refresh_token: 'fresh-refresh',
+        })
       );
       return;
     }
 
     if (
-      req.method === "GET" &&
-      req.url === "/internal/v2/fastapi/zenocode/models/api.json"
+      req.method === 'GET' &&
+      req.url === '/internal/v2/fastapi/zenocode/models/api.json'
     ) {
       modelAuthHeader = req.headers.authorization || null;
-      if (modelAuthHeader === "Bearer expired-access") {
-        res.writeHead(401, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ detail: "Token has expired" }));
+      if (modelAuthHeader === 'Bearer stale-invalid-token') {
+        res.writeHead(401, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ detail: 'Invalid token format' }));
         return;
       }
 
-      res.writeHead(200, { "Content-Type": "application/json" });
+      res.writeHead(200, { 'Content-Type': 'application/json' });
       res.end(
         JSON.stringify({
           textcortex: {
             models: {
-              "minimax-m3-thinking": {},
-              "kimi-k2-6-non-thinking": {},
-              "kimi-k2-6-thinking": {},
-              "kimi-k2-5": {},
-              "kimi-k2-5-thinking": {},
-              "glm-5-2-non-thinking": {},
-              "glm-5-2-thinking": {},
-              "glm-5-1-non-thinking": {},
-              "glm-5-1-thinking": {},
+              'minimax-m3-thinking': {},
+              'kimi-k2-6-non-thinking': {},
+              'kimi-k2-6-thinking': {},
+              'kimi-k2-5': {},
+              'kimi-k2-5-thinking': {},
+              'glm-5-2-non-thinking': {},
+              'glm-5-2-thinking': {},
+              'glm-5-3': {},
+              'glm-5-1-non-thinking': {},
+              'glm-5-1-thinking': {},
             },
           },
-        }),
+        })
       );
       return;
     }
 
-    res.writeHead(404, { "Content-Type": "application/json" });
-    res.end(JSON.stringify({ detail: "not found" }));
+    res.writeHead(404, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ detail: 'not found' }));
   });
 
-  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
   const address = server.address();
   const baseUrl = `http://127.0.0.1:${address.port}`;
 
   t.after(async () => {
-    await new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())));
+    await new Promise((resolve, reject) =>
+      server.close((error) => (error ? reject(error) : resolve()))
+    );
   });
 
   const result = await new Promise((resolve, reject) => {
     const child = spawn(
       process.execPath,
-      [scriptPath.pathname, "--prepare-only"],
+      [scriptPath.pathname, '--prepare-only'],
       {
         cwd: tempDir,
         env: {
           ...process.env,
           ZENOCODE_HOME: zenocodeHome,
           TEXTCORTEX_BASE_URL: baseUrl,
-          ZENOCODE_NO_BANNER: "1",
+          TEXTCORTEX_API_KEY: 'stale-invalid-token',
+          ZENOCODE_NO_BANNER: '1',
         },
-        stdio: ["ignore", "pipe", "pipe"],
-      },
+        stdio: ['ignore', 'pipe', 'pipe'],
+      }
     );
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (chunk) => {
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', (chunk) => {
       stdout += String(chunk);
     });
-    child.stderr.on("data", (chunk) => {
+    child.stderr.on('data', (chunk) => {
       stderr += String(chunk);
     });
-    child.on("error", reject);
-    child.on("exit", (code, signal) => resolve({ code, signal, stdout, stderr }));
+    child.on('error', reject);
+    child.on('exit', (code, signal) =>
+      resolve({ code, signal, stdout, stderr })
+    );
   });
 
-  assert.equal(result.code, 0);
+  assert.equal(result.code, 0, result.stderr);
   assert.equal(refreshCalls, 1);
-  assert.equal(refreshedAuthHeader, "Bearer refresh-token");
-  assert.equal(modelAuthHeader, "Bearer fresh-access");
+  assert.equal(refreshedAuthHeader, 'Bearer refresh-token');
+  assert.equal(modelAuthHeader, 'Bearer fresh-access');
 
-  const savedCredentials = JSON.parse(await fs.readFile(credentialsPath, "utf-8"));
-  assert.equal(savedCredentials.access_token, "fresh-access");
-  assert.equal(savedCredentials.refresh_token, "fresh-refresh");
+  const savedCredentials = JSON.parse(
+    await fs.readFile(credentialsPath, 'utf-8')
+  );
+  assert.equal(savedCredentials.access_token, 'fresh-access');
+  assert.equal(savedCredentials.refresh_token, 'fresh-refresh');
 
   const savedConfig = JSON.parse(
-    await fs.readFile(path.join(zenocodeHome, "opencode.jsonc"), "utf-8"),
+    await fs.readFile(path.join(zenocodeHome, 'zenocode.jsonc'), 'utf-8')
   );
-  assert.equal(savedConfig.model, "textcortex/minimax-m3-thinking");
+  assert.equal(savedConfig.model, 'textcortex/minimax-m3-thinking');
 
   const savedModels = JSON.parse(
-    await fs.readFile(path.join(zenocodeHome, "models.json"), "utf-8"),
+    await fs.readFile(path.join(zenocodeHome, 'models.json'), 'utf-8')
+  );
+  assert.ok(savedModels.textcortex.models['glm-5-2-non-thinking']);
+  assert.ok(savedModels.textcortex.models['glm-5-3']);
+  assert.equal(
+    savedModels.textcortex.models['glm-5-1-non-thinking'],
+    undefined
   );
-  assert.ok(savedModels.textcortex.models["glm-5-2-non-thinking"]);
+  assert.equal(savedModels.textcortex.models['glm-5-1-thinking'], undefined);
 });
 
-test("login launches the runtime immediately with system TUI theming", async (t) => {
-  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "zenocode-login-"));
-  const zenocodeHome = path.join(tempDir, ".zenocode");
-  const runtimeLogPath = path.join(tempDir, "runtime-log.json");
-  const fakeRuntimePath = path.join(tempDir, "fake-opencode");
-  const scriptPath = new URL("./run-zenocode.mjs", import.meta.url);
+test('login launches with the newly issued token even when the environment token is stale', async (t) => {
+  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'zenocode-login-'));
+  const zenocodeHome = path.join(tempDir, '.zenocode');
+  const runtimeLogPath = path.join(tempDir, 'runtime-log.json');
+  const fakeRuntimePath = path.join(tempDir, 'fake-opencode');
+  const scriptPath = new URL('./run-zenocode.mjs', import.meta.url);
+  let modelAuthHeader = null;
 
   t.after(async () => {
     await fs.rm(tempDir, { recursive: true, force: true });
@@ -724,6 +883,7 @@ async function main() {
     env: {
       OPENCODE_CONFIG: process.env.OPENCODE_CONFIG,
       OPENCODE_TUI_CONFIG: process.env.OPENCODE_TUI_CONFIG,
+      OPENCODE_DISABLE_AUTOUPDATE: process.env.OPENCODE_DISABLE_AUTOUPDATE,
       TEXTCORTEX_API_KEY: process.env.TEXTCORTEX_API_KEY,
     },
   };
@@ -735,83 +895,91 @@ main().catch((error) => {
   process.exit(1);
 });
 `,
-    "utf-8",
+    'utf-8'
   );
   await fs.chmod(fakeRuntimePath, 0o755);
 
   const server = http.createServer((req, res) => {
     if (
-      req.method === "POST" &&
-      req.url === "/internal/v2/fastapi/zenocode/oauth2/initiate"
+      req.method === 'POST' &&
+      req.url === '/internal/v2/fastapi/zenocode/oauth2/initiate'
     ) {
-      res.writeHead(200, { "Content-Type": "application/json" });
+      res.writeHead(200, { 'Content-Type': 'application/json' });
       res.end(
         JSON.stringify({
           data: {
-            device_code: "device-code",
-            user_code: "ABCD-1234",
-            verification_url_complete: "https://textcortex.example/verify",
+            device_code: 'device-code',
+            user_code: 'ABCD-1234',
+            verification_url_complete: 'https://textcortex.example/verify',
             interval: 0,
             expires_in: 30,
           },
-        }),
+        })
       );
       return;
     }
 
     if (
-      req.method === "POST" &&
-      req.url === "/internal/v2/fastapi/zenocode/oauth2/token"
+      req.method === 'POST' &&
+      req.url === '/internal/v2/fastapi/zenocode/oauth2/token'
     ) {
-      res.writeHead(200, { "Content-Type": "application/json" });
+      res.writeHead(200, { 'Content-Type': 'application/json' });
       res.end(
         JSON.stringify({
           data: {
-            access_token: "fresh-access",
-            refresh_token: "fresh-refresh",
-            auth_id: "auth_123",
+            access_token: 'fresh-access',
+            refresh_token: 'fresh-refresh',
+            auth_id: 'auth_123',
           },
-        }),
+        })
       );
       return;
     }
 
     if (
-      req.method === "GET" &&
-      req.url === "/internal/v2/fastapi/zenocode/models/api.json"
+      req.method === 'GET' &&
+      req.url === '/internal/v2/fastapi/zenocode/models/api.json'
     ) {
-      res.writeHead(200, { "Content-Type": "application/json" });
+      modelAuthHeader = req.headers.authorization || null;
+      if (modelAuthHeader !== 'Bearer fresh-access') {
+        res.writeHead(401, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ detail: 'Invalid token format' }));
+        return;
+      }
+
+      res.writeHead(200, { 'Content-Type': 'application/json' });
       res.end(
         JSON.stringify({
           textcortex: {
             models: {
-              "minimax-m3-thinking": {},
-              "kimi-k2-6-non-thinking": {},
-              "kimi-k2-6-thinking": {},
-              "kimi-k2-5": {},
-              "kimi-k2-5-thinking": {},
-              "glm-5-2-non-thinking": {},
-              "glm-5-2-thinking": {},
-              "glm-5-1-non-thinking": {},
-              "glm-5-1-thinking": {},
+              'minimax-m3-thinking': {},
+              'kimi-k2-6-non-thinking': {},
+              'kimi-k2-6-thinking': {},
+              'kimi-k2-5': {},
+              'kimi-k2-5-thinking': {},
+              'glm-5-2-non-thinking': {},
+              'glm-5-2-thinking': {},
+              'glm-5-3': {},
+              'glm-5-1-non-thinking': {},
+              'glm-5-1-thinking': {},
             },
           },
-        }),
+        })
       );
       return;
     }
 
-    res.writeHead(404, { "Content-Type": "application/json" });
-    res.end(JSON.stringify({ detail: "not found" }));
+    res.writeHead(404, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ detail: 'not found' }));
   });
 
-  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
   const address = server.address();
   const baseUrl = `http://127.0.0.1:${address.port}`;
 
   t.after(async () => {
     await new Promise((resolve, reject) =>
-      server.close((error) => (error ? reject(error) : resolve())),
+      server.close((error) => (error ? reject(error) : resolve()))
     );
   });
 
@@ -820,122 +988,147 @@ main().catch((error) => {
       process.execPath,
       [
         scriptPath.pathname,
-        "login",
-        "--email",
-        "person@example.com",
-        "--no-launch-browser",
+        'login',
+        '--email',
+        'person@example.com',
+        '--no-launch-browser',
       ],
       {
         cwd: tempDir,
         env: {
           ...process.env,
           ZENOCODE_HOME: zenocodeHome,
-          ZENOCODE_NO_BANNER: "1",
+          ZENOCODE_NO_BANNER: '1',
           ZENOCODE_OPENCODE_BIN_PATH: fakeRuntimePath,
           TEXTCORTEX_BASE_URL: baseUrl,
+          TEXTCORTEX_API_KEY: 'stale-invalid-token',
           RUNTIME_LOG_PATH: runtimeLogPath,
         },
-        stdio: ["ignore", "pipe", "pipe"],
-      },
+        stdio: ['ignore', 'pipe', 'pipe'],
+      }
     );
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (chunk) => {
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', (chunk) => {
       stdout += String(chunk);
     });
-    child.stderr.on("data", (chunk) => {
+    child.stderr.on('data', (chunk) => {
       stderr += String(chunk);
     });
-    child.on("error", reject);
-    child.on("exit", (code, signal) => resolve({ code, signal, stdout, stderr }));
+    child.on('error', reject);
+    child.on('exit', (code, signal) =>
+      resolve({ code, signal, stdout, stderr })
+    );
   });
 
   assert.equal(result.code, 0);
   assert.match(result.stdout, /Login successful for auth_123/);
   assert.match(result.stdout, /Zenocode config ready at/);
+  assert.equal(modelAuthHeader, 'Bearer fresh-access');
 
-  const runtimeInvocation = JSON.parse(await fs.readFile(runtimeLogPath, "utf-8"));
+  const runtimeInvocation = JSON.parse(
+    await fs.readFile(runtimeLogPath, 'utf-8')
+  );
   assert.deepEqual(runtimeInvocation.args, []);
-  assert.equal(runtimeInvocation.env.TEXTCORTEX_API_KEY, "fresh-access");
+  assert.equal(runtimeInvocation.env.TEXTCORTEX_API_KEY, 'fresh-access');
 
   const opencodeConfig = JSON.parse(
-    await fs.readFile(runtimeInvocation.env.OPENCODE_CONFIG, "utf-8"),
+    await fs.readFile(runtimeInvocation.env.OPENCODE_CONFIG, 'utf-8')
   );
-  assert.equal(opencodeConfig.theme, "system");
-  assert.equal(opencodeConfig.model, "textcortex/minimax-m3-thinking");
+  assert.equal(opencodeConfig.theme, 'system');
+  assert.equal(opencodeConfig.autoupdate, false);
+  assert.equal(opencodeConfig.model, 'textcortex/minimax-m3-thinking');
+  assert.equal(runtimeInvocation.env.OPENCODE_DISABLE_AUTOUPDATE, 'true');
 
   const modelsConfig = JSON.parse(
-    await fs.readFile(path.join(zenocodeHome, "models.json"), "utf-8"),
+    await fs.readFile(path.join(zenocodeHome, 'models.json'), 'utf-8')
   );
-  assert.ok(modelsConfig.textcortex.models["glm-5-2-non-thinking"]);
+  assert.ok(modelsConfig.textcortex.models['glm-5-2-non-thinking']);
+  assert.ok(modelsConfig.textcortex.models['glm-5-3']);
+  assert.equal(
+    modelsConfig.textcortex.models['glm-5-1-non-thinking'],
+    undefined
+  );
+  assert.equal(modelsConfig.textcortex.models['glm-5-1-thinking'], undefined);
 
   const tuiConfig = JSON.parse(
-    await fs.readFile(runtimeInvocation.env.OPENCODE_TUI_CONFIG, "utf-8"),
+    await fs.readFile(runtimeInvocation.env.OPENCODE_TUI_CONFIG, 'utf-8')
   );
-  assert.equal(tuiConfig.theme, "system");
+  assert.equal(tuiConfig.theme, 'system');
 });
 
-test("logout removes runtime credentials and blocks shared fallback credentials", async (t) => {
-  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "zenocode-logout-"));
-  const zenocodeHome = path.join(tempDir, ".zenocode");
-  const codecortexHome = path.join(tempDir, ".codecortex");
-  const homeCredentialsPath = path.join(tempDir, ".credentials.json");
-  const runtimeCredentialsPath = path.join(zenocodeHome, "credentials.json");
-  const legacyRuntimeCredentialsPath = path.join(codecortexHome, "credentials.json");
-  const scriptPath = new URL("./run-zenocode.mjs", import.meta.url);
+test('logout removes runtime credentials and blocks shared fallback credentials', async (t) => {
+  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'zenocode-logout-'));
+  const zenocodeHome = path.join(tempDir, '.zenocode');
+  const codecortexHome = path.join(tempDir, '.codecortex');
+  const homeCredentialsPath = path.join(tempDir, '.credentials.json');
+  const runtimeCredentialsPath = path.join(zenocodeHome, 'credentials.json');
+  const legacyRuntimeCredentialsPath = path.join(
+    codecortexHome,
+    'credentials.json'
+  );
+  const scriptPath = new URL('./run-zenocode.mjs', import.meta.url);
 
   t.after(async () => {
     await fs.rm(tempDir, { recursive: true, force: true });
   });
 
   await fs.mkdir(path.dirname(runtimeCredentialsPath), { recursive: true });
-  await fs.mkdir(path.dirname(legacyRuntimeCredentialsPath), { recursive: true });
-  await fs.writeFile(runtimeCredentialsPath, JSON.stringify({ access_token: "current" }));
+  await fs.mkdir(path.dirname(legacyRuntimeCredentialsPath), {
+    recursive: true,
+  });
+  await fs.writeFile(
+    runtimeCredentialsPath,
+    JSON.stringify({ access_token: 'current' })
+  );
   await fs.writeFile(
     legacyRuntimeCredentialsPath,
-    JSON.stringify({ access_token: "legacy" }),
+    JSON.stringify({ access_token: 'legacy' })
+  );
+  await fs.writeFile(
+    homeCredentialsPath,
+    JSON.stringify({ access_token: 'home' })
   );
-  await fs.writeFile(homeCredentialsPath, JSON.stringify({ access_token: "home" }));
 
   const result = await new Promise((resolve, reject) => {
-    const child = spawn(
-      process.execPath,
-      [scriptPath.pathname, "logout"],
-      {
-        cwd: tempDir,
-        env: {
-          ...process.env,
-          HOME: tempDir,
-          ZENOCODE_HOME: zenocodeHome,
-          CODECORTEX_HOME: codecortexHome,
-        },
-        stdio: ["ignore", "pipe", "pipe"],
+    const child = spawn(process.execPath, [scriptPath.pathname, 'logout'], {
+      cwd: tempDir,
+      env: {
+        ...process.env,
+        HOME: tempDir,
+        ZENOCODE_HOME: zenocodeHome,
+        CODECORTEX_HOME: codecortexHome,
       },
-    );
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (chunk) => {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', (chunk) => {
       stdout += String(chunk);
     });
-    child.stderr.on("data", (chunk) => {
+    child.stderr.on('data', (chunk) => {
       stderr += String(chunk);
     });
-    child.on("error", reject);
-    child.on("exit", (code, signal) => resolve({ code, signal, stdout, stderr }));
+    child.on('error', reject);
+    child.on('exit', (code, signal) =>
+      resolve({ code, signal, stdout, stderr })
+    );
   });
 
-  assert.equal(result.code, 0);
-  await assert.rejects(fs.stat(runtimeCredentialsPath), { code: "ENOENT" });
-  await assert.rejects(fs.stat(legacyRuntimeCredentialsPath), { code: "ENOENT" });
+  assert.equal(result.code, 0, result.stderr);
+  await assert.rejects(fs.stat(runtimeCredentialsPath), { code: 'ENOENT' });
+  await assert.rejects(fs.stat(legacyRuntimeCredentialsPath), {
+    code: 'ENOENT',
+  });
   assert.deepEqual(
-    JSON.parse(await fs.readFile(homeCredentialsPath, "utf-8")),
-    { access_token: "home" },
+    JSON.parse(await fs.readFile(homeCredentialsPath, 'utf-8')),
+    { access_token: 'home' }
   );
 
   const prepareOnlyResult = await new Promise((resolve, reject) => {
     const child = spawn(
       process.execPath,
-      [scriptPath.pathname, "--prepare-only"],
+      [scriptPath.pathname, '--prepare-only'],
       {
         cwd: tempDir,
         env: {
@@ -943,23 +1136,25 @@ test("logout removes runtime credentials and blocks shared fallback credentials"
           HOME: tempDir,
           ZENOCODE_HOME: zenocodeHome,
           CODECORTEX_HOME: codecortexHome,
-          ZENOCODE_NO_BANNER: "1",
+          ZENOCODE_NO_BANNER: '1',
         },
-        stdio: ["ignore", "pipe", "pipe"],
-      },
+        stdio: ['ignore', 'pipe', 'pipe'],
+      }
     );
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (chunk) => {
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', (chunk) => {
       stdout += String(chunk);
     });
-    child.stderr.on("data", (chunk) => {
+    child.stderr.on('data', (chunk) => {
       stderr += String(chunk);
     });
-    child.on("error", reject);
-    child.on("exit", (code, signal) => resolve({ code, signal, stdout, stderr }));
+    child.on('error', reject);
+    child.on('exit', (code, signal) =>
+      resolve({ code, signal, stdout, stderr })
+    );
   });
 
-  assert.equal(prepareOnlyResult.code, 1);
+  assert.equal(prepareOnlyResult.code, 1, prepareOnlyResult.stderr);
   assert.match(prepareOnlyResult.stderr, /Missing API token/);
 });