kimaki 0.10.1 → 0.10.2

package/dist/cli-runner.js

@@ -938,35 +938,16 @@ export async function run({ restartOnboarding, addChannels, useWorktrees, enable
     startCaffeinate();
     const forceRestartOnboarding = Boolean(restartOnboarding);
     const forceGateway = Boolean(gateway);
-    // Step 0: Ensure required CLI tools are installed (OpenCode + Bun).
-    // Run checks in parallel since they're independent `which` calls.
-    await Promise.all([
-        ensureCommandAvailable({
-            name: 'opencode',
-            envPathKey: 'OPENCODE_PATH',
-            installUnix: 'curl -fsSL https://opencode.ai/install | bash',
-            installWindows: 'irm https://opencode.ai/install.ps1 | iex',
-            possiblePathsUnix: [
-                '~/.local/bin/opencode',
-                '~/.opencode/bin/opencode',
-                '/usr/local/bin/opencode',
-                '/opt/opencode/bin/opencode',
-            ],
-            possiblePathsWindows: [
-                '~\\.local\\bin\\opencode.exe',
-                '~\\AppData\\Local\\opencode\\opencode.exe',
-                '~\\.opencode\\bin\\opencode.exe',
-            ],
-        }),
-        ensureCommandAvailable({
-            name: 'bun',
-            envPathKey: 'BUN_PATH',
-            installUnix: 'curl -fsSL https://bun.sh/install | bash',
-            installWindows: 'irm bun.sh/install.ps1 | iex',
-            possiblePathsUnix: ['~/.bun/bin/bun', '/usr/local/bin/bun'],
-            possiblePathsWindows: ['~\\.bun\\bin\\bun.exe'],
-        }),
-    ]);
+    // Step 0: Ensure bun is installed. OpenCode is downloaded on first run
+    // to ~/.kimaki/bin/ (pinned version), so no install check is needed.
+    await ensureCommandAvailable({
+        name: 'bun',
+        envPathKey: 'BUN_PATH',
+        installUnix: 'curl -fsSL https://bun.sh/install | bash',
+        installWindows: 'irm bun.sh/install.ps1 | iex',
+        possiblePathsUnix: ['~/.bun/bin/bun', '/usr/local/bin/bun'],
+        possiblePathsWindows: ['~\\.bun\\bin\\bun.exe'],
+    });
     void backgroundUpgradeKimaki();
     // Start in-process Hrana server before database init. Required for the bot
     // process because it serves as both the DB server and the single-instance

package/dist/kimaki-opencode-plugin-loading.e2e.test.js

@@ -47,7 +47,7 @@ test('opencode server loads plugin without errors', async () => {
         fs.mkdirSync(directory, { recursive: true });
     });
     const { command, args, windowsVerbatimArguments, } = getSpawnCommandAndArgs({
-        resolvedCommand: resolveOpencodeCommand(),
+        resolvedCommand: await resolveOpencodeCommand(),
         baseArgs: ['serve', '--port', port.toString(), '--print-logs', '--log-level', 'DEBUG'],
     });
     const serverProcess = spawn(command, args, {

package/dist/opencode.js

@@ -255,8 +255,164 @@ function ensureProcessCleanupHandlersRegistered() {
 // cleanup sends SIGTERM it only kills the shell, leaving the actual opencode
 // process orphaned (reparented to PID 1). Resolving the path upfront lets
 // us spawn the binary directly and SIGTERM reaches the right process.
+//
+// Resolution order:
+// 1. OPENCODE_PATH env var (explicit user override)
+// 2. Downloaded binary in ~/.kimaki/bin/opencode-{VERSION}
+//
+// The binary is downloaded from GitHub releases on first run and cached.
+// Version is pinned in code so kimaki is not affected by bugged releases.
+// Always stored in the default data dir (~/.kimaki) regardless of custom
+// data dir settings, so one binary serves all configurations.
+const OPENCODE_VERSION = '1.14.41';
+// Always use ~/.kimaki/bin for the opencode binary, regardless of custom data dir.
+function getOpencodeBinDir() {
+    const defaultDataDir = path.join(os.homedir(), '.kimaki');
+    return path.join(defaultDataDir, 'bin');
+}
+function getOpencodeBinaryPath() {
+    const binaryName = process.platform === 'win32' ? `opencode-${OPENCODE_VERSION}.exe` : `opencode-${OPENCODE_VERSION}`;
+    return path.join(getOpencodeBinDir(), binaryName);
+}
+// Returns candidate target names ordered by preference, matching the logic in
+// the official opencode install script (musl detection, AVX2/baseline fallback).
+function getOpencodeDownloadCandidates() {
+    const platformMap = { darwin: 'darwin', linux: 'linux', win32: 'windows' };
+    const archMap = { x64: 'x64', arm64: 'arm64', arm: 'arm' };
+    const platform = platformMap[process.platform] || process.platform;
+    const arch = archMap[process.arch] || process.arch;
+    const base = `${platform}-${arch}`;
+    if (platform !== 'linux') {
+        // macOS/Windows: no musl, just check baseline for x64
+        if (arch === 'x64')
+            return [`${base}-baseline`, base];
+        return [base];
+    }
+    // Linux: detect musl libc
+    const isMusl = (() => {
+        try {
+            if (fs.existsSync('/etc/alpine-release'))
+                return true;
+        }
+        catch { /* ignore */ }
+        try {
+            const out = execFileSync('ldd', ['--version'], { encoding: 'utf8', timeout: 3000, stdio: ['pipe', 'pipe', 'pipe'] });
+            if (out.toLowerCase().includes('musl'))
+                return true;
+        }
+        catch (e) {
+            // ldd --version writes to stderr on musl systems and exits non-zero
+            if (e && typeof e === 'object' && 'stderr' in e) {
+                const stderr = String(e.stderr);
+                if (stderr.toLowerCase().includes('musl'))
+                    return true;
+            }
+        }
+        return false;
+    })();
+    if (arch === 'x64') {
+        // x64 Linux: prefer baseline (safe on all x64 CPUs) then full, with musl variants
+        if (isMusl)
+            return [`${base}-baseline-musl`, `${base}-musl`, `${base}-baseline`, base];
+        return [`${base}-baseline`, base, `${base}-baseline-musl`, `${base}-musl`];
+    }
+    // arm64 Linux
+    if (isMusl)
+        return [`${base}-musl`, base];
+    return [base, `${base}-musl`];
+}
+async function downloadOpencodeIfMissing() {
+    const binaryPath = getOpencodeBinaryPath();
+    if (fs.existsSync(binaryPath)) {
+        return binaryPath;
+    }
+    const binDir = getOpencodeBinDir();
+    fs.mkdirSync(binDir, { recursive: true });
+    const candidates = getOpencodeDownloadCandidates();
+    const ext = process.platform === 'linux' ? '.tar.gz' : '.zip';
+    const extractedName = process.platform === 'win32' ? 'opencode.exe' : 'opencode';
+    // Use a unique temp dir to avoid races between concurrent first-run processes
+    const tmpDir = fs.mkdtempSync(path.join(binDir, '.opencode-dl-'));
+    const tmpArchive = path.join(tmpDir, `archive${ext}`);
+    const { spinner } = await import('@clack/prompts');
+    const s = spinner();
+    s.start(`Downloading opencode v${OPENCODE_VERSION}...\n`);
+    try {
+        // Try each candidate URL until one succeeds (handles musl/baseline variants)
+        let downloaded = false;
+        for (const candidate of candidates) {
+            const url = `https://github.com/anomalyco/opencode/releases/download/v${OPENCODE_VERSION}/opencode-${candidate}${ext}`;
+            const response = await fetch(url, { redirect: 'follow', signal: AbortSignal.timeout(120_000) });
+            if (response.status === 404)
+                continue;
+            if (!response.ok) {
+                throw new Error(`Failed to download opencode: HTTP ${response.status} from ${url}`);
+            }
+            fs.writeFileSync(tmpArchive, Buffer.from(await response.arrayBuffer()));
+            downloaded = true;
+            break;
+        }
+        if (!downloaded) {
+            throw new Error(`No opencode binary found for platform ${process.platform}/${process.arch} (tried: ${candidates.join(', ')})`);
+        }
+        // Extract into the temp dir
+        const { execFileSync } = await import('node:child_process');
+        if (process.platform === 'linux') {
+            execFileSync('tar', ['xzf', tmpArchive, '-C', tmpDir], { timeout: 30_000 });
+        }
+        else if (process.platform === 'win32') {
+            execFileSync('powershell.exe', [
+                '-NoProfile', '-Command',
+                `Expand-Archive -LiteralPath '${tmpArchive.replaceAll("'", "''")}' -DestinationPath '${tmpDir.replaceAll("'", "''")}' -Force`,
+            ], { timeout: 30_000 });
+        }
+        else {
+            execFileSync('unzip', ['-o', tmpArchive, '-d', tmpDir], { timeout: 30_000 });
+        }
+        // Move extracted binary to versioned path
+        const extractedPath = path.join(tmpDir, extractedName);
+        if (!fs.existsSync(extractedPath)) {
+            throw new Error(`Expected binary not found after extraction: ${extractedPath}`);
+        }
+        fs.chmodSync(extractedPath, 0o755);
+        try {
+            fs.renameSync(extractedPath, binaryPath);
+        }
+        catch {
+            // Another concurrent process may have won the race; that's fine
+            if (fs.existsSync(binaryPath))
+                return binaryPath;
+            throw new Error(`Failed to move opencode binary to ${binaryPath}`);
+        }
+        // Delete old versions (match opencode-X.Y.Z or opencode-X.Y.Z.exe exactly)
+        const currentName = path.basename(binaryPath);
+        for (const entry of fs.readdirSync(binDir)) {
+            if (entry === currentName)
+                continue;
+            if (/^opencode-\d+\.\d+\.\d+(?:\.exe)?$/.test(entry)) {
+                try {
+                    fs.unlinkSync(path.join(binDir, entry));
+                }
+                catch { /* ignore */ }
+            }
+        }
+        s.stop(`Downloaded opencode v${OPENCODE_VERSION}`);
+        return binaryPath;
+    }
+    catch (error) {
+        s.stop('Failed to download opencode');
+        throw error;
+    }
+    finally {
+        // Clean up temp dir
+        try {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+        catch { /* ignore */ }
+    }
+}
 let resolvedOpencodeCommand = null;
-export function resolveOpencodeCommand() {
+export async function resolveOpencodeCommand() {
     if (resolvedOpencodeCommand) {
         return resolvedOpencodeCommand;
     }
@@ -268,37 +424,13 @@ export function resolveOpencodeCommand() {
         });
         if (resolvedFromEnv) {
             resolvedOpencodeCommand = resolvedFromEnv;
+            opencodeLogger.log(`Resolved opencode binary from OPENCODE_PATH: ${resolvedFromEnv}`);
             return resolvedFromEnv;
         }
     }
-    const isWindows = process.platform === 'win32';
-    const whichCmd = isWindows ? 'where' : 'which';
-    const result = errore.try({
-        try: () => {
-            const commandOutput = execFileSync(whichCmd, ['opencode'], {
-                encoding: 'utf8',
-                timeout: 5000,
-            });
-            const resolved = selectResolvedCommand({
-                output: commandOutput,
-                isWindows,
-            });
-            if (resolved) {
-                return resolved;
-            }
-            throw new Error('opencode not found in PATH');
-        },
-        catch: () => new Error('opencode not found in PATH'),
-    });
-    if (result instanceof Error) {
-        // Fall back to bare command name — spawn will fail with a clear error
-        // if it can't find the binary.
-        opencodeLogger.warn('Could not resolve opencode path via which, falling back to "opencode"');
-        return 'opencode';
-    }
-    resolvedOpencodeCommand = result;
-    opencodeLogger.log(`Resolved opencode binary: ${result}`);
-    return result;
+    const downloaded = await downloadOpencodeIfMissing();
+    resolvedOpencodeCommand = downloaded;
+    return downloaded;
 }
 async function getOpenPort() {
     return new Promise((resolve, reject) => {
@@ -394,7 +526,7 @@ async function startSingleServer({ directory, } = {}) {
         'WARN',
     ];
     const { command: spawnCommand, args: spawnArgs, windowsVerbatimArguments, } = getSpawnCommandAndArgs({
-        resolvedCommand: resolveOpencodeCommand(),
+        resolvedCommand: await resolveOpencodeCommand(),
         baseArgs: serveArgs,
     });
     // Server config uses permissive defaults. Per-directory external_directory

package/dist/session-handler/thread-session-runtime.js

@@ -962,15 +962,15 @@ export class ThreadSessionRuntime {
                 backoffMs = Math.min(backoffMs * 2, maxBackoffMs);
                 continue;
             }
-            // Reset backoff on successful connection
-            backoffMs = 500;
             const events = subscribeResult.stream;
             logger.log(`[LISTENER] Connected to event stream for thread ${this.threadId}`);
             // Re-bootstrap sentPartIds on reconnect to prevent re-sending
             // parts that arrived while we were disconnected.
             await this.bootstrapSentPartIds();
+            let receivedAnyEvent = false;
             const iterResult = await errore.tryAsync(async () => {
                 for await (const event of events) {
+                    receivedAnyEvent = true;
                     // Each event is dispatched through the serialized action queue
                     // to prevent interleaving mutations from concurrent events.
                     await this.dispatchAction(() => {
@@ -978,6 +978,13 @@ export class ThreadSessionRuntime {
                     });
                 }
             });
+            // Only reset backoff when the stream was alive long enough to
+            // deliver at least one event. If it closes immediately the server
+            // is likely not ready; keep escalating backoff to avoid a tight
+            // reconnect loop (GitHub issue #126).
+            if (receivedAnyEvent) {
+                backoffMs = 500;
+            }
             if (iterResult instanceof Error) {
                 if (isAbortError(iterResult)) {
                     return; // disposed
@@ -987,6 +994,16 @@ export class ThreadSessionRuntime {
                 await delay(backoffMs);
                 backoffMs = Math.min(backoffMs * 2, maxBackoffMs);
             }
+            else {
+                // Stream completed normally (server closed the connection).
+                // This can happen when the opencode server restarts, the SSE
+                // endpoint times out, or there are no active sessions for this
+                // directory. Without a delay here the loop reconnects immediately,
+                // creating a tight infinite reconnect loop (GitHub issue #126).
+                logger.log(`[LISTENER] Stream ended normally for thread ${this.threadId}, reconnecting in ${backoffMs}ms`);
+                await delay(backoffMs);
+                backoffMs = Math.min(backoffMs * 2, maxBackoffMs);
+            }
         }
     }
     // ── Session Demux Guard ─────────────────────────────────────

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.10.1",
+  "version": "0.10.2",
   "repository": "https://github.com/remorses/kimaki",
   "bin": "bin.js",
   "files": [
@@ -25,8 +25,8 @@
     "tsx": "^4.20.5",
     "undici": "^8.0.2",
     "discord-digital-twin": "^0.1.0",
-    "db": "^0.0.0",
     "opencode-cached-provider": "^0.0.1",
+    "db": "^0.0.0",
     "opencode-deterministic-provider": "^0.0.1"
   },
   "dependencies": {
@@ -52,7 +52,6 @@
     "libsql": "^0.5.22",
     "marked": "^17.0.5",
     "mime": "^4.1.0",
-    "opencode-ai": "1.14.41",
     "opusscript": "^0.0.8",
     "picocolors": "^1.1.1",
     "pretty-ms": "^9.3.0",
@@ -64,9 +63,9 @@
     "zod": "^4.3.6",
     "zustand": "^5.0.11",
     "errore": "^0.14.1",
-    "opencode-injection-guard": "^0.2.1",
+    "traforo": "^0.5.0",
     "libsqlproxy": "^0.1.0",
-    "traforo": "^0.5.0"
+    "opencode-injection-guard": "^0.2.1"
   },
   "optionalDependencies": {
     "@snazzah/davey": "^0.1.10",

package/skills/goke/SKILL.md

@@ -337,3 +337,156 @@ cli
     }
   })
 ```
+
+## Remote Server Auth & Config
+
+CLIs that talk to a remote server must support multiple server URLs so users can self-host, use a preview/staging environment, or point to localhost during development. Auth tokens and other per-server state live in a JSON config file keyed by API URL.
+
+### Config file location
+
+Store config at `~/.cliname/config.json`. The directory is named after the CLI binary. Use `os.homedir()` to resolve `~`.
+
+### Config structure
+
+The config is an object keyed by server URL. Each entry holds auth tokens and any other per-server state. The CLI reads/writes only the entry matching the current `--api-url`.
+
+```ts
+// ~/.cliname/config.json
+{
+  "https://api.cliname.com": {
+    "accessToken": "tok_abc123",
+    "refreshToken": "rt_xyz789",
+    "expiresAt": "2026-08-01T00:00:00Z"
+  },
+  "https://staging.cliname.com": {
+    "accessToken": "tok_staging_456"
+  },
+  "http://localhost:3000": {
+    "accessToken": "tok_dev_789"
+  }
+}
+```
+
+### Global `--api-url` option
+
+Register `--api-url` as a global option with a default pointing to the production hosted service. The `.use()` middleware resolves the final URL from the flag, env var, or default, then **writes it back to `process.env`**. All other code just reads `process.env.CLINAME_API_URL` instead of threading `options.apiUrl` through every function call. This avoids type-safety issues since global options aren't visible in command action types.
+
+```ts
+import { goke } from 'goke'
+import { z } from 'zod'
+
+const DEFAULT_API_URL = 'https://api.cliname.com'
+
+const cli = goke('cliname')
+
+cli.option(
+  '--api-url [url]',
+  z.string().url().optional().describe('Server URL'),
+)
+
+cli.use((options) => {
+  const apiUrl = (
+    options.apiUrl
+    || process.env.CLINAME_API_URL
+    || DEFAULT_API_URL
+  ).replace(/\/+$/, '') // normalize: strip trailing slash so config keys are consistent
+
+  process.env.CLINAME_API_URL = apiUrl
+})
+```
+
+After this middleware runs, any module can call `getApiUrl()` without receiving it as a parameter:
+
+```ts
+export function getApiUrl(): string {
+  return process.env.CLINAME_API_URL!
+}
+```
+
+### Reading and writing config
+
+Config helpers take the injected `fs` from the action context as an object argument. This keeps them portable across normal Node.js runs and JustBash sandboxes.
+
+```ts
+import path from 'node:path'
+import os from 'node:os'
+import type { GokeFs } from 'goke'
+
+const CONFIG_DIR = path.join(os.homedir(), '.cliname')
+const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json')
+
+interface ServerConfig {
+  accessToken?: string
+  refreshToken?: string
+  expiresAt?: string
+}
+
+type Config = Record<string, ServerConfig>
+
+async function loadConfig({ fs }: { fs: GokeFs }): Promise<Config> {
+  try {
+    return JSON.parse(await fs.readFile(CONFIG_PATH, 'utf-8'))
+  } catch {
+    return {}
+  }
+}
+
+async function saveConfig({ fs, config }: { fs: GokeFs; config: Config }) {
+  await fs.mkdir(CONFIG_DIR, { recursive: true })
+  await fs.writeFile(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n')
+}
+
+async function getServerConfig({ fs }: { fs: GokeFs }): Promise<ServerConfig> {
+  const config = await loadConfig({ fs })
+  return config[getApiUrl()] ?? {}
+}
+
+async function setServerConfig({ fs, data }: { fs: GokeFs; data: ServerConfig }) {
+  const apiUrl = getApiUrl()
+  const config = await loadConfig({ fs })
+  config[apiUrl] = { ...config[apiUrl], ...data }
+  await saveConfig({ fs, config })
+}
+```
+
+### Using it in commands
+
+Commands pass the injected `{ fs }` to config helpers and read the API URL via `getApiUrl()`.
+
+```ts
+cli
+  .command('login', 'Authenticate with the server')
+  .action(async (_options, { fs, console }) => {
+    const apiUrl = getApiUrl()
+    const token = await doLogin(apiUrl)
+    await setServerConfig({ fs, data: { accessToken: token } })
+    console.log(`Logged in to ${apiUrl}`)
+  })
+
+cli
+  .command('status', 'Show current config')
+  .action(async (_options, { fs, console }) => {
+    const apiUrl = getApiUrl()
+    const server = await getServerConfig({ fs })
+    console.log(`Server: ${apiUrl}`)
+    console.log(`Authenticated: ${server.accessToken ? 'yes' : 'no'}`)
+  })
+
+cli
+  .command('logout', 'Clear auth for current server')
+  .action(async (_options, { fs, console }) => {
+    const apiUrl = getApiUrl()
+    const config = await loadConfig({ fs })
+    delete config[apiUrl]
+    await saveConfig({ fs, config })
+    console.log(`Logged out from ${apiUrl}`)
+  })
+```
+
+### Why key by URL
+
+- Users can be logged in to production and staging simultaneously
+- Self-hosters get isolated auth without conflicting with the hosted service
+- Developers can point to `http://localhost:3000` during development without losing their production token
+- Switching servers is just `--api-url` or setting an env var; no re-login needed if the server was used before
+```

package/skills/tuistory/SKILL.md

@@ -58,6 +58,9 @@ tuistory read -s dev
 
 # later, read only the new output
 tuistory read -s dev
+
+# restart the server (sends Ctrl+C, waits, relaunches same command/cwd/env)
+tuistory -s dev restart
 ```
 
 Why this is better than `tmux`:

package/src/cli-runner.ts

@@ -1345,35 +1345,16 @@ export async function run({
   const forceRestartOnboarding = Boolean(restartOnboarding)
   const forceGateway = Boolean(gateway)
 
-  // Step 0: Ensure required CLI tools are installed (OpenCode + Bun).
-  // Run checks in parallel since they're independent `which` calls.
-  await Promise.all([
-    ensureCommandAvailable({
-      name: 'opencode',
-      envPathKey: 'OPENCODE_PATH',
-      installUnix: 'curl -fsSL https://opencode.ai/install | bash',
-      installWindows: 'irm https://opencode.ai/install.ps1 | iex',
-      possiblePathsUnix: [
-        '~/.local/bin/opencode',
-        '~/.opencode/bin/opencode',
-        '/usr/local/bin/opencode',
-        '/opt/opencode/bin/opencode',
-      ],
-      possiblePathsWindows: [
-        '~\\.local\\bin\\opencode.exe',
-        '~\\AppData\\Local\\opencode\\opencode.exe',
-        '~\\.opencode\\bin\\opencode.exe',
-      ],
-    }),
-    ensureCommandAvailable({
-      name: 'bun',
-      envPathKey: 'BUN_PATH',
-      installUnix: 'curl -fsSL https://bun.sh/install | bash',
-      installWindows: 'irm bun.sh/install.ps1 | iex',
-      possiblePathsUnix: ['~/.bun/bin/bun', '/usr/local/bin/bun'],
-      possiblePathsWindows: ['~\\.bun\\bin\\bun.exe'],
-    }),
-  ])
+  // Step 0: Ensure bun is installed. OpenCode is downloaded on first run
+  // to ~/.kimaki/bin/ (pinned version), so no install check is needed.
+  await ensureCommandAvailable({
+    name: 'bun',
+    envPathKey: 'BUN_PATH',
+    installUnix: 'curl -fsSL https://bun.sh/install | bash',
+    installWindows: 'irm bun.sh/install.ps1 | iex',
+    possiblePathsUnix: ['~/.bun/bin/bun', '/usr/local/bin/bun'],
+    possiblePathsWindows: ['~\\.bun\\bin\\bun.exe'],
+  })
 
 
   void backgroundUpgradeKimaki()

package/src/kimaki-opencode-plugin-loading.e2e.test.ts

@@ -65,7 +65,7 @@ test(
       args,
       windowsVerbatimArguments,
     } = getSpawnCommandAndArgs({
-      resolvedCommand: resolveOpencodeCommand(),
+      resolvedCommand: await resolveOpencodeCommand(),
       baseArgs: ['serve', '--port', port.toString(), '--print-logs', '--log-level', 'DEBUG'],
     })
 

package/src/opencode.ts

@@ -406,9 +406,160 @@ function ensureProcessCleanupHandlersRegistered(): void {
 // cleanup sends SIGTERM it only kills the shell, leaving the actual opencode
 // process orphaned (reparented to PID 1). Resolving the path upfront lets
 // us spawn the binary directly and SIGTERM reaches the right process.
+//
+// Resolution order:
+// 1. OPENCODE_PATH env var (explicit user override)
+// 2. Downloaded binary in ~/.kimaki/bin/opencode-{VERSION}
+//
+// The binary is downloaded from GitHub releases on first run and cached.
+// Version is pinned in code so kimaki is not affected by bugged releases.
+// Always stored in the default data dir (~/.kimaki) regardless of custom
+// data dir settings, so one binary serves all configurations.
+
+const OPENCODE_VERSION = '1.14.41'
+
+// Always use ~/.kimaki/bin for the opencode binary, regardless of custom data dir.
+function getOpencodeBinDir(): string {
+  const defaultDataDir = path.join(os.homedir(), '.kimaki')
+  return path.join(defaultDataDir, 'bin')
+}
+
+function getOpencodeBinaryPath(): string {
+  const binaryName = process.platform === 'win32' ? `opencode-${OPENCODE_VERSION}.exe` : `opencode-${OPENCODE_VERSION}`
+  return path.join(getOpencodeBinDir(), binaryName)
+}
+
+// Returns candidate target names ordered by preference, matching the logic in
+// the official opencode install script (musl detection, AVX2/baseline fallback).
+function getOpencodeDownloadCandidates(): string[] {
+  const platformMap: Record<string, string> = { darwin: 'darwin', linux: 'linux', win32: 'windows' }
+  const archMap: Record<string, string> = { x64: 'x64', arm64: 'arm64', arm: 'arm' }
+  const platform = platformMap[process.platform] || process.platform
+  const arch = archMap[process.arch] || process.arch
+  const base = `${platform}-${arch}`
+
+  if (platform !== 'linux') {
+    // macOS/Windows: no musl, just check baseline for x64
+    if (arch === 'x64') return [`${base}-baseline`, base]
+    return [base]
+  }
+
+  // Linux: detect musl libc
+  const isMusl = (() => {
+    try { if (fs.existsSync('/etc/alpine-release')) return true } catch { /* ignore */ }
+    try {
+      const out = execFileSync('ldd', ['--version'], { encoding: 'utf8', timeout: 3000, stdio: ['pipe', 'pipe', 'pipe'] })
+      if (out.toLowerCase().includes('musl')) return true
+    } catch (e: unknown) {
+      // ldd --version writes to stderr on musl systems and exits non-zero
+      if (e && typeof e === 'object' && 'stderr' in e) {
+        const stderr = String((e as { stderr: unknown }).stderr)
+        if (stderr.toLowerCase().includes('musl')) return true
+      }
+    }
+    return false
+  })()
+
+  if (arch === 'x64') {
+    // x64 Linux: prefer baseline (safe on all x64 CPUs) then full, with musl variants
+    if (isMusl) return [`${base}-baseline-musl`, `${base}-musl`, `${base}-baseline`, base]
+    return [`${base}-baseline`, base, `${base}-baseline-musl`, `${base}-musl`]
+  }
+  // arm64 Linux
+  if (isMusl) return [`${base}-musl`, base]
+  return [base, `${base}-musl`]
+}
+
+
+async function downloadOpencodeIfMissing(): Promise<string> {
+  const binaryPath = getOpencodeBinaryPath()
+  if (fs.existsSync(binaryPath)) {
+    return binaryPath
+  }
+
+  const binDir = getOpencodeBinDir()
+  fs.mkdirSync(binDir, { recursive: true })
+
+  const candidates = getOpencodeDownloadCandidates()
+  const ext = process.platform === 'linux' ? '.tar.gz' : '.zip'
+  const extractedName = process.platform === 'win32' ? 'opencode.exe' : 'opencode'
+
+  // Use a unique temp dir to avoid races between concurrent first-run processes
+  const tmpDir = fs.mkdtempSync(path.join(binDir, '.opencode-dl-'))
+  const tmpArchive = path.join(tmpDir, `archive${ext}`)
+
+  const { spinner } = await import('@clack/prompts')
+  const s = spinner()
+  s.start(`Downloading opencode v${OPENCODE_VERSION}...\n`)
+
+  try {
+    // Try each candidate URL until one succeeds (handles musl/baseline variants)
+    let downloaded = false
+    for (const candidate of candidates) {
+      const url = `https://github.com/anomalyco/opencode/releases/download/v${OPENCODE_VERSION}/opencode-${candidate}${ext}`
+      const response = await fetch(url, { redirect: 'follow', signal: AbortSignal.timeout(120_000) })
+      if (response.status === 404) continue
+      if (!response.ok) {
+        throw new Error(`Failed to download opencode: HTTP ${response.status} from ${url}`)
+      }
+      fs.writeFileSync(tmpArchive, Buffer.from(await response.arrayBuffer()))
+      downloaded = true
+      break
+    }
+    if (!downloaded) {
+      throw new Error(`No opencode binary found for platform ${process.platform}/${process.arch} (tried: ${candidates.join(', ')})`)
+    }
+
+    // Extract into the temp dir
+    const { execFileSync } = await import('node:child_process')
+    if (process.platform === 'linux') {
+      execFileSync('tar', ['xzf', tmpArchive, '-C', tmpDir], { timeout: 30_000 })
+    } else if (process.platform === 'win32') {
+      execFileSync('powershell.exe', [
+        '-NoProfile', '-Command',
+        `Expand-Archive -LiteralPath '${tmpArchive.replaceAll("'", "''")}' -DestinationPath '${tmpDir.replaceAll("'", "''")}' -Force`,
+      ], { timeout: 30_000 })
+    } else {
+      execFileSync('unzip', ['-o', tmpArchive, '-d', tmpDir], { timeout: 30_000 })
+    }
+
+    // Move extracted binary to versioned path
+    const extractedPath = path.join(tmpDir, extractedName)
+    if (!fs.existsSync(extractedPath)) {
+      throw new Error(`Expected binary not found after extraction: ${extractedPath}`)
+    }
+    fs.chmodSync(extractedPath, 0o755)
+    try {
+      fs.renameSync(extractedPath, binaryPath)
+    } catch {
+      // Another concurrent process may have won the race; that's fine
+      if (fs.existsSync(binaryPath)) return binaryPath
+      throw new Error(`Failed to move opencode binary to ${binaryPath}`)
+    }
+
+    // Delete old versions (match opencode-X.Y.Z or opencode-X.Y.Z.exe exactly)
+    const currentName = path.basename(binaryPath)
+    for (const entry of fs.readdirSync(binDir)) {
+      if (entry === currentName) continue
+      if (/^opencode-\d+\.\d+\.\d+(?:\.exe)?$/.test(entry)) {
+        try { fs.unlinkSync(path.join(binDir, entry)) } catch { /* ignore */ }
+      }
+    }
+
+    s.stop(`Downloaded opencode v${OPENCODE_VERSION}`)
+    return binaryPath
+  } catch (error) {
+    s.stop('Failed to download opencode')
+    throw error
+  } finally {
+    // Clean up temp dir
+    try { fs.rmSync(tmpDir, { recursive: true, force: true }) } catch { /* ignore */ }
+  }
+}
+
 let resolvedOpencodeCommand: string | null = null
 
-export function resolveOpencodeCommand(): string {
+export async function resolveOpencodeCommand(): Promise<string> {
   if (resolvedOpencodeCommand) {
     return resolvedOpencodeCommand
   }
@@ -421,40 +572,14 @@ export function resolveOpencodeCommand(): string {
     })
     if (resolvedFromEnv) {
       resolvedOpencodeCommand = resolvedFromEnv
+      opencodeLogger.log(`Resolved opencode binary from OPENCODE_PATH: ${resolvedFromEnv}`)
       return resolvedFromEnv
     }
   }
 
-  const isWindows = process.platform === 'win32'
-  const whichCmd = isWindows ? 'where' : 'which'
-  const result = errore.try({
-    try: () => {
-      const commandOutput = execFileSync(whichCmd, ['opencode'], {
-        encoding: 'utf8',
-        timeout: 5000,
-      })
-      const resolved = selectResolvedCommand({
-        output: commandOutput,
-        isWindows,
-      })
-      if (resolved) {
-        return resolved
-      }
-      throw new Error('opencode not found in PATH')
-    },
-    catch: () => new Error('opencode not found in PATH'),
-  })
-
-  if (result instanceof Error) {
-    // Fall back to bare command name — spawn will fail with a clear error
-    // if it can't find the binary.
-    opencodeLogger.warn('Could not resolve opencode path via which, falling back to "opencode"')
-    return 'opencode'
-  }
-
-  resolvedOpencodeCommand = result
-  opencodeLogger.log(`Resolved opencode binary: ${result}`)
-  return result
+  const downloaded = await downloadOpencodeIfMissing()
+  resolvedOpencodeCommand = downloaded
+  return downloaded
 }
 async function getOpenPort(): Promise<number> {
   return new Promise((resolve, reject) => {
@@ -585,7 +710,7 @@ async function startSingleServer({
     args: spawnArgs,
     windowsVerbatimArguments,
   } = getSpawnCommandAndArgs({
-    resolvedCommand: resolveOpencodeCommand(),
+    resolvedCommand: await resolveOpencodeCommand(),
     baseArgs: serveArgs,
   })
 

package/src/session-handler/thread-session-runtime.ts

@@ -1417,8 +1417,6 @@ export class ThreadSessionRuntime {
         continue
       }
 
-      // Reset backoff on successful connection
-      backoffMs = 500
       const events = subscribeResult.stream
 
       logger.log(
@@ -1429,8 +1427,10 @@ export class ThreadSessionRuntime {
       // parts that arrived while we were disconnected.
       await this.bootstrapSentPartIds()
 
+      let receivedAnyEvent = false
       const iterResult = await errore.tryAsync(async () => {
         for await (const event of events) {
+          receivedAnyEvent = true
           // Each event is dispatched through the serialized action queue
           // to prevent interleaving mutations from concurrent events.
           await this.dispatchAction(() => {
@@ -1439,6 +1439,14 @@ export class ThreadSessionRuntime {
         }
       })
 
+      // Only reset backoff when the stream was alive long enough to
+      // deliver at least one event. If it closes immediately the server
+      // is likely not ready; keep escalating backoff to avoid a tight
+      // reconnect loop (GitHub issue #126).
+      if (receivedAnyEvent) {
+        backoffMs = 500
+      }
+
       if (iterResult instanceof Error) {
         if (isAbortError(iterResult)) {
           return // disposed
@@ -1450,6 +1458,17 @@ export class ThreadSessionRuntime {
         )
         await delay(backoffMs)
         backoffMs = Math.min(backoffMs * 2, maxBackoffMs)
+      } else {
+        // Stream completed normally (server closed the connection).
+        // This can happen when the opencode server restarts, the SSE
+        // endpoint times out, or there are no active sessions for this
+        // directory. Without a delay here the loop reconnects immediately,
+        // creating a tight infinite reconnect loop (GitHub issue #126).
+        logger.log(
+          `[LISTENER] Stream ended normally for thread ${this.threadId}, reconnecting in ${backoffMs}ms`,
+        )
+        await delay(backoffMs)
+        backoffMs = Math.min(backoffMs * 2, maxBackoffMs)
       }
     }
   }