npm - mini-coder - Versions diffs - 0.2.3 → 0.3.1 - Mend

mini-coder 0.2.3 → 0.3.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/README.md +2 -2
package/dist/mc.js +648 -682
package/docs/KNOWN_ISSUES.md +1 -0
package/docs/design-decisions.md +2 -45
package/docs/mini-coder.1.md +3 -8
package/docs/superpowers/plans/2026-03-30-anthropic-oauth-removal.md +61 -0
package/docs/superpowers/specs/2026-03-30-anthropic-oauth-removal-design.md +47 -0
package/package.json +1 -1

package/dist/mc.js CHANGED Viewed

@@ -2,10 +2,10 @@
 // @bun
 // src/index.ts
-import * as c22 from "yoctocolors";
+import * as c20 from "yoctocolors";
 // src/agent/agent.ts
-import * as c12 from "yoctocolors";
+import * as c11 from "yoctocolors";
 // src/mcp/client.ts
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
@@ -13,7 +13,7 @@ import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 // src/internal/version.ts
-var PACKAGE_VERSION = "0.2.3";
+var PACKAGE_VERSION = "0.3.1";
 // src/mcp/client.ts
 async function connectMcpServer(config) {
@@ -70,7 +70,7 @@ async function connectMcpServer(config) {
 // src/session/db/connection.ts
 import { Database } from "bun:sqlite";
-import { existsSync, mkdirSync, unlinkSync } from "fs";
+import { existsSync, mkdirSync, renameSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
 function getConfigDir() {
@@ -201,27 +201,32 @@ function configureDb(db) {
   db.exec("PRAGMA foreign_keys=ON;");
   db.exec("PRAGMA busy_timeout=1000;");
 }
+function rotateDbFiles(dbPath, version) {
+  const backupBase = `${dbPath}.bak-v${version}-${Date.now()}`;
+  for (const suffix of ["", "-wal", "-shm"]) {
+    const path = `${dbPath}${suffix}`;
+    if (!existsSync(path))
+      continue;
+    renameSync(path, `${backupBase}${suffix}`);
+  }
+}
 function getDb() {
   if (!_db) {
     const dbPath = getDbPath();
+    const dbExists = existsSync(dbPath);
     let db = new Database(dbPath, { create: true });
     configureDb(db);
     const version = db.query("PRAGMA user_version").get()?.user_version ?? 0;
-    if (version !== DB_VERSION) {
+    if (dbExists && version !== DB_VERSION) {
       try {
         db.close();
       } catch {}
-      for (const path of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
-        if (existsSync(path))
-          unlinkSync(path);
-      }
+      rotateDbFiles(dbPath, version);
       db = new Database(dbPath, { create: true });
       configureDb(db);
-      db.exec(SCHEMA);
-      db.exec(`PRAGMA user_version = ${DB_VERSION};`);
-    } else {
-      db.exec(SCHEMA);
     }
+    db.exec(SCHEMA);
+    db.exec(`PRAGMA user_version = ${DB_VERSION};`);
     _db = db;
   }
   return _db;
@@ -339,7 +344,7 @@ function deleteMcpServer(name) {
 }
 // src/cli/output.ts
 import { homedir as homedir4 } from "os";
-import * as c8 from "yoctocolors";
+import * as c7 from "yoctocolors";
 // src/agent/context-files.ts
 import { existsSync as existsSync2, readFileSync } from "fs";
@@ -436,7 +441,7 @@ import { createGoogleGenerativeAI } from "@ai-sdk/google";
 import { createOpenAI } from "@ai-sdk/openai";
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
-// src/session/oauth/anthropic.ts
+// src/session/oauth/openai.ts
 import { createServer } from "http";
 // src/session/oauth/pkce.ts
@@ -457,19 +462,27 @@ async function generatePKCE() {
   return { verifier, challenge };
 }
-// src/session/oauth/anthropic.ts
-var CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
-var AUTHORIZE_URL = "https://claude.ai/oauth/authorize";
-var TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
+// src/session/oauth/openai.ts
+var CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+var AUTHORIZE_URL = "https://auth.openai.com/oauth/authorize";
+var TOKEN_URL = "https://auth.openai.com/oauth/token";
 var CALLBACK_HOST = "127.0.0.1";
-var CALLBACK_PORT = 53692;
-var CALLBACK_PATH = "/callback";
+var CALLBACK_PORT = 1455;
+var CALLBACK_PATH = "/auth/callback";
 var REDIRECT_URI = `http://localhost:${CALLBACK_PORT}${CALLBACK_PATH}`;
-var SCOPES = "org:create_api_key user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload";
+var SCOPES = "openid profile email offline_access";
 var LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
 var SUCCESS_HTML = `<!doctype html>
 <html lang="en"><head><meta charset="utf-8"><title>Authenticated</title></head>
-<body><p>Authentication successful. Return to your terminal.</p></body></html>`;
+<body><p>OpenAI authentication successful. Return to your terminal.</p></body></html>`;
+function createState() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  let hex = "";
+  for (const b of bytes)
+    hex += b.toString(16).padStart(2, "0");
+  return hex;
+}
 function startCallbackServer(expectedState) {
   return new Promise((resolve2, reject) => {
     let result = null;
@@ -488,7 +501,7 @@ function startCallbackServer(expectedState) {
         return;
       }
       res.writeHead(200, { "Content-Type": "text/html" }).end(SUCCESS_HTML);
-      result = { code, state };
+      result = { code };
     });
     server.on("error", reject);
     server.listen(CALLBACK_PORT, CALLBACK_HOST, () => {
@@ -512,10 +525,9 @@ async function postTokenRequest(body, label) {
   const res = await fetch(TOKEN_URL, {
     method: "POST",
     headers: {
-      "Content-Type": "application/json",
-      Accept: "application/json"
+      "Content-Type": "application/x-www-form-urlencoded"
     },
-    body: JSON.stringify(body),
+    body,
     signal: AbortSignal.timeout(30000)
   });
   if (!res.ok) {
@@ -529,57 +541,72 @@ async function postTokenRequest(body, label) {
     expires: Date.now() + data.expires_in * 1000 - 5 * 60 * 1000
   };
 }
-function exchangeCode(code, state, verifier) {
-  return postTokenRequest({
+function exchangeCode(code, verifier) {
+  return postTokenRequest(new URLSearchParams({
     grant_type: "authorization_code",
     client_id: CLIENT_ID,
     code,
-    state,
-    redirect_uri: REDIRECT_URI,
-    code_verifier: verifier
-  }, "Token exchange");
+    code_verifier: verifier,
+    redirect_uri: REDIRECT_URI
+  }), "Token exchange");
 }
-function refreshAnthropicToken(refreshToken) {
-  return postTokenRequest({
+function refreshOpenAIToken(refreshToken) {
+  return postTokenRequest(new URLSearchParams({
     grant_type: "refresh_token",
-    client_id: CLIENT_ID,
-    refresh_token: refreshToken
-  }, "Token refresh");
+    refresh_token: refreshToken,
+    client_id: CLIENT_ID
+  }), "Token refresh");
 }
-async function loginAnthropic(callbacks) {
+async function loginOpenAI(callbacks) {
   const { verifier, challenge } = await generatePKCE();
-  const cb = await startCallbackServer(verifier);
+  const state = createState();
+  const cb = await startCallbackServer(state);
   try {
     const params = new URLSearchParams({
-      code: "true",
-      client_id: CLIENT_ID,
       response_type: "code",
+      client_id: CLIENT_ID,
       redirect_uri: REDIRECT_URI,
       scope: SCOPES,
       code_challenge: challenge,
       code_challenge_method: "S256",
-      state: verifier
+      state,
+      id_token_add_organizations: "true",
+      codex_cli_simplified_flow: "true",
+      originator: "mc"
     });
     callbacks.onOpenUrl(`${AUTHORIZE_URL}?${params}`, "Complete login in your browser.");
     const result = await cb.waitForCode();
     if (!result)
       throw new Error("Login cancelled or no code received");
     callbacks.onProgress("Exchanging authorization code for tokens\u2026");
-    return exchangeCode(result.code, result.state, verifier);
+    return exchangeCode(result.code, verifier);
   } finally {
     cb.server.close();
   }
 }
-var anthropicOAuth = {
-  id: "anthropic",
-  name: "Anthropic (Claude Pro/Max)",
-  login: loginAnthropic,
-  refreshToken: refreshAnthropicToken
+function extractAccountId(accessToken) {
+  try {
+    const parts = accessToken.split(".");
+    const jwt = parts[1];
+    if (parts.length !== 3 || !jwt)
+      return null;
+    const payload = JSON.parse(atob(jwt));
+    const auth = payload["https://api.openai.com/auth"];
+    return auth?.chatgpt_account_id ?? null;
+  } catch {
+    return null;
+  }
+}
+var openaiOAuth = {
+  id: "openai",
+  name: "OpenAI (ChatGPT Plus/Pro)",
+  login: loginOpenAI,
+  refreshToken: refreshOpenAIToken
 };
 // src/session/oauth/auth-storage.ts
 var PROVIDERS = new Map([
-  [anthropicOAuth.id, anthropicOAuth]
+  [openaiOAuth.id, openaiOAuth]
 ]);
 function getOAuthProviders() {
   return [...PROVIDERS.values()];
@@ -608,10 +635,10 @@ function isAuthError(err) {
   return /\b(401|403)\b/.test(err.message);
 }
 function isLoggedIn(provider) {
-  return getStoredToken(provider) !== null;
+  return PROVIDERS.has(provider) && getStoredToken(provider) !== null;
 }
 function listLoggedInProviders() {
-  return getDb().query("SELECT provider FROM oauth_tokens ORDER BY provider").all().map((r) => r.provider);
+  return getDb().query("SELECT provider FROM oauth_tokens ORDER BY provider").all().map((r) => r.provider).filter((provider) => PROVIDERS.has(provider));
 }
 async function login(providerId, callbacks) {
   const provider = PROVIDERS.get(providerId);
@@ -1140,41 +1167,53 @@ async function fetchZenModels() {
   });
 }
 async function fetchOpenAIModels() {
-  const key = process.env.OPENAI_API_KEY;
-  if (!key)
-    return null;
-  return fetchPaginatedModelsList(`${OPENAI_BASE}/v1/models`, { headers: { Authorization: `Bearer ${key}` } }, 6000, "data", "id", (_item, modelId) => ({
-    providerModelId: modelId,
-    displayName: modelId,
-    contextWindow: null,
-    free: false
-  }));
-}
-async function getAnthropicAuth() {
-  const envKey = process.env.ANTHROPIC_API_KEY;
-  if (envKey)
-    return { key: envKey, oauth: false };
-  if (isLoggedIn("anthropic")) {
-    const token = await getAccessToken("anthropic");
-    if (token)
-      return { key: token, oauth: true };
+  const envKey = process.env.OPENAI_API_KEY;
+  if (envKey) {
+    return fetchPaginatedModelsList(`${OPENAI_BASE}/v1/models`, { headers: { Authorization: `Bearer ${envKey}` } }, 6000, "data", "id", (_item, modelId) => ({
+      providerModelId: modelId,
+      displayName: modelId,
+      contextWindow: null,
+      free: false
+    }));
+  }
+  if (isLoggedIn("openai")) {
+    const token = await getAccessToken("openai");
+    if (!token)
+      return null;
+    return fetchCodexOAuthModels(token);
   }
   return null;
 }
-async function fetchAnthropicModels() {
-  const auth = await getAnthropicAuth();
-  if (!auth)
+var CODEX_MODELS_URL = "https://chatgpt.com/backend-api/codex/models?client_version=1.0.0";
+async function fetchCodexOAuthModels(token) {
+  try {
+    const res = await fetch(CODEX_MODELS_URL, {
+      headers: { Authorization: `Bearer ${token}` },
+      signal: AbortSignal.timeout(6000)
+    });
+    if (!res.ok)
+      return null;
+    const data = await res.json();
+    return (data.models ?? []).filter((m) => m.visibility === "list").map((m) => ({
+      providerModelId: m.slug,
+      displayName: m.display_name || m.slug,
+      contextWindow: m.context_window,
+      free: false
+    }));
+  } catch {
     return null;
-  const headers = {
-    "anthropic-version": "2023-06-01"
-  };
-  if (auth.oauth) {
-    headers.Authorization = `Bearer ${auth.key}`;
-    headers["anthropic-beta"] = "oauth-2025-04-20";
-  } else {
-    headers["x-api-key"] = auth.key;
   }
-  const payload = await fetchJson(`${ANTHROPIC_BASE}/v1/models`, { headers }, 6000);
+}
+async function fetchAnthropicModels() {
+  const key = process.env.ANTHROPIC_API_KEY;
+  if (!key)
+    return null;
+  const payload = await fetchJson(`${ANTHROPIC_BASE}/v1/models`, {
+    headers: {
+      "anthropic-version": "2023-06-01",
+      "x-api-key": key
+    }
+  }, 6000);
   return processModelsList(payload, "data", "id", (item, modelId) => {
     const displayName = typeof item.display_name === "string" && item.display_name.trim().length > 0 ? item.display_name : modelId;
     return {
@@ -1236,7 +1275,7 @@ async function fetchProviderCandidates(provider) {
 var MODELS_DEV_SYNC_KEY = "last_models_dev_sync_at";
 var PROVIDER_SYNC_KEY_PREFIX = "last_provider_sync_at:";
 var CACHE_VERSION_KEY = "model_info_cache_version";
-var CACHE_VERSION = 3;
+var CACHE_VERSION = 5;
 var MODEL_INFO_TTL_MS = 24 * 60 * 60 * 1000;
 var REMOTE_PROVIDER_ENV_KEYS = [
   { provider: "zen", envKeys: ["OPENCODE_API_KEY"] },
@@ -1281,8 +1320,8 @@ function hasAnyEnvKey(env, keys) {
 }
 function getRemoteProvidersFromEnv(env) {
   const providers = REMOTE_PROVIDER_ENV_KEYS.filter((entry) => hasAnyEnvKey(env, entry.envKeys)).map((entry) => entry.provider);
-  if (!providers.includes("anthropic") && isLoggedIn("anthropic")) {
-    providers.push("anthropic");
+  if (!providers.includes("openai") && isLoggedIn("openai")) {
+    providers.push("openai");
   }
   return providers;
 }
@@ -1487,27 +1526,6 @@ var SUPPORTED_PROVIDERS = [
   "ollama"
 ];
 var ZEN_BASE2 = "https://opencode.ai/zen/v1";
-var OAUTH_STRIP_BETAS = new Set;
-function createOAuthFetch(accessToken) {
-  const oauthFetch = async (input, init) => {
-    let opts = init;
-    if (opts?.headers) {
-      const h = new Headers(opts.headers);
-      const beta = h.get("anthropic-beta");
-      if (beta) {
-        const filtered = beta.split(",").filter((b) => !OAUTH_STRIP_BETAS.has(b)).join(",");
-        h.set("anthropic-beta", filtered);
-      }
-      h.delete("x-api-key");
-      h.set("authorization", `Bearer ${accessToken}`);
-      h.set("user-agent", "claude-cli/2.1.75");
-      h.set("x-app", "cli");
-      opts = { ...opts, headers: Object.fromEntries(h.entries()) };
-    }
-    return fetch(input, opts);
-  };
-  return oauthFetch;
-}
 function requireEnv(name) {
   const value = process.env[name];
   if (!value)
@@ -1586,32 +1604,64 @@ var ZEN_BACKEND_RESOLVERS = {
 function resolveZenModel(modelId) {
   return ZEN_BACKEND_RESOLVERS[getZenBackend(modelId)](modelId);
 }
-function resolveOpenAIModel(modelId) {
-  return modelId.startsWith("gpt-") ? directProviders.openai().responses(modelId) : directProviders.openai()(modelId);
-}
-var oauthAnthropicCache = null;
-function createOAuthAnthropicProvider(token) {
-  return createAnthropic({
-    apiKey: "",
-    fetch: createOAuthFetch(token),
-    headers: {
-      "anthropic-beta": "claude-code-20250219,oauth-2025-04-20"
+function createOAuthOpenAIProvider(token) {
+  const accountId = extractAccountId(token);
+  return createOpenAI({
+    apiKey: "oauth",
+    baseURL: OPENAI_CODEX_BASE_URL,
+    fetch: (input, init) => {
+      const h = new Headers(init?.headers);
+      h.delete("OpenAI-Organization");
+      h.delete("OpenAI-Project");
+      h.set("Authorization", `Bearer ${token}`);
+      if (accountId)
+        h.set("chatgpt-account-id", accountId);
+      let body = init?.body;
+      if (typeof body === "string") {
+        try {
+          const parsed = JSON.parse(body);
+          if (parsed.input && Array.isArray(parsed.input)) {
+            if (!parsed.instructions) {
+              const sysIdx = parsed.input.findIndex((m) => m.role === "developer" || m.role === "system");
+              if (sysIdx !== -1) {
+                const sysMsg = parsed.input[sysIdx];
+                parsed.instructions = typeof sysMsg.content === "string" ? sysMsg.content : JSON.stringify(sysMsg.content);
+                parsed.input.splice(sysIdx, 1);
+              }
+            }
+            delete parsed.max_output_tokens;
+            parsed.store = false;
+            parsed.stream = true;
+            body = JSON.stringify(parsed);
+          }
+        } catch {}
+      }
+      return fetch(input, {
+        ...init,
+        body,
+        headers: Object.fromEntries(h.entries())
+      });
     }
   });
 }
-async function resolveAnthropicModel(modelId) {
-  if (isLoggedIn("anthropic")) {
-    const token = await getAccessToken("anthropic");
+async function resolveOpenAIModel(modelId) {
+  if (isLoggedIn("openai")) {
+    const token = await getAccessToken("openai");
     if (token) {
-      if (!oauthAnthropicCache || oauthAnthropicCache.token !== token) {
-        oauthAnthropicCache = {
+      if (!oauthOpenAICache || oauthOpenAICache.token !== token) {
+        oauthOpenAICache = {
           token,
-          provider: createOAuthAnthropicProvider(token)
+          provider: createOAuthOpenAIProvider(token)
         };
       }
-      return oauthAnthropicCache.provider(modelId);
+      return oauthOpenAICache.provider.responses(modelId);
     }
   }
+  return modelId.startsWith("gpt-") ? directProviders.openai().responses(modelId) : directProviders.openai()(modelId);
+}
+var OPENAI_CODEX_BASE_URL = "https://chatgpt.com/backend-api/codex";
+var oauthOpenAICache = null;
+async function resolveAnthropicModel(modelId) {
   return directProviders.anthropic()(modelId);
 }
 var PROVIDER_MODEL_RESOLVERS = {
@@ -1636,18 +1686,15 @@ async function resolveModel(modelString) {
   }
   return PROVIDER_MODEL_RESOLVERS[provider](modelId);
 }
-function isAnthropicOAuth() {
-  return isLoggedIn("anthropic");
-}
 function discoverConnectedProviders() {
   const result = [];
   if (process.env.OPENCODE_API_KEY)
     result.push({ name: "zen", via: "env" });
-  if (isLoggedIn("anthropic"))
-    result.push({ name: "anthropic", via: "oauth" });
-  else if (process.env.ANTHROPIC_API_KEY)
+  if (process.env.ANTHROPIC_API_KEY)
     result.push({ name: "anthropic", via: "env" });
-  if (process.env.OPENAI_API_KEY)
+  if (isLoggedIn("openai"))
+    result.push({ name: "openai", via: "oauth" });
+  else if (process.env.OPENAI_API_KEY)
     result.push({ name: "openai", via: "env" });
   if (process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY)
     result.push({ name: "google", via: "env" });
@@ -1658,9 +1705,9 @@ function discoverConnectedProviders() {
 function autoDiscoverModel() {
   if (process.env.OPENCODE_API_KEY)
     return "zen/claude-sonnet-4-6";
-  if (process.env.ANTHROPIC_API_KEY || isLoggedIn("anthropic"))
+  if (process.env.ANTHROPIC_API_KEY)
     return "anthropic/claude-sonnet-4-6";
-  if (process.env.OPENAI_API_KEY)
+  if (process.env.OPENAI_API_KEY || isLoggedIn("openai"))
     return "openai/gpt-5.4";
   if (process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY)
     return "google/gemini-3.1-pro";
@@ -2290,9 +2337,6 @@ class Spinner {
     terminal.setBeforeWriteCallback(null);
     terminal.stderrWrite("\r\x1B[2K\x1B[?25h");
   }
-  update(label) {
-    this.label = label;
-  }
   _tick() {
     const f = SPINNER_FRAMES[this.frame++ % SPINNER_FRAMES.length] ?? "\u28FE";
     const label = this.label ? c2.dim(` ${this.label}`) : "";
@@ -2346,19 +2390,6 @@ function buildContextSegment(opts) {
 function renderStatusLine(segments) {
   return segments.join(STATUS_SEP);
 }
-function buildStatusBarSignature(opts) {
-  return JSON.stringify({
-    model: opts.model,
-    cwd: opts.cwd,
-    gitBranch: opts.gitBranch,
-    sessionId: opts.sessionId,
-    inputTokens: opts.inputTokens,
-    outputTokens: opts.outputTokens,
-    contextTokens: opts.contextTokens,
-    contextWindow: opts.contextWindow,
-    thinkingEffort: opts.thinkingEffort ?? null
-  });
-}
 function fitStatusSegments(required, optional, cols) {
   const fittedOptional = [...optional];
   let line = renderStatusLine([...required, ...fittedOptional]);
@@ -2400,8 +2431,8 @@ function renderStatusBar(opts) {
 }
 // src/cli/stream-render.ts
-import { basename as basename2 } from "path";
-import * as c7 from "yoctocolors";
+import * as c6 from "yoctocolors";
+import { createHighlighter } from "yoctomarkdown";
 // src/llm-api/history/gemini.ts
 function getGeminiThoughtSignature(part) {
@@ -2659,60 +2690,6 @@ function extractAssistantText(newMessages) {
 `);
 }
-// src/cli/live-reasoning.ts
-import * as c4 from "yoctocolors";
-function styleReasoningText(text) {
-  return c4.italic(c4.dim(text));
-}
-class LiveReasoningBlock {
-  blockOpen = false;
-  lineOpen = false;
-  append(delta) {
-    if (!delta)
-      return;
-    this.openBlock();
-    const lines = delta.split(`
-`);
-    for (const [index, line] of lines.entries()) {
-      if (line)
-        this.writeText(line);
-      if (index < lines.length - 1)
-        this.endLine();
-    }
-  }
-  isOpen() {
-    return this.blockOpen;
-  }
-  finish() {
-    if (!this.blockOpen)
-      return;
-    if (this.lineOpen)
-      writeln();
-    this.blockOpen = false;
-    this.lineOpen = false;
-  }
-  openBlock() {
-    if (this.blockOpen)
-      return;
-    writeln(`${G.info} ${c4.dim("reasoning")}`);
-    this.blockOpen = true;
-  }
-  writeText(text) {
-    if (!this.lineOpen) {
-      write("  ");
-      this.lineOpen = true;
-    }
-    write(styleReasoningText(text));
-  }
-  endLine() {
-    if (!this.lineOpen)
-      write("  ");
-    writeln();
-    this.lineOpen = false;
-  }
-}
 // src/cli/reasoning.ts
 function normalizeReasoningDelta(delta) {
   return delta.replace(/\r\n?/g, `
@@ -2746,130 +2723,34 @@ function normalizeReasoningText(text) {
 `);
 }
-// src/cli/stream-render-content.ts
-import { createHighlighter } from "yoctomarkdown";
-class StreamRenderContent {
-  spinner;
-  quiet;
-  inText = false;
-  accumulatedText = "";
-  accumulatedReasoning = "";
-  highlighter;
-  constructor(spinner, quiet = false) {
-    this.spinner = spinner;
-    this.quiet = quiet;
-  }
-  getText() {
-    return this.accumulatedText;
-  }
-  getReasoning() {
-    return this.accumulatedReasoning;
-  }
-  hasOpenContent() {
-    return this.inText;
-  }
-  appendTextDelta(delta, renderedVisibleOutput) {
-    let text = delta ?? "";
-    if (!text)
-      return;
-    if (!this.inText) {
-      text = text.trimStart();
-      if (!text)
-        return;
-      if (!this.quiet) {
-        this.spinner.stop();
-        if (renderedVisibleOutput)
-          writeln();
-        write(`${G.reply} `);
-      }
-      this.inText = true;
-      if (!this.quiet && terminal.isStdoutTTY)
-        this.highlighter = createHighlighter();
-    }
-    const isFirstLine = !this.accumulatedText.includes(`
-`);
-    this.accumulatedText += text;
-    if (this.quiet)
-      return;
-    this.spinner.stop();
-    if (this.highlighter) {
-      let colored = this.highlighter.write(text);
-      if (colored) {
-        if (isFirstLine && colored.startsWith("\x1B[2K\r")) {
-          colored = `\x1B[2K\r${G.reply} ${colored.slice(5)}`;
-        }
-        write(colored);
-      }
-    } else {
-      write(text);
-    }
-  }
-  appendReasoningDelta(delta) {
-    const text = delta ?? "";
-    if (!text)
-      return "";
-    let appended = text;
-    if (this.accumulatedReasoning.endsWith("**") && text.startsWith("**") && !this.accumulatedReasoning.endsWith(`
-`)) {
-      appended = `
-${text}`;
-    }
-    this.accumulatedReasoning += appended;
-    return appended;
-  }
-  flushOpenContent() {
-    if (!this.inText)
-      return;
-    if (this.quiet) {
-      this.inText = false;
-      return;
-    }
-    if (this.highlighter) {
-      let finalColored = this.highlighter.end();
-      if (finalColored) {
-        const isFirstLine = !this.accumulatedText.includes(`
-`);
-        if (isFirstLine && finalColored.startsWith("\x1B[2K\r")) {
-          finalColored = `\x1B[2K\r${G.reply} ${finalColored.slice(5)}`;
-        }
-        write(finalColored);
-      }
-    }
-    writeln();
-    this.inText = false;
-  }
-}
 // src/cli/tool-render.ts
-import * as c6 from "yoctocolors";
+import * as c5 from "yoctocolors";
 // src/cli/tool-result-renderers.ts
-import * as c5 from "yoctocolors";
+import * as c4 from "yoctocolors";
 function writePreviewLines(opts) {
   if (!opts.value.trim())
     return;
   const lines = opts.value.split(`
 `);
-  writeln(`    ${c5.dim(opts.label)} ${c5.dim(`(${lines.length} lines)`)}`);
+  if (opts.label)
+    writeln(`${c4.dim(opts.label)} ${c4.dim(`(${lines.length} lines)`)}`);
   if (!Number.isFinite(opts.maxLines) || lines.length <= opts.maxLines) {
-    for (const line of lines) {
-      writeln(`    ${opts.lineColor("\u2502")} ${line}`);
-    }
+    for (const line of lines)
+      writeln(line);
     return;
   }
   const headCount = Math.max(1, Math.ceil(opts.maxLines / 2));
   const tailCount = Math.max(0, Math.floor(opts.maxLines / 2));
-  for (const line of lines.slice(0, headCount)) {
-    writeln(`    ${opts.lineColor("\u2502")} ${line}`);
-  }
+  for (const line of lines.slice(0, headCount))
+    writeln(line);
   const hiddenLines = Math.max(0, lines.length - (headCount + tailCount));
   if (hiddenLines > 0) {
-    writeln(`    ${opts.lineColor("\u2502")} ${c5.dim(`\u2026 +${hiddenLines} lines`)}`);
+    writeln(c4.dim(`\u2026 +${hiddenLines} lines`));
   }
   if (tailCount > 0) {
-    for (const line of lines.slice(-tailCount)) {
-      writeln(`    ${opts.lineColor("\u2502")} ${line}`);
-    }
+    for (const line of lines.slice(-tailCount))
+      writeln(line);
   }
 }
 function truncateOneLine(value, max = 100, verboseOutput = false) {
@@ -2928,11 +2809,11 @@ function renderShellResult(result, opts) {
   const stdoutLines = countShellLines(r.stdout);
   const stderrLines = countShellLines(r.stderr);
   const stdoutSingleLine = getSingleShellLine(r.stdout);
-  let badge = c5.red("error");
+  let badge = c4.red("error");
   if (r.timedOut)
-    badge = c5.yellow("timeout");
+    badge = c4.yellow("timeout");
   else if (r.success)
-    badge = c5.green("done");
+    badge = c4.green("done");
   const parts = buildShellSummaryParts({
     exitCode: r.exitCode,
     stdoutLines,
@@ -2940,11 +2821,10 @@ function renderShellResult(result, opts) {
     stdoutSingleLine,
     verboseOutput
   });
-  writeln(`    ${badge} ${c5.dim(parts.join(" \xB7 "))}`);
+  writeln(`${badge} ${c4.dim(parts.join(" \xB7 "))}`);
   writePreviewLines({
     label: "stderr",
     value: displayStderr,
-    lineColor: c5.red,
     maxLines: verboseOutput ? Number.POSITIVE_INFINITY : 10
   });
   if (shouldPreviewShellStdout({
@@ -2956,7 +2836,6 @@ function renderShellResult(result, opts) {
     writePreviewLines({
       label: "stdout",
       value: displayStdout,
-      lineColor: c5.dim,
       maxLines: verboseOutput ? Number.POSITIVE_INFINITY : 20
     });
   }
@@ -2967,21 +2846,21 @@ function buildSkillDescriptionPart(description, verboseOutput = false) {
   if (!trimmed)
     return "";
   if (verboseOutput)
-    return `  ${c5.dim("\xB7")}  ${c5.dim(trimmed)}`;
-  return `  ${c5.dim("\xB7")}  ${c5.dim(trimmed.length > 60 ? `${trimmed.slice(0, 57)}\u2026` : trimmed)}`;
+    return `  ${c4.dim("\xB7")}  ${c4.dim(trimmed)}`;
+  return `  ${c4.dim("\xB7")}  ${c4.dim(trimmed.length > 60 ? `${trimmed.slice(0, 57)}\u2026` : trimmed)}`;
 }
 function renderSkillSummaryLine(skill, opts) {
   const name = skill.name ?? "(unknown)";
   const source = skill.source ?? "unknown";
-  const labelPrefix = opts?.label ? `${c5.dim(opts.label)}  ` : "";
-  writeln(`    ${G.info} ${labelPrefix}${name}  ${c5.dim("\xB7")}  ${c5.dim(source)}${buildSkillDescriptionPart(skill.description, opts?.verboseOutput === true)}`);
+  const labelPrefix = opts?.label ? `${c4.dim(opts.label)}  ` : "";
+  writeln(`${G.info} ${labelPrefix}${name}  ${c4.dim("\xB7")}  ${c4.dim(source)}${buildSkillDescriptionPart(skill.description, opts?.verboseOutput === true)}`);
 }
 function renderListSkillsResult(result, opts) {
   const r = result;
   if (!Array.isArray(r?.skills))
     return false;
   if (r.skills.length === 0) {
-    writeln(`    ${G.info} ${c5.dim("no skills")}`);
+    writeln(`${G.info} ${c4.dim("no skills")}`);
     return true;
   }
   const maxSkills = opts?.verboseOutput ? r.skills.length : 6;
@@ -2991,7 +2870,7 @@ function renderListSkillsResult(result, opts) {
     });
   }
   if (r.skills.length > maxSkills) {
-    writeln(`    ${c5.dim(`+${r.skills.length - maxSkills} more skills`)}`);
+    writeln(`${c4.dim(`+${r.skills.length - maxSkills} more skills`)}`);
   }
   return true;
 }
@@ -3000,13 +2879,20 @@ function renderReadSkillResult(result, _opts) {
   if (!r || typeof r !== "object")
     return false;
   if (!r.skill) {
-    writeln(`    ${G.info} ${c5.dim("skill")}  ${c5.dim("(not found)")}`);
+    if (typeof r.note === "string" && r.note.trim().length > 0) {
+      writeln(`${G.info} ${c4.dim("skill")}  ${c4.dim(r.note.trim())}`);
+      return true;
+    }
+    writeln(`${G.info} ${c4.dim("skill")}  ${c4.dim("(not found)")}`);
     return true;
   }
   renderSkillSummaryLine(r.skill, {
     label: "skill",
     verboseOutput: _opts?.verboseOutput === true
   });
+  if (typeof r.note === "string" && r.note.trim().length > 0) {
+    writeln(c4.dim(r.note.trim()));
+  }
   return true;
 }
 function renderWebSearchResult(result, opts) {
@@ -3014,19 +2900,19 @@ function renderWebSearchResult(result, opts) {
   if (!Array.isArray(r?.results))
     return false;
   if (r.results.length === 0) {
-    writeln(`    ${G.info} ${c5.dim("no results")}`);
+    writeln(`${G.info} ${c4.dim("no results")}`);
     return true;
   }
   const maxResults = opts?.verboseOutput ? r.results.length : 5;
   for (const item of r.results.slice(0, maxResults)) {
     const title = (item.title?.trim() || item.url || "(untitled)").replace(/\s+/g, " ");
-    const score = typeof item.score === "number" ? c5.dim(` (${item.score.toFixed(2)})`) : "";
-    writeln(`    ${c5.dim("\u2022")} ${title}${score}`);
+    const score = typeof item.score === "number" ? c4.dim(` (${item.score.toFixed(2)})`) : "";
+    writeln(`${c4.dim("\u2022")} ${title}${score}`);
     if (item.url)
-      writeln(`      ${c5.dim(item.url)}`);
+      writeln(`  ${c4.dim(item.url)}`);
   }
   if (r.results.length > maxResults) {
-    writeln(`    ${c5.dim(`  +${r.results.length - maxResults} more`)}`);
+    writeln(`${c4.dim(`+${r.results.length - maxResults} more`)}`);
   }
   return true;
 }
@@ -3035,23 +2921,23 @@ function renderWebContentResult(result, opts) {
   if (!Array.isArray(r?.results))
     return false;
   if (r.results.length === 0) {
-    writeln(`    ${G.info} ${c5.dim("no pages")}`);
+    writeln(`${G.info} ${c4.dim("no pages")}`);
     return true;
   }
   const maxPages = opts?.verboseOutput ? r.results.length : 3;
   for (const item of r.results.slice(0, maxPages)) {
     const title = (item.title?.trim() || item.url || "(untitled)").replace(/\s+/g, " ");
-    writeln(`    ${c5.dim("\u2022")} ${title}`);
+    writeln(`${c4.dim("\u2022")} ${title}`);
     if (item.url)
-      writeln(`      ${c5.dim(item.url)}`);
+      writeln(`  ${c4.dim(item.url)}`);
     const preview = (item.text ?? "").replace(/\s+/g, " ").trim();
     if (preview) {
       const trimmed = opts?.verboseOutput || preview.length <= 220 ? preview : `${preview.slice(0, 217)}\u2026`;
-      writeln(`      ${c5.dim(trimmed)}`);
+      writeln(`  ${c4.dim(trimmed)}`);
     }
   }
   if (r.results.length > maxPages) {
-    writeln(`    ${c5.dim(`  +${r.results.length - maxPages} more`)}`);
+    writeln(`${c4.dim(`+${r.results.length - maxPages} more`)}`);
   }
   return true;
 }
@@ -3061,11 +2947,11 @@ function renderMcpResult(result, opts) {
   let rendered = false;
   for (const block of content.slice(0, maxBlocks)) {
     if (block?.type === "text" && block.text) {
-      const maxLines = opts?.verboseOutput ? Number.POSITIVE_INFINITY : 6;
-      const lines = block.text.split(`
-`).slice(0, maxLines);
-      for (const line of lines)
-        writeln(`    ${c5.dim("\u2502")} ${line}`);
+      writePreviewLines({
+        label: "",
+        value: block.text,
+        maxLines: opts?.verboseOutput ? Number.POSITIVE_INFINITY : 6
+      });
       rendered = true;
     }
   }
@@ -3153,43 +3039,58 @@ function formatShellCallLine(cmd) {
   const { cwd, rest } = parseShellCdPrefix(cmd);
   const firstCmd = extractFirstCommand(rest);
   const glyph = shellCmdGlyph(firstCmd, rest);
-  const cwdSuffix = cwd ? ` ${c6.dim(`in ${cwd}`)}` : "";
-  const display = truncateText(rest, 80);
-  return `${glyph} ${display}${cwdSuffix}`;
+  const cwdSuffix = cwd ? ` ${c5.dim(`in ${cwd}`)}` : "";
+  return `${glyph} ${rest}${cwdSuffix}`;
 }
 function buildToolCallLine(name, args) {
   const a = args && typeof args === "object" ? args : {};
   if (name === "shell") {
     const cmd = String(a.command ?? "").trim();
     if (!cmd)
-      return `${G.run} ${c6.dim("shell")}`;
+      return `${G.run} ${c5.dim("shell")}`;
     return formatShellCallLine(cmd);
   }
   if (name === "listSkills") {
-    return `${G.search} ${c6.dim("list skills")}`;
+    return `${G.search} ${c5.dim("list skills")}`;
   }
   if (name === "readSkill") {
     const skillName = typeof a.name === "string" ? a.name : "";
-    return `${G.read} ${c6.dim("read skill")}${skillName ? ` ${skillName}` : ""}`;
+    return `${G.read} ${c5.dim("read skill")}${skillName ? ` ${skillName}` : ""}`;
   }
   if (name === "webSearch") {
     const query = typeof a.query === "string" ? a.query : "";
-    const short = query.length > 60 ? `${query.slice(0, 57)}\u2026` : query;
-    return `${G.search} ${c6.dim("search")}${short ? ` ${short}` : ""}`;
+    return `${G.search} ${c5.dim("search")}${query ? ` ${query}` : ""}`;
   }
   if (name === "webContent") {
     const urls = Array.isArray(a.urls) ? a.urls : [];
     const label = urls.length === 1 ? String(urls[0]) : `${urls.length} url${urls.length !== 1 ? "s" : ""}`;
-    const short = label.length > 60 ? `${label.slice(0, 57)}\u2026` : label;
-    return `${G.read} ${c6.dim("fetch")} ${short}`;
+    return `${G.read} ${c5.dim("fetch")} ${label}`;
   }
   if (name.startsWith("mcp_")) {
-    return `${G.mcp} ${c6.dim(name)}`;
+    return `${G.mcp} ${c5.dim(name)}`;
   }
-  return `${toolGlyph(name)} ${c6.dim(name)}`;
+  return `${toolGlyph(name)} ${c5.dim(name)}`;
 }
-function renderToolCall(toolName, args) {
-  writeln(`  ${buildToolCallLine(toolName, args)}`);
+function renderToolCall(toolName, args, opts) {
+  const line = buildToolCallLine(toolName, args);
+  if (opts?.verboseOutput) {
+    writeln(line);
+    return;
+  }
+  const lines = line.split(`
+`);
+  if (lines.length <= 6) {
+    writeln(line);
+    return;
+  }
+  const head = lines.slice(0, 3);
+  const tail = lines.slice(-2);
+  const hidden = lines.length - head.length - tail.length;
+  for (const l of head)
+    writeln(l);
+  writeln(c5.dim(`\u2026 +${hidden} lines`));
+  for (const l of tail)
+    writeln(l);
 }
 function formatErrorBadge(result) {
   let msg;
@@ -3201,11 +3102,11 @@ function formatErrorBadge(result) {
     msg = JSON.stringify(result);
   const oneLiner = msg.split(`
 `)[0] ?? msg;
-  return `${G.err} ${c6.red(oneLiner)}`;
+  return `${G.err} ${c5.red(oneLiner)}`;
 }
 function renderToolResult(toolName, result, isError, opts) {
   if (isError) {
-    writeln(`    ${formatErrorBadge(result)}`);
+    writeln(formatErrorBadge(result));
     return;
   }
   if (renderToolResultByName(toolName, result, opts)) {
@@ -3213,32 +3114,130 @@ function renderToolResult(toolName, result, isError, opts) {
   }
   const text = JSON.stringify(result);
   if (opts?.verboseOutput || text.length <= 120) {
-    writeln(`    ${c6.dim(text)}`);
+    writeln(c5.dim(text));
     return;
   }
-  writeln(`    ${c6.dim(`${text.slice(0, 117)}\u2026`)}`);
+  writeln(c5.dim(`${text.slice(0, 117)}\u2026`));
 }
 // src/cli/stream-render.ts
+function styleReasoning(text) {
+  return c6.italic(c6.dim(text));
+}
+function writeReasoningDelta(delta, state) {
+  if (!delta)
+    return;
+  if (!state.blockOpen) {
+    writeln(`${G.info} ${c6.dim("reasoning")}`);
+    state.blockOpen = true;
+  }
+  const lines = delta.split(`
+`);
+  for (const [i, line] of lines.entries()) {
+    if (line) {
+      if (!state.lineOpen) {
+        write("  ");
+        state.lineOpen = true;
+      }
+      write(styleReasoning(line));
+    }
+    if (i < lines.length - 1) {
+      if (!state.lineOpen)
+        write("  ");
+      writeln();
+      state.lineOpen = false;
+    }
+  }
+}
+function finishReasoning(state) {
+  if (!state.blockOpen)
+    return;
+  if (state.lineOpen)
+    writeln();
+  state.blockOpen = false;
+  state.lineOpen = false;
+}
+function appendTextDelta(delta, state, spinner, quiet, renderedVisibleOutput) {
+  let chunk = delta ?? "";
+  if (!chunk)
+    return state.inText;
+  if (!state.inText) {
+    chunk = chunk.trimStart();
+    if (!chunk)
+      return false;
+    if (!quiet) {
+      spinner.stop();
+      if (renderedVisibleOutput)
+        writeln();
+      write(`${G.reply} `);
+    }
+    state.inText = true;
+    if (!quiet && terminal.isStdoutTTY) {
+      state.highlighter = createHighlighter();
+    }
+  }
+  const isFirstLine = !state.text.includes(`
+`);
+  state.text += chunk;
+  if (quiet)
+    return state.inText;
+  spinner.stop();
+  if (state.highlighter) {
+    let colored = state.highlighter.write(chunk);
+    if (colored) {
+      if (isFirstLine && colored.startsWith("\x1B[2K\r")) {
+        colored = `\x1B[2K\r${G.reply} ${colored.slice(5)}`;
+      }
+      write(colored);
+    }
+  } else {
+    write(chunk);
+  }
+  return state.inText;
+}
+function flushText(state, quiet) {
+  if (!state.inText)
+    return;
+  if (!quiet) {
+    if (state.highlighter) {
+      let finalColored = state.highlighter.end();
+      if (finalColored) {
+        const isFirstLine = !state.text.includes(`
+`);
+        if (isFirstLine && finalColored.startsWith("\x1B[2K\r")) {
+          finalColored = `\x1B[2K\r${G.reply} ${finalColored.slice(5)}`;
+        }
+        write(finalColored);
+      }
+    }
+    writeln();
+  }
+  state.inText = false;
+}
 async function renderTurn(events, spinner, opts) {
   const quiet = opts?.quiet ?? false;
   const showReasoning = !quiet && (opts?.showReasoning ?? true);
   const verboseOutput = opts?.verboseOutput ?? false;
-  const content = new StreamRenderContent(spinner, quiet);
-  const liveReasoning = new LiveReasoningBlock;
+  const textState = {
+    inText: false,
+    text: "",
+    highlighter: undefined
+  };
+  let reasoningRaw = "";
+  let reasoningComputed = false;
+  let reasoningText = "";
+  const reasoningState = { blockOpen: false, lineOpen: false };
+  const startedToolCalls = new Set;
+  const toolCallInfo = new Map;
+  let parallelCallCount = 0;
   let inputTokens = 0;
   let outputTokens = 0;
   let contextTokens = 0;
   let newMessages = [];
-  const startedToolCalls = new Set;
-  const toolCallInfo = new Map;
-  let parallelCallCount = 0;
   let renderedVisibleOutput = false;
-  let reasoningComputed = false;
-  let reasoningText = "";
   const getReasoningText = () => {
     if (!reasoningComputed) {
-      reasoningText = normalizeReasoningText(content.getReasoning());
+      reasoningText = normalizeReasoningText(reasoningRaw);
       reasoningComputed = true;
     }
     return reasoningText;
@@ -3246,29 +3245,42 @@ async function renderTurn(events, spinner, opts) {
   for await (const event of events) {
     switch (event.type) {
       case "text-delta": {
-        liveReasoning.finish();
-        content.appendTextDelta(event.delta, renderedVisibleOutput);
-        if (content.hasOpenContent())
+        finishReasoning(reasoningState);
+        textState.inText = appendTextDelta(event.delta, textState, spinner, quiet, renderedVisibleOutput);
+        if (textState.inText)
           renderedVisibleOutput = true;
         break;
       }
       case "reasoning-delta": {
-        content.flushOpenContent();
-        const delta = content.appendReasoningDelta(normalizeReasoningDelta(event.delta));
+        flushText(textState, quiet);
+        let appended = normalizeReasoningDelta(event.delta);
+        if (reasoningRaw.endsWith("**") && appended.startsWith("**") && !reasoningRaw.endsWith(`
+`)) {
+          appended = `
+${appended}`;
+        }
+        reasoningRaw += appended;
         reasoningComputed = false;
-        if (showReasoning && delta) {
+        if (showReasoning && appended) {
           spinner.stop();
-          if (renderedVisibleOutput && !liveReasoning.isOpen())
+          if (renderedVisibleOutput && !reasoningState.blockOpen)
             writeln();
-          liveReasoning.append(delta);
+          writeReasoningDelta(appended, reasoningState);
           renderedVisibleOutput = true;
         }
         break;
       }
+      case "tool-input-delta": {
+        if (quiet)
+          break;
+        finishReasoning(reasoningState);
+        flushText(textState, quiet);
+        spinner.start(`composing ${event.toolName}\u2026`);
+        break;
+      }
       case "tool-call-start": {
-        if (startedToolCalls.has(event.toolCallId)) {
+        if (startedToolCalls.has(event.toolCallId))
           break;
-        }
         const isConsecutiveToolCall = startedToolCalls.size > 0 && toolCallInfo.size > 0;
         startedToolCalls.add(event.toolCallId);
         toolCallInfo.set(event.toolCallId, {
@@ -3278,13 +3290,14 @@ async function renderTurn(events, spinner, opts) {
         if (toolCallInfo.size > 1) {
           parallelCallCount = toolCallInfo.size;
         }
-        liveReasoning.finish();
-        content.flushOpenContent();
+        finishReasoning(reasoningState);
+        flushText(textState, quiet);
         if (!quiet) {
           spinner.stop();
-          if (renderedVisibleOutput && !isConsecutiveToolCall)
+          if (renderedVisibleOutput && !isConsecutiveToolCall) {
             writeln();
-          renderToolCall(event.toolName, event.args);
+          }
+          renderToolCall(event.toolName, event.args, { verboseOutput });
           renderedVisibleOutput = true;
           spinner.start(event.toolName);
         }
@@ -3294,11 +3307,11 @@ async function renderTurn(events, spinner, opts) {
         startedToolCalls.delete(event.toolCallId);
         const callInfo = toolCallInfo.get(event.toolCallId);
         toolCallInfo.delete(event.toolCallId);
-        liveReasoning.finish();
+        finishReasoning(reasoningState);
         if (!quiet) {
           spinner.stop();
           if (parallelCallCount > 1 && callInfo) {
-            writeln(`    ${c7.dim("\u21B3")} ${callInfo.label}`);
+            writeln(`${c6.dim("\u21B3")} ${callInfo.label}`);
           }
           if (toolCallInfo.size === 0)
             parallelCallCount = 0;
@@ -3314,31 +3327,20 @@ async function renderTurn(events, spinner, opts) {
         break;
       }
       case "context-pruned": {
-        liveReasoning.finish();
-        content.flushOpenContent();
+        finishReasoning(reasoningState);
+        flushText(textState, quiet);
         if (!quiet) {
           spinner.stop();
           const removedKb = (event.removedBytes / 1024).toFixed(1);
-          writeln(`${G.info} ${c7.dim("context pruned")}  ${c7.dim(`\u2013${event.removedMessageCount} messages`)}  ${c7.dim(`\u2013${removedKb} KB`)}`);
-          renderedVisibleOutput = true;
-        }
-        break;
-      }
-      case "file-generated": {
-        liveReasoning.finish();
-        content.flushOpenContent();
-        if (!quiet) {
-          spinner.stop();
-          if (renderedVisibleOutput)
-            writeln();
-          writeln(`${G.info} ${c7.dim("file")}  ${c7.dim(event.mediaType)}  ${c7.dim("\u2192")}  ${basename2(event.filePath)}`);
+          writeln(`${G.info} ${c6.dim("context pruned")}  ${c6.dim(`\u2013${event.removedMessageCount} messages`)}  ${c6.dim(`\u2013${removedKb} KB`)}`);
           renderedVisibleOutput = true;
+          spinner.start("thinking");
         }
         break;
       }
       case "turn-complete": {
-        liveReasoning.finish();
-        content.flushOpenContent();
+        finishReasoning(reasoningState);
+        flushText(textState, quiet);
         spinner.stop();
         if (!quiet && !renderedVisibleOutput)
           writeln();
@@ -3349,14 +3351,14 @@ async function renderTurn(events, spinner, opts) {
         break;
       }
       case "turn-error": {
-        liveReasoning.finish();
-        content.flushOpenContent();
+        finishReasoning(reasoningState);
+        flushText(textState, quiet);
         spinner.stop();
         inputTokens = event.inputTokens;
         outputTokens = event.outputTokens;
         contextTokens = event.contextTokens;
         if (isAbortError(event.error)) {
-          newMessages = buildAbortMessages(event.partialMessages, content.getText());
+          newMessages = buildAbortMessages(event.partialMessages, textState.text);
         } else {
           renderError(event.error, "turn");
           throw new RenderedError(event.error);
@@ -3405,17 +3407,17 @@ function renderUserMessage(text) {
   }
 }
 var G = {
-  prompt: c8.green("\u203A"),
-  reply: c8.cyan("\u25C6"),
-  search: c8.yellow("?"),
-  read: c8.dim("\u2190"),
-  write: c8.green("\u270E"),
-  run: c8.dim("$"),
-  mcp: c8.yellow("\u2699"),
-  ok: c8.green("\u2714"),
-  err: c8.red("\u2716"),
-  warn: c8.yellow("!"),
-  info: c8.dim("\xB7")
+  prompt: c7.green("\u203A"),
+  reply: c7.cyan("\u25C6"),
+  search: c7.yellow("?"),
+  read: c7.dim("\u2190"),
+  write: c7.green("\u270E"),
+  run: c7.dim("$"),
+  mcp: c7.yellow("\u2699"),
+  ok: c7.green("\u2714"),
+  err: c7.red("\u2716"),
+  warn: c7.yellow("!"),
+  info: c7.dim("\xB7")
 };
 var PREFIX = {
   user: G.prompt,
@@ -3437,17 +3439,17 @@ class RenderedError extends Error {
 function renderError(err, context = "render") {
   logError(err, context);
   const parsed = parseAppError(err);
-  writeln(`${G.err} ${c8.red(parsed.headline)}`);
+  writeln(`${G.err} ${c7.red(parsed.headline)}`);
   if (parsed.hint) {
-    writeln(`  ${c8.dim(parsed.hint)}`);
+    writeln(`  ${c7.dim(parsed.hint)}`);
   }
 }
 function renderBanner(model, cwd) {
   writeln();
   const title = PACKAGE_VERSION ? `mini-coder \xB7 v${PACKAGE_VERSION}` : "mini-coder";
-  writeln(`  ${c8.cyan("mc")}  ${c8.dim(title)}`);
-  writeln(`  ${c8.dim(model)}  ${c8.dim("\xB7")}  ${c8.dim(tildePath(cwd))}`);
-  writeln(`  ${c8.dim("/help for commands  \xB7  esc cancel  \xB7  ctrl+d exit")}`);
+  writeln(`  ${c7.cyan("mc")}  ${c7.dim(title)}`);
+  writeln(`  ${c7.dim(model)}  ${c7.dim("\xB7")}  ${c7.dim(tildePath(cwd))}`);
+  writeln(`  ${c7.dim("/help for commands  \xB7  esc cancel  \xB7  ctrl+d exit")}`);
   const items = [];
   if (getPreferredShowReasoning())
     items.push("reasoning: on");
@@ -3460,7 +3462,7 @@ function renderBanner(model, cwd) {
   if (skills.size > 0)
     items.push(`${skills.size} skill${skills.size > 1 ? "s" : ""}`);
   if (items.length > 0) {
-    writeln(`  ${c8.dim(items.join("  \xB7  "))}`);
+    writeln(`  ${c7.dim(items.join("  \xB7  "))}`);
   }
   const connParts = [];
   for (const p of discoverConnectedProviders()) {
@@ -3470,7 +3472,7 @@ function renderBanner(model, cwd) {
   if (mcpCount > 0)
     connParts.push(`${mcpCount} mcp`);
   if (connParts.length > 0) {
-    writeln(`  ${c8.dim(connParts.join(" \xB7 "))}`);
+    writeln(`  ${c7.dim(connParts.join(" \xB7 "))}`);
   }
   writeln();
 }
@@ -3485,7 +3487,7 @@ class CliReporter {
     if (this.quiet)
       return;
     this.spinner.stop();
-    writeln(`${G.info} ${c8.dim(msg)}`);
+    writeln(`${G.info} ${c7.dim(msg)}`);
   }
   error(msg, hint) {
     this.spinner.stop();
@@ -3689,10 +3691,10 @@ function setPreferredVerboseOutput(verbose) {
   setSetting("preferred_verbose_output", verbose ? "true" : "false");
 }
 // src/agent/session-runner.ts
-import * as c11 from "yoctocolors";
+import * as c10 from "yoctocolors";
 // src/cli/input.ts
-import * as c9 from "yoctocolors";
+import * as c8 from "yoctocolors";
 // src/cli/input-buffer.ts
 var PASTE_TOKEN_START = 57344;
@@ -4101,7 +4103,7 @@ function watchForCancel(abortController) {
   process.stdin.on("data", onData);
   return cleanup;
 }
-var PROMPT = c9.green("\u25B6 ");
+var PROMPT = c8.green("\u25B6 ");
 var PROMPT_RAW_LEN = 2;
 async function readline(opts) {
   const cwd = opts.cwd ?? process.cwd();
@@ -4150,7 +4152,7 @@ async function readline(opts) {
     process.stdout.write(`${CLEAR_LINE}${prompt}${display}${CSI}${PROMPT_RAW_LEN + displayCursor + 1}G`);
   }
   function renderSearchPrompt() {
-    process.stdout.write(`${CLEAR_LINE}${c9.cyan("search:")} ${searchQuery}\u2588`);
+    process.stdout.write(`${CLEAR_LINE}${c8.cyan("search:")} ${searchQuery}\u2588`);
   }
   function applyHistory() {
     if (histIdx < history.length) {
@@ -4412,36 +4414,12 @@ import { streamText } from "ai";
 // src/llm-api/turn-execution.ts
 import { dynamicTool, jsonSchema } from "ai";
-// src/llm-api/generated-files.ts
-import { join as join6 } from "path";
-var MEDIA_TYPE_TO_EXT = {
-  "image/jpeg": "jpg",
-  "image/svg+xml": "svg"
-};
-function extensionFromMediaType(mediaType) {
-  if (MEDIA_TYPE_TO_EXT[mediaType])
-    return MEDIA_TYPE_TO_EXT[mediaType];
-  const slash = mediaType.indexOf("/");
-  if (slash === -1 || slash === mediaType.length - 1)
-    return "bin";
-  return mediaType.slice(slash + 1);
-}
-var counter = 0;
-async function saveGeneratedFile(file, cwd) {
-  counter += 1;
-  const ext = extensionFromMediaType(file.mediaType);
-  const name = `generated-${counter}.${ext}`;
-  const filePath = join6(cwd, name);
-  await Bun.write(filePath, file.uint8Array);
-  return filePath;
-}
 // src/llm-api/turn-stream-events.ts
-function shouldLogStreamChunk(c10) {
-  return c10.type !== "text-delta" && c10.type !== "reasoning" && c10.type !== "reasoning-delta";
+function shouldLogStreamChunk(c9) {
+  return c9.type !== "text-delta" && c9.type !== "reasoning" && c9.type !== "reasoning-delta" && c9.type !== "tool-input-delta";
 }
-function extractToolArgs(c10) {
-  return c10.input ?? c10.args;
+function extractToolArgs(c9) {
+  return c9.input ?? c9.args;
 }
 function hasRenderableToolArgs(args) {
   if (args === null || args === undefined)
@@ -4454,10 +4432,10 @@ function hasRenderableToolArgs(args) {
     return Object.keys(args).length > 0;
   return true;
 }
-function mapStreamChunkToTurnEvent(c10) {
-  switch (c10.type) {
+function mapStreamChunkToTurnEvent(c9) {
+  switch (c9.type) {
     case "text-delta": {
-      const delta = typeof c10.text === "string" ? c10.text : "";
+      const delta = typeof c9.text === "string" ? c9.text : "";
       return {
         type: "text-delta",
         delta
@@ -4465,7 +4443,7 @@ function mapStreamChunkToTurnEvent(c10) {
     }
     case "reasoning-delta":
     case "reasoning": {
-      const delta = getReasoningDeltaFromStreamChunk(c10);
+      const delta = getReasoningDeltaFromStreamChunk(c9);
       if (delta === null)
         return null;
       return {
@@ -4474,49 +4452,65 @@ function mapStreamChunkToTurnEvent(c10) {
       };
     }
     case "tool-input-start": {
-      const args = extractToolArgs(c10);
-      const hasStableToolCallId = typeof c10.toolCallId === "string" && c10.toolCallId.trim().length > 0;
+      const args = extractToolArgs(c9);
+      const hasStableToolCallId = typeof c9.toolCallId === "string" && c9.toolCallId.trim().length > 0;
       if (hasStableToolCallId && !hasRenderableToolArgs(args))
         return null;
       return {
         type: "tool-call-start",
-        toolCallId: String(c10.toolCallId ?? ""),
-        toolName: String(c10.toolName ?? ""),
+        toolCallId: String(c9.toolCallId ?? ""),
+        toolName: String(c9.toolName ?? ""),
         args
       };
     }
+    case "tool-input-delta": {
+      let delta = "";
+      if (typeof c9.inputTextDelta === "string") {
+        delta = c9.inputTextDelta;
+      } else if (typeof c9.delta === "string") {
+        delta = c9.delta;
+      }
+      if (!delta)
+        return null;
+      return {
+        type: "tool-input-delta",
+        toolCallId: String(c9.toolCallId ?? c9.id ?? ""),
+        toolName: String(c9.toolName ?? ""),
+        inputTextDelta: delta
+      };
+    }
     case "tool-call": {
       return {
         type: "tool-call-start",
-        toolCallId: String(c10.toolCallId ?? ""),
-        toolName: String(c10.toolName ?? ""),
-        args: extractToolArgs(c10)
+        toolCallId: String(c9.toolCallId ?? ""),
+        toolName: String(c9.toolName ?? ""),
+        args: extractToolArgs(c9)
       };
     }
     case "tool-result": {
       let result;
-      if ("output" in c10)
-        result = c10.output;
-      else if ("result" in c10)
-        result = c10.result;
+      if ("output" in c9)
+        result = c9.output;
+      else if ("result" in c9)
+        result = c9.result;
       return {
         type: "tool-result",
-        toolCallId: String(c10.toolCallId ?? ""),
-        toolName: String(c10.toolName ?? ""),
+        toolCallId: String(c9.toolCallId ?? ""),
+        toolName: String(c9.toolName ?? ""),
         result,
-        isError: "isError" in c10 ? Boolean(c10.isError) : false
+        isError: "isError" in c9 ? Boolean(c9.isError) : false
       };
     }
     case "tool-error":
       return {
         type: "tool-result",
-        toolCallId: String(c10.toolCallId ?? ""),
-        toolName: String(c10.toolName ?? ""),
-        result: c10.error ?? "Tool execution failed",
+        toolCallId: String(c9.toolCallId ?? ""),
+        toolName: String(c9.toolName ?? ""),
+        result: c9.error ?? "Tool execution failed",
         isError: true
       };
     case "error": {
-      throw normalizeUnknownError(c10.error);
+      throw normalizeUnknownError(c9.error);
     }
     default:
       return null;
@@ -4532,9 +4526,9 @@ function toCoreTool(def) {
   return dynamicTool({
     description: def.description,
     inputSchema: schema,
-    execute: async (input) => {
+    execute: async (input, { abortSignal }) => {
       try {
-        return await def.execute(input);
+        return await def.execute(input, abortSignal ? { signal: abortSignal } : undefined);
       } catch (err) {
         throw normalizeUnknownError(err);
       }
@@ -4685,6 +4679,7 @@ class StreamToolCallTracker {
   syntheticCount = 0;
   pendingByTool = new Map;
   deferredStartsByTool = new Map;
+  toolNameById = new Map;
   prepare(chunk) {
     const type = chunk.type;
     if (!type) {
@@ -4693,6 +4688,8 @@ class StreamToolCallTracker {
     if (type === "tool-input-start") {
       const toolName = normalizeToolName(chunk.toolName);
       const toolCallId = normalizeStringId(chunk.toolCallId);
+      if (toolCallId && toolName)
+        this.toolNameById.set(toolCallId, toolName);
       const args = extractToolArgs(chunk);
       if (!hasRenderableToolArgs(args)) {
         if (!toolCallId) {
@@ -4727,6 +4724,16 @@ class StreamToolCallTracker {
         suppressTurnEvent: false
       };
     }
+    if (type === "tool-input-delta") {
+      const id = normalizeStringId(chunk.id ?? chunk.toolCallId);
+      const toolName = id ? this.toolNameById.get(id) : undefined;
+      if (toolName) {
+        return {
+          chunk: { ...chunk, toolName, toolCallId: id },
+          suppressTurnEvent: false
+        };
+      }
+    }
     return { chunk, suppressTurnEvent: false };
   }
   trackRenderableStart(chunk, toolName, existingToolCallId) {
@@ -4788,18 +4795,6 @@ async function* mapFullStreamToTurnEvents(stream, opts) {
         yield { type: "context-pruned", ...rec };
       }
     }
-    if (originalChunk.type === "file" && opts.cwd) {
-      const fileData = originalChunk.file;
-      if (fileData?.uint8Array) {
-        const filePath = await saveGeneratedFile(fileData, opts.cwd);
-        yield {
-          type: "file-generated",
-          filePath,
-          mediaType: fileData.mediaType
-        };
-        continue;
-      }
-    }
     const prepared = toolCallTracker.prepare(originalChunk);
     const chunk = prepared.chunk;
     const route = textPhaseTracker.route(chunk);
@@ -4892,11 +4887,34 @@ function getMessageDiagnostics(messages) {
     }
   };
 }
+function collectPrunableToolNames(messages) {
+  const names = new Set;
+  for (const message of messages) {
+    if (!Array.isArray(message.content))
+      continue;
+    for (const part of message.content) {
+      if (!isRecord(part))
+        continue;
+      const partRecord = part;
+      const toolName = partRecord.toolName;
+      if (typeof toolName !== "string" || toolName.length === 0)
+        continue;
+      if (toolName === "readSkill")
+        continue;
+      names.add(toolName);
+    }
+  }
+  return [...names].sort((a, b) => a.localeCompare(b));
+}
+function buildToolCallPruning(messages, type) {
+  const tools = collectPrunableToolNames(messages);
+  return tools.length === 0 ? "none" : [{ type, tools }];
+}
 function applyContextPruning(messages) {
   return pruneMessages({
     messages,
     reasoning: "before-last-message",
-    toolCalls: "before-last-40-messages",
+    toolCalls: buildToolCallPruning(messages, "before-last-40-messages"),
     emptyMessages: "remove"
   });
 }
@@ -4905,7 +4923,7 @@ function applyStepPruning(messages, initialMessageCount) {
   return pruneMessages({
     messages,
     reasoning: "none",
-    toolCalls: `before-last-${40 + newMessageCount}-messages`,
+    toolCalls: buildToolCallPruning(messages, `before-last-${40 + newMessageCount}-messages`),
     emptyMessages: "remove"
   });
 }
@@ -5086,26 +5104,10 @@ function prepareTurnMessages(input) {
       diagnostics: getMessageDiagnostics(compacted)
     });
   }
-  let finalMessages = compacted;
-  let finalSystemPrompt = systemPrompt;
-  if (isAnthropicModelFamily(modelString) && isAnthropicOAuth()) {
-    const ccIdentity = "You are Claude Code, Anthropic's official CLI for Claude.";
-    const systemMessages = [
-      { role: "system", content: ccIdentity }
-    ];
-    if (finalSystemPrompt) {
-      systemMessages.push({
-        role: "system",
-        content: finalSystemPrompt
-      });
-      finalSystemPrompt = undefined;
-    }
-    finalMessages = [...systemMessages, ...finalMessages];
-  }
   const wasPruned = postStats.messageCount < preStats.messageCount;
   return {
-    messages: finalMessages,
-    systemPrompt: finalSystemPrompt,
+    messages: compacted,
+    systemPrompt,
     pruned: wasPruned,
     prePruneMessageCount: preStats.messageCount,
     prePruneTotalBytes: preStats.totalBytes,
@@ -5220,12 +5222,6 @@ function buildTurnProviderOptions(input) {
   const thinkingOpts = thinkingEffort ? getThinkingProviderOptions(modelString, thinkingEffort) : null;
   const reasoningSummaryRequested = isRecord(thinkingOpts) && isRecord(thinkingOpts.openai) && typeof thinkingOpts.openai.reasoningSummary === "string";
   const cacheFamily = getCacheFamily(modelString);
-  const googleOpts = isGeminiModelFamily(modelString) ? {
-    google: {
-      responseModalities: ["TEXT", "IMAGE"],
-      ...isRecord(thinkingOpts?.google) ? thinkingOpts.google : {}
-    }
-  } : {};
   const providerOptions = {
     ...thinkingOpts ?? {},
     ...isOpenAIGPT(modelString) ? {
@@ -5233,8 +5229,7 @@ function buildTurnProviderOptions(input) {
         store: false,
         ...isRecord(thinkingOpts?.openai) ? thinkingOpts.openai : {}
       }
-    } : {},
-    ...googleOpts
+    } : {}
   };
   return {
     cacheFamily,
@@ -5312,8 +5307,7 @@ async function* runTurn(options) {
     tools,
     systemPrompt,
     signal,
-    thinkingEffort,
-    cwd
+    thinkingEffort
   } = options;
   const rawToolSet = buildToolSet(tools);
   const toolSet = annotateToolCaching(rawToolSet, modelString);
@@ -5364,7 +5358,6 @@ async function* runTurn(options) {
     result.response.catch(() => {});
     for await (const event of mapFullStreamToTurnEvents(result.fullStream, {
       stepPruneQueue,
-      ...cwd ? { cwd } : {},
       onChunk: (streamChunk) => {
         if (streamChunk.type === "tool-call" || streamChunk.type === "tool-result") {
           logApiEvent("stream chunk", {
@@ -5407,7 +5400,7 @@ async function* runTurn(options) {
 }
 // src/session/manager.ts
-import * as c10 from "yoctocolors";
+import * as c9 from "yoctocolors";
 function newSession(model, cwd) {
   const id = generateSessionId();
   const row = createSession({ id, cwd, model });
@@ -5442,21 +5435,21 @@ function renderSessionTable(footer) {
   if (sessions.length === 0)
     return false;
   writeln(`
-${c10.bold("Recent sessions:")}`);
+${c9.bold("Recent sessions:")}`);
   for (const s of sessions) {
     const date = new Date(s.updated_at).toLocaleString();
     const cwd = tildePath(s.cwd);
-    const title = s.title || c10.dim("(untitled)");
-    writeln(`  ${c10.dim(s.id.padEnd(14))} ${title.padEnd(30)} ${c10.cyan(s.model.split("/").pop() ?? s.model).padEnd(20)} ${c10.dim(cwd)}  ${c10.dim(date)}`);
+    const title = s.title || c9.dim("(untitled)");
+    writeln(`  ${c9.dim(s.id.padEnd(14))} ${title.padEnd(30)} ${c9.cyan(s.model.split("/").pop() ?? s.model).padEnd(20)} ${c9.dim(cwd)}  ${c9.dim(date)}`);
   }
   writeln(`
 ${footer}`);
   return true;
 }
 function printSessionList() {
-  const shown = renderSessionTable(`${c10.dim("Use")} mc --resume <id> ${c10.dim("to continue a session.")}`);
+  const shown = renderSessionTable(`${c9.dim("Use")} mc --resume <id> ${c9.dim("to continue a session.")}`);
   if (!shown)
-    writeln(c10.dim("No sessions found."));
+    writeln(c9.dim("No sessions found."));
 }
 function getMostRecentSession() {
   const sessions = listSessions(1);
@@ -5564,6 +5557,12 @@ Guidelines:
 - Make parallel tool calls when the lookups are independent \u2014 this speeds up multi-file investigation.
 - Before starting work, scan the skills list below. If there is even a small chance a skill applies to your task, load it with \`readSkill\` and follow its instructions before writing code or responding. Skills are mandatory when they match \u2014 not optional references.
 - Keep it simple: DRY, KISS, YAGNI. Avoid unnecessary complexity.
+- Apply Rob Pike's 5 Rules of Programming:
+  1. You can't tell where a program is going to spend its time. Bottlenecks occur in surprising places, so don't try to second guess and put in a speed hack until you've proven that's where the bottleneck is.
+  2. Measure. Don't tune for speed until you've measured, and even then don't unless one part of the code overwhelms the rest.
+  3. Fancy algorithms are slow when n is small, and n is usually small. Fancy algorithms have big constants. Until you know that n is frequently going to be big, don't get fancy. (Even if n does get big, use Rule 2 first.)
+  4. Fancy algorithms are buggier than simple ones, and they're much harder to implement. Use simple algorithms as well as simple data structures.
+  5. Data dominates. If you've chosen the right data structures and organized things well, the algorithms will almost always be self-evident. Data structures, not algorithms, are central to programming.
 # File editing with mc-edit
 \`mc-edit\` applies one exact-text replacement per invocation. It fails deterministically if the old text is missing or matches more than once.
@@ -5687,7 +5686,7 @@ class SessionRunner {
       }
       this.session = resumed;
       this.currentModel = this.session.model;
-      this.reporter.info(`Resumed session ${this.session.id} (${c11.cyan(this.currentModel)})`);
+      this.reporter.info(`Resumed session ${this.session.id} (${c10.cyan(this.currentModel)})`);
     } else {
       this.session = newSession(this.currentModel, this.cwd);
     }
@@ -5780,8 +5779,7 @@ ${output}
           tools: this.tools,
           ...systemPrompt ? { systemPrompt } : {},
           signal: abortController.signal,
-          ...this.currentThinkingEffort ? { thinkingEffort: this.currentThinkingEffort } : {},
-          cwd: this.cwd
+          ...this.currentThinkingEffort ? { thinkingEffort: this.currentThinkingEffort } : {}
         });
         const { inputTokens, outputTokens, contextTokens, newMessages } = await this.reporter.renderTurn(events, {
           showReasoning: this.showReasoning,
@@ -5884,7 +5882,7 @@ import { z as z3 } from "zod";
 // src/internal/file-edit/command.ts
 import { existsSync as existsSync4 } from "fs";
-import { dirname as dirname3, extname, join as join7 } from "path";
+import { dirname as dirname3, extname, join as join6 } from "path";
 import { fileURLToPath } from "url";
 function quoteShellArg(value) {
   return `'${value.replaceAll("'", `'\\''`)}'`;
@@ -5896,7 +5894,7 @@ function resolveSiblingFileEditScript(scriptPath) {
   const mainDir = dirname3(scriptPath);
   const mainBase = scriptPath.slice(mainDir.length + 1);
   if (mainBase === `index${ext}` || mainBase === `mc${ext}`) {
-    return join7(mainDir, `mc-edit${ext}`);
+    return join6(mainDir, `mc-edit${ext}`);
   }
   return null;
 }
@@ -5905,7 +5903,7 @@ function resolveModuleLocalFileEditScript(moduleUrl) {
   const ext = extname(modulePath);
   if (!ext)
     return null;
-  const helperPath = join7(dirname3(modulePath), "..", "..", `mc-edit${ext}`);
+  const helperPath = join6(dirname3(modulePath), "..", "..", `mc-edit${ext}`);
   return existsSync4(helperPath) ? helperPath : null;
 }
 function resolveProcessScriptPath(mainModule, argv1) {
@@ -5937,8 +5935,8 @@ var ShellSchema = z3.object({
   timeout: z3.number().int().min(1000).nullable().describe("Timeout in milliseconds. If omitted, the command runs until it exits."),
   env: z3.record(z3.string(), z3.string()).nullable().describe("Additional environment variables to set")
 });
-var MAX_OUTPUT_BYTES = 1e4;
-async function runShellCommand(input) {
+var MAX_OUTPUT_BYTES = 24000;
+async function runShellCommand(input, options) {
   const cwd = input.cwd ?? process.cwd();
   const timeout = input.timeout ?? undefined;
   const inputEnv = input.env ?? undefined;
@@ -5960,8 +5958,7 @@ ${input.command}`], {
     stdout: "pipe",
     stderr: "pipe"
   });
-  const timer = timeout ? setTimeout(() => {
-    timedOut = true;
+  function killProc() {
     try {
       proc.kill("SIGTERM");
       setTimeout(() => {
@@ -5973,7 +5970,20 @@ ${input.command}`], {
     for (const reader of readers) {
       reader.cancel().catch(() => {});
     }
+  }
+  const timer = timeout ? setTimeout(() => {
+    timedOut = true;
+    killProc();
   }, timeout) : undefined;
+  const abortSignal = options?.signal;
+  const onAbort = () => {
+    killProc();
+  };
+  if (abortSignal?.aborted) {
+    onAbort();
+  } else {
+    abortSignal?.addEventListener("abort", onAbort, { once: true });
+  }
   async function collectStream(stream) {
     const reader = stream.getReader();
     readers.push(reader);
@@ -6017,6 +6027,7 @@ ${input.command}`], {
   } finally {
     if (timer)
       clearTimeout(timer);
+    abortSignal?.removeEventListener("abort", onAbort);
     restoreTerminal();
     if (wasRaw) {
       try {
@@ -6041,7 +6052,7 @@ var shellTool = {
   name: "shell",
   description: "Execute a shell command. Returns stdout, stderr, and exit code. " + "Use this for reading/searching code, running tests, builds, git commands, and invoking `mc-edit` for partial file edits. " + "Prefer non-interactive commands. Avoid commands that run indefinitely.",
   schema: ShellSchema,
-  execute: runShellCommand
+  execute: (input, options) => runShellCommand(input, options)
 };
 // src/agent/tools.ts
@@ -6049,11 +6060,11 @@ function withCwdDefault(tool, cwd) {
   const originalExecute = tool.execute;
   return {
     ...tool,
-    execute: async (input) => {
+    execute: async (input, options) => {
       const patched = typeof input === "object" && input !== null ? input : {};
       if (patched.cwd === undefined)
         patched.cwd = cwd;
-      return originalExecute(patched);
+      return originalExecute(patched, options);
     }
   };
 }
@@ -6096,7 +6107,7 @@ async function initAgent(opts) {
   for (const row of listMcpServers()) {
     try {
       await connectAndAddMcp(row.name);
-      opts.reporter.info(`MCP: connected ${c12.cyan(row.name)}`);
+      opts.reporter.info(`MCP: connected ${c11.cyan(row.name)}`);
     } catch (e) {
       opts.reporter.error(`MCP: failed to connect ${row.name}: ${String(e)}`);
     }
@@ -6154,7 +6165,7 @@ async function initAgent(opts) {
 }
 // src/cli/args.ts
-import * as c13 from "yoctocolors";
+import * as c12 from "yoctocolors";
 function parseArgs(argv) {
   const args = {
     model: null,
@@ -6203,11 +6214,11 @@ function parseArgs(argv) {
   return args;
 }
 function printHelp() {
-  writeln(`${c13.bold("mini-coder")} \u2014 a small, fast CLI coding agent
+  writeln(`${c12.bold("mini-coder")} \u2014 a small, fast CLI coding agent
 `);
-  writeln(`${c13.bold("Usage:")}  mc [options] [prompt]
+  writeln(`${c12.bold("Usage:")}  mc [options] [prompt]
 `);
-  writeln(`${c13.bold("Options:")}`);
+  writeln(`${c12.bold("Options:")}`);
   const opts = [
     ["-m, --model <id>", "Model to use (e.g. zen/claude-sonnet-4-6)"],
     ["-c, --continue", "Continue the most recent session"],
@@ -6217,10 +6228,10 @@ function printHelp() {
     ["-h, --help", "Show this help"]
   ];
   for (const [flag, desc] of opts) {
-    writeln(`  ${c13.cyan((flag ?? "").padEnd(22))} ${c13.dim(desc ?? "")}`);
+    writeln(`  ${c12.cyan((flag ?? "").padEnd(22))} ${c12.dim(desc ?? "")}`);
   }
   writeln(`
-${c13.bold("Provider env vars:")}`);
+${c12.bold("Provider env vars:")}`);
   const envs = [
     ["OPENCODE_API_KEY", "OpenCode Zen (recommended)"],
     ["ANTHROPIC_API_KEY", "Anthropic direct"],
@@ -6231,62 +6242,19 @@ ${c13.bold("Provider env vars:")}`);
     ["OLLAMA_BASE_URL", "Ollama base URL (default: http://localhost:11434)"]
   ];
   for (const [env, desc] of envs) {
-    writeln(`  ${c13.yellow((env ?? "").padEnd(22))} ${c13.dim(desc ?? "")}`);
+    writeln(`  ${c12.yellow((env ?? "").padEnd(22))} ${c12.dim(desc ?? "")}`);
   }
   writeln(`
-${c13.bold("Examples:")}`);
-  writeln(`  mc                           ${c13.dim("# interactive session")}`);
-  writeln(`  mc "explain this codebase"   ${c13.dim("# one-shot prompt then exit")}`);
-  writeln(`  mc -c                        ${c13.dim("# continue last session")}`);
-  writeln(`  mc -m ollama/llama3.2        ${c13.dim("# use local Ollama model")}`);
-  writeln(`  mc -l                        ${c13.dim("# list sessions")}`);
-}
-// src/cli/bootstrap.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync2, writeFileSync } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join8 } from "path";
-import * as c14 from "yoctocolors";
-var REVIEW_SKILL_CONTENT = `---
-name: review
-description: "Review recent changes for correctness, code quality, and performance. Use when the user asks to review, check, or audit recent code changes, diffs, or pull requests."
-context: fork
----
-Review recent changes and provide actionable feedback.
-## Steps
-1. Identify the changes to review \u2014 check \`git diff\`, \`git log\`, and staged files.
-2. Read the changed files and understand the intent behind each change.
-3. Evaluate each change against the criteria below.
-4. Output a concise summary with only the issues found. If nothing is wrong, say so.
-## Review criteria
-- **Correctness** \u2014 Are the changes aligned with their stated goal? Do they introduce bugs or regressions?
-- **Code quality** \u2014 Is there duplicate, dead, or overly complex code? Are abstractions appropriate?
-- **Performance** \u2014 Are there unnecessary allocations, redundant I/O, or algorithmic concerns?
-- **Edge cases** \u2014 Are boundary conditions and error paths handled?
-## Guidelines
-- Never flag style choices as bugs \u2014 don't be a zealot.
-- Never flag false positives \u2014 verify before raising an issue.
-- Keep feedback actionable: say what's wrong and suggest a fix.
-`;
-function bootstrapGlobalDefaults() {
-  const skillDir = join8(homedir6(), ".agents", "skills", "review");
-  const skillPath = join8(skillDir, "SKILL.md");
-  if (!existsSync5(skillPath)) {
-    mkdirSync2(skillDir, { recursive: true });
-    writeFileSync(skillPath, REVIEW_SKILL_CONTENT, "utf-8");
-    writeln(`${c14.green("\u2713")} created ${c14.dim("~/.agents/skills/review/SKILL.md")} ${c14.dim("(edit it to customise your reviews)")}`);
-  }
+${c12.bold("Examples:")}`);
+  writeln(`  mc                           ${c12.dim("# interactive session")}`);
+  writeln(`  mc "explain this codebase"   ${c12.dim("# one-shot prompt then exit")}`);
+  writeln(`  mc -c                        ${c12.dim("# continue last session")}`);
+  writeln(`  mc -m ollama/llama3.2        ${c12.dim("# use local Ollama model")}`);
+  writeln(`  mc -l                        ${c12.dim("# list sessions")}`);
 }
 // src/cli/file-refs.ts
-import { join as join9 } from "path";
+import { join as join7 } from "path";
 async function resolveFileRefs(text, cwd) {
   const atPattern = /@([\w./\-_]+)/g;
   let result = text;
@@ -6296,7 +6264,7 @@ async function resolveFileRefs(text, cwd) {
     const ref = match[1];
     if (!ref)
       continue;
-    const filePath = ref.startsWith("/") ? ref : join9(cwd, ref);
+    const filePath = ref.startsWith("/") ? ref : join7(cwd, ref);
     if (isImageFilename(ref)) {
       const attachment = await loadImageFile(filePath);
       if (attachment) {
@@ -6318,25 +6286,25 @@ ${content}
 }
 // src/cli/input-loop.ts
-import * as c21 from "yoctocolors";
+import * as c19 from "yoctocolors";
 // src/cli/commands.ts
 import { randomBytes } from "crypto";
-import { unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
+import { unlinkSync, writeFileSync } from "fs";
 import { tmpdir } from "os";
-import { join as join10 } from "path";
-import * as c20 from "yoctocolors";
+import { join as join8 } from "path";
+import * as c18 from "yoctocolors";
 // src/cli/commands-help.ts
-import * as c15 from "yoctocolors";
+import * as c13 from "yoctocolors";
 function renderEntries(entries) {
   for (const [label, description] of entries) {
-    writeln(`  ${c15.cyan(label.padEnd(28))} ${c15.dim(description)}`);
+    writeln(`  ${c13.cyan(label.padEnd(28))} ${c13.dim(description)}`);
   }
 }
 function renderHelpCommand(ctx) {
   writeln();
-  writeln(`  ${c15.dim("session")}`);
+  writeln(`  ${c13.dim("session")}`);
   renderEntries([
     ["/session [id]", "list sessions or switch to one"],
     ["/new", "start a fresh session"],
@@ -6344,7 +6312,7 @@ function renderHelpCommand(ctx) {
     ["/exit", "quit"]
   ]);
   writeln();
-  writeln(`  ${c15.dim("model + context")}`);
+  writeln(`  ${c13.dim("model + context")}`);
   renderEntries([
     ["/model [id]", "list or switch models"],
     ["/reasoning [on|off]", "toggle reasoning display"],
@@ -6352,12 +6320,12 @@ function renderHelpCommand(ctx) {
     ["/mcp list", "list MCP servers"],
     ["/mcp add <n> <t> [u]", "add an MCP server"],
     ["/mcp remove <name>", "remove an MCP server"],
-    ["/login [provider]", "login via OAuth (e.g. anthropic)"],
+    ["/login [provider]", "login via OAuth (e.g. openai)"],
     ["/logout <provider>", "clear OAuth tokens"],
     ["/help", "show this help"]
   ]);
   writeln();
-  writeln(`  ${c15.dim("prompt")}`);
+  writeln(`  ${c13.dim("prompt")}`);
   renderEntries([
     ["ask normally", "send a prompt to the current agent"],
     ["!cmd", "run a shell command and keep the result in context"],
@@ -6367,44 +6335,44 @@ function renderHelpCommand(ctx) {
   const skills = loadSkillsIndex(ctx.cwd);
   if (skills.size > 0) {
     writeln();
-    writeln(`  ${c15.dim("skills")}`);
+    writeln(`  ${c13.dim("skills")}`);
     for (const skill of skills.values()) {
-      const source = skill.source === "local" ? c15.dim("local") : c15.dim("global");
+      const source = skill.source === "local" ? c13.dim("local") : c13.dim("global");
       const desc = truncateText(skill.description, 80);
-      writeln(`  ${c15.green(`/${skill.name}`.padEnd(28))} ${c15.dim(desc)} ${c15.dim("\xB7")} ${source}`);
+      writeln(`  ${c13.green(`/${skill.name}`.padEnd(28))} ${c13.dim(desc)} ${c13.dim("\xB7")} ${source}`);
     }
   }
   writeln();
-  writeln(`  ${c15.dim("keys")}  ${c15.dim("esc")} cancel response  ${c15.dim("\xB7")}  ${c15.dim("ctrl+c / ctrl+d")} exit  ${c15.dim("\xB7")}  ${c15.dim("ctrl+r")} history search  ${c15.dim("\xB7")}  ${c15.dim("\u2191\u2193")} history`);
+  writeln(`  ${c13.dim("keys")}  ${c13.dim("esc")} cancel response  ${c13.dim("\xB7")}  ${c13.dim("ctrl+c / ctrl+d")} exit  ${c13.dim("\xB7")}  ${c13.dim("ctrl+r")} history search  ${c13.dim("\xB7")}  ${c13.dim("\u2191\u2193")} history`);
   writeln();
 }
 // src/cli/commands-login.ts
-import * as c16 from "yoctocolors";
+import * as c14 from "yoctocolors";
 function renderLoginHelp() {
   writeln();
-  writeln(`  ${c16.dim("usage:")}`);
-  writeln(`    /login                 ${c16.dim("show login status")}`);
-  writeln(`    /login <provider>      ${c16.dim("login via OAuth")}`);
-  writeln(`    /logout <provider>     ${c16.dim("clear saved tokens")}`);
+  writeln(`  ${c14.dim("usage:")}`);
+  writeln(`    /login                 ${c14.dim("show login status")}`);
+  writeln(`    /login <provider>      ${c14.dim("login via OAuth")}`);
+  writeln(`    /logout <provider>     ${c14.dim("clear saved tokens")}`);
   writeln();
-  writeln(`  ${c16.dim("providers:")}`);
+  writeln(`  ${c14.dim("providers:")}`);
   for (const p of getOAuthProviders()) {
-    const status = isLoggedIn(p.id) ? c16.green("logged in") : c16.dim("not logged in");
-    writeln(`    ${c16.cyan(p.id.padEnd(20))} ${p.name} ${c16.dim("\xB7")} ${status}`);
+    const status = isLoggedIn(p.id) ? c14.green("logged in") : c14.dim("not logged in");
+    writeln(`    ${c14.cyan(p.id.padEnd(20))} ${p.name} ${c14.dim("\xB7")} ${status}`);
   }
   writeln();
 }
 function renderStatus() {
   const loggedIn = listLoggedInProviders();
   if (loggedIn.length === 0) {
-    writeln(`${PREFIX.info} ${c16.dim("no OAuth logins \u2014 use")} /login <provider>`);
+    writeln(`${PREFIX.info} ${c14.dim("no OAuth logins \u2014 use")} /login <provider>`);
     return;
   }
   for (const id of loggedIn) {
     const provider = getOAuthProvider(id);
     const name = provider?.name ?? id;
-    writeln(`${PREFIX.success} ${c16.cyan(id)} ${c16.dim(name)}`);
+    writeln(`${PREFIX.success} ${c14.cyan(id)} ${c14.dim(name)}`);
   }
 }
 async function handleLoginCommand(ctx, args) {
@@ -6425,7 +6393,7 @@ async function handleLoginCommand(ctx, args) {
   if (isLoggedIn(providerId)) {
     const token = await getAccessToken(providerId);
     if (token) {
-      writeln(`${PREFIX.success} already logged in to ${c16.cyan(provider.name)}`);
+      writeln(`${PREFIX.success} already logged in to ${c14.cyan(provider.name)}`);
       return;
     }
   }
@@ -6436,7 +6404,7 @@ async function handleLoginCommand(ctx, args) {
         ctx.stopSpinner();
         writeln(`${PREFIX.info} ${instructions}`);
         writeln();
-        writeln(`  ${c16.cyan(url)}`);
+        writeln(`  ${c14.cyan(url)}`);
         writeln();
         let open = "xdg-open";
         if (process.platform === "darwin")
@@ -6448,12 +6416,12 @@ async function handleLoginCommand(ctx, args) {
       },
       onProgress: (msg) => {
         ctx.stopSpinner();
-        writeln(`${PREFIX.info} ${c16.dim(msg)}`);
+        writeln(`${PREFIX.info} ${c14.dim(msg)}`);
         ctx.startSpinner("exchanging tokens");
       }
     });
     ctx.stopSpinner();
-    writeln(`${PREFIX.success} logged in to ${c16.cyan(provider.name)}`);
+    writeln(`${PREFIX.success} logged in to ${c14.cyan(provider.name)}`);
   } catch (err) {
     ctx.stopSpinner();
     writeln(`${PREFIX.error} login failed: ${err.message}`);
@@ -6465,16 +6433,21 @@ function handleLogoutCommand(_ctx, args) {
     writeln(`${PREFIX.error} usage: /logout <provider>`);
     return;
   }
+  const provider = getOAuthProvider(providerId);
+  if (!provider) {
+    writeln(`${PREFIX.error} unknown provider "${providerId}" \u2014 available: ${getOAuthProviders().map((p) => p.id).join(", ")}`);
+    return;
+  }
   if (!isLoggedIn(providerId)) {
-    writeln(`${PREFIX.info} ${c16.dim("not logged in to")} ${providerId}`);
+    writeln(`${PREFIX.info} ${c14.dim("not logged in to")} ${providerId}`);
     return;
   }
   logout(providerId);
-  writeln(`${PREFIX.success} logged out of ${c16.cyan(providerId)}`);
+  writeln(`${PREFIX.success} logged out of ${c14.cyan(provider.id)}`);
 }
 // src/cli/commands-mcp.ts
-import * as c17 from "yoctocolors";
+import * as c15 from "yoctocolors";
 async function handleMcpCommand(ctx, args) {
   const parts = args.trim().split(/\s+/);
   const sub = parts[0] ?? "list";
@@ -6482,15 +6455,15 @@ async function handleMcpCommand(ctx, args) {
     case "list": {
       const servers = listMcpServers();
       if (servers.length === 0) {
-        writeln(c17.dim("  no MCP servers configured"));
-        writeln(c17.dim("  /mcp add <name> http <url>  \xB7  /mcp add <name> stdio <cmd> [args...]"));
+        writeln(c15.dim("  no MCP servers configured"));
+        writeln(c15.dim("  /mcp add <name> http <url>  \xB7  /mcp add <name> stdio <cmd> [args...]"));
         return;
       }
       writeln();
       for (const s of servers) {
         const detailText = s.url ?? s.command ?? "";
-        const detail = detailText ? c17.dim(`  ${detailText}`) : "";
-        writeln(`  ${c17.yellow("\u2699")} ${c17.bold(s.name)}  ${c17.dim(s.transport)}${detail}`);
+        const detail = detailText ? c15.dim(`  ${detailText}`) : "";
+        writeln(`  ${c15.yellow("\u2699")} ${c15.bold(s.name)}  ${c15.dim(s.transport)}${detail}`);
       }
       return;
     }
@@ -6535,9 +6508,9 @@ async function handleMcpCommand(ctx, args) {
       }
       try {
         await ctx.connectMcpServer(name);
-        writeln(`${PREFIX.success} mcp server ${c17.cyan(name)} added and connected`);
+        writeln(`${PREFIX.success} mcp server ${c15.cyan(name)} added and connected`);
       } catch (e) {
-        writeln(`${PREFIX.success} mcp server ${c17.cyan(name)} saved  ${c17.dim(`(connection failed: ${String(e)})`)}`);
+        writeln(`${PREFIX.success} mcp server ${c15.cyan(name)} saved  ${c15.dim(`(connection failed: ${String(e)})`)}`);
       }
       return;
     }
@@ -6549,17 +6522,17 @@ async function handleMcpCommand(ctx, args) {
         return;
       }
       deleteMcpServer(name);
-      writeln(`${PREFIX.success} mcp server ${c17.cyan(name)} removed`);
+      writeln(`${PREFIX.success} mcp server ${c15.cyan(name)} removed`);
       return;
     }
     default:
       writeln(`${PREFIX.error} unknown: /mcp ${sub}`);
-      writeln(c17.dim("  subcommands: list \xB7 add \xB7 remove"));
+      writeln(c15.dim("  subcommands: list \xB7 add \xB7 remove"));
   }
 }
 // src/cli/commands-model.ts
-import * as c18 from "yoctocolors";
+import * as c16 from "yoctocolors";
 import { select } from "yoctoselect";
 var THINKING_EFFORTS = ["low", "medium", "high", "xhigh"];
 function parseThinkingEffort(value) {
@@ -6579,21 +6552,21 @@ function renderModelUpdatedMessage(ctx, modelId, effortArg) {
   if (effortArg) {
     if (effortArg === "off") {
       ctx.setThinkingEffort(null);
-      writeln(`${PREFIX.success} model \u2192 ${c18.cyan(modelId)} ${c18.dim("(thinking disabled)")}`);
+      writeln(`${PREFIX.success} model \u2192 ${c16.cyan(modelId)} ${c16.dim("(thinking disabled)")}`);
       return;
     }
     const effort = parseThinkingEffort(effortArg);
     if (effort) {
       ctx.setThinkingEffort(effort);
-      writeln(`${PREFIX.success} model \u2192 ${c18.cyan(modelId)} ${c18.dim(`(\u2726 ${effort})`)}`);
+      writeln(`${PREFIX.success} model \u2192 ${c16.cyan(modelId)} ${c16.dim(`(\u2726 ${effort})`)}`);
       return;
     }
-    writeln(`${PREFIX.success} model \u2192 ${c18.cyan(modelId)}`);
-    writeln(`${PREFIX.error} unknown effort level ${c18.cyan(effortArg)} (use low, medium, high, xhigh, off)`);
+    writeln(`${PREFIX.success} model \u2192 ${c16.cyan(modelId)}`);
+    writeln(`${PREFIX.error} unknown effort level ${c16.cyan(effortArg)} (use low, medium, high, xhigh, off)`);
     return;
   }
-  const effortTag = ctx.thinkingEffort ? c18.dim(` (\u2726 ${ctx.thinkingEffort})`) : "";
-  writeln(`${PREFIX.success} model \u2192 ${c18.cyan(modelId)}${effortTag}`);
+  const effortTag = ctx.thinkingEffort ? c16.dim(` (\u2726 ${ctx.thinkingEffort})`) : "";
+  writeln(`${PREFIX.success} model \u2192 ${c16.cyan(modelId)}${effortTag}`);
 }
 async function handleModelSet(ctx, args) {
   const parts = args.trim().split(/\s+/).filter(Boolean);
@@ -6606,7 +6579,7 @@ async function handleModelSet(ctx, args) {
     const snapshot = await fetchAvailableModels();
     const match = findModelIdByAlias(idArg, snapshot.models.map((model) => model.id));
     if (!match) {
-      writeln(`${PREFIX.error} unknown model ${c18.cyan(idArg)}  ${c18.dim("\u2014 run /models for the full list")}`);
+      writeln(`${PREFIX.error} unknown model ${c16.cyan(idArg)}  ${c16.dim("\u2014 run /models for the full list")}`);
       return;
     }
     modelId = match;
@@ -6626,7 +6599,7 @@ function handleModelEffort(ctx, effortArg) {
     return;
   }
   ctx.setThinkingEffort(effort);
-  writeln(`${PREFIX.success} thinking effort \u2192 ${c18.cyan(effort)}`);
+  writeln(`${PREFIX.success} thinking effort \u2192 ${c16.cyan(effort)}`);
 }
 async function handleModelSelect(ctx) {
   ctx.startSpinner("fetching models");
@@ -6634,20 +6607,20 @@ async function handleModelSelect(ctx) {
   ctx.stopSpinner();
   if (snapshot.models.length === 0) {
     writeln(`${PREFIX.error} No models found. Check your API keys or Ollama connection.`);
-    writeln(c18.dim("  Set OPENCODE_API_KEY for Zen, or start Ollama for local models."));
+    writeln(c16.dim("  Set OPENCODE_API_KEY for Zen, or start Ollama for local models."));
     return;
   }
   if (snapshot.stale) {
     const lastSync = snapshot.lastSyncAt ? new Date(snapshot.lastSyncAt).toLocaleString() : "never";
     const refreshTag = snapshot.refreshing ? " (refreshing in background)" : "";
-    writeln(c18.dim(`  model metadata is stale (last sync: ${lastSync})${refreshTag}`));
+    writeln(c16.dim(`  model metadata is stale (last sync: ${lastSync})${refreshTag}`));
   }
   const items = snapshot.models.map((model) => {
     const isCurrent = ctx.currentModel === model.id;
-    const freeTag = model.free ? c18.green(" free") : "";
-    const contextTag = model.context ? c18.dim(` ${Math.round(model.context / 1000)}k`) : "";
-    const currentTag = isCurrent ? c18.cyan(" \u25C0") : "";
-    const providerTag = c18.dim(` [${model.provider}]`);
+    const freeTag = model.free ? c16.green(" free") : "";
+    const contextTag = model.context ? c16.dim(` ${Math.round(model.context / 1000)}k`) : "";
+    const currentTag = isCurrent ? c16.cyan(" \u25C0") : "";
+    const providerTag = c16.dim(` [${model.provider}]`);
     return {
       label: `${model.displayName}${freeTag}${contextTag}${currentTag}${providerTag}`,
       value: model.id,
@@ -6680,7 +6653,7 @@ async function handleModelCommand(ctx, args) {
 }
 // src/cli/commands-session.ts
-import * as c19 from "yoctocolors";
+import * as c17 from "yoctocolors";
 import { select as select2 } from "yoctoselect";
 async function handleSessionCommand(ctx, args) {
   const id = args.trim();
@@ -6689,15 +6662,15 @@ async function handleSessionCommand(ctx, args) {
     const ok2 = ctx.switchSession(id);
     ctx.stopSpinner();
     if (ok2) {
-      writeln(`${PREFIX.success} switched to session ${c19.cyan(id)} (${c19.cyan(ctx.currentModel)})`);
+      writeln(`${PREFIX.success} switched to session ${c17.cyan(id)} (${c17.cyan(ctx.currentModel)})`);
     } else {
-      writeln(`${PREFIX.error} session ${c19.cyan(id)} not found`);
+      writeln(`${PREFIX.error} session ${c17.cyan(id)} not found`);
     }
     return;
   }
   const sessions = listSessions(50);
   if (sessions.length === 0) {
-    writeln(`${PREFIX.info} ${c19.dim("no sessions found")}`);
+    writeln(`${PREFIX.info} ${c17.dim("no sessions found")}`);
     return;
   }
   const items = sessions.map((s) => {
@@ -6706,7 +6679,7 @@ async function handleSessionCommand(ctx, args) {
     const cwd = tildePath(s.cwd);
     const date = new Date(s.updated_at).toLocaleDateString();
     return {
-      label: `${c19.dim(s.id)}  ${title}  ${c19.cyan(model)}  ${c19.dim(cwd)}  ${c19.dim(date)}`,
+      label: `${c17.dim(s.id)}  ${title}  ${c17.cyan(model)}  ${c17.dim(cwd)}  ${c17.dim(date)}`,
       value: s.id,
       filterText: `${s.id} ${s.title} ${s.model} ${s.cwd}`
     };
@@ -6722,9 +6695,9 @@ async function handleSessionCommand(ctx, args) {
     return;
   const ok = ctx.switchSession(picked);
   if (ok) {
-    writeln(`${PREFIX.success} switched to session ${c19.cyan(picked)} (${c19.cyan(ctx.currentModel)})`);
+    writeln(`${PREFIX.success} switched to session ${c17.cyan(picked)} (${c17.cyan(ctx.currentModel)})`);
   } else {
-    writeln(`${PREFIX.error} session ${c19.cyan(picked)} not found`);
+    writeln(`${PREFIX.error} session ${c17.cyan(picked)} not found`);
   }
 }
@@ -6734,9 +6707,9 @@ async function handleUndo(ctx) {
   try {
     const ok = await ctx.undoLastTurn();
     if (ok) {
-      writeln(`${PREFIX.success} ${c20.dim("last conversation turn removed")}`);
+      writeln(`${PREFIX.success} ${c18.dim("last conversation turn removed")}`);
     } else {
-      writeln(`${PREFIX.info} ${c20.dim("nothing to undo")}`);
+      writeln(`${PREFIX.info} ${c18.dim("nothing to undo")}`);
     }
   } finally {
     ctx.stopSpinner();
@@ -6794,7 +6767,7 @@ async function handleCommand(command, args, ctx) {
         if (loaded2) {
           const srcPath = skill.source === "local" ? `.agents/skills/${skill.name}/SKILL.md` : `~/.agents/skills/${skill.name}/SKILL.md`;
           if (skill.context === "fork") {
-            writeln(`${PREFIX.info} ${c20.cyan(skill.name)} ${c20.dim(`[${srcPath}] (forked subagent)`)}`);
+            writeln(`${PREFIX.info} ${c18.cyan(skill.name)} ${c18.dim(`[${srcPath}] (forked subagent)`)}`);
             writeln();
             const subagentPrompt = args ? `${loaded2.content}
@@ -6802,7 +6775,7 @@ ${args}` : loaded2.content;
             const result = await runForkedSkill(skill.name, subagentPrompt, ctx.cwd);
             return { type: "inject-user-message", text: result };
           }
-          writeln(`${PREFIX.info} ${c20.cyan(skill.name)} ${c20.dim(`[${srcPath}]`)}`);
+          writeln(`${PREFIX.info} ${c18.cyan(skill.name)} ${c18.dim(`[${srcPath}]`)}`);
           writeln();
           const prompt = args ? `${loaded2.content}
@@ -6810,16 +6783,16 @@ ${args}` : loaded2.content;
           return { type: "inject-user-message", text: prompt };
         }
       }
-      writeln(`${PREFIX.error} unknown: /${command}  ${c20.dim("\u2014 /help for commands")}`);
+      writeln(`${PREFIX.error} unknown: /${command}  ${c18.dim("\u2014 /help for commands")}`);
       return { type: "unknown", command };
     }
   }
 }
 async function runForkedSkill(skillName, prompt, cwd) {
-  const tmpFile = join10(tmpdir(), `mc-fork-${randomBytes(8).toString("hex")}.md`);
-  writeFileSync2(tmpFile, prompt, "utf8");
+  const tmpFile = join8(tmpdir(), `mc-fork-${randomBytes(8).toString("hex")}.md`);
+  writeFileSync(tmpFile, prompt, "utf8");
   try {
-    writeln(`${PREFIX.info} ${c20.dim("running subagent\u2026")}`);
+    writeln(`${PREFIX.info} ${c18.dim("running subagent\u2026")}`);
     const proc = Bun.spawn([process.execPath, Bun.main], {
       cwd,
       stdin: Bun.file(tmpFile),
@@ -6844,24 +6817,24 @@ ${stderr.trim()}`;
 ${output}`;
   } finally {
     try {
-      unlinkSync2(tmpFile);
+      unlinkSync(tmpFile);
     } catch {}
   }
 }
 function handleBooleanToggleCommand(opts) {
   const mode = opts.args.trim().toLowerCase();
   if (!mode) {
-    writeln(`${PREFIX.success} ${opts.label} ${opts.current ? c20.green("on") : c20.dim("off")}`);
+    writeln(`${PREFIX.success} ${opts.label} ${opts.current ? c18.green("on") : c18.dim("off")}`);
     return;
   }
   if (mode === "on") {
     opts.set(true);
-    writeln(`${PREFIX.success} ${opts.label} ${c20.green("on")}`);
+    writeln(`${PREFIX.success} ${opts.label} ${c18.green("on")}`);
     return;
   }
   if (mode === "off") {
     opts.set(false);
-    writeln(`${PREFIX.success} ${opts.label} ${c20.dim("off")}`);
+    writeln(`${PREFIX.success} ${opts.label} ${c18.dim("off")}`);
     return;
   }
   writeln(`${PREFIX.error} usage: ${opts.usage}`);
@@ -6921,13 +6894,12 @@ async function getGitBranch(cwd) {
 }
 async function runInputLoop(opts) {
   const { cwd, reporter, cmdCtx, runner } = opts;
-  let lastStatusSignature = null;
   while (true) {
     const branch = await getGitBranch(cwd);
     const status = runner.getStatusInfo();
     const cwdDisplay = tildePath(cwd);
     const contextWindow = getContextWindow(status.model);
-    const statusData = {
+    reporter.renderStatusBar({
       model: status.model,
       cwd: cwdDisplay,
       gitBranch: branch,
@@ -6937,12 +6909,7 @@ async function runInputLoop(opts) {
       contextTokens: status.lastContextTokens,
       contextWindow,
       thinkingEffort: status.thinkingEffort
-    };
-    const statusSignature = buildStatusBarSignature(statusData);
-    if (statusSignature !== lastStatusSignature) {
-      reporter.renderStatusBar(statusData);
-      lastStatusSignature = statusSignature;
-    }
+    });
     let input;
     try {
       input = await readline({ cwd });
@@ -6951,14 +6918,14 @@ async function runInputLoop(opts) {
     }
     switch (input.type) {
       case "eof":
-        reporter.writeText(c21.dim("Goodbye."));
+        reporter.writeText(c19.dim("Goodbye."));
         return;
       case "interrupt":
         continue;
       case "command": {
         const result = await handleCommand(input.command, input.args, cmdCtx);
         if (result.type === "exit") {
-          reporter.writeText(c21.dim("Goodbye."));
+          reporter.writeText(c19.dim("Goodbye."));
           return;
         }
         if (result.type === "inject-user-message") {
@@ -7065,13 +7032,12 @@ async function main() {
     if (last) {
       sessionId = last.id;
     } else {
-      writeln(c22.dim("No previous session found, starting fresh."));
+      writeln(c20.dim("No previous session found, starting fresh."));
     }
   } else if (args.sessionId) {
     sessionId = args.sessionId;
   }
   const model = args.model ?? getPreferredModel() ?? autoDiscoverModel();
-  bootstrapGlobalDefaults();
   if (!prompt) {
     renderBanner(model, args.cwd);
   }