@textcortex/zenocode 0.1.15 → 0.1.17

package/README.md

@@ -46,9 +46,9 @@ Zenocode releases its launcher and managed runtime together. Update both with:
 npm install -g @textcortex/zenocode@latest
 ```
 
-The terminal runtime does not install upstream OpenCode updates. Running `zenocode upgrade` prints the managed update command above.
+The terminal runtime never checks for, offers, or installs upstream OpenCode updates: the startup update check, the in-app "Update Available" prompt, and the runtime's `/global/upgrade` API are all removed at build time. Running `zenocode upgrade` prints the managed update command above.
 
-Runtime package versions include a Zenocode revision suffix (for example, `1.18.10-zenocode.1`). Increment that revision when the Zenocode source overlay changes without an upstream version bump, so an immutable npm runtime release can always be replaced deliberately.
+Runtime package versions include a Zenocode revision suffix (for example, `1.18.10-zenocode.3`). Increment that revision when the Zenocode source overlay changes without an upstream version bump, so an immutable npm runtime release can always be replaced deliberately.
 
 ## Models
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@textcortex/zenocode",
-  "version": "0.1.15",
+  "version": "0.1.17",
   "description": "Secure, TextCortex-managed coding agent for customers that runs in your terminal, edits files, runs scripts, and more.",
   "keywords": [
     "ai",

package/scripts/build-branded-opencode.mjs

@@ -7,10 +7,12 @@ import path from 'node:path';
 import process from 'node:process';
 import { fileURLToPath } from 'node:url';
 import {
+  openCodeBunVersion,
   openCodeRef,
   openCodeVersion,
   zenocodeRuntimeVersion,
 } from './opencode-version.mjs';
+import { smokeTestRuntimeBinary } from './runtime-smoke.mjs';
 import { applyZenocodeSourceBranding } from './source-branding.mjs';
 
 const currentFilePath = realpathSync(fileURLToPath(import.meta.url));
@@ -229,6 +231,29 @@ async function runAndCapture(command, args, options = {}) {
   });
 }
 
+/**
+ * Fail unless the runtime is compiled with the Bun release that both Zenocode
+ * and the upstream checkout pin. Another Bun release can compile a runtime that
+ * passes `--version` but crashes on the first prompt.
+ */
+export function assertPinnedBunToolchain({ installedVersion, packageManager }) {
+  const expected = `bun@${openCodeBunVersion}`;
+  if (packageManager !== expected) {
+    throw new Error(
+      `upstream OpenCode pins ${packageManager || 'no packageManager'}, but ` +
+        `opencode-version.mjs pins ${expected}. Update openCodeBunVersion ` +
+        'together with openCodeVersion.'
+    );
+  }
+  const installed = installedVersion.trim();
+  if (installed !== openCodeBunVersion) {
+    throw new Error(
+      `Bun ${installed} is installed, but the Zenocode runtime must be built ` +
+        `with Bun ${openCodeBunVersion}.`
+    );
+  }
+}
+
 async function requireCommand(command, args = ['--version']) {
   try {
     await run(command, args, { stdio: 'ignore' });
@@ -807,8 +832,21 @@ async function main() {
     cloneArgs.push(forkUrl, checkoutDir);
     await run(gitCommand, cloneArgs);
 
+    const upstreamPackage = JSON.parse(
+      await fs.readFile(path.join(checkoutDir, 'package.json'), 'utf-8')
+    );
+    const { stdout: installedBunVersion } = await runAndCapture(bunCommand, [
+      '--version',
+    ]);
+    assertPinnedBunToolchain({
+      installedVersion: installedBunVersion,
+      packageManager: upstreamPackage.packageManager,
+    });
+
     await applyZenocodeSourceBranding(checkoutDir);
-    await run(bunCommand, ['install'], { cwd: checkoutDir });
+    await run(bunCommand, ['install', '--frozen-lockfile'], {
+      cwd: checkoutDir,
+    });
     await run(
       bunCommand,
       ['./packages/opencode/script/build.ts', ...buildArgs],
@@ -872,6 +910,8 @@ async function main() {
     if (process.platform !== 'win32') {
       await fs.chmod(localBinaryPath, 0o755);
     }
+    await smokeTestRuntimeBinary(localBinaryPath);
+    console.log(`Runtime smoke test passed: ${localBinaryPath}`);
 
     console.log('\nZenocode branded build complete.');
     console.log(`Branded binary: ${localBinaryPath}`);

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

@@ -1,6 +1,7 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
 import {
+  assertPinnedBunToolchain,
   buildPublishCommandArgs,
   buildWrapperBinMap,
   binaryFilenameForPackage,
@@ -15,12 +16,13 @@ import {
   trustedPublishingRepository,
   zenocodeRuntimeVersion,
 } from './build-branded-opencode.mjs';
+import { openCodeBunVersion } from './opencode-version.mjs';
 
 test('branded OpenCode build defaults to the latest stable upstream release', () => {
   assert.equal(defaultOpenCodeForkUrl, 'https://github.com/sst/opencode');
   assert.equal(defaultOpenCodeRef, 'v1.18.10');
   assert.equal(defaultOpenCodeVersion, '1.18.10');
-  assert.equal(zenocodeRuntimeVersion, '1.18.10-zenocode.1');
+  assert.equal(zenocodeRuntimeVersion, '1.18.10-zenocode.3');
   assert.deepEqual(defaultOpenCodeBuildArgs, []);
 });
 
@@ -127,3 +129,36 @@ test('selectLatestTarball returns the sorted newest tarball', () => {
   );
   assert.equal(selectLatestTarball(['README.md']), null);
 });
+
+test('runtime builds use the Bun release that upstream pins', () => {
+  assert.equal(openCodeBunVersion, '1.3.14');
+  assert.doesNotThrow(() =>
+    assertPinnedBunToolchain({
+      installedVersion: '1.3.14\n',
+      packageManager: 'bun@1.3.14',
+    })
+  );
+});
+
+test('runtime builds refuse a Bun release other than the pinned one', () => {
+  // Bun 1.4.2 compiled a runtime that crashed on every prompt (0.1.15, 0.1.16).
+  assert.throws(
+    () =>
+      assertPinnedBunToolchain({
+        installedVersion: '1.4.2',
+        packageManager: 'bun@1.3.14',
+      }),
+    /Bun 1\.4\.2 is installed, but the Zenocode runtime must be built with Bun 1\.3\.14/
+  );
+});
+
+test('runtime builds refuse an upstream checkout that pins a different Bun', () => {
+  assert.throws(
+    () =>
+      assertPinnedBunToolchain({
+        installedVersion: '1.3.14',
+        packageManager: 'bun@1.3.20',
+      }),
+    /upstream OpenCode pins bun@1\.3\.20[\s\S]*openCodeBunVersion/
+  );
+});

package/scripts/opencode-version.mjs

@@ -1,6 +1,13 @@
 export const openCodeVersion = '1.18.10';
 export const openCodeRef = `v${openCodeVersion}`;
+/**
+ * Bun release that compiles the runtime. It must equal the `packageManager`
+ * pin of the upstream OpenCode release above, and the build fails otherwise:
+ * a newer Bun compiled a runtime that crashed on every prompt while
+ * `--version` still worked. Change it together with `openCodeVersion`.
+ */
+export const openCodeBunVersion = '1.3.14';
 export const zenocodeRuntimePackageName = '@textcortex/zenocode-ai';
-export const zenocodeRuntimeRevision = 1;
+export const zenocodeRuntimeRevision = 3;
 export const zenocodeRuntimeVersion = `${openCodeVersion}-zenocode.${zenocodeRuntimeRevision}`;
 export const zenocodeRuntimePackageSpec = `${zenocodeRuntimePackageName}@${zenocodeRuntimeVersion}`;

package/scripts/run-zenocode.test.mjs

@@ -30,7 +30,7 @@ import {
 test('Zenocode launches the pinned TextCortex-owned runtime by default', () => {
   assert.equal(
     resolveLaunchPackage(),
-    '@textcortex/zenocode-ai@1.18.10-zenocode.1'
+    '@textcortex/zenocode-ai@1.18.10-zenocode.3'
   );
 });
 
@@ -316,13 +316,13 @@ test('buildPackageLauncherInvocation launches the owned runtime package unchange
   const invocation = buildPackageLauncherInvocation({
     runner: {
       command: 'pnpm',
-      args: ['dlx', '@textcortex/zenocode-ai@1.18.10-zenocode.1', '--version'],
+      args: ['dlx', '@textcortex/zenocode-ai@1.18.10-zenocode.3', '--version'],
     },
   });
 
   assert.deepEqual(invocation, {
     command: 'pnpm',
-    args: ['dlx', '@textcortex/zenocode-ai@1.18.10-zenocode.1', '--version'],
+    args: ['dlx', '@textcortex/zenocode-ai@1.18.10-zenocode.3', '--version'],
   });
 });
 

package/scripts/runtime-smoke.mjs

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import { realpathSync } from 'node:fs';
+import fs from 'node:fs/promises';
+import http from 'node:http';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+import {
+  buildOpenCodeConfig,
+  buildOpenCodeTuiConfig,
+} from './run-zenocode.mjs';
+
+const currentFilePath = realpathSync(fileURLToPath(import.meta.url));
+const providerID = 'textcortex';
+const smokeModel = 'zenocode-smoke';
+const providerPathPrefix = '/internal/v2/fastapi/zenocode/v1';
+
+/** Text the mock provider streams back; a working runtime prints it. */
+export const smokeReply = 'zenocode-runtime-smoke-ok';
+
+function chatCompletionChunk(delta, finishReason = null) {
+  return {
+    id: 'chatcmpl-zenocode-smoke',
+    object: 'chat.completion.chunk',
+    created: 0,
+    model: smokeModel,
+    choices: [{ index: 0, delta, finish_reason: finishReason }],
+  };
+}
+
+/**
+ * Serve the Zenocode backend's OpenAI-compatible chat endpoint on loopback,
+ * streaming {@link smokeReply} for every completion request.
+ */
+async function startMockProvider() {
+  const state = { providerRequests: 0, unexpectedRequests: [] };
+  const server = http.createServer((request, response) => {
+    request.resume();
+    request.on('end', () => {
+      if (
+        request.method !== 'POST' ||
+        request.url !== `${providerPathPrefix}/chat/completions`
+      ) {
+        state.unexpectedRequests.push(`${request.method} ${request.url}`);
+        response.writeHead(404).end();
+        return;
+      }
+      state.providerRequests += 1;
+      response.writeHead(200, {
+        'content-type': 'text/event-stream',
+        'cache-control': 'no-cache',
+      });
+      const events = [
+        chatCompletionChunk({ role: 'assistant', content: smokeReply }),
+        {
+          ...chatCompletionChunk({}, 'stop'),
+          usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
+        },
+      ];
+      for (const event of events) {
+        response.write(`data: ${JSON.stringify(event)}\n\n`);
+      }
+      response.end('data: [DONE]\n\n');
+    });
+  });
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+  const { port } = server.address();
+  return {
+    baseUrl: `http://127.0.0.1:${port}`,
+    state,
+    close: () => new Promise((resolve) => server.close(resolve)),
+  };
+}
+
+/** Write the model catalog and configs the launcher would generate. */
+async function writeRuntimeFiles(dir, baseUrl) {
+  const modelsPath = path.join(dir, 'models.json');
+  const configPath = path.join(dir, 'zenocode.jsonc');
+  const tuiConfigPath = path.join(dir, 'tui.json');
+  const catalog = {
+    [providerID]: {
+      id: providerID,
+      name: 'TextCortex',
+      api: new URL(providerPathPrefix, baseUrl).toString(),
+      env: ['TEXTCORTEX_API_KEY'],
+      models: {
+        [smokeModel]: {
+          id: smokeModel,
+          name: 'Zenocode smoke model',
+          attachment: false,
+          reasoning: false,
+          temperature: true,
+          tool_call: true,
+          limit: { context: 100000, output: 4096 },
+          modalities: { input: ['text'], output: ['text'] },
+          options: {},
+        },
+      },
+    },
+  };
+  const config = buildOpenCodeConfig({
+    baseUrl,
+    providerID,
+    model: smokeModel,
+    smallModel: smokeModel,
+  });
+  await fs.writeFile(modelsPath, JSON.stringify(catalog), 'utf-8');
+  await fs.writeFile(configPath, JSON.stringify(config), 'utf-8');
+  await fs.writeFile(
+    tuiConfigPath,
+    JSON.stringify(buildOpenCodeTuiConfig()),
+    'utf-8'
+  );
+  return { modelsPath, configPath, tuiConfigPath };
+}
+
+/**
+ * Prove a compiled runtime can answer a prompt, not just print `--version`.
+ *
+ * Runs `<binary> run <prompt>` against a loopback mock of the Zenocode
+ * provider, in a throwaway HOME so no machine state leaks in. Resolves with the
+ * runtime output; rejects if the runtime crashes, hangs past `timeoutMs`, or
+ * exits without printing the streamed provider reply.
+ */
+export async function smokeTestRuntimeBinary(
+  binaryPath,
+  { timeoutMs = 120_000 } = {}
+) {
+  const provider = await startMockProvider();
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'zenocode-smoke-'));
+  try {
+    const home = path.join(root, 'home');
+    const workdir = path.join(root, 'work');
+    await fs.mkdir(home, { recursive: true });
+    await fs.mkdir(workdir, { recursive: true });
+    const files = await writeRuntimeFiles(root, provider.baseUrl);
+
+    const child = spawn(binaryPath, ['run', 'Reply with the smoke token.'], {
+      cwd: workdir,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: {
+        PATH: process.env.PATH,
+        SYSTEMROOT: process.env.SYSTEMROOT,
+        HOME: home,
+        USERPROFILE: home,
+        XDG_CONFIG_HOME: path.join(home, '.config'),
+        XDG_DATA_HOME: path.join(home, '.local', 'share'),
+        XDG_CACHE_HOME: path.join(home, '.cache'),
+        XDG_STATE_HOME: path.join(home, '.local', 'state'),
+        OPENCODE_MODELS_PATH: files.modelsPath,
+        OPENCODE_CONFIG: files.configPath,
+        OPENCODE_TUI_CONFIG: files.tuiConfigPath,
+        OPENCODE_DISABLE_AUTOUPDATE: 'true',
+        TEXTCORTEX_API_KEY: 'zenocode-smoke',
+      },
+    });
+    let output = '';
+    child.stdout.on('data', (chunk) => (output += chunk.toString('utf-8')));
+    child.stderr.on('data', (chunk) => (output += chunk.toString('utf-8')));
+
+    const outcome = await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        child.kill('SIGKILL');
+        resolve({ timedOut: true });
+      }, timeoutMs);
+      child.on('error', (error) => {
+        clearTimeout(timer);
+        reject(error);
+      });
+      child.on('exit', (code) => {
+        clearTimeout(timer);
+        resolve({ code });
+      });
+    });
+
+    const details = [
+      `provider requests: ${provider.state.providerRequests}`,
+      provider.state.unexpectedRequests.length
+        ? `unexpected requests: ${provider.state.unexpectedRequests.join(', ')}`
+        : null,
+      `runtime output:\n${output.slice(-4000)}`,
+    ]
+      .filter(Boolean)
+      .join('\n');
+    if (outcome.timedOut) {
+      throw new Error(
+        `Runtime smoke test did not finish within ${timeoutMs} ms.\n${details}`
+      );
+    }
+    if (outcome.code !== 0) {
+      throw new Error(
+        `Runtime smoke test exited with code ${outcome.code}.\n${details}`
+      );
+    }
+    if (!output.includes(smokeReply)) {
+      throw new Error(
+        `Runtime smoke test did not print the provider reply.\n${details}`
+      );
+    }
+    return { output, providerRequests: provider.state.providerRequests };
+  } finally {
+    await provider.close();
+    await fs.rm(root, { recursive: true, force: true });
+  }
+}
+
+if (process.argv[1] && realpathSync(process.argv[1]) === currentFilePath) {
+  const binaryPath = process.argv[2];
+  if (!binaryPath) {
+    console.error('Usage: node runtime-smoke.mjs <runtime-binary>');
+    process.exit(2);
+  }
+  smokeTestRuntimeBinary(path.resolve(binaryPath)).then(
+    () => console.log(`Runtime smoke test passed: ${binaryPath}`),
+    (error) => {
+      console.error(error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  );
+}

package/scripts/runtime-smoke.test.mjs

@@ -0,0 +1,81 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import { smokeReply, smokeTestRuntimeBinary } from './runtime-smoke.mjs';
+
+/** Write an executable Node script that stands in for the runtime binary. */
+async function writeFakeRuntime(body) {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'zenocode-smoke-test-'));
+  const filePath = path.join(dir, 'fake-runtime.mjs');
+  await fs.writeFile(filePath, `#!/usr/bin/env node\n${body}\n`, 'utf-8');
+  await fs.chmod(filePath, 0o755);
+  return filePath;
+}
+
+// Behaves like a working runtime: reads the generated config and model catalog,
+// streams one chat completion from the configured provider, and prints it.
+const workingRuntime = `
+import fs from 'node:fs';
+const config = JSON.parse(fs.readFileSync(process.env.OPENCODE_CONFIG, 'utf-8'));
+const catalog = JSON.parse(fs.readFileSync(process.env.OPENCODE_MODELS_PATH, 'utf-8'));
+const [providerID, model] = config.model.split('/');
+if (!catalog[providerID]?.models?.[model]) process.exit(3);
+const response = await fetch(config.provider[providerID].options.baseURL + '/chat/completions', {
+  method: 'POST',
+  headers: {
+    authorization: 'Bearer ' + process.env.TEXTCORTEX_API_KEY,
+    'content-type': 'application/json',
+  },
+  body: JSON.stringify({ model, stream: true, messages: [{ role: 'user', content: process.argv.at(-1) }] }),
+});
+let text = '';
+for (const line of (await response.text()).split('\\n')) {
+  if (!line.startsWith('data: ') || line === 'data: [DONE]') continue;
+  text += JSON.parse(line.slice(6)).choices[0]?.delta?.content ?? '';
+}
+console.log(text);
+`;
+
+test('runtime smoke passes when the runtime streams a provider reply', async () => {
+  const binary = await writeFakeRuntime(workingRuntime);
+
+  const result = await smokeTestRuntimeBinary(binary);
+
+  assert.match(result.output, new RegExp(smokeReply));
+  assert.ok(result.providerRequests >= 1);
+});
+
+test('runtime smoke fails when the runtime crashes before the provider call', async () => {
+  // The Bun 1.4.2 build failed exactly like this: `--version` worked, but the
+  // first prompt died while building the system prompt.
+  const binary = await writeFakeRuntime(`
+console.error('Error: { "name": "UnknownError", "message": "Unexpected server error." }');
+process.exit(1);
+`);
+
+  await assert.rejects(
+    smokeTestRuntimeBinary(binary),
+    /exited with code 1[\s\S]*Unexpected server error/
+  );
+});
+
+test('runtime smoke fails when the runtime exits cleanly without a reply', async () => {
+  const binary = await writeFakeRuntime(`console.log('nothing to see');`);
+
+  await assert.rejects(
+    smokeTestRuntimeBinary(binary),
+    /did not print the provider reply/
+  );
+});
+
+test('runtime smoke fails when the runtime hangs', async () => {
+  const binary = await writeFakeRuntime(`setInterval(() => {}, 1000);`);
+
+  await assert.rejects(
+    smokeTestRuntimeBinary(binary, { timeoutMs: 1500 }),
+    /did not finish within 1500 ms/
+  );
+});

package/scripts/source-branding.mjs

@@ -112,6 +112,109 @@ const zenocodeUpgradeSource = `/**
 export async function upgrade() {}
 `;
 
+/** Pinned upstream TUI handler that offers an in-app runtime upgrade. */
+export const openCodeUpdatePromptSource = `  event.on("installation.update-available", async (evt) => {
+    console.log("installation.update-available", evt)
+    const version = evt.properties.version
+
+    const skipped = kv.get("skipped_version")
+    if (skipped && !isVersionGreater(version, skipped)) return
+
+    const choice = await DialogConfirm.show(
+      dialog,
+      \`Update Available\`,
+      \`A new release v\${version} is available. Would you like to update now?\`,
+      "skip",
+    )
+
+    if (choice === false) {
+      kv.set("skipped_version", version)
+      return
+    }
+
+    if (choice !== true) return
+
+    toast.show({
+      variant: "info",
+      message: \`Updating to v\${version}...\`,
+      duration: 30000,
+    })
+
+    const result = await sdk.client.global.upgrade({ target: version })
+
+    if (result.error || !result.data?.success) {
+      toast.show({
+        variant: "error",
+        title: "Update Failed",
+        message: "Update failed",
+        duration: 10000,
+      })
+      return
+    }
+
+    await DialogAlert.show(
+      dialog,
+      "Update Complete",
+      \`Successfully updated to OpenCode v\${result.data.version}. Please restart the application.\`,
+    )
+
+    void exit()
+  })
+`;
+
+// Zenocode pins its runtime package, so an in-app upgrade can never take effect
+// and the "restart to finish updating" prompt would loop on every launch.
+const zenocodeUpdatePromptSource = `  // Zenocode owns runtime updates; see apps/zenocode/scripts/source-branding.mjs.
+  event.on("installation.update-available", () => {})
+`;
+
+/** Pinned upstream server handler behind POST /global/upgrade. */
+export const openCodeServerUpgradeSource = `    const upgrade = Effect.fn("GlobalHttpApi.upgrade")(function* (ctx: { payload: typeof GlobalUpgradeInput.Type }) {
+      const method = yield* installation.method()
+      if (method === "unknown") {
+        return {
+          status: 400,
+          body: { success: false as const, error: "Unknown installation method" },
+        }
+      }
+      const target = ctx.payload.target || (yield* installation.latest(method))
+      const result = yield* installation.upgrade(method, target).pipe(
+        Effect.as({ status: 200, body: { success: true as const, version: target } }),
+        Effect.catch((err) =>
+          Effect.succeed({
+            status: 500,
+            body: {
+              success: false as const,
+              error: err instanceof Error ? err.message : String(err),
+            },
+          }),
+        ),
+      )
+      if (!result.body.success) return result
+      GlobalBus.emit("event", {
+        directory: "global",
+        payload: {
+          type: Installation.Event.Updated.type,
+          properties: { version: target },
+        },
+      })
+      return result
+    })
+`;
+
+const zenocodeServerUpgradeSource = `    const upgrade = Effect.fn("GlobalHttpApi.upgrade")(function* (_ctx: {
+      payload: typeof GlobalUpgradeInput.Type
+    }) {
+      return {
+        status: 400,
+        body: {
+          success: false as const,
+          error: "Zenocode manages runtime updates. Reinstall Zenocode to update.",
+        },
+      }
+    })
+`;
+
 function decodeLogoLine(line) {
   return line.replace(/\\u([0-9a-fA-F]{4})/g, (_, codePoint) =>
     String.fromCharCode(Number.parseInt(codePoint, 16))
@@ -205,8 +308,18 @@ const sourceBrandingRules = new Map([
         count: 1,
       },
       {
-        from: 'Successfully updated to OpenCode',
-        to: 'Successfully updated to Zenocode',
+        from: openCodeUpdatePromptSource,
+        to: zenocodeUpdatePromptSource,
+        count: 1,
+      },
+    ],
+  ],
+  [
+    'packages/opencode/src/server/routes/instance/httpapi/handlers/global.ts',
+    [
+      {
+        from: openCodeServerUpgradeSource,
+        to: zenocodeServerUpgradeSource,
         count: 1,
       },
     ],

package/scripts/source-branding.test.mjs

@@ -3,6 +3,8 @@ import test from 'node:test';
 
 import {
   brandOpenCodeSourceFile,
+  openCodeServerUpgradeSource,
+  openCodeUpdatePromptSource,
   sourceBrandingFiles,
 } from './source-branding.mjs';
 
@@ -26,17 +28,45 @@ renderer.setTerminalTitle("OpenCode")
 renderer.setTerminalTitle("OpenCode")
 renderer.setTerminalTitle(\`OC | \${title}\`)
 renderer.setTerminalTitle(\`OC | \${route.data.id}\`)
-\`Successfully updated to OpenCode v\${result.data.version}. Please restart the application.\`
-`;
+${openCodeUpdatePromptSource}`;
 
   const branded = brandOpenCodeSourceFile('packages/tui/src/app.tsx', source);
 
   assert.match(branded, /setTerminalTitle\("Zenocode"\)/);
   assert.match(branded, /setTerminalTitle\(`ZC \| \$\{title\}`\)/);
-  assert.match(branded, /Successfully updated to Zenocode/);
   assert.doesNotMatch(branded, /OpenCode/);
 });
 
+test('source branding removes the in-app update prompt', () => {
+  const branded = brandOpenCodeSourceFile(
+    'packages/tui/src/app.tsx',
+    `renderer.setTerminalTitle("OpenCode")
+renderer.setTerminalTitle("OpenCode")
+renderer.setTerminalTitle(\`OC | \${title}\`)
+renderer.setTerminalTitle(\`OC | \${route.data.id}\`)
+${openCodeUpdatePromptSource}`
+  );
+
+  assert.match(
+    branded,
+    /event\.on\("installation\.update-available", \(\) => \{\}\)/
+  );
+  assert.doesNotMatch(branded, /Update Available/);
+  assert.doesNotMatch(branded, /global\.upgrade/);
+});
+
+test('source branding refuses runtime upgrades through the server API', () => {
+  const branded = brandOpenCodeSourceFile(
+    'packages/opencode/src/server/routes/instance/httpapi/handlers/global.ts',
+    openCodeServerUpgradeSource
+  );
+
+  assert.match(branded, /Zenocode manages runtime updates/);
+  assert.match(branded, /status: 400/);
+  assert.doesNotMatch(branded, /installation\.upgrade\(/);
+  assert.doesNotMatch(branded, /installation\.latest\(/);
+});
+
 test('source branding replaces the terminal network identity', () => {
   const source = `
 describe: "custom domain name for mDNS service (default: opencode.local)",