mini-coder 0.0.16 → 0.0.17

package/dist/mc.js

@@ -295,6 +295,8 @@ function renderStatusBar(opts) {
   const left = [c3.cyan(opts.model)];
   if (opts.thinkingEffort)
     left.push(c3.dim(`\u2726 ${opts.thinkingEffort}`));
+  if (opts.showReasoning)
+    left.push(c3.dim("\uD83E\uDD14"));
   if (opts.provider && opts.provider !== "zen")
     left.push(c3.dim(opts.provider));
   left.push(c3.dim(opts.sessionId.slice(0, 8)));
@@ -898,17 +900,20 @@ function renderToolResult(toolName, result, isError, toolCallId) {
 }
 
 // src/cli/stream-render.ts
-async function renderTurn(events, spinner) {
+async function renderTurn(events, spinner, opts) {
+  const showReasoning = opts?.showReasoning ?? true;
   let inText = false;
   let inReasoning = false;
   let rawBuffer = "";
   let accumulatedText = "";
+  let accumulatedReasoning = "";
   let inFence = false;
   let inputTokens = 0;
   let outputTokens = 0;
   let contextTokens = 0;
   let newMessages = [];
   function renderAndWrite(raw, endWithNewline) {
+    spinner.stop();
     const rendered = renderLine(raw, inFence);
     inFence = rendered.inFence;
     const finalOutput = inReasoning ? c7.dim(rendered.output) : rendered.output;
@@ -960,13 +965,15 @@ async function renderTurn(events, spinner) {
         break;
       }
       case "reasoning-delta": {
+        accumulatedReasoning += event.delta;
+        if (!showReasoning) {
+          break;
+        }
         if (!inReasoning) {
           if (inText) {
             flushAnyText();
           }
           spinner.stop();
-          write(`${c7.dim("Thinking...")}
-`);
           inReasoning = true;
         }
         rawBuffer += event.delta;
@@ -1014,12 +1021,18 @@ async function renderTurn(events, spinner) {
       }
     }
   }
-  return { inputTokens, outputTokens, contextTokens, newMessages };
+  return {
+    inputTokens,
+    outputTokens,
+    contextTokens,
+    newMessages,
+    reasoningText: accumulatedReasoning
+  };
 }
 
 // src/cli/output.ts
 var HOME2 = homedir3();
-var PACKAGE_VERSION = "0.0.16";
+var PACKAGE_VERSION = "0.0.17";
 function tildePath(p) {
   return p.startsWith(HOME2) ? `~${p.slice(HOME2.length)}` : p;
 }
@@ -1473,6 +1486,8 @@ var GOOGLE_BASE = "https://generativelanguage.googleapis.com/v1beta";
 var MODELS_DEV_URL = "https://models.dev/api.json";
 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 = 2;
 var MODEL_INFO_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 var runtimeCache = emptyRuntimeCache();
 var loaded = false;
@@ -1719,6 +1734,8 @@ function getProviderSyncKey(provider) {
 }
 function isModelInfoStale(now = Date.now()) {
   ensureLoaded();
+  if (parseStateInt(CACHE_VERSION_KEY) !== CACHE_VERSION)
+    return true;
   if (isStaleTimestamp(parseStateInt(MODELS_DEV_SYNC_KEY), now))
     return true;
   for (const provider of getProvidersRequiredForFreshness()) {
@@ -1757,8 +1774,7 @@ async function fetchZenModels() {
   const key = process.env.OPENCODE_API_KEY;
   if (!key)
     return null;
-  const payload = await fetchJson(`${ZEN_BASE}/models`, { headers: { Authorization: `Bearer ${key}` } }, 8000);
-  return processModelsList(payload, "data", "id", (item, modelId) => {
+  return fetchPaginatedModelsList(`${ZEN_BASE}/models`, { headers: { Authorization: `Bearer ${key}` } }, 8000, "data", "id", (item, modelId) => {
     const contextWindow = typeof item.context_window === "number" && Number.isFinite(item.context_window) ? Math.max(0, Math.trunc(item.context_window)) : null;
     return {
       providerModelId: modelId,
@@ -1784,12 +1800,39 @@ function processModelsList(payload, arrayKey, idKey, mapper) {
   }
   return out;
 }
+async function fetchPaginatedModelsList(url, init, timeoutMs, arrayKey, idKey, mapper) {
+  const out = [];
+  const seen = new Set;
+  const baseUrl = new URL(url);
+  let nextAfter = null;
+  for (let page = 0;page < 10; page += 1) {
+    const currentUrl = new URL(baseUrl);
+    if (nextAfter !== null)
+      currentUrl.searchParams.set("after", nextAfter);
+    const payload = await fetchJson(currentUrl.toString(), init, timeoutMs);
+    const rows = processModelsList(payload, arrayKey, idKey, mapper);
+    if (rows === null) {
+      return null;
+    }
+    for (const row of rows) {
+      if (seen.has(row.providerModelId))
+        continue;
+      seen.add(row.providerModelId);
+      out.push(row);
+    }
+    if (!isRecord(payload))
+      break;
+    if (payload.has_more !== true || typeof payload.last_id !== "string")
+      break;
+    nextAfter = payload.last_id;
+  }
+  return out;
+}
 async function fetchOpenAIModels() {
   const key = process.env.OPENAI_API_KEY;
   if (!key)
     return null;
-  const payload = await fetchJson(`${OPENAI_BASE}/v1/models`, { headers: { Authorization: `Bearer ${key}` } }, 6000);
-  return processModelsList(payload, "data", "id", (item, modelId) => ({
+  return fetchPaginatedModelsList(`${OPENAI_BASE}/v1/models`, { headers: { Authorization: `Bearer ${key}` } }, 6000, "data", "id", (item, modelId) => ({
     providerModelId: modelId,
     displayName: item.id,
     contextWindow: null,
@@ -1900,6 +1943,7 @@ async function refreshModelInfoInternal() {
     replaceProviderModels(result.provider, rows);
     setModelInfoState(getProviderSyncKey(result.provider), String(now));
   }
+  setModelInfoState(CACHE_VERSION_KEY, String(CACHE_VERSION));
   loadCacheFromDb();
 }
 function refreshModelInfoInBackground(opts) {
@@ -2157,9 +2201,19 @@ function clampEffort(effort, max) {
   const m = ORDER.indexOf(max);
   return ORDER[Math.min(i, m)];
 }
-function getThinkingProviderOptions(modelString, effort) {
+var GEMINI_TOOL_CALL_AFFECTED_MODELS = /^gemini-(2\.5|3)/;
+function shouldDisableGeminiThinkingForTools(modelString) {
+  const { provider, modelId } = parseModelString(modelString);
+  if (provider !== "google" && provider !== "zen")
+    return false;
+  return GEMINI_TOOL_CALL_AFFECTED_MODELS.test(modelId);
+}
+function getThinkingProviderOptions(modelString, effort, hasTools = false) {
   if (!supportsThinking2(modelString))
     return null;
+  if (hasTools && shouldDisableGeminiThinkingForTools(modelString)) {
+    return null;
+  }
   const { provider, modelId } = parseModelString(modelString);
   if (provider === "anthropic" || provider === "zen" && modelId.startsWith("claude-")) {
     const isAdaptive = /^claude-3-7/.test(modelId) || /^claude-sonnet-4/.test(modelId) || /^claude-opus-4/.test(modelId);
@@ -2179,7 +2233,7 @@ function getThinkingProviderOptions(modelString, effort) {
   if (provider === "openai" || provider === "zen" && (modelId.startsWith("o") || modelId.startsWith("gpt-5"))) {
     const supportsXhigh = /^gpt-5\.[2-9]/.test(modelId) || /^o4/.test(modelId);
     const clamped = supportsXhigh ? effort : clampEffort(effort, "high");
-    return { openai: { reasoningEffort: clamped } };
+    return { openai: { reasoningEffort: clamped, reasoningSummary: "auto" } };
   }
   if (provider === "google" || provider === "zen" && modelId.startsWith("gemini-")) {
     if (/^gemini-3/.test(modelId)) {
@@ -2446,6 +2500,15 @@ function setPreferredThinkingEffort(effort) {
     setSetting("preferred_thinking_effort", effort);
   }
 }
+function getPreferredShowReasoning() {
+  const v = getSetting("preferred_show_reasoning");
+  if (v === null)
+    return true;
+  return v !== "false";
+}
+function setPreferredShowReasoning(show) {
+  setSetting("preferred_show_reasoning", show ? "true" : "false");
+}
 function getPreferredActiveAgent() {
   return getSetting("preferred_active_agent");
 }
@@ -2685,6 +2748,25 @@ async function handleModel(ctx, args) {
   writeln(c10.dim("  /model <id>  to switch  \xB7  e.g. /model zen/claude-sonnet-4-6"));
   writeln(c10.dim("  /model effort <low|medium|high|xhigh|off>  to set thinking effort"));
 }
+function handleReasoning(ctx, args) {
+  const mode = args.trim().toLowerCase();
+  if (!mode) {
+    ctx.setShowReasoning(!ctx.showReasoning);
+    writeln(`${PREFIX.success} reasoning display ${ctx.showReasoning ? c10.green("on") : c10.dim("off")}`);
+    return;
+  }
+  if (mode === "on") {
+    ctx.setShowReasoning(true);
+    writeln(`${PREFIX.success} reasoning display ${c10.green("on")}`);
+    return;
+  }
+  if (mode === "off") {
+    ctx.setShowReasoning(false);
+    writeln(`${PREFIX.success} reasoning display ${c10.dim("off")}`);
+    return;
+  }
+  writeln(`${PREFIX.error} usage: /reasoning <on|off>`);
+}
 function handlePlan(ctx) {
   ctx.setPlanMode(!ctx.planMode);
   if (ctx.planMode) {
@@ -2870,6 +2952,7 @@ function handleHelp(ctx, custom) {
   const cmds = [
     ["/model [id]", "list or switch models (fetches live list)"],
     ["/undo", "remove the last turn from conversation history"],
+    ["/reasoning [on|off]", "toggle display of model reasoning output"],
     ["/plan", "toggle plan mode (read-only tools + MCP)"],
     [
       "/ralph",
@@ -2936,6 +3019,9 @@ async function handleCommand(command, args, ctx) {
     case "undo":
       await handleUndo(ctx);
       return { type: "handled" };
+    case "reasoning":
+      handleReasoning(ctx, args);
+      return { type: "handled" };
     case "plan":
       handlePlan(ctx);
       return { type: "handled" };
@@ -3606,6 +3692,16 @@ import * as c14 from "yoctocolors";
 
 // src/llm-api/turn.ts
 import { dynamicTool, jsonSchema, stepCountIs, streamText } from "ai";
+function getReasoningDeltaFromStreamChunk(chunk) {
+  if (chunk.type !== "reasoning-delta" && chunk.type !== "reasoning") {
+    return null;
+  }
+  if (typeof chunk.text === "string")
+    return chunk.text;
+  if (typeof chunk.textDelta === "string")
+    return chunk.textDelta;
+  return "";
+}
 var MAX_STEPS = 50;
 function isZodSchema(s) {
   return s !== null && typeof s === "object" && "_def" in s;
@@ -3624,6 +3720,77 @@ function toCoreTool(def) {
     }
   });
 }
+function isRecord2(value) {
+  return value !== null && typeof value === "object";
+}
+function normalizeProviderOptions(part) {
+  if (!isRecord2(part))
+    return part;
+  if (part.providerOptions !== undefined || part.providerMetadata === undefined) {
+    return part;
+  }
+  return {
+    ...part,
+    providerOptions: part.providerMetadata
+  };
+}
+function normalizeMessageProviderOptions(message) {
+  if (!Array.isArray(message.content))
+    return message;
+  return {
+    ...message,
+    content: message.content.map((part) => normalizeProviderOptions(part))
+  };
+}
+function getGeminiThoughtSignature(part) {
+  if (!isRecord2(part))
+    return null;
+  const providerOptions = isRecord2(part.providerOptions) ? part.providerOptions : isRecord2(part.providerMetadata) ? part.providerMetadata : null;
+  if (!providerOptions)
+    return null;
+  for (const provider of ["google", "vertex"]) {
+    const metadata = providerOptions[provider];
+    if (!isRecord2(metadata))
+      continue;
+    const signature = metadata.thoughtSignature;
+    if (typeof signature === "string" && signature.length > 0) {
+      return signature;
+    }
+  }
+  return null;
+}
+function isToolCallPart(part) {
+  return isRecord2(part) && part.type === "tool-call";
+}
+function assistantMessageHasUnsignedGeminiToolCall(message) {
+  if (message.role !== "assistant" || !Array.isArray(message.content)) {
+    return false;
+  }
+  for (const part of message.content) {
+    if (!isToolCallPart(part))
+      continue;
+    if (getGeminiThoughtSignature(part) === null)
+      return true;
+  }
+  return false;
+}
+function sanitizeGeminiToolMessages(messages, modelString, hasTools) {
+  if (!hasTools || !shouldDisableGeminiThinkingForTools(modelString)) {
+    return messages;
+  }
+  let sanitized = messages.map((message) => normalizeMessageProviderOptions(message));
+  while (true) {
+    const brokenIndex = sanitized.findIndex((message) => assistantMessageHasUnsignedGeminiToolCall(message));
+    if (brokenIndex === -1)
+      return sanitized;
+    const nextUserIndex = sanitized.findIndex((message, index) => index > brokenIndex && message.role === "user");
+    if (nextUserIndex !== -1) {
+      sanitized = sanitized.slice(nextUserIndex);
+      continue;
+    }
+    return sanitized.slice(0, brokenIndex);
+  }
+}
 function isOpenAIGPT(modelString) {
   const { provider, modelId } = parseModelString(modelString);
   return (provider === "openai" || provider === "zen") && modelId.startsWith("gpt-");
@@ -3649,8 +3816,22 @@ async function* runTurn(options) {
   const partialState = { messages: [] };
   try {
     const useInstructions = systemPrompt !== undefined && isOpenAIGPT(modelString);
-    logApiEvent("turn start", { modelString, messageCount: messages.length });
-    const thinkingOpts = thinkingEffort ? getThinkingProviderOptions(modelString, thinkingEffort) : null;
+    const toolCount = Object.keys(toolSet).length;
+    const thinkingOpts = thinkingEffort ? getThinkingProviderOptions(modelString, thinkingEffort, toolCount > 0) : null;
+    const reasoningSummaryRequested = isRecord2(thinkingOpts) && isRecord2(thinkingOpts.openai) && typeof thinkingOpts.openai.reasoningSummary === "string";
+    logApiEvent("turn start", {
+      modelString,
+      messageCount: messages.length,
+      reasoningSummaryRequested
+    });
+    const turnMessages = sanitizeGeminiToolMessages(messages, modelString, toolCount > 0);
+    if (turnMessages.length !== messages.length) {
+      logApiEvent("gemini tool history truncated", {
+        modelString,
+        originalMessages: messages.length,
+        sanitizedMessages: turnMessages.length
+      });
+    }
     const mergedProviderOptions = {
       ...useInstructions ? { openai: { instructions: systemPrompt, store: false } } : {},
       ...thinkingOpts ?? {},
@@ -3664,7 +3845,7 @@ async function* runTurn(options) {
     };
     const streamOpts = {
       model,
-      messages,
+      messages: turnMessages,
       tools: toolSet,
       stopWhen: stepCountIs(MAX_STEPS),
       onStepFinish: (step) => {
@@ -3686,7 +3867,7 @@ async function* runTurn(options) {
         }
         return;
       },
-      ...systemPrompt ? { system: systemPrompt } : {},
+      ...systemPrompt && !useInstructions ? { system: systemPrompt } : {},
       ...Object.keys(mergedProviderOptions).length > 0 ? { providerOptions: mergedProviderOptions } : {},
       ...signal ? { abortSignal: signal } : {},
       experimental_repairToolCall: async ({ toolCall }) => {
@@ -3697,7 +3878,7 @@ async function* runTurn(options) {
     result.response.catch(() => {});
     for await (const chunk of result.fullStream) {
       const c13 = chunk;
-      if (c13.type !== "text-delta" && c13.type !== "reasoning") {
+      if (c13.type !== "text-delta" && c13.type !== "reasoning" && c13.type !== "reasoning-delta") {
         logApiEvent("stream chunk", {
           type: c13.type,
           toolCallId: c13.toolCallId,
@@ -3716,8 +3897,11 @@ async function* runTurn(options) {
           };
           break;
         }
+        case "reasoning-delta":
         case "reasoning": {
-          const delta = typeof c13.textDelta === "string" ? c13.textDelta : "";
+          const delta = getReasoningDeltaFromStreamChunk(c13);
+          if (delta === null)
+            break;
           yield {
             type: "reasoning-delta",
             delta
@@ -4998,6 +5182,7 @@ class SessionRunner {
   mcpTools;
   currentModel;
   currentThinkingEffort;
+  showReasoning;
   session;
   coreHistory;
   turnIndex = 1;
@@ -5017,6 +5202,7 @@ class SessionRunner {
     this.mcpTools = opts.mcpTools;
     this.currentModel = opts.initialModel;
     this.currentThinkingEffort = opts.initialThinkingEffort;
+    this.showReasoning = opts.initialShowReasoning;
     this.extraSystemPrompt = opts.extraSystemPrompt;
     this.isSubagent = opts.isSubagent;
     this.killSubprocesses = opts.killSubprocesses;
@@ -5094,7 +5280,9 @@ class SessionRunner {
         signal: abortController.signal,
         ...this.currentThinkingEffort ? { thinkingEffort: this.currentThinkingEffort } : {}
       });
-      const { inputTokens, outputTokens, contextTokens, newMessages } = await this.reporter.renderTurn(events);
+      const { inputTokens, outputTokens, contextTokens, newMessages } = await this.reporter.renderTurn(events, {
+        showReasoning: this.showReasoning
+      });
       if (newMessages.length > 0) {
         this.coreHistory.push(...newMessages);
         this.session.messages.push(...newMessages);
@@ -5119,7 +5307,13 @@ class SessionRunner {
 }
 
 // src/tools/worktree.ts
-import { copyFileSync, existsSync as existsSync6, mkdirSync as mkdirSync5, symlinkSync } from "fs";
+import {
+  copyFileSync,
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync5,
+  rmSync,
+  symlinkSync
+} from "fs";
 import { dirname as dirname2, join as join13 } from "path";
 async function runGit(cwd, args) {
   try {
@@ -5241,22 +5435,56 @@ async function cleanupBranch(mainCwd, branch) {
     throw gitError(`Failed to delete branch "${branch}"`, (result.stderr || result.stdout).trim());
   }
 }
+function shouldSkipUntrackedPath(path) {
+  return path === "node_modules" || path.startsWith("node_modules/");
+}
+async function syncTrackedChanges(mainRoot, worktreeRoot) {
+  const trackedResult = await runGit(mainRoot, [
+    "diff",
+    "--name-status",
+    "-M",
+    "HEAD"
+  ]);
+  if (trackedResult.exitCode !== 0)
+    return;
+  for (const line of splitNonEmptyLines(trackedResult.stdout)) {
+    const [statusToken, firstPath, secondPath] = line.split("\t");
+    const status = statusToken?.trim() ?? "";
+    if (!status || !firstPath)
+      continue;
+    if (status.startsWith("R") || status.startsWith("C")) {
+      if (!secondPath)
+        continue;
+      const src2 = join13(mainRoot, secondPath);
+      const dst2 = join13(worktreeRoot, secondPath);
+      if (existsSync6(src2)) {
+        mkdirSync5(dirname2(dst2), { recursive: true });
+        copyFileSync(src2, dst2);
+      }
+      if (status.startsWith("R")) {
+        rmSync(join13(worktreeRoot, firstPath), { force: true });
+      }
+      continue;
+    }
+    if (status.startsWith("D")) {
+      rmSync(join13(worktreeRoot, firstPath), { force: true });
+      continue;
+    }
+    const src = join13(mainRoot, firstPath);
+    const dst = join13(worktreeRoot, firstPath);
+    if (!existsSync6(src))
+      continue;
+    mkdirSync5(dirname2(dst), { recursive: true });
+    copyFileSync(src, dst);
+  }
+}
 async function applyParentChanges(mainCwd, worktreeCwd) {
   try {
     const [mainRoot, worktreeRoot] = await Promise.all([
       getRepoRoot2(mainCwd),
       getRepoRoot2(worktreeCwd)
     ]);
-    const diffResult = await runGit(mainRoot, ["diff", "HEAD", "--binary"]);
-    if (diffResult.exitCode === 0 && diffResult.stdout.trim()) {
-      const proc = Bun.spawn(["git", "apply", "-"], {
-        cwd: worktreeRoot,
-        stdin: Buffer.from(diffResult.stdout),
-        stdout: "pipe",
-        stderr: "pipe"
-      });
-      await proc.exited;
-    }
+    await syncTrackedChanges(mainRoot, worktreeRoot);
     const untrackedResult = await runGit(mainRoot, [
       "ls-files",
       "--others",
@@ -5264,6 +5492,8 @@ async function applyParentChanges(mainCwd, worktreeCwd) {
     ]);
     if (untrackedResult.exitCode === 0) {
       for (const file of splitNonEmptyLines(untrackedResult.stdout)) {
+        if (shouldSkipUntrackedPath(file))
+          continue;
         try {
           const src = join13(mainRoot, file);
           const dst = join13(worktreeRoot, file);
@@ -5286,7 +5516,7 @@ function getMcCommand() {
 var MAX_SUBAGENT_DEPTH = 10;
 function createSubagentRunner(cwd, getCurrentModel) {
   const activeProcs = new Map;
-  const subagentDepth = parseInt(process.env.MC_SUBAGENT_DEPTH ?? "0", 10);
+  const subagentDepth = Number.parseInt(process.env.MC_SUBAGENT_DEPTH ?? "0", 10);
   let mergeLockTail = Promise.resolve();
   const mergeSubagentBranch = async (branch) => {
     const prev = mergeLockTail;
@@ -5472,6 +5702,7 @@ async function runAgent(opts) {
     mcpTools,
     initialModel: currentModel,
     initialThinkingEffort: opts.initialThinkingEffort,
+    initialShowReasoning: opts.initialShowReasoning,
     sessionId: opts.sessionId,
     extraSystemPrompt: opts.agentSystemPrompt,
     isSubagent: opts.headless,
@@ -5506,6 +5737,13 @@ async function runAgent(opts) {
       runner.currentThinkingEffort = e;
       setPreferredThinkingEffort(e);
     },
+    get showReasoning() {
+      return runner.showReasoning;
+    },
+    setShowReasoning: (show) => {
+      runner.showReasoning = show;
+      setPreferredShowReasoning(show);
+    },
     get planMode() {
       return runner.planMode;
     },
@@ -5561,7 +5799,8 @@ async function runAgent(opts) {
       contextWindow: getContextWindow2(runner.currentModel) ?? 0,
       ralphMode: runner.ralphMode,
       thinkingEffort: runner.currentThinkingEffort,
-      activeAgent: activeAgentName
+      activeAgent: activeAgentName,
+      showReasoning: runner.showReasoning
     });
   }
   if (opts.headless) {
@@ -5594,17 +5833,21 @@ class HeadlessReporter {
   writeText(_text) {}
   startSpinner(_label) {}
   stopSpinner() {}
-  async renderTurn(events) {
+  async renderTurn(events, _opts) {
     let inputTokens = 0;
     let outputTokens = 0;
     let contextTokens = 0;
     let newMessages = [];
     let accumulatedText = "";
+    let reasoningText = "";
     for await (const event of events) {
       switch (event.type) {
         case "text-delta":
           accumulatedText += event.delta;
           break;
+        case "reasoning-delta":
+          reasoningText += event.delta;
+          break;
         case "turn-complete":
           inputTokens = event.inputTokens;
           outputTokens = event.outputTokens;
@@ -5622,7 +5865,13 @@ class HeadlessReporter {
         }
       }
     }
-    return { inputTokens, outputTokens, contextTokens, newMessages };
+    return {
+      inputTokens,
+      outputTokens,
+      contextTokens,
+      newMessages,
+      reasoningText
+    };
   }
   renderStatusBar(_data) {}
   renderHook(_toolName, _scriptPath, _success) {}
@@ -5655,8 +5904,8 @@ class CliReporter {
   stopSpinner() {
     this.spinner.stop();
   }
-  async renderTurn(events) {
-    return renderTurn(events, this.spinner);
+  async renderTurn(events, opts) {
+    return renderTurn(events, this.spinner, opts);
   }
   renderStatusBar(data) {
     renderStatusBar(data);
@@ -5723,7 +5972,7 @@ function parseArgs(argv) {
         args.agentName = argv[++i] ?? null;
         break;
       case "--output-fd": {
-        const fd = parseInt(argv[++i] ?? "", 10);
+        const fd = Number.parseInt(argv[++i] ?? "", 10);
         if (!Number.isNaN(fd))
           args.outputFd = fd;
         break;
@@ -5882,6 +6131,7 @@ async function main() {
         model: modelOverride,
         cwd: runCwd,
         initialThinkingEffort: getPreferredThinkingEffort(),
+        initialShowReasoning: getPreferredShowReasoning(),
         reporter: new HeadlessReporter,
         initialPrompt: args.prompt ?? "",
         headless: true,
@@ -5913,6 +6163,7 @@ async function main() {
       model,
       cwd: args.cwd,
       initialThinkingEffort: getPreferredThinkingEffort(),
+      initialShowReasoning: getPreferredShowReasoning(),
       reporter: new CliReporter
     };
     if (sessionId)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mini-coder",
-	"version": "0.0.16",
+	"version": "0.0.17",
 	"description": "A small, fast CLI coding agent",
 	"module": "src/index.ts",
 	"type": "module",