@textcortex/zenocode 0.1.12 → 0.1.14

package/README.md

@@ -4,6 +4,12 @@ Zenocode is the secure coding agent for TextCortex customers. It runs in your te
 
 Built for teams that need speed, control, and trust, Zenocode combines a terminal-native coding workflow with workspace routing and enterprise security from day one.
 
+## Requirements
+
+Zenocode is available on the **pay-as-you-go (PAYG)** plan. Your TextCortex account — or the organization seat assigned to you — must be on PAYG. On any other plan (Free, subscription, Business, Unlimited), `zenocode login` and model discovery return **"Zenocode is only available on the pay-as-you-go plan."** Switch your account (or ask your workspace admin to assign you a PAYG seat) before installing.
+
+If you already use pay-as-you-go and just ran out of wallet credits, top up under **Settings → Billing** (`/user/dashboard/settings/billing`). If you are not on pay-as-you-go yet, pick a plan on the **plan selection** page (`/billing/plans`). The in-app Zenocode dialog (sidebar → Zenocode) links you to the right one automatically based on your account.
+
 ## What This Package Does
 
 - Launches Zenocode from your terminal with the `zenocode` or `codecortex` command
@@ -31,13 +37,17 @@ The first `zenocode login` launches Zenocode automatically after browser authent
 
 If you already have an API key, you can also start Zenocode by setting `TEXTCORTEX_API_KEY` or `TEXTCORTEX_API_TOKEN`.
 
+## Models
+
+Zenocode uses **GPT-5.6 Luna** by default. You can switch to any other model available to your TextCortex workspace from the model picker inside the agent. Available models are discovered automatically from your account, so the default falls back to the next best coding model (for example Kimi K2.7 Code) when Luna is not available to you.
+
 ## Built For Security And Compliance
 
-Zenocode is built for organizations that treat security, compliance, and data sovereignty as non-negotiable.
+Zenocode is built for organizations that treat security, compliance, and data governance as non-negotiable.
 
-- Hosted in the European Union on GDPR-compliant infrastructure
+- TextCortex-managed routing with workspace-aware model availability
 - SOC 2 and ISO 27001 certified
-- Built for European data sovereignty
+- Model region metadata is surfaced for routing and governance decisions
 - Zero data training: your data is not used for model training or fine-tuning
 - Optional services or LLMs hosted outside the EU are covered by the EU-US Data Privacy Framework or GDPR Standard Contractual Clauses
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@textcortex/zenocode",
-  "version": "0.1.12",
-  "description": "Secure, EU-hosted coding agent for TextCortex customers that runs in your terminal, edits files, runs scripts, and more.",
+  "version": "0.1.14",
+  "description": "Secure, TextCortex-managed coding agent for customers that runs in your terminal, edits files, runs scripts, and more.",
   "keywords": [
     "ai",
     "agent",
@@ -11,12 +11,17 @@
     "developer-tools",
     "textcortex",
     "secure",
-    "eu-hosted",
+    "enterprise",
     "gdpr"
   ],
   "private": false,
   "license": "UNLICENSED",
   "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/textcortex/platform.git",
+    "directory": "apps/zenocode"
+  },
   "publishConfig": {
     "access": "public"
   },

package/scripts/branding-patch.mjs

@@ -139,21 +139,55 @@ export function patchOpenCodeVersionFooterText(text) {
   return { patched, text: next };
 }
 
+export function patchOpenCodeDisplayNameText(text) {
+  const replacements = [
+    ['TD("Uninstall OpenCode")', 'TD("Uninstall Zenocode")'],
+    ['"name":"OpenCode"', '"name":"Zenocode"'],
+    ['"short_name":"OpenCode"', '"short_name":"Zenocode"'],
+  ];
+
+  let patched = false;
+  let nextText = text;
+  for (const [target, replacement] of replacements) {
+    if (!nextText.includes(target)) {
+      continue;
+    }
+    nextText = nextText.replaceAll(target, replacement);
+    patched = true;
+  }
+
+  return { patched, text: nextText };
+}
+
 export function patchZenocodeBinaryText(text) {
   let patched = false;
   let nextText = text;
+  const patches = {
+    logo: false,
+    footer: false,
+    displayName: false,
+  };
 
   const logoPatch = patchLogoSnippetText(nextText);
   if (logoPatch.patched) {
     nextText = logoPatch.text;
     patched = true;
+    patches.logo = true;
   }
 
   const footerPatch = patchOpenCodeVersionFooterText(nextText);
   if (footerPatch.patched) {
     nextText = footerPatch.text;
     patched = true;
+    patches.footer = true;
   }
 
-  return { patched, text: nextText };
+  const displayNamePatch = patchOpenCodeDisplayNameText(nextText);
+  if (displayNamePatch.patched) {
+    nextText = displayNamePatch.text;
+    patched = true;
+    patches.displayName = true;
+  }
+
+  return { patched, patches, text: nextText };
 }

package/scripts/branding-patch.test.mjs

@@ -1,6 +1,11 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { padBinaryReplacement, patchOpenCodeVersionFooterText } from "./branding-patch.mjs";
+import {
+  padBinaryReplacement,
+  patchOpenCodeDisplayNameText,
+  patchOpenCodeVersionFooterText,
+  patchZenocodeBinaryText,
+} from "./branding-patch.mjs";
 
 test("padBinaryReplacement keeps binary length stable", () => {
   const padded = padBinaryReplacement("abcdef", "abc");
@@ -54,3 +59,31 @@ test("patchOpenCodeVersionFooterText is a no-op when already branded", () => {
   assert.equal(result.patched, false);
   assert.equal(result.text, branded);
 });
+
+test("patchOpenCodeDisplayNameText rewrites current compiled display names", () => {
+  const text = [
+    'TD("Uninstall OpenCode");"name":"OpenCode","short_name":"OpenCode"',
+    '"Powered by OpenCode"',
+  ].join(";");
+
+  const result = patchOpenCodeDisplayNameText(text);
+
+  assert.equal(result.patched, true);
+  assert.equal(result.text.length, text.length);
+  assert.equal(
+    result.text,
+    'TD("Uninstall Zenocode");"name":"Zenocode","short_name":"Zenocode";"Powered by OpenCode"',
+  );
+});
+
+test("patchZenocodeBinaryText reports display-name-only branding separately", () => {
+  const result = patchZenocodeBinaryText('"name":"OpenCode"');
+
+  assert.equal(result.patched, true);
+  assert.deepEqual(result.patches, {
+    logo: false,
+    footer: false,
+    displayName: true,
+  });
+  assert.equal(result.text, '"name":"Zenocode"');
+});

package/scripts/build-branded-opencode.mjs

@@ -7,17 +7,31 @@ import path from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
 import { patchZenocodeBinaryText } from "./branding-patch.mjs";
+import { openCodeRef, openCodeVersion } from "./opencode-version.mjs";
 
 const currentFilePath = realpathSync(fileURLToPath(import.meta.url));
 const __dirname = path.dirname(currentFilePath);
 const appRoot = path.resolve(__dirname, "..");
 const defaultOutputDir = path.join(appRoot, ".zenocode", "brand-build");
+export const defaultOpenCodeForkUrl = "https://github.com/sst/opencode";
+export const defaultOpenCodeRef = openCodeRef;
+export const defaultOpenCodeVersion = openCodeVersion;
+export const defaultOpenCodeBuildArgs = ["--skip-install"];
+export const trustedPublishingRepository = {
+  type: "git",
+  url: "git+https://github.com/textcortex/platform.git",
+};
+const displayNameOnlyBrandingRefs = new Set([defaultOpenCodeRef]);
 
 const forkUrl =
   process.env.ZENOCODE_OPENCODE_FORK_URL ||
   process.env.CODECORTEX_OPENCODE_FORK_URL ||
-  "https://github.com/anomalyco/opencode";
-const forkRef = (process.env.ZENOCODE_OPENCODE_REF || process.env.CODECORTEX_OPENCODE_REF || "").trim();
+  defaultOpenCodeForkUrl;
+const forkRef = (
+  process.env.ZENOCODE_OPENCODE_REF ||
+  process.env.CODECORTEX_OPENCODE_REF ||
+  defaultOpenCodeRef
+).trim();
 const outputDir =
   process.env.ZENOCODE_BRANDED_OUTPUT_DIR ||
   process.env.CODECORTEX_BRANDED_OUTPUT_DIR ||
@@ -36,16 +50,27 @@ const publishTag =
   process.env.ZENOCODE_PUBLISH_TAG ||
   process.env.CODECORTEX_PUBLISH_TAG ||
   "latest";
-const buildArgs = (
+const publishProvenance =
+  (process.env.ZENOCODE_NPM_PROVENANCE || process.env.CODECORTEX_NPM_PROVENANCE) === "1";
+const configuredBuildArgs = (
   process.env.ZENOCODE_OPENCODE_BUILD_ARGS ||
   process.env.CODECORTEX_OPENCODE_BUILD_ARGS ||
   ""
-)
-  .trim()
-  .split(/\s+/)
-  .filter(Boolean);
+).trim();
+const buildArgs = configuredBuildArgs
+  ? configuredBuildArgs.split(/\s+/).filter(Boolean)
+  : defaultOpenCodeBuildArgs;
 const cliArgs = process.argv.slice(2);
 
+export function deriveOpenCodeVersionFromRef(ref, fallbackVersion = defaultOpenCodeVersion) {
+  const match = ref.match(/^v?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)(?:\+.*)?$/);
+  return match?.[1] || fallbackVersion;
+}
+
+export function allowsDisplayNameOnlyBranding(ref) {
+  return displayNameOnlyBrandingRefs.has(ref);
+}
+
 function _command(name) {
   if (process.platform === "win32" && ["npm", "pnpm", "npx"].includes(name)) {
     return `${name}.cmd`;
@@ -207,6 +232,20 @@ async function writeJson(filePath, payload) {
   await fs.writeFile(filePath, `${JSON.stringify(payload, null, 2)}\n`, "utf-8");
 }
 
+export function selectLatestTarball(entries) {
+  const tarballs = entries.filter((entry) => entry.endsWith(".tgz")).sort((left, right) => {
+    const leftVersion = left.match(/-(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)(?:\+.*)?\.tgz$/)?.[1];
+    const rightVersion = right.match(/-(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)(?:\+.*)?\.tgz$/)?.[1];
+    if (leftVersion && rightVersion) {
+      return compareSemver(leftVersion, rightVersion);
+    }
+    if (leftVersion) return 1;
+    if (rightVersion) return -1;
+    return left.localeCompare(right);
+  });
+  return tarballs[tarballs.length - 1] || null;
+}
+
 async function maybePublishedVersion(packageName) {
   const npmCommand = _command("npm");
   try {
@@ -230,15 +269,18 @@ async function maybePublishedVersion(packageName) {
 async function packPackage(packageDir) {
   const npmCommand = _command("npm");
   await run(npmCommand, ["pack"], { cwd: packageDir });
-  const tarballs = (await fs.readdir(packageDir)).filter((entry) => entry.endsWith(".tgz")).sort();
-  if (!tarballs.length) {
+  const tarball = selectLatestTarball(await fs.readdir(packageDir));
+  if (!tarball) {
     throw new Error(`npm pack did not produce a tarball in ${packageDir}`);
   }
-  return path.join(packageDir, tarballs[tarballs.length - 1]);
+  return path.join(packageDir, tarball);
 }
 
-export function buildPublishCommandArgs(tarballPath, { tag } = {}) {
+export function buildPublishCommandArgs(tarballPath, { tag, provenance = false } = {}) {
   const args = ["publish", tarballPath, "--access", "public"];
+  if (provenance) {
+    args.push("--provenance");
+  }
   if (tag) {
     args.push("--tag", tag);
   }
@@ -262,14 +304,79 @@ async function publishTarballIfNeeded(packageName, version, tarballPath, cwd) {
   }
 
   const npmCommand = _command("npm");
-  await run(npmCommand, buildPublishCommandArgs(tarballPath, { tag: publishTag }), { cwd });
+  await run(npmCommand, buildPublishCommandArgs(tarballPath, { tag: publishTag, provenance: publishProvenance }), { cwd });
   return { published: true, skipped: false };
 }
 
+async function readPublishTarget(packageDir) {
+  const pkg = await readJson(path.join(packageDir, "package.json"));
+  if (typeof pkg?.name !== "string" || typeof pkg?.version !== "string") {
+    throw new Error(`Invalid package metadata in ${packageDir}`);
+  }
+  const tarball = selectLatestTarball(await fs.readdir(packageDir));
+  if (!tarball) {
+    throw new Error(`Missing npm tarball in ${packageDir}`);
+  }
+  return {
+    packageName: pkg.name,
+    version: pkg.version,
+    tarballPath: path.join(packageDir, tarball),
+    cwd: packageDir,
+  };
+}
+
+async function publishExistingPackages(artifactDir) {
+  const packageRoot = path.join(artifactDir, "npm-binaries");
+  const entries = await fs.readdir(packageRoot, { withFileTypes: true });
+  const binaryPackageDirs = entries
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => path.join(packageRoot, entry.name))
+    .sort();
+  if (!binaryPackageDirs.length) {
+    throw new Error(`No existing binary packages found under ${packageRoot}`);
+  }
+
+  const targets = [];
+  for (const packageDir of binaryPackageDirs) {
+    targets.push(await readPublishTarget(packageDir));
+  }
+  targets.push(await readPublishTarget(path.join(artifactDir, "npm-package")));
+
+  const published = [];
+  const skipped = [];
+  for (const target of targets) {
+    const result = await publishTarballIfNeeded(
+      target.packageName,
+      target.version,
+      target.tarballPath,
+      target.cwd,
+    );
+    if (result.published) {
+      published.push(target.packageName);
+    } else if (result.skipped) {
+      skipped.push(target.packageName);
+    }
+  }
+
+  if (published.length) {
+    console.log(`Published packages: ${published.join(", ")}`);
+  }
+  if (skipped.length) {
+    console.log(`Skipped already-published packages: ${skipped.join(", ")}`);
+  }
+}
+
 function _binaryFilename() {
   return process.platform === "win32" ? "opencode.exe" : "opencode";
 }
 
+async function adHocSignBinary(binaryPath) {
+  if (process.platform !== "darwin") return;
+  await run("codesign", ["--force", "--sign", "-", binaryPath], {
+    stdio: "ignore",
+  });
+}
+
 async function patchBinaryAtPath(binaryPath) {
   const buffer = await fs.readFile(binaryPath);
   const originalLength = buffer.length;
@@ -277,6 +384,12 @@ async function patchBinaryAtPath(binaryPath) {
   if (!patch.patched) {
     throw new Error(`Branding patch did not match binary ${binaryPath}`);
   }
+  const patchedMandatoryBranding = patch.patches.logo || patch.patches.footer;
+  if (!patchedMandatoryBranding && !allowsDisplayNameOnlyBranding(forkRef)) {
+    throw new Error(
+      `Branding patch only matched display names for ${binaryPath}; update the logo/footer patch signatures before building ${forkRef}.`,
+    );
+  }
   const nextBuffer = Buffer.from(patch.text, "latin1");
   if (nextBuffer.length !== originalLength) {
     throw new Error(`Branding patch changed binary length for ${binaryPath}`);
@@ -285,6 +398,7 @@ async function patchBinaryAtPath(binaryPath) {
   if (process.platform !== "win32") {
     await fs.chmod(binaryPath, 0o755);
   }
+  await adHocSignBinary(binaryPath);
 }
 
 function _buildWrapperExecutable({ runtimePackageName, binName }) {
@@ -501,6 +615,7 @@ async function buildWrapperPackage({
     version,
     license: "MIT",
     type: "commonjs",
+    repository: trustedPublishingRepository,
     bin: buildWrapperBinMap(packageName, binName),
     optionalDependencies: Object.fromEntries(
       binaryPackages.map((pkg) => [pkg.brandedName, pkg.version]),
@@ -555,6 +670,7 @@ async function prepareBinaryPackages({ distDir, artifactDir, runtimePackageName
     const targetDir = path.join(packageRoot, brandedName.replace("/", "__"));
     await fs.cp(sourceDir, targetDir, { recursive: true });
     pkg.name = brandedName;
+    pkg.repository = trustedPublishingRepository;
     await writeJson(path.join(targetDir, "package.json"), pkg);
     await patchBinaryAtPath(path.join(targetDir, "bin", _binaryFilename()));
 
@@ -608,21 +724,29 @@ async function main() {
     console.log("  ZENOCODE_OPENCODE_BUILD_ARGS  Additional args for upstream build script");
     console.log("  ZENOCODE_PUBLISH=1            Publish packages to npm");
     console.log(`  ZENOCODE_PUBLISH_TAG          npm tag (default: ${publishTag})`);
+    console.log("  --publish-existing            Publish tarballs from the output directory without rebuilding");
     console.log("  Legacy CODECORTEX_* env names are still accepted for compatibility.");
     return;
   }
 
+  const npmCommand = _command("npm");
+  await requireCommand(npmCommand);
+
+  const artifactDir = path.resolve(outputDir);
+
+  if (cliArgs.includes("--publish-existing")) {
+    await publishExistingPackages(artifactDir);
+    return;
+  }
+
   const gitCommand = _command("git");
   const bunCommand = _command("bun");
-  const npmCommand = _command("npm");
   await requireCommand(gitCommand);
   await requireCommand(bunCommand);
-  await requireCommand(npmCommand);
 
   const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "zenocode-opencode-"));
   const checkoutDir = path.join(tempRoot, "opencode");
   const distDir = path.join(checkoutDir, "packages", "opencode", "dist");
-  const artifactDir = path.resolve(outputDir);
 
   try {
     const cloneArgs = ["clone", "--depth=1"];
@@ -636,7 +760,16 @@ async function main() {
     await run(
       bunCommand,
       ["./packages/opencode/script/build.ts", "--single", ...buildArgs],
-      { cwd: checkoutDir },
+      {
+        cwd: checkoutDir,
+        env: {
+          ...process.env,
+          OPENCODE_CHANNEL: process.env.OPENCODE_CHANNEL || "latest",
+          OPENCODE_VERSION:
+            process.env.OPENCODE_VERSION ||
+            deriveOpenCodeVersionFromRef(forkRef, defaultOpenCodeVersion),
+        },
+      },
     );
 
     await fs.mkdir(artifactDir, { recursive: true });

package/scripts/build-branded-opencode.test.mjs

@@ -3,9 +3,35 @@ import test from "node:test";
 import {
   buildPublishCommandArgs,
   buildWrapperBinMap,
+  allowsDisplayNameOnlyBranding,
+  defaultOpenCodeBuildArgs,
+  defaultOpenCodeForkUrl,
+  defaultOpenCodeRef,
+  defaultOpenCodeVersion,
+  deriveOpenCodeVersionFromRef,
   mapBrandedBinaryPackageName,
+  selectLatestTarball,
+  trustedPublishingRepository,
 } from "./build-branded-opencode.mjs";
 
+test("branded OpenCode build defaults to the latest stable upstream release", () => {
+  assert.equal(defaultOpenCodeForkUrl, "https://github.com/sst/opencode");
+  assert.equal(defaultOpenCodeRef, "v1.17.6");
+  assert.equal(defaultOpenCodeVersion, "1.17.6");
+  assert.deepEqual(defaultOpenCodeBuildArgs, ["--skip-install"]);
+});
+
+test("deriveOpenCodeVersionFromRef follows explicit tag overrides", () => {
+  assert.equal(deriveOpenCodeVersionFromRef("v1.17.5"), "1.17.5");
+  assert.equal(deriveOpenCodeVersionFromRef("1.18.0-beta.1"), "1.18.0-beta.1");
+  assert.equal(deriveOpenCodeVersionFromRef("main", "1.17.4"), "1.17.4");
+});
+
+test("display-name-only branding is limited to reviewed upstream refs", () => {
+  assert.equal(allowsDisplayNameOnlyBranding(defaultOpenCodeRef), true);
+  assert.equal(allowsDisplayNameOnlyBranding("v1.17.7"), false);
+});
+
 test("mapBrandedBinaryPackageName scopes runtime binaries under zenocode", () => {
   assert.equal(
     mapBrandedBinaryPackageName("opencode-darwin-arm64", "@textcortex/zenocode-ai"),
@@ -25,7 +51,26 @@ test("buildWrapperBinMap includes package, opencode, and zenocode entrypoints",
   });
 });
 
-test("buildPublishCommandArgs omits npm provenance for runtime tarball publishing", () => {
+test("generated runtime packages point trusted publishing at this repository", () => {
+  assert.deepEqual(trustedPublishingRepository, {
+    type: "git",
+    url: "git+https://github.com/textcortex/platform.git",
+  });
+});
+
+test("buildPublishCommandArgs enables npm provenance for trusted publishing", () => {
+  assert.deepEqual(buildPublishCommandArgs("package.tgz", { tag: "latest", provenance: true }), [
+    "publish",
+    "package.tgz",
+    "--access",
+    "public",
+    "--provenance",
+    "--tag",
+    "latest",
+  ]);
+});
+
+test("buildPublishCommandArgs omits npm provenance unless requested", () => {
   assert.deepEqual(buildPublishCommandArgs("package.tgz", { tag: "latest" }), [
     "publish",
     "package.tgz",
@@ -44,3 +89,15 @@ test("buildPublishCommandArgs omits tag arguments when no tag is provided", () =
     "public",
   ]);
 });
+
+test("selectLatestTarball returns the sorted newest tarball", () => {
+  assert.equal(
+    selectLatestTarball([
+      "README.md",
+      "textcortex-zenocode-linux-x64-1.9.0.tgz",
+      "textcortex-zenocode-linux-x64-1.10.0.tgz",
+    ]),
+    "textcortex-zenocode-linux-x64-1.10.0.tgz",
+  );
+  assert.equal(selectLatestTarball(["README.md"]), null);
+});

package/scripts/opencode-version.mjs

@@ -0,0 +1,4 @@
+export const openCodePackageName = "opencode-ai";
+export const openCodeVersion = "1.17.6";
+export const openCodeRef = `v${openCodeVersion}`;
+export const openCodePackageSpec = `${openCodePackageName}@${openCodeVersion}`;

package/scripts/run-zenocode.mjs

@@ -11,6 +11,10 @@ import {
   patchZenocodeBinaryText,
   zenocodeLogo,
 } from "./branding-patch.mjs";
+import {
+  openCodePackageName,
+  openCodePackageSpec,
+} from "./opencode-version.mjs";
 
 const currentFilePath = realpathSync(fileURLToPath(import.meta.url));
 const __dirname = path.dirname(currentFilePath);
@@ -40,19 +44,29 @@ const configuredOpencodePackage =
   process.env.CODECORTEX_OPENCODE_PACKAGE ||
   process.env.OPENCODE_PACKAGE ||
   null;
-const defaultBrandedOpencodePackage = "@textcortex/zenocode-ai";
+const defaultBrandedOpencodePackage = openCodePackageSpec;
 const legacyBrandedOpencodePackage = "@textcortex/opencode-ai";
-const fallbackOpencodePackage = "opencode-ai";
+const fallbackOpencodePackage = openCodePackageName;
 const opencodePackage = configuredOpencodePackage || defaultBrandedOpencodePackage;
 const opencodeBinaryPath =
   process.env.ZENOCODE_OPENCODE_BIN_PATH ||
   process.env.CODECORTEX_OPENCODE_BIN_PATH ||
   "";
-const oauthInitiatePath = "/internal/v1/fastapi/zenocode/oauth2/initiate";
-const oauthTokenPath = "/internal/v1/fastapi/zenocode/oauth2/token";
+const oauthInitiatePath = "/internal/v2/fastapi/zenocode/oauth2/initiate";
+const oauthTokenPath = "/internal/v2/fastapi/zenocode/oauth2/token";
 const defaultOrder = [
+  "gpt-5-6-luna",
+  "kimi-k2p7-code-non-thinking",
+  "kimi-k2p7-code-thinking",
+  "minimax-m3-thinking",
+  "kimi-k2-6-non-thinking",
+  "kimi-k2-6-thinking",
+  "kimi-k2-5",
   "kimi-k2-5-thinking",
-  "glm-5",
+  "glm-5-2-non-thinking",
+  "glm-5-2-thinking",
+  "glm-5-1-non-thinking",
+  "glm-5-1-thinking",
   "gpt-5-2",
   "gpt-5-1",
   "gpt-5",
@@ -387,7 +401,8 @@ export function chooseDefaults(models) {
   const ids = Object.keys(models);
   if (!ids.length) throw new Error("No models were returned by the backend.");
   const model = defaultOrder.find((id) => ids.includes(id)) || ids[0];
-  const smallModel = ids.find((id) => id.includes("mini") || id.includes("haiku")) || model;
+  const smallModel =
+    ids.find((id) => id.includes("-mini") || id.includes("haiku")) || model;
   return { model, smallModel };
 }
 
@@ -403,7 +418,7 @@ export function buildOpenCodeConfig({ baseUrl, providerID, model, smallModel })
       [providerID]: {
         name: "Zenocode",
         options: {
-          baseURL: new URL("/internal/v1/fastapi/zenocode/v1", baseUrl).toString(),
+          baseURL: new URL("/internal/v2/fastapi/zenocode/v1", baseUrl).toString(),
         },
       },
       // Older fallback opencode-ai builds can load the Codex auth plugin when
@@ -464,7 +479,7 @@ async function requestJson(url, init) {
 }
 
 async function prepareRuntime(baseUrl, token) {
-  const modelsUrl = new URL("/internal/v1/fastapi/zenocode/models/api.json", baseUrl).toString();
+  const modelsUrl = new URL("/internal/v2/fastapi/zenocode/models/api.json", baseUrl).toString();
   const { response, payload, text } = await requestJson(modelsUrl, {
     headers: { Authorization: `Bearer ${token}`, Accept: "application/json" },
   });
@@ -954,11 +969,26 @@ function _runtimeBrandedBinaryPath() {
   return path.join(runtimeDir, "bin", binaryName);
 }
 
+export function packageNameFromSpecifier(packageSpecifier) {
+  if (!packageSpecifier.includes("@")) {
+    return packageSpecifier;
+  }
+  if (!packageSpecifier.startsWith("@")) {
+    return packageSpecifier.split("@")[0];
+  }
+
+  const versionSeparator = packageSpecifier.lastIndexOf("@");
+  return versionSeparator > packageSpecifier.indexOf("/")
+    ? packageSpecifier.slice(0, versionSeparator)
+    : packageSpecifier;
+}
+
 function shouldPatchOpencodeRuntimePackage(packageName) {
+  const runtimePackageName = packageNameFromSpecifier(packageName);
   return (
-    packageName.endsWith("/opencode-ai") ||
-    packageName.endsWith("/zenocode-ai") ||
-    packageName === "opencode-ai"
+    runtimePackageName.endsWith("/opencode-ai") ||
+    runtimePackageName.endsWith("/zenocode-ai") ||
+    runtimePackageName === openCodePackageName
   );
 }
 
@@ -999,6 +1029,88 @@ async function _collectPnpmDlxPnpmDirs(rootDir) {
   return pnpmDirs;
 }
 
+async function _collectNodeModulesDirs(rootDir) {
+  const queue = [{ dir: rootDir, depth: 0 }];
+  const nodeModulesDirs = [];
+
+  while (queue.length) {
+    const current = queue.shift();
+    const nodeModulesPath = path.join(current.dir, "node_modules");
+    if (await _pathExists(nodeModulesPath)) {
+      nodeModulesDirs.push(nodeModulesPath);
+    }
+
+    if (current.depth >= 3) continue;
+    let entries = [];
+    try {
+      entries = await fs.readdir(current.dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name === "node_modules") continue;
+      queue.push({ dir: path.join(current.dir, entry.name), depth: current.depth + 1 });
+    }
+  }
+
+  return nodeModulesDirs;
+}
+
+async function _collectOpencodeBinariesFromNodeModules(nodeModulesPath) {
+  const binaryName = process.platform === "win32" ? "opencode.exe" : "opencode";
+  const hiddenCachedBinaryName = ".opencode";
+  const candidates = [];
+
+  let topLevel = [];
+  try {
+    topLevel = await fs.readdir(nodeModulesPath, { withFileTypes: true });
+  } catch {
+    return candidates;
+  }
+
+  for (const moduleEntry of topLevel) {
+    if (!moduleEntry.isDirectory()) continue;
+
+    if (moduleEntry.name === openCodePackageName) {
+      const cachedPath = path.join(nodeModulesPath, openCodePackageName, "bin", hiddenCachedBinaryName);
+      if (await _pathExists(cachedPath)) candidates.push(cachedPath);
+      continue;
+    }
+
+    if (moduleEntry.name.startsWith("opencode-")) {
+      const binaryPath = path.join(nodeModulesPath, moduleEntry.name, "bin", binaryName);
+      if (await _pathExists(binaryPath)) candidates.push(binaryPath);
+      continue;
+    }
+
+    if (!moduleEntry.name.startsWith("@")) continue;
+    const scopePath = path.join(nodeModulesPath, moduleEntry.name);
+    let scopedPackages = [];
+    try {
+      scopedPackages = await fs.readdir(scopePath, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const scopedPackage of scopedPackages) {
+      if (!scopedPackage.isDirectory()) continue;
+      const scopedNodeModulesPath = path.join(scopePath, scopedPackage.name);
+
+      if (scopedPackage.name === "opencode-ai") {
+        const cachedPath = path.join(scopedNodeModulesPath, "bin", hiddenCachedBinaryName);
+        if (await _pathExists(cachedPath)) candidates.push(cachedPath);
+        continue;
+      }
+
+      if (!scopedPackage.name.startsWith("opencode-")) continue;
+      const binaryPath = path.join(scopedNodeModulesPath, "bin", binaryName);
+      if (await _pathExists(binaryPath)) candidates.push(binaryPath);
+    }
+  }
+
+  return candidates;
+}
+
 async function _collectPnpmDlxOpencodeBinaries() {
   const dlxRoots = [
     path.join(os.homedir(), "Library", "Caches", "pnpm", "dlx"),
@@ -1006,8 +1118,6 @@ async function _collectPnpmDlxOpencodeBinaries() {
     path.join(process.env.LOCALAPPDATA || "", "pnpm", "dlx"),
   ].filter(Boolean);
 
-  const binaryName = process.platform === "win32" ? "opencode.exe" : "opencode";
-  const hiddenCachedBinaryName = ".opencode";
   const candidates = [];
 
   for (const root of dlxRoots) {
@@ -1026,51 +1136,7 @@ async function _collectPnpmDlxOpencodeBinaries() {
         const nodeModulesPath = path.join(pnpmDir, entry.name, "node_modules");
         if (!(await _pathExists(nodeModulesPath))) continue;
 
-        let topLevel = [];
-        try {
-          topLevel = await fs.readdir(nodeModulesPath, { withFileTypes: true });
-        } catch {
-          continue;
-        }
-
-        for (const moduleEntry of topLevel) {
-          if (!moduleEntry.isDirectory()) continue;
-
-          if (moduleEntry.name === "opencode-ai") {
-            const cachedPath = path.join(nodeModulesPath, "opencode-ai", "bin", hiddenCachedBinaryName);
-            if (await _pathExists(cachedPath)) candidates.push(cachedPath);
-            continue;
-          }
-
-          if (moduleEntry.name.startsWith("opencode-")) {
-            const binaryPath = path.join(nodeModulesPath, moduleEntry.name, "bin", binaryName);
-            if (await _pathExists(binaryPath)) candidates.push(binaryPath);
-            continue;
-          }
-
-          if (!moduleEntry.name.startsWith("@")) continue;
-          const scopePath = path.join(nodeModulesPath, moduleEntry.name);
-          let scopedPackages = [];
-          try {
-            scopedPackages = await fs.readdir(scopePath, { withFileTypes: true });
-          } catch {
-            continue;
-          }
-          for (const scopedPackage of scopedPackages) {
-            if (!scopedPackage.isDirectory()) continue;
-            const scopedNodeModulesPath = path.join(scopePath, scopedPackage.name);
-
-            if (scopedPackage.name === "opencode-ai") {
-              const cachedPath = path.join(scopedNodeModulesPath, "bin", hiddenCachedBinaryName);
-              if (await _pathExists(cachedPath)) candidates.push(cachedPath);
-              continue;
-            }
-
-            if (!scopedPackage.name.startsWith("opencode-")) continue;
-            const binaryPath = path.join(scopedNodeModulesPath, "bin", binaryName);
-            if (await _pathExists(binaryPath)) candidates.push(binaryPath);
-          }
-        }
+        candidates.push(...await _collectOpencodeBinariesFromNodeModules(nodeModulesPath));
       }
     }
   }
@@ -1078,6 +1144,44 @@ async function _collectPnpmDlxOpencodeBinaries() {
   return [...new Set(candidates)];
 }
 
+async function _collectNpxOpencodeBinaries() {
+  const npxRoots = [
+    path.join(os.homedir(), ".npm", "_npx"),
+    path.join(process.env.LOCALAPPDATA || "", "npm-cache", "_npx"),
+  ].filter(Boolean);
+  const candidates = [];
+
+  for (const root of npxRoots) {
+    if (!(await _pathExists(root))) continue;
+    const nodeModulesDirs = await _collectNodeModulesDirs(root);
+    for (const nodeModulesDir of nodeModulesDirs) {
+      candidates.push(...await _collectOpencodeBinariesFromNodeModules(nodeModulesDir));
+    }
+  }
+
+  return [...new Set(candidates)];
+}
+
+function _buildPackageWarmupArgs(packageName, runner) {
+  if (runner.command === _runnerCommand("pnpm")) {
+    return ["dlx", packageName, "--version"];
+  }
+  if (runner.command === _runnerCommand("npx")) {
+    return ["--yes", packageName, "--version"];
+  }
+  return null;
+}
+
+async function _collectRunnerOpencodeBinaries(runner) {
+  if (runner.command === _runnerCommand("pnpm")) {
+    return _collectPnpmDlxOpencodeBinaries();
+  }
+  if (runner.command === _runnerCommand("npx")) {
+    return _collectNpxOpencodeBinaries();
+  }
+  return [];
+}
+
 async function _adHocSignBinary(binaryPath) {
   if (process.platform !== "darwin") return;
   try {
@@ -1143,9 +1247,6 @@ async function _ensurePatchedOpencodeDlxBinaries(packageName, runner, options) {
   if (!shouldPatchOpencodeRuntimePackage(packageName)) {
     return null;
   }
-  if (runner.command !== _runnerCommand("pnpm")) {
-    return null;
-  }
   if (
     process.env.ZENOCODE_DISABLE_OPENCODE_LOGO_PATCH === "1" ||
     process.env.CODECORTEX_DISABLE_OPENCODE_LOGO_PATCH === "1"
@@ -1153,19 +1254,18 @@ async function _ensurePatchedOpencodeDlxBinaries(packageName, runner, options) {
     return null;
   }
 
-  let binaryCandidates = await _collectPnpmDlxOpencodeBinaries();
-  if (!binaryCandidates.length) {
-    // Warm cache so we have a concrete binary to patch.
-    try {
-      await runChild(runner.command, ["dlx", packageName, "--version"], {
+  const warmupArgs = _buildPackageWarmupArgs(packageName, runner);
+  try {
+    if (warmupArgs) {
+      await runChild(runner.command, warmupArgs, {
         ...options,
         stdio: "ignore",
       });
-    } catch {
-      // ignore warm-up failures and continue with best effort patching
     }
-    binaryCandidates = await _collectPnpmDlxOpencodeBinaries();
+  } catch {
+    // ignore warm-up failures and continue with best effort patching
   }
+  const binaryCandidates = await _collectRunnerOpencodeBinaries(runner);
 
   if (!binaryCandidates.length) {
     return null;
@@ -1198,6 +1298,22 @@ export function buildPackageLauncherChildOptions(options, pinnedRuntimePath) {
   };
 }
 
+export function buildPackageLauncherInvocation({ runner, args, pinnedRuntimePath }) {
+  if (pinnedRuntimePath) {
+    return {
+      command: pinnedRuntimePath,
+      args,
+      usePinnedRuntime: true,
+    };
+  }
+
+  return {
+    command: runner.command,
+    args: runner.args,
+    usePinnedRuntime: false,
+  };
+}
+
 async function runPackageLauncher(packageName, args, options) {
   const runners = [
     { command: _runnerCommand("pnpm"), args: ["dlx", packageName, ...args] },
@@ -1215,9 +1331,17 @@ async function runPackageLauncher(packageName, args, options) {
         }
       }
 
-      const childOptions = buildPackageLauncherChildOptions(options, pinnedRuntimePath);
+      const invocation = buildPackageLauncherInvocation({
+        runner,
+        args,
+        pinnedRuntimePath,
+      });
+      const childOptions = buildPackageLauncherChildOptions(
+        options,
+        invocation.usePinnedRuntime ? null : pinnedRuntimePath,
+      );
 
-      const result = await runChild(runner.command, runner.args, childOptions);
+      const result = await runChild(invocation.command, invocation.args, childOptions);
       if (result.signal) {
         process.kill(process.pid, result.signal);
         return;
@@ -1363,10 +1487,11 @@ export async function runRuntimeWithSessionRecovery({
 }
 
 async function packageExistsOnNpm(packageName) {
+  const packageSpecName = packageNameFromSpecifier(packageName);
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), 4_000);
   try {
-    const response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(packageName)}`, {
+    const response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(packageSpecName)}`, {
       method: "GET",
       headers: { Accept: "application/json" },
       signal: controller.signal,
@@ -1424,6 +1549,11 @@ function shouldRenderBanner(args) {
   return !args.some((arg) => suppressFlags.has(arg));
 }
 
+export function shouldBypassZenocodePreparation(args) {
+  const metadataFlags = new Set(["--help", "-h", "--version", "-v", "completion"]);
+  return metadataFlags.has(args[0]);
+}
+
 function maybeRenderBanner(args) {
   if (!shouldRenderBanner(args)) {
     return;
@@ -1617,6 +1747,15 @@ async function main() {
   }
 
   maybeRenderBanner(runtimeArgs);
+  if (shouldBypassZenocodePreparation(runtimeArgs)) {
+    const launchPackage = await resolveLaunchPackage();
+    await runPackageLauncher(launchPackage, runtimeArgs, {
+      cwd: process.cwd(),
+      env: { ...process.env },
+    });
+    return;
+  }
+
   const tokenResolution = await resolveTokenWithAutoLogin(baseUrl, runtimeArgs, {
     preferLocalhost,
   });

package/scripts/run-zenocode.test.mjs

@@ -11,32 +11,99 @@ import {
 } from "./branding-patch.mjs";
 import {
   buildOpenCodeConfig,
+  buildPackageLauncherInvocation,
   buildPackageLauncherChildOptions,
   canRecoverRuntimeSessionFromTranscript,
   buildZenocodeBanner,
   chooseDefaults,
   hasLocalBaseUrlFlag,
+  packageNameFromSpecifier,
   resolveLoginBaseUrl,
   resolveLoginSuccessIdentifier,
   resolveTextCortexBaseUrl,
   runRuntimeWithSessionRecovery,
+  shouldBypassZenocodePreparation,
   shouldFallbackLoginToCloud,
   writePrivateJsonFile,
 } from "./run-zenocode.mjs";
 
-test("chooseDefaults prefers kimi k2.5 thinking for Zenocode", () => {
+test("chooseDefaults prefers GPT-5.6 Luna as the Zenocode default", () => {
   const defaults = chooseDefaults({
-    "glm-5": {},
-    "kimi-k2-5-thinking": {},
+    "kimi-k2p7-code-non-thinking": {},
+    "gpt-5-6-luna": {},
+    "glm-5-2-non-thinking": {},
+    "minimax-m3-thinking": {},
     "gpt-5-2": {},
   });
 
   assert.deepEqual(defaults, {
-    model: "kimi-k2-5-thinking",
-    smallModel: "kimi-k2-5-thinking",
+    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", () => {
+  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": {},
+  });
+
+  assert.deepEqual(defaults, {
+    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", () => {
+  const defaults = chooseDefaults({
+    "glm-5-1-non-thinking": {},
+    "glm-5-2-non-thinking": {},
+    "gpt-5-mini": {},
+  });
+
+  assert.deepEqual(defaults, {
+    model: "glm-5-2-non-thinking",
+    smallModel: "gpt-5-mini",
+  });
+});
+
+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": {},
+  });
+
+  assert.deepEqual(defaults, {
+    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("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({
@@ -128,12 +195,13 @@ test("buildOpenCodeConfig includes an openai stub for fallback runtime auth plug
   const config = buildOpenCodeConfig({
     baseUrl: "http://127.0.0.1:8080",
     providerID: "textcortex",
-    model: "kimi-k2-5-thinking",
-    smallModel: "kimi-k2-5-thinking",
+    model: "minimax-m3-thinking",
+    smallModel: "gpt-5-2",
   });
 
   assert.deepEqual(config.enabled_providers, ["textcortex"]);
-  assert.equal(config.model, "textcortex/kimi-k2-5-thinking");
+  assert.equal(config.model, "textcortex/minimax-m3-thinking");
+  assert.equal(config.small_model, "textcortex/gpt-5-2");
   assert.equal(config.theme, "system");
   assert.ok(config.provider.openai);
   assert.deepEqual(config.provider.openai.models, {});
@@ -156,6 +224,40 @@ test("buildPackageLauncherChildOptions keeps fallback package launchers attached
   });
 });
 
+test("buildPackageLauncherInvocation runs pinned runtimes directly", () => {
+  const invocation = buildPackageLauncherInvocation({
+    runner: {
+      command: "npx",
+      args: ["--yes", "opencode-ai@1.17.6", "--version"],
+    },
+    args: ["--version"],
+    pinnedRuntimePath: "/tmp/zenocode-runtime",
+  });
+
+  assert.deepEqual(invocation, {
+    command: "/tmp/zenocode-runtime",
+    args: ["--version"],
+    usePinnedRuntime: true,
+  });
+});
+
+test("buildPackageLauncherInvocation uses package runners without a pinned runtime", () => {
+  const invocation = buildPackageLauncherInvocation({
+    runner: {
+      command: "pnpm",
+      args: ["dlx", "opencode-ai@1.17.6", "--version"],
+    },
+    args: ["--version"],
+    pinnedRuntimePath: null,
+  });
+
+  assert.deepEqual(invocation, {
+    command: "pnpm",
+    args: ["dlx", "opencode-ai@1.17.6", "--version"],
+    usePinnedRuntime: false,
+  });
+});
+
 test("buildZenocodeBanner renders block logo art instead of plain text", () => {
   const banner = buildZenocodeBanner();
 
@@ -510,7 +612,7 @@ test("prepare-only refreshes stored Zenocode credentials when the access token h
 
     if (
       req.method === "GET" &&
-      req.url === "/internal/v1/fastapi/zenocode/models/api.json"
+      req.url === "/internal/v2/fastapi/zenocode/models/api.json"
     ) {
       modelAuthHeader = req.headers.authorization || null;
       if (modelAuthHeader === "Bearer expired-access") {
@@ -524,8 +626,15 @@ test("prepare-only refreshes stored Zenocode credentials when the access token h
         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": {},
+              "glm-5-2-non-thinking": {},
+              "glm-5-2-thinking": {},
+              "glm-5-1-non-thinking": {},
+              "glm-5-1-thinking": {},
             },
           },
         }),
@@ -580,6 +689,16 @@ test("prepare-only refreshes stored Zenocode credentials when the access token h
   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"),
+  );
+  assert.equal(savedConfig.model, "textcortex/minimax-m3-thinking");
+
+  const savedModels = JSON.parse(
+    await fs.readFile(path.join(zenocodeHome, "models.json"), "utf-8"),
+  );
+  assert.ok(savedModels.textcortex.models["glm-5-2-non-thinking"]);
 });
 
 test("login launches the runtime immediately with system TUI theming", async (t) => {
@@ -623,7 +742,7 @@ main().catch((error) => {
   const server = http.createServer((req, res) => {
     if (
       req.method === "POST" &&
-      req.url === "/internal/v1/fastapi/zenocode/oauth2/initiate"
+      req.url === "/internal/v2/fastapi/zenocode/oauth2/initiate"
     ) {
       res.writeHead(200, { "Content-Type": "application/json" });
       res.end(
@@ -642,7 +761,7 @@ main().catch((error) => {
 
     if (
       req.method === "POST" &&
-      req.url === "/internal/v1/fastapi/zenocode/oauth2/token"
+      req.url === "/internal/v2/fastapi/zenocode/oauth2/token"
     ) {
       res.writeHead(200, { "Content-Type": "application/json" });
       res.end(
@@ -659,15 +778,22 @@ main().catch((error) => {
 
     if (
       req.method === "GET" &&
-      req.url === "/internal/v1/fastapi/zenocode/models/api.json"
+      req.url === "/internal/v2/fastapi/zenocode/models/api.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": {},
+              "glm-5-2-non-thinking": {},
+              "glm-5-2-thinking": {},
+              "glm-5-1-non-thinking": {},
+              "glm-5-1-thinking": {},
             },
           },
         }),
@@ -736,6 +862,12 @@ main().catch((error) => {
     await fs.readFile(runtimeInvocation.env.OPENCODE_CONFIG, "utf-8"),
   );
   assert.equal(opencodeConfig.theme, "system");
+  assert.equal(opencodeConfig.model, "textcortex/minimax-m3-thinking");
+
+  const modelsConfig = JSON.parse(
+    await fs.readFile(path.join(zenocodeHome, "models.json"), "utf-8"),
+  );
+  assert.ok(modelsConfig.textcortex.models["glm-5-2-non-thinking"]);
 
   const tuiConfig = JSON.parse(
     await fs.readFile(runtimeInvocation.env.OPENCODE_TUI_CONFIG, "utf-8"),