reasonix 0.0.3 → 0.0.5

package/dist/cli/index.js

@@ -1,11 +1,264 @@
 #!/usr/bin/env node
-import {
-  DeepSeekClient
-} from "./chunk-T2ODXAJP.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
 
+// src/client.ts
+import { createParser } from "eventsource-parser";
+
+// src/retry.ts
+var DEFAULT_RETRYABLE_STATUSES = [408, 429, 500, 502, 503, 504];
+async function fetchWithRetry(fetchFn, url, init, opts = {}) {
+  const maxAttempts = opts.maxAttempts ?? 4;
+  const initial = opts.initialBackoffMs ?? 500;
+  const cap = opts.maxBackoffMs ?? 1e4;
+  const retryable = new Set(opts.retryableStatuses ?? DEFAULT_RETRYABLE_STATUSES);
+  let lastError;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    if (opts.signal?.aborted) throw new Error("aborted");
+    try {
+      const resp = await fetchFn(url, init);
+      if (resp.ok || !retryable.has(resp.status)) return resp;
+      if (attempt === maxAttempts - 1) return resp;
+      await resp.text().catch(() => void 0);
+      const waitMs = computeWait(attempt, initial, cap, resp.headers.get("Retry-After"));
+      opts.onRetry?.({ attempt: attempt + 1, reason: `http ${resp.status}`, waitMs });
+      await sleep(waitMs, opts.signal);
+    } catch (err) {
+      lastError = err;
+      if (isAbortError(err) || opts.signal?.aborted) throw err;
+      if (attempt === maxAttempts - 1) throw err;
+      const waitMs = computeWait(attempt, initial, cap, null);
+      opts.onRetry?.({
+        attempt: attempt + 1,
+        reason: `network: ${messageOf(err)}`,
+        waitMs
+      });
+      await sleep(waitMs, opts.signal);
+    }
+  }
+  throw lastError ?? new Error("fetchWithRetry: loop exited unexpectedly");
+}
+function computeWait(attempt, initial, cap, retryAfter) {
+  if (retryAfter) {
+    const seconds = Number.parseFloat(retryAfter);
+    if (Number.isFinite(seconds) && seconds > 0) {
+      return Math.min(seconds * 1e3, cap);
+    }
+  }
+  const exp = initial * 2 ** attempt;
+  const jitter = exp * (0.75 + Math.random() * 0.5);
+  return Math.min(Math.max(jitter, 0), cap);
+}
+function sleep(ms, signal) {
+  if (ms <= 0) return Promise.resolve();
+  return new Promise((resolve2, reject) => {
+    const timer = setTimeout(resolve2, ms);
+    if (signal) {
+      const onAbort = () => {
+        clearTimeout(timer);
+        reject(new Error("aborted"));
+      };
+      if (signal.aborted) onAbort();
+      else signal.addEventListener("abort", onAbort, { once: true });
+    }
+  });
+}
+function isAbortError(err) {
+  if (!err || typeof err !== "object") return false;
+  const name = err.name;
+  return name === "AbortError";
+}
+function messageOf(err) {
+  if (err instanceof Error) return err.message;
+  try {
+    return String(err);
+  } catch {
+    return "unknown error";
+  }
+}
+
+// src/client.ts
+var Usage = class _Usage {
+  constructor(promptTokens = 0, completionTokens = 0, totalTokens = 0, promptCacheHitTokens = 0, promptCacheMissTokens = 0) {
+    this.promptTokens = promptTokens;
+    this.completionTokens = completionTokens;
+    this.totalTokens = totalTokens;
+    this.promptCacheHitTokens = promptCacheHitTokens;
+    this.promptCacheMissTokens = promptCacheMissTokens;
+  }
+  promptTokens;
+  completionTokens;
+  totalTokens;
+  promptCacheHitTokens;
+  promptCacheMissTokens;
+  get cacheHitRatio() {
+    const denom = this.promptCacheHitTokens + this.promptCacheMissTokens;
+    return denom > 0 ? this.promptCacheHitTokens / denom : 0;
+  }
+  static fromApi(raw) {
+    const u = raw ?? {};
+    return new _Usage(
+      u.prompt_tokens ?? 0,
+      u.completion_tokens ?? 0,
+      u.total_tokens ?? 0,
+      u.prompt_cache_hit_tokens ?? 0,
+      u.prompt_cache_miss_tokens ?? 0
+    );
+  }
+};
+var DeepSeekClient = class {
+  apiKey;
+  baseUrl;
+  timeoutMs;
+  retry;
+  _fetch;
+  constructor(opts = {}) {
+    const apiKey = opts.apiKey ?? process.env.DEEPSEEK_API_KEY;
+    if (!apiKey) {
+      throw new Error(
+        "DEEPSEEK_API_KEY is not set. Put it in .env or pass apiKey to DeepSeekClient."
+      );
+    }
+    this.apiKey = apiKey;
+    this.baseUrl = (opts.baseUrl ?? process.env.DEEPSEEK_BASE_URL ?? "https://api.deepseek.com").replace(/\/+$/, "");
+    this.timeoutMs = opts.timeoutMs ?? 12e4;
+    this._fetch = opts.fetch ?? globalThis.fetch.bind(globalThis);
+    this.retry = opts.retry ?? {};
+  }
+  buildPayload(opts, stream) {
+    const payload = {
+      model: opts.model,
+      messages: opts.messages,
+      stream
+    };
+    if (opts.tools?.length) payload.tools = opts.tools;
+    if (opts.temperature !== void 0) payload.temperature = opts.temperature;
+    if (opts.maxTokens !== void 0) payload.max_tokens = opts.maxTokens;
+    if (opts.responseFormat) payload.response_format = opts.responseFormat;
+    return payload;
+  }
+  async chat(opts) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), this.timeoutMs);
+    const signal = opts.signal ?? ctrl.signal;
+    try {
+      const resp = await fetchWithRetry(
+        this._fetch,
+        `${this.baseUrl}/chat/completions`,
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${this.apiKey}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(this.buildPayload(opts, false)),
+          signal
+        },
+        { ...this.retry, signal }
+      );
+      if (!resp.ok) {
+        throw new Error(`DeepSeek ${resp.status}: ${await resp.text()}`);
+      }
+      const data = await resp.json();
+      const choice = data.choices?.[0]?.message ?? {};
+      return {
+        content: choice.content ?? "",
+        reasoningContent: choice.reasoning_content ?? null,
+        toolCalls: choice.tool_calls ?? [],
+        usage: Usage.fromApi(data.usage),
+        raw: data
+      };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async *stream(opts) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), this.timeoutMs);
+    const signal = opts.signal ?? ctrl.signal;
+    let resp;
+    try {
+      resp = await fetchWithRetry(
+        this._fetch,
+        `${this.baseUrl}/chat/completions`,
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${this.apiKey}`,
+            "Content-Type": "application/json",
+            Accept: "text/event-stream"
+          },
+          body: JSON.stringify(this.buildPayload(opts, true)),
+          signal
+        },
+        { ...this.retry, signal }
+      );
+    } catch (err) {
+      clearTimeout(timer);
+      throw err;
+    }
+    if (!resp.ok || !resp.body) {
+      clearTimeout(timer);
+      throw new Error(`DeepSeek ${resp.status}: ${await resp.text().catch(() => "")}`);
+    }
+    const queue = [];
+    let done = false;
+    const parser = createParser({
+      onEvent: (ev) => {
+        if (!ev.data || ev.data === "[DONE]") {
+          done = true;
+          return;
+        }
+        try {
+          const json = JSON.parse(ev.data);
+          const delta = json.choices?.[0]?.delta ?? {};
+          const finishReason = json.choices?.[0]?.finish_reason ?? void 0;
+          const chunk = { raw: json, finishReason };
+          if (typeof delta.content === "string" && delta.content.length > 0) {
+            chunk.contentDelta = delta.content;
+          }
+          if (typeof delta.reasoning_content === "string" && delta.reasoning_content.length > 0) {
+            chunk.reasoningDelta = delta.reasoning_content;
+          }
+          if (Array.isArray(delta.tool_calls) && delta.tool_calls.length > 0) {
+            const tc = delta.tool_calls[0];
+            chunk.toolCallDelta = {
+              index: tc.index ?? 0,
+              id: tc.id,
+              name: tc.function?.name,
+              argumentsDelta: tc.function?.arguments
+            };
+          }
+          if (json.usage) {
+            chunk.usage = Usage.fromApi(json.usage);
+          }
+          queue.push(chunk);
+        } catch {
+        }
+      }
+    });
+    const reader = resp.body.getReader();
+    const decoder = new TextDecoder();
+    try {
+      while (true) {
+        if (queue.length > 0) {
+          yield queue.shift();
+          continue;
+        }
+        if (done) break;
+        const { value, done: streamDone } = await reader.read();
+        if (streamDone) break;
+        parser.feed(decoder.decode(value, { stream: true }));
+      }
+      while (queue.length > 0) yield queue.shift();
+    } finally {
+      clearTimeout(timer);
+      reader.releaseLock();
+    }
+  }
+};
+
 // src/harvest.ts
 function emptyPlanState() {
   return { subgoals: [], hypotheses: [], uncertainties: [], rejectedPaths: [] };
@@ -96,6 +349,66 @@ function sanitizeArray(raw, maxItems, maxItemLen) {
   return out;
 }
 
+// src/consistency.ts
+var defaultSelector = (samples) => {
+  if (samples.length === 0) throw new Error("defaultSelector: samples is empty");
+  return samples.slice().sort((a, b) => {
+    const uDiff = a.planState.uncertainties.length - b.planState.uncertainties.length;
+    if (uDiff !== 0) return uDiff;
+    const aLen = a.response.content?.length ?? 0;
+    const bLen = b.response.content?.length ?? 0;
+    return aLen - bLen;
+  })[0];
+};
+async function runBranches(client, request, opts = {}) {
+  const budget = Math.max(1, opts.budget ?? 1);
+  const temperatures = resolveTemperatures(budget, opts.temperatures);
+  const selector = opts.selector ?? defaultSelector;
+  const samples = await Promise.all(
+    temperatures.map(async (temperature, index) => {
+      const response = await client.chat({ ...request, temperature });
+      const planState = await harvest(response.reasoningContent, client, opts.harvestOptions);
+      const sample = { index, temperature, response, planState };
+      try {
+        opts.onSampleDone?.(sample);
+      } catch {
+      }
+      return sample;
+    })
+  );
+  return { chosen: selector(samples), samples };
+}
+function aggregateBranchUsage(samples) {
+  let promptTokens = 0;
+  let completionTokens = 0;
+  let totalTokens = 0;
+  let promptCacheHitTokens = 0;
+  let promptCacheMissTokens = 0;
+  for (const s of samples) {
+    promptTokens += s.response.usage.promptTokens;
+    completionTokens += s.response.usage.completionTokens;
+    totalTokens += s.response.usage.totalTokens;
+    promptCacheHitTokens += s.response.usage.promptCacheHitTokens;
+    promptCacheMissTokens += s.response.usage.promptCacheMissTokens;
+  }
+  return {
+    promptTokens,
+    completionTokens,
+    totalTokens,
+    promptCacheHitTokens,
+    promptCacheMissTokens
+  };
+}
+function resolveTemperatures(budget, custom) {
+  if (custom && custom.length >= budget) return [...custom.slice(0, budget)];
+  if (budget === 1) return [0];
+  const out = [];
+  for (let i = 0; i < budget; i++) {
+    out.push(Number((i / (budget - 1)).toFixed(2)));
+  }
+  return out;
+}
+
 // src/memory.ts
 import { createHash } from "crypto";
 var ImmutablePrefix = class {
@@ -347,6 +660,74 @@ function repairTruncatedJson(input) {
   }
 }
 
+// src/repair/flatten.ts
+function analyzeSchema(schema) {
+  if (!schema) return { shouldFlatten: false, leafCount: 0, maxDepth: 0 };
+  let leafCount = 0;
+  let maxDepth = 0;
+  walk(schema, 0, (depth, isLeaf) => {
+    if (isLeaf) leafCount++;
+    if (depth > maxDepth) maxDepth = depth;
+  });
+  return {
+    shouldFlatten: leafCount > 10 || maxDepth > 2,
+    leafCount,
+    maxDepth
+  };
+}
+function flattenSchema(schema) {
+  const flatProps = {};
+  const required = [];
+  collect("", schema, flatProps, required, true);
+  return {
+    type: "object",
+    properties: flatProps,
+    required
+  };
+}
+function nestArguments(flatArgs) {
+  const out = {};
+  for (const [key, value] of Object.entries(flatArgs)) {
+    setByPath(out, key.split("."), value);
+  }
+  return out;
+}
+function walk(schema, depth, visit) {
+  if (schema.type === "object" && schema.properties) {
+    for (const child of Object.values(schema.properties)) {
+      walk(child, depth + 1, visit);
+    }
+    return;
+  }
+  if (schema.type === "array" && schema.items) {
+    walk(schema.items, depth + 1, visit);
+    return;
+  }
+  visit(depth, true);
+}
+function collect(prefix, schema, out, required, isRootRequired) {
+  if (schema.type === "object" && schema.properties) {
+    const requiredSet = new Set(schema.required ?? []);
+    for (const [key, child] of Object.entries(schema.properties)) {
+      const nextPrefix = prefix ? `${prefix}.${key}` : key;
+      const childRequired = isRootRequired && requiredSet.has(key);
+      collect(nextPrefix, child, out, required, childRequired);
+    }
+    return;
+  }
+  out[prefix] = schema;
+  if (isRootRequired) required.push(prefix);
+}
+function setByPath(target, path, value) {
+  let cur = target;
+  for (let i = 0; i < path.length - 1; i++) {
+    const key = path[i];
+    if (typeof cur[key] !== "object" || cur[key] === null) cur[key] = {};
+    cur = cur[key];
+  }
+  cur[path[path.length - 1]] = value;
+}
+
 // src/repair/index.ts
 var ToolCallRepair = class {
   storm;
@@ -468,9 +849,20 @@ function round(n, digits) {
 // src/tools.ts
 var ToolRegistry = class {
   _tools = /* @__PURE__ */ new Map();
+  _autoFlatten;
+  constructor(opts = {}) {
+    this._autoFlatten = opts.autoFlatten !== false;
+  }
   register(def) {
     if (!def.name) throw new Error("tool requires a name");
-    this._tools.set(def.name, def);
+    const internal = { ...def };
+    if (this._autoFlatten && def.parameters) {
+      const decision = analyzeSchema(def.parameters);
+      if (decision.shouldFlatten) {
+        internal.flatSchema = flattenSchema(def.parameters);
+      }
+    }
+    this._tools.set(def.name, internal);
     return this;
   }
   has(name) {
@@ -482,13 +874,17 @@ var ToolRegistry = class {
   get size() {
     return this._tools.size;
   }
+  /** True if a registered tool's schema was flattened for the model. */
+  wasFlattened(name) {
+    return Boolean(this._tools.get(name)?.flatSchema);
+  }
   specs() {
     return [...this._tools.values()].map((t) => ({
       type: "function",
       function: {
         name: t.name,
         description: t.description ?? "",
-        parameters: t.parameters ?? { type: "object", properties: {} }
+        parameters: t.flatSchema ?? t.parameters ?? { type: "object", properties: {} }
       }
     }));
   }
@@ -499,12 +895,15 @@ var ToolRegistry = class {
     }
     let args;
     try {
-      args = typeof argumentsRaw === "string" ? argumentsRaw.trim() ? JSON.parse(argumentsRaw) : {} : argumentsRaw ?? {};
+      args = typeof argumentsRaw === "string" ? argumentsRaw.trim() ? JSON.parse(argumentsRaw) ?? {} : {} : argumentsRaw ?? {};
     } catch (err) {
       return JSON.stringify({
         error: `invalid tool arguments JSON: ${err.message}`
       });
     }
+    if (tool.flatSchema && args && typeof args === "object" && hasDotKey(args)) {
+      args = nestArguments(args);
+    }
     try {
       const result = await tool.fn(args);
       return typeof result === "string" ? result : JSON.stringify(result);
@@ -515,34 +914,85 @@ var ToolRegistry = class {
     }
   }
 };
+function hasDotKey(obj) {
+  for (const k of Object.keys(obj)) {
+    if (k.includes(".")) return true;
+  }
+  return false;
+}
 
 // src/loop.ts
 var CacheFirstLoop = class {
   client;
   prefix;
   tools;
-  model;
   maxToolIters;
-  stream;
-  harvestEnabled;
-  harvestOptions;
   log = new AppendOnlyLog();
   scratch = new VolatileScratch();
   stats = new SessionStats();
   repair;
+  // Mutable via configure() — slash commands in the TUI / library callers tweak
+  // these mid-session so users don't have to restart to try harvest or branch.
+  model;
+  stream;
+  harvestEnabled;
+  harvestOptions;
+  branchEnabled;
+  branchOptions;
   _turn = 0;
+  _streamPreference;
   constructor(opts) {
     this.client = opts.client;
     this.prefix = opts.prefix;
     this.tools = opts.tools ?? new ToolRegistry();
     this.model = opts.model ?? "deepseek-chat";
     this.maxToolIters = opts.maxToolIters ?? 8;
-    this.stream = opts.stream ?? true;
-    this.harvestEnabled = opts.harvest === true || typeof opts.harvest === "object" && opts.harvest !== null;
-    this.harvestOptions = typeof opts.harvest === "object" && opts.harvest !== null ? opts.harvest : {};
+    if (typeof opts.branch === "number") {
+      this.branchOptions = { budget: opts.branch };
+    } else if (opts.branch && typeof opts.branch === "object") {
+      this.branchOptions = opts.branch;
+    } else {
+      this.branchOptions = {};
+    }
+    this.branchEnabled = (this.branchOptions.budget ?? 1) > 1;
+    const harvestForced = this.branchEnabled;
+    this.harvestEnabled = harvestForced || opts.harvest === true || typeof opts.harvest === "object" && opts.harvest !== null;
+    this.harvestOptions = typeof opts.harvest === "object" && opts.harvest !== null ? opts.harvest : this.branchOptions.harvestOptions ?? {};
+    this._streamPreference = opts.stream ?? true;
+    this.stream = this.branchEnabled ? false : this._streamPreference;
     const allowedNames = /* @__PURE__ */ new Set([...this.prefix.toolSpecs.map((s) => s.function.name)]);
     this.repair = new ToolCallRepair({ allowedToolNames: allowedNames });
   }
+  /**
+   * Reconfigure model/harvest/branch/stream mid-session. The loop's log,
+   * scratch, and stats are preserved — only the per-turn behavior changes.
+   * Used by the TUI's slash commands and by library callers who want to
+   * flip a knob between turns.
+   */
+  configure(opts) {
+    if (opts.model !== void 0) this.model = opts.model;
+    if (opts.stream !== void 0) this._streamPreference = opts.stream;
+    if (opts.branch !== void 0) {
+      if (typeof opts.branch === "number") {
+        this.branchOptions = { budget: opts.branch };
+      } else if (opts.branch && typeof opts.branch === "object") {
+        this.branchOptions = opts.branch;
+      } else {
+        this.branchOptions = {};
+      }
+      this.branchEnabled = (this.branchOptions.budget ?? 1) > 1;
+    }
+    if (opts.harvest !== void 0) {
+      const want = opts.harvest === true || typeof opts.harvest === "object" && opts.harvest !== null;
+      this.harvestEnabled = want || this.branchEnabled;
+      if (typeof opts.harvest === "object" && opts.harvest !== null) {
+        this.harvestOptions = opts.harvest;
+      }
+    } else if (this.branchEnabled) {
+      this.harvestEnabled = true;
+    }
+    this.stream = this.branchEnabled ? false : this._streamPreference;
+  }
   buildMessages(pendingUser) {
     const msgs = [...this.prefix.toMessages(), ...this.log.toMessages()];
     if (pendingUser !== null) msgs.push({ role: "user", content: pendingUser });
@@ -559,8 +1009,85 @@ var CacheFirstLoop = class {
       let reasoningContent = "";
       let toolCalls = [];
       let usage = null;
+      let branchSummary;
+      let preHarvestedPlanState;
       try {
-        if (this.stream) {
+        if (this.branchEnabled) {
+          const budget = this.branchOptions.budget ?? 1;
+          yield {
+            turn: this._turn,
+            role: "branch_start",
+            content: "",
+            branchProgress: {
+              completed: 0,
+              total: budget,
+              latestIndex: -1,
+              latestTemperature: -1,
+              latestUncertainties: -1
+            }
+          };
+          const queue = [];
+          let waiter = null;
+          const onSampleDone = (sample) => {
+            if (waiter) {
+              const w = waiter;
+              waiter = null;
+              w(sample);
+            } else {
+              queue.push(sample);
+            }
+          };
+          const branchPromise = runBranches(
+            this.client,
+            {
+              model: this.model,
+              messages,
+              tools: toolSpecs.length ? toolSpecs : void 0
+            },
+            {
+              ...this.branchOptions,
+              harvestOptions: this.harvestOptions,
+              onSampleDone
+            }
+          );
+          for (let k = 0; k < budget; k++) {
+            const sample = queue.shift() ?? await new Promise((resolve2) => {
+              waiter = resolve2;
+            });
+            yield {
+              turn: this._turn,
+              role: "branch_progress",
+              content: "",
+              branchProgress: {
+                completed: k + 1,
+                total: budget,
+                latestIndex: sample.index,
+                latestTemperature: sample.temperature,
+                latestUncertainties: sample.planState.uncertainties.length
+              }
+            };
+          }
+          const result = await branchPromise;
+          assistantContent = result.chosen.response.content;
+          reasoningContent = result.chosen.response.reasoningContent ?? "";
+          toolCalls = result.chosen.response.toolCalls;
+          const agg = aggregateBranchUsage(result.samples);
+          usage = new Usage(
+            agg.promptTokens,
+            agg.completionTokens,
+            agg.totalTokens,
+            agg.promptCacheHitTokens,
+            agg.promptCacheMissTokens
+          );
+          preHarvestedPlanState = result.chosen.planState;
+          branchSummary = summarizeBranch(result.chosen, result.samples);
+          yield {
+            turn: this._turn,
+            role: "branch_done",
+            content: "",
+            branch: branchSummary
+          };
+        } else if (this.stream) {
           const callBuf = /* @__PURE__ */ new Map();
           for await (const chunk of this.client.stream({
             model: this.model,
@@ -620,17 +1147,13 @@ var CacheFirstLoop = class {
         };
         return;
       }
-      const turnStats = this.stats.record(
-        this._turn,
-        this.model,
-        usage ?? new (await import("./client-RIVGDOJP.js")).Usage()
-      );
+      const turnStats = this.stats.record(this._turn, this.model, usage ?? new Usage());
       if (pendingUser !== null) {
         this.log.append({ role: "user", content: pendingUser });
         pendingUser = null;
       }
       this.scratch.reasoning = reasoningContent || null;
-      const planState = this.harvestEnabled ? await harvest(reasoningContent || null, this.client, this.harvestOptions) : emptyPlanState();
+      const planState = preHarvestedPlanState ? preHarvestedPlanState : this.harvestEnabled ? await harvest(reasoningContent || null, this.client, this.harvestOptions) : emptyPlanState();
       const { calls: repairedCalls, report } = this.repair.process(
         toolCalls,
         reasoningContent || null
@@ -642,7 +1165,8 @@ var CacheFirstLoop = class {
         content: assistantContent,
         stats: turnStats,
         planState,
-        repair: report
+        repair: report,
+        branch: branchSummary
       };
       if (repairedCalls.length === 0) {
         yield { turn: this._turn, role: "done", content: assistantContent };
@@ -678,6 +1202,14 @@ var CacheFirstLoop = class {
     return msg;
   }
 };
+function summarizeBranch(chosen, samples) {
+  return {
+    budget: samples.length,
+    chosenIndex: chosen.index,
+    uncertainties: samples.map((s) => s.planState.uncertainties.length),
+    temperatures: samples.map((s) => s.temperature)
+  };
+}
 
 // src/env.ts
 import { readFileSync } from "fs";
@@ -751,22 +1283,67 @@ var VERSION = "0.0.1";
 
 // src/cli/commands/chat.tsx
 import { render } from "ink";
-import React7, { useState as useState3 } from "react";
+import React7, { useState as useState4 } from "react";
 
 // src/cli/ui/App.tsx
 import { createWriteStream } from "fs";
-import { Box as Box5, Static, useApp } from "ink";
-import React5, { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Box as Box5, Static, Text as Text5, useApp } from "ink";
+import React5, { useCallback, useEffect as useEffect2, useMemo, useRef, useState as useState2 } from "react";
 
 // src/cli/ui/EventLog.tsx
 import { Box as Box2, Text as Text2 } from "ink";
-import React2 from "react";
+import React2, { useEffect, useState } from "react";
 
 // src/cli/ui/markdown.tsx
 import { Box, Text } from "ink";
 import React from "react";
+var SUPERSCRIPT = {
+  "0": "\u2070",
+  "1": "\xB9",
+  "2": "\xB2",
+  "3": "\xB3",
+  "4": "\u2074",
+  "5": "\u2075",
+  "6": "\u2076",
+  "7": "\u2077",
+  "8": "\u2078",
+  "9": "\u2079",
+  "+": "\u207A",
+  "-": "\u207B",
+  n: "\u207F"
+};
+var SUBSCRIPT = {
+  "0": "\u2080",
+  "1": "\u2081",
+  "2": "\u2082",
+  "3": "\u2083",
+  "4": "\u2084",
+  "5": "\u2085",
+  "6": "\u2086",
+  "7": "\u2087",
+  "8": "\u2088",
+  "9": "\u2089",
+  "+": "\u208A",
+  "-": "\u208B"
+};
+function toSuperscript(s) {
+  let out = "";
+  for (const c of s) out += SUPERSCRIPT[c] ?? c;
+  return out;
+}
+function toSubscript(s) {
+  let out = "";
+  for (const c of s) out += SUBSCRIPT[c] ?? c;
+  return out;
+}
 function stripMath(s) {
-  return s.replace(/\\\(\s*/g, "").replace(/\s*\\\)/g, "").replace(/\\\[\s*/g, "\n").replace(/\s*\\\]/g, "\n").replace(/\\boxed\{([^}]+)\}/g, "\u3010$1\u3011").replace(/\\sqrt\{([^}]+)\}/g, "\u221A($1)").replace(/\\frac\{([^}]+)\}\{([^}]+)\}/g, "($1)/($2)").replace(/\\text\{([^}]+)\}/g, "$1").replace(/\\cdot/g, "\xB7").replace(/\\times/g, "\xD7").replace(/\\div/g, "\xF7").replace(/\\pm/g, "\xB1").replace(/\\mp/g, "\u2213").replace(/\\leq/g, "\u2264").replace(/\\geq/g, "\u2265").replace(/\\neq/g, "\u2260").replace(/\\approx/g, "\u2248").replace(/\\in\b/g, "\u2208").replace(/\\notin\b/g, "\u2209").replace(/\\infty/g, "\u221E").replace(/\\sum\b/g, "\u03A3").replace(/\\prod\b/g, "\u03A0").replace(/\\int\b/g, "\u222B").replace(/\\alpha/g, "\u03B1").replace(/\\beta/g, "\u03B2").replace(/\\gamma/g, "\u03B3").replace(/\\delta/g, "\u03B4").replace(/\\theta/g, "\u03B8").replace(/\\lambda/g, "\u03BB").replace(/\\mu/g, "\u03BC").replace(/\\pi/g, "\u03C0").replace(/\\sigma/g, "\u03C3").replace(/\\phi/g, "\u03C6").replace(/\\omega/g, "\u03C9").replace(/\\implies\b/g, "\u21D2").replace(/\\iff\b/g, "\u21D4").replace(/\\to\b/g, "\u2192").replace(/\\rightarrow/g, "\u2192").replace(/\\Rightarrow/g, "\u21D2").replace(/\\leftarrow/g, "\u2190").replace(/\\Leftarrow/g, "\u21D0").replace(/\\ldots/g, "\u2026").replace(/\\cdots/g, "\u22EF").replace(/\\quad/g, "  ").replace(/\\qquad/g, "    ").replace(/\\,/g, " ").replace(/\\;/g, " ").replace(/\\!/g, "").replace(/\\\\/g, "\n").replace(/[ \t]{2,}/g, " ");
+  return s.replace(/\\\(\s*/g, "").replace(/\s*\\\)/g, "").replace(/\\\[\s*/g, "\n").replace(/\s*\\\]/g, "\n").replace(
+    /\\[dt]?frac\s*\{((?:[^{}]|\{[^{}]*\})+)\}\s*\{((?:[^{}]|\{[^{}]*\})+)\}/g,
+    (_m, num, den) => `(${num.trim()})/(${den.trim()})`
+  ).replace(
+    /\\binom\s*\{([^{}]+)\}\s*\{([^{}]+)\}/g,
+    (_m, n, k) => `C(${n.trim()},${k.trim()})`
+  ).replace(/\\sqrt\s*\{([^{}]+)\}/g, (_m, g) => `\u221A(${g.trim()})`).replace(/\\boxed\s*\{([^{}]+)\}/g, (_m, g) => `\u3010${g.trim()}\u3011`).replace(/\\text\s*\{([^{}]+)\}/g, (_m, g) => g.trim()).replace(/\\overline\s*\{([^{}]+)\}/g, (_m, g) => `${g.trim()}\u0304`).replace(/\\hat\s*\{([^{}]+)\}/g, (_m, g) => `${g.trim()}\u0302`).replace(/\\vec\s*\{([^{}]+)\}/g, (_m, g) => `\u2192${g.trim()}`).replace(/\\cdot/g, "\xB7").replace(/\\times/g, "\xD7").replace(/\\div/g, "\xF7").replace(/\\pm/g, "\xB1").replace(/\\mp/g, "\u2213").replace(/\\leq/g, "\u2264").replace(/\\geq/g, "\u2265").replace(/\\neq/g, "\u2260").replace(/\\approx/g, "\u2248").replace(/\\in\b/g, "\u2208").replace(/\\notin\b/g, "\u2209").replace(/\\infty/g, "\u221E").replace(/\\sum\b/g, "\u03A3").replace(/\\prod\b/g, "\u03A0").replace(/\\int\b/g, "\u222B").replace(/\\alpha/g, "\u03B1").replace(/\\beta/g, "\u03B2").replace(/\\gamma/g, "\u03B3").replace(/\\delta/g, "\u03B4").replace(/\\theta/g, "\u03B8").replace(/\\lambda/g, "\u03BB").replace(/\\mu/g, "\u03BC").replace(/\\pi/g, "\u03C0").replace(/\\sigma/g, "\u03C3").replace(/\\phi/g, "\u03C6").replace(/\\omega/g, "\u03C9").replace(/\\implies\b/g, "\u21D2").replace(/\\iff\b/g, "\u21D4").replace(/\\to\b/g, "\u2192").replace(/\\rightarrow/g, "\u2192").replace(/\\Rightarrow/g, "\u21D2").replace(/\\leftarrow/g, "\u2190").replace(/\\Leftarrow/g, "\u21D0").replace(/\\ldots/g, "\u2026").replace(/\\cdots/g, "\u22EF").replace(/\\quad/g, "  ").replace(/\\qquad/g, "    ").replace(/\\,/g, " ").replace(/\\;/g, " ").replace(/\\!/g, "").replace(/\\\\/g, "\n").replace(/\^\{([\w+-]+)\}/g, (_m, g) => toSuperscript(g)).replace(/\^([0-9+\-n])/g, (_m, g) => toSuperscript(g)).replace(/_\{([\w+-]+)\}/g, (_m, g) => toSubscript(g)).replace(/_([0-9+\-])/g, (_m, g) => toSubscript(g)).replace(/\\[a-zA-Z]+\s*\{([^{}]+)\}\s*\{([^{}]+)\}/g, "($1)/($2)").replace(/\\[a-zA-Z]+\s*\{([^{}]+)\}/g, "$1").replace(/\\[a-zA-Z]+/g, "").replace(/[ \t]{2,}/g, " ");
 }
 var INLINE_RE = /(\*\*([^*\n]+?)\*\*|`([^`\n]+?)`|(?<![*\w])\*([^*\n]+?)\*(?!\w))/g;
 function InlineMd({ text }) {
@@ -914,7 +1491,7 @@ var EventRow = React2.memo(function EventRow2({ event }) {
   }
   if (event.role === "assistant") {
     if (event.streaming) return /* @__PURE__ */ React2.createElement(StreamingAssistant, { event });
-    return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "green" }, "assistant")), event.reasoning ? /* @__PURE__ */ React2.createElement(ReasoningBlock, { reasoning: event.reasoning }) : null, !isPlanStateEmpty(event.planState) ? /* @__PURE__ */ React2.createElement(PlanStateBlock, { planState: event.planState }) : null, event.text ? /* @__PURE__ */ React2.createElement(Markdown, { text: event.text }) : /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "(no content)"), event.stats ? /* @__PURE__ */ React2.createElement(StatsLine, { stats: event.stats }) : null, event.repair ? /* @__PURE__ */ React2.createElement(Text2, { color: "magenta" }, event.repair) : null);
+    return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "green" }, "assistant")), event.branch ? /* @__PURE__ */ React2.createElement(BranchBlock, { branch: event.branch }) : null, event.reasoning ? /* @__PURE__ */ React2.createElement(ReasoningBlock, { reasoning: event.reasoning }) : null, !isPlanStateEmpty(event.planState) ? /* @__PURE__ */ React2.createElement(PlanStateBlock, { planState: event.planState }) : null, event.text ? /* @__PURE__ */ React2.createElement(Markdown, { text: event.text }) : /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "(no content)"), event.stats ? /* @__PURE__ */ React2.createElement(StatsLine, { stats: event.stats }) : null, event.repair ? /* @__PURE__ */ React2.createElement(Text2, { color: "magenta" }, event.repair) : null);
   }
   if (event.role === "tool") {
     return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text2, { color: "yellow" }, `tool<${event.toolName ?? "?"}>  \u2192`), /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, " ", truncate(event.text, 400)));
@@ -927,6 +1504,14 @@ var EventRow = React2.memo(function EventRow2({ event }) {
   }
   return /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, null, event.text));
 });
+function BranchBlock({ branch }) {
+  const per = branch.uncertainties.map((u, i) => {
+    const marker = i === branch.chosenIndex ? "\u25B8" : " ";
+    const t = (branch.temperatures[i] ?? 0).toFixed(1);
+    return `${marker} #${i} T=${t} u=${u}`;
+  }).join("  ");
+  return /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { color: "blue" }, "\u{1F500} branched ", /* @__PURE__ */ React2.createElement(Text2, { bold: true }, branch.budget), ` samples \u2192 picked #${branch.chosenIndex}   `, /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, per)));
+}
 function PlanStateBlock({ planState }) {
   const lines = [];
   if (planState.subgoals.length) lines.push(["subgoals", planState.subgoals]);
@@ -941,10 +1526,29 @@ function ReasoningBlock({ reasoning }) {
   const preview = flat.length <= max ? flat : `${flat.slice(0, max)}\u2026 (+${flat.length - max} chars)`;
   return /* @__PURE__ */ React2.createElement(Box2, { marginBottom: 1 }, /* @__PURE__ */ React2.createElement(Text2, { dimColor: true, italic: true }, "\u21B3 thinking: ", preview));
 }
+function Elapsed() {
+  const [s, setS] = useState(0);
+  useEffect(() => {
+    const start = Date.now();
+    const id = setInterval(() => setS(Math.floor((Date.now() - start) / 1e3)), 1e3);
+    return () => clearInterval(id);
+  }, []);
+  const mm = String(Math.floor(s / 60)).padStart(2, "0");
+  const ss = String(s % 60).padStart(2, "0");
+  return /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, `${mm}:${ss}`);
+}
 function StreamingAssistant({ event }) {
+  if (event.branchProgress) {
+    const p = event.branchProgress;
+    if (p.completed === 0) {
+      return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "green" }, "assistant", " "), /* @__PURE__ */ React2.createElement(Text2, { color: "blue" }, "\u{1F500} launching ", p.total, " parallel samples (R1 thinking in parallel)\u2026", " "), /* @__PURE__ */ React2.createElement(Elapsed, null)), /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "  ", "spread across T=0.0/0.5/1.0 \xB7 typical wait 30-90s for reasoner"));
+    }
+    const pct = Math.round(p.completed / p.total * 100);
+    return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "green" }, "assistant", " "), /* @__PURE__ */ React2.createElement(Text2, { color: "blue" }, "\u{1F500} branching ", p.completed, "/", p.total, " (", pct, "%)", " "), /* @__PURE__ */ React2.createElement(Elapsed, null)), /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "  latest #", p.latestIndex, " T=", p.latestTemperature.toFixed(1), " u=", p.latestUncertainties, p.completed < p.total ? "  \xB7 waiting for other samples\u2026" : "  \xB7 selecting winner\u2026"));
+  }
   const tail = lastLine(event.text, 140);
   const reasoningTail = event.reasoning ? lastLine(event.reasoning, 120) : "";
-  return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "green" }, "assistant", " "), /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "(streaming \xB7 ", event.text.length, event.reasoning ? ` + think ${event.reasoning.length}` : "", " chars)")), reasoningTail ? /* @__PURE__ */ React2.createElement(Text2, { dimColor: true, italic: true }, "\u21B3 thinking: ", reasoningTail) : null, tail ? /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "\u25B8 ", tail) : /* @__PURE__ */ React2.createElement(Text2, { dimColor: true, italic: true }, "  (waiting for first token\u2026)"));
+  return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "green" }, "assistant", " "), /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "(streaming \xB7 ", event.text.length, event.reasoning ? ` + think ${event.reasoning.length}` : "", " chars)", " "), /* @__PURE__ */ React2.createElement(Elapsed, null)), reasoningTail ? /* @__PURE__ */ React2.createElement(Text2, { dimColor: true, italic: true }, "\u21B3 thinking: ", reasoningTail) : null, tail ? /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "\u25B8 ", tail) : /* @__PURE__ */ React2.createElement(Text2, { dimColor: true, italic: true }, "  (waiting for first token\u2026)"));
 }
 function lastLine(s, maxChars) {
   const flat = s.replace(/\s+/g, " ").trim();
@@ -970,7 +1574,7 @@ function PromptInput({
   disabled,
   placeholder
 }) {
-  const effectivePlaceholder = disabled ? placeholder ?? "\u2026waiting for response\u2026" : placeholder ?? 'type a message, or "/exit"';
+  const effectivePlaceholder = disabled ? placeholder ?? "\u2026waiting for response\u2026" : placeholder ?? "type a message, or /command";
   return /* @__PURE__ */ React3.createElement(Box3, { borderStyle: "round", borderColor: disabled ? "gray" : "cyan", paddingX: 1 }, /* @__PURE__ */ React3.createElement(Text3, { bold: true, color: disabled ? "gray" : "cyan" }, "you \u203A", " "), /* @__PURE__ */ React3.createElement(
     TextInput,
     {
@@ -986,21 +1590,120 @@ function PromptInput({
 // src/cli/ui/StatsPanel.tsx
 import { Box as Box4, Text as Text4 } from "ink";
 import React4 from "react";
-function StatsPanel({ summary, model, prefixHash }) {
+function StatsPanel({
+  summary,
+  model,
+  prefixHash,
+  harvestOn,
+  branchBudget
+}) {
   const hitPct = (summary.cacheHitRatio * 100).toFixed(1);
   const hitColor = summary.cacheHitRatio >= 0.7 ? "green" : summary.cacheHitRatio >= 0.4 ? "yellow" : "red";
-  return /* @__PURE__ */ React4.createElement(Box4, { borderStyle: "round", borderColor: "cyan", flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React4.createElement(Box4, { justifyContent: "space-between" }, /* @__PURE__ */ React4.createElement(Text4, null, /* @__PURE__ */ React4.createElement(Text4, { color: "cyan", bold: true }, "Reasonix"), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, " \xB7 model "), /* @__PURE__ */ React4.createElement(Text4, { color: "yellow" }, model), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, " \xB7 prefix "), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, prefixHash)), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "turns ", summary.turns)), /* @__PURE__ */ React4.createElement(Box4, { marginTop: 1, gap: 3 }, /* @__PURE__ */ React4.createElement(Text4, null, /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "cache hit "), /* @__PURE__ */ React4.createElement(Text4, { color: hitColor, bold: true }, hitPct, "%")), /* @__PURE__ */ React4.createElement(Text4, null, /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "cost "), /* @__PURE__ */ React4.createElement(Text4, { color: "green" }, "$", summary.totalCostUsd.toFixed(6))), /* @__PURE__ */ React4.createElement(Text4, null, /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "vs Claude "), /* @__PURE__ */ React4.createElement(Text4, null, "$", summary.claudeEquivalentUsd.toFixed(6))), /* @__PURE__ */ React4.createElement(Text4, null, /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "saving "), /* @__PURE__ */ React4.createElement(Text4, { color: "green", bold: true }, summary.savingsVsClaudePct.toFixed(1), "%"))));
+  const branchOn = (branchBudget ?? 1) > 1;
+  return /* @__PURE__ */ React4.createElement(Box4, { borderStyle: "round", borderColor: "cyan", flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React4.createElement(Box4, { justifyContent: "space-between" }, /* @__PURE__ */ React4.createElement(Text4, null, /* @__PURE__ */ React4.createElement(Text4, { color: "cyan", bold: true }, "Reasonix"), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, " \xB7 model "), /* @__PURE__ */ React4.createElement(Text4, { color: "yellow" }, model), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, " \xB7 prefix "), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, prefixHash), harvestOn ? /* @__PURE__ */ React4.createElement(Text4, { color: "magenta" }, " \xB7 harvest") : null, branchOn ? /* @__PURE__ */ React4.createElement(Text4, { color: "blue" }, " \xB7 branch", branchBudget) : null), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "turns ", summary.turns, " \xB7 type /help")), /* @__PURE__ */ React4.createElement(Box4, { marginTop: 1, gap: 3 }, /* @__PURE__ */ React4.createElement(Text4, null, /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "cache hit "), /* @__PURE__ */ React4.createElement(Text4, { color: hitColor, bold: true }, hitPct, "%")), /* @__PURE__ */ React4.createElement(Text4, null, /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "cost "), /* @__PURE__ */ React4.createElement(Text4, { color: "green" }, "$", summary.totalCostUsd.toFixed(6))), /* @__PURE__ */ React4.createElement(Text4, null, /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "vs Claude "), /* @__PURE__ */ React4.createElement(Text4, null, "$", summary.claudeEquivalentUsd.toFixed(6))), /* @__PURE__ */ React4.createElement(Text4, null, /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "saving "), /* @__PURE__ */ React4.createElement(Text4, { color: "green", bold: true }, summary.savingsVsClaudePct.toFixed(1), "%"))));
+}
+
+// src/cli/ui/slash.ts
+function parseSlash(text) {
+  if (!text.startsWith("/")) return null;
+  const parts = text.slice(1).trim().split(/\s+/);
+  const cmd = parts[0]?.toLowerCase() ?? "";
+  if (!cmd) return null;
+  return { cmd, args: parts.slice(1) };
+}
+function handleSlash(cmd, args, loop) {
+  switch (cmd) {
+    case "exit":
+    case "quit":
+      return { exit: true };
+    case "clear":
+      return { clear: true };
+    case "help":
+    case "?":
+      return {
+        info: [
+          "Commands:",
+          "  /help                    this message",
+          "  /status                  show current settings",
+          "  /preset <fast|smart|max> one-tap presets \u2014 see below",
+          "  /model <id>              deepseek-chat or deepseek-reasoner",
+          "  /harvest [on|off]        Pillar 2: structured plan-state extraction",
+          "  /branch <N|off>          run N parallel samples (N>=2), pick most confident",
+          "  /clear                   clear displayed history (log is kept)",
+          "  /exit                    quit",
+          "",
+          "Presets:",
+          "  fast   deepseek-chat   no harvest  no branch    ~1\xA2/100turns  \u2190 default",
+          "  smart  reasoner        harvest                  ~10x cost, slower",
+          "  max    reasoner        harvest     branch 3     ~30x cost, slowest"
+        ].join("\n")
+      };
+    case "status": {
+      const branchBudget = loop.branchOptions.budget ?? 1;
+      return {
+        info: `model=${loop.model}  harvest=${loop.harvestEnabled ? "on" : "off"}  branch=${branchBudget > 1 ? branchBudget : "off"}  stream=${loop.stream ? "on" : "off"}`
+      };
+    }
+    case "model": {
+      const id = args[0];
+      if (!id) return { info: "usage: /model <id>   (try deepseek-chat or deepseek-reasoner)" };
+      loop.configure({ model: id });
+      return { info: `model \u2192 ${id}` };
+    }
+    case "harvest": {
+      const arg = (args[0] ?? "").toLowerCase();
+      const on = arg === "" ? !loop.harvestEnabled : arg === "on" || arg === "true" || arg === "1";
+      loop.configure({ harvest: on });
+      return { info: `harvest \u2192 ${loop.harvestEnabled ? "on" : "off"}` };
+    }
+    case "preset": {
+      const name = (args[0] ?? "").toLowerCase();
+      if (name === "fast" || name === "default") {
+        loop.configure({ model: "deepseek-chat", harvest: false, branch: 1 });
+        return { info: "preset \u2192 fast  (deepseek-chat, no harvest, no branch)" };
+      }
+      if (name === "smart") {
+        loop.configure({ model: "deepseek-reasoner", harvest: true, branch: 1 });
+        return { info: "preset \u2192 smart  (reasoner + harvest, ~10x cost vs fast)" };
+      }
+      if (name === "max" || name === "best") {
+        loop.configure({ model: "deepseek-reasoner", harvest: true, branch: 3 });
+        return {
+          info: "preset \u2192 max  (reasoner + harvest + branch3, ~30x cost vs fast, slowest)"
+        };
+      }
+      return { info: "usage: /preset <fast|smart|max>" };
+    }
+    case "branch": {
+      const raw = (args[0] ?? "").toLowerCase();
+      if (raw === "" || raw === "off" || raw === "0" || raw === "1") {
+        loop.configure({ branch: 1 });
+        return { info: "branch \u2192 off" };
+      }
+      const n = Number.parseInt(raw, 10);
+      if (!Number.isFinite(n) || n < 2) {
+        return { info: "usage: /branch <N>   (N>=2, or 'off')" };
+      }
+      if (n > 8) {
+        return { info: "branch budget capped at 8 to prevent runaway cost" };
+      }
+      loop.configure({ branch: n });
+      return { info: `branch \u2192 ${n}  (harvest auto-enabled; streaming disabled)` };
+    }
+    default:
+      return { unknown: true, info: `unknown command: /${cmd}  (try /help)` };
+  }
 }
 
 // src/cli/ui/App.tsx
 var FLUSH_INTERVAL_MS = 60;
-function App({ model, system, transcript, harvest: harvest2 }) {
+function App({ model, system, transcript, harvest: harvest2, branch }) {
   const { exit } = useApp();
-  const [historical, setHistorical] = useState([]);
-  const [streaming, setStreaming] = useState(null);
-  const [input, setInput] = useState("");
-  const [busy, setBusy] = useState(false);
-  const [summary, setSummary] = useState({
+  const [historical, setHistorical] = useState2([]);
+  const [streaming, setStreaming] = useState2(null);
+  const [input, setInput] = useState2("");
+  const [busy, setBusy] = useState2(false);
+  const [summary, setSummary] = useState2({
     turns: 0,
     totalCostUsd: 0,
     claudeEquivalentUsd: 0,
@@ -1011,7 +1714,7 @@ function App({ model, system, transcript, harvest: harvest2 }) {
   if (transcript && !transcriptRef.current) {
     transcriptRef.current = createWriteStream(transcript, { flags: "a" });
   }
-  useEffect(() => {
+  useEffect2(() => {
     return () => {
       transcriptRef.current?.end();
     };
@@ -1021,10 +1724,10 @@ function App({ model, system, transcript, harvest: harvest2 }) {
     if (loopRef.current) return loopRef.current;
     const client = new DeepSeekClient();
     const prefix = new ImmutablePrefix({ system });
-    const l = new CacheFirstLoop({ client, prefix, model, harvest: harvest2 });
+    const l = new CacheFirstLoop({ client, prefix, model, harvest: harvest2, branch });
     loopRef.current = l;
     return l;
-  }, [model, system, harvest2]);
+  }, [model, system, harvest2, branch]);
   const prefixHash = loop.prefix.fingerprint;
   const writeTranscript = useCallback((ev) => {
     transcriptRef.current?.write(
@@ -1043,13 +1746,28 @@ function App({ model, system, transcript, harvest: harvest2 }) {
       const text = raw.trim();
       if (!text || busy) return;
       setInput("");
-      if (text === "/exit" || text === "/quit") {
-        transcriptRef.current?.end();
-        exit();
-        return;
-      }
-      if (text === "/clear") {
-        setHistorical([]);
+      const slash = parseSlash(text);
+      if (slash) {
+        const result = handleSlash(slash.cmd, slash.args, loop);
+        if (result.exit) {
+          transcriptRef.current?.end();
+          exit();
+          return;
+        }
+        if (result.clear) {
+          setHistorical([]);
+          return;
+        }
+        if (result.info) {
+          setHistorical((prev) => [
+            ...prev,
+            {
+              id: `sys-${Date.now()}`,
+              role: "info",
+              text: result.info
+            }
+          ]);
+        }
         return;
       }
       setHistorical((prev) => [...prev, { id: `u-${Date.now()}`, role: "user", text }]);
@@ -1080,6 +1798,23 @@ function App({ model, system, transcript, harvest: harvest2 }) {
           if (ev.role === "assistant_delta") {
             if (ev.content) contentBuf.current += ev.content;
             if (ev.reasoningDelta) reasoningBuf.current += ev.reasoningDelta;
+          } else if (ev.role === "branch_start") {
+            setStreaming({
+              id: assistantId,
+              role: "assistant",
+              text: "",
+              streaming: true,
+              branchProgress: ev.branchProgress
+            });
+          } else if (ev.role === "branch_progress") {
+            setStreaming({
+              id: assistantId,
+              role: "assistant",
+              text: "",
+              streaming: true,
+              branchProgress: ev.branchProgress
+            });
+          } else if (ev.role === "branch_done") {
           } else if (ev.role === "assistant_final") {
             flush();
             const repairNote = ev.repair ? describeRepair(ev.repair) : "";
@@ -1092,6 +1827,7 @@ function App({ model, system, transcript, harvest: harvest2 }) {
                 text: ev.content || streamRef.text,
                 reasoning: streamRef.reasoning || void 0,
                 planState: ev.planState,
+                branch: ev.branch,
                 stats: ev.stats,
                 repair: repairNote || void 0,
                 streaming: false
@@ -1125,7 +1861,19 @@ function App({ model, system, transcript, harvest: harvest2 }) {
     },
     [busy, exit, loop, writeTranscript]
   );
-  return /* @__PURE__ */ React5.createElement(Box5, { flexDirection: "column" }, /* @__PURE__ */ React5.createElement(StatsPanel, { summary, model, prefixHash }), /* @__PURE__ */ React5.createElement(Static, { items: historical }, (item) => /* @__PURE__ */ React5.createElement(EventRow, { key: item.id, event: item })), streaming ? /* @__PURE__ */ React5.createElement(Box5, { marginY: 1 }, /* @__PURE__ */ React5.createElement(EventRow, { event: streaming })) : null, /* @__PURE__ */ React5.createElement(PromptInput, { value: input, onChange: setInput, onSubmit: handleSubmit, disabled: busy }));
+  return /* @__PURE__ */ React5.createElement(Box5, { flexDirection: "column" }, /* @__PURE__ */ React5.createElement(
+    StatsPanel,
+    {
+      summary,
+      model: loop.model,
+      prefixHash,
+      harvestOn: loop.harvestEnabled,
+      branchBudget: loop.branchOptions.budget
+    }
+  ), /* @__PURE__ */ React5.createElement(Static, { items: historical }, (item) => /* @__PURE__ */ React5.createElement(EventRow, { key: item.id, event: item })), streaming ? /* @__PURE__ */ React5.createElement(Box5, { marginY: 1 }, /* @__PURE__ */ React5.createElement(EventRow, { event: streaming })) : null, /* @__PURE__ */ React5.createElement(PromptInput, { value: input, onChange: setInput, onSubmit: handleSubmit, disabled: busy }), /* @__PURE__ */ React5.createElement(CommandStrip, null));
+}
+function CommandStrip() {
+  return /* @__PURE__ */ React5.createElement(Box5, { paddingX: 2 }, /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, "/help \xB7 /preset ", "<fast|smart|max>", " \xB7 /model \xB7 /harvest \xB7 /branch \xB7 /clear \xB7 /exit"));
 }
 function describeRepair(repair) {
   const parts = [];
@@ -1136,12 +1884,12 @@ function describeRepair(repair) {
 }
 
 // src/cli/ui/Setup.tsx
-import { Box as Box6, Text as Text5, useApp as useApp2 } from "ink";
+import { Box as Box6, Text as Text6, useApp as useApp2 } from "ink";
 import TextInput2 from "ink-text-input";
-import React6, { useState as useState2 } from "react";
+import React6, { useState as useState3 } from "react";
 function Setup({ onReady }) {
-  const [value, setValue] = useState2("");
-  const [error, setError] = useState2(null);
+  const [value, setValue] = useState3("");
+  const [error, setError] = useState3(null);
   const { exit } = useApp2();
   const handleSubmit = (raw) => {
     const trimmed = raw.trim();
@@ -1162,7 +1910,7 @@ function Setup({ onReady }) {
     }
     onReady(trimmed);
   };
-  return /* @__PURE__ */ React6.createElement(Box6, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React6.createElement(Text5, { bold: true, color: "cyan" }, "Welcome to Reasonix."), /* @__PURE__ */ React6.createElement(Box6, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(Text5, null, "Paste your DeepSeek API key to get started.")), /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "Get one (free credit on signup): https://platform.deepseek.com/api_keys"), /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "Saved locally to ", defaultConfigPath()), /* @__PURE__ */ React6.createElement(Box6, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(Text5, { bold: true, color: "cyan" }, "key \u203A "), /* @__PURE__ */ React6.createElement(
+  return /* @__PURE__ */ React6.createElement(Box6, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React6.createElement(Text6, { bold: true, color: "cyan" }, "Welcome to Reasonix."), /* @__PURE__ */ React6.createElement(Box6, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(Text6, null, "Paste your DeepSeek API key to get started.")), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "Get one (free credit on signup): https://platform.deepseek.com/api_keys"), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "Saved locally to ", defaultConfigPath()), /* @__PURE__ */ React6.createElement(Box6, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(Text6, { bold: true, color: "cyan" }, "key \u203A "), /* @__PURE__ */ React6.createElement(
     TextInput2,
     {
       value,
@@ -1171,12 +1919,12 @@ function Setup({ onReady }) {
       mask: "\u2022",
       placeholder: "sk-..."
     }
-  )), error ? /* @__PURE__ */ React6.createElement(Box6, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(Text5, { color: "red" }, error)) : value ? /* @__PURE__ */ React6.createElement(Box6, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "preview: ", redactKey(value))) : null, /* @__PURE__ */ React6.createElement(Box6, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "(Type /exit to abort.)")));
+  )), error ? /* @__PURE__ */ React6.createElement(Box6, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(Text6, { color: "red" }, error)) : value ? /* @__PURE__ */ React6.createElement(Box6, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "preview: ", redactKey(value))) : null, /* @__PURE__ */ React6.createElement(Box6, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "(Type /exit to abort.)")));
 }
 
 // src/cli/commands/chat.tsx
 function Root({ initialKey, ...appProps }) {
-  const [key, setKey] = useState3(initialKey);
+  const [key, setKey] = useState4(initialKey);
   if (!key) {
     return /* @__PURE__ */ React7.createElement(
       Setup,
@@ -1195,7 +1943,8 @@ function Root({ initialKey, ...appProps }) {
       model: appProps.model,
       system: appProps.system,
       transcript: appProps.transcript,
-      harvest: appProps.harvest
+      harvest: appProps.harvest,
+      branch: appProps.branch
     }
   );
 }
@@ -1305,12 +2054,17 @@ program.name("reasonix").description("DeepSeek-native agent framework \u2014 bui
 program.command("chat").description("Interactive Ink TUI with live cache/cost panel.").option("-m, --model <id>", "DeepSeek model id", "deepseek-chat").option("-s, --system <prompt>", "System prompt (pinned in the immutable prefix)", DEFAULT_SYSTEM).option("--transcript <path>", "Write a JSONL transcript to this path").option(
   "--harvest",
   "Extract typed plan state from R1 reasoning (Pillar 2, adds a cheap V3 call per turn)"
+).option(
+  "--branch <n>",
+  "Self-consistency: run N parallel samples per turn and pick the most confident (disables streaming; enables harvest)",
+  (v) => Number.parseInt(v, 10)
 ).action(async (opts) => {
   await chatCommand({
     model: opts.model,
     system: opts.system,
     transcript: opts.transcript,
-    harvest: !!opts.harvest
+    harvest: !!opts.harvest,
+    branch: Number.isFinite(opts.branch) && opts.branch > 1 ? opts.branch : void 0
   });
 });
 program.command("run <task>").description("Run a single task non-interactively, streaming output.").option("-m, --model <id>", "DeepSeek model id", "deepseek-chat").option("-s, --system <prompt>", "System prompt", DEFAULT_SYSTEM).action(async (task, opts) => {