reasonix 0.25.1 → 0.26.0

package/dist/index.js

@@ -451,6 +451,54 @@ function resolveTemperatures(budget, custom) {
   return out;
 }
 
+// src/core/pause-gate.ts
+var PauseGate = class {
+  _nextId = 0;
+  _pending = /* @__PURE__ */ new Map();
+  _listeners = /* @__PURE__ */ new Set();
+  /** Block until the user responds. Takes a named options object so the
+   *  kind and payload fields don't get confused at the call site. */
+  ask(opts) {
+    const { kind, payload } = opts;
+    if (this._listeners.size === 0) {
+      throw new Error(
+        `${kind}: no confirmation listener registered \u2014 cannot prompt the user. This tool can only be used inside an interactive Reasonix session.`
+      );
+    }
+    return new Promise((resolve10) => {
+      const id = this._nextId++;
+      const request = { id, kind, payload };
+      this._pending.set(id, { resolve: resolve10, request });
+      for (const fn of this._listeners) {
+        try {
+          fn(request);
+        } catch {
+        }
+      }
+    });
+  }
+  /** Resolve a pending request. Called by the App's modal callback. */
+  resolve(id, data) {
+    const p = this._pending.get(id);
+    if (!p) return;
+    this._pending.delete(id);
+    p.resolve(data);
+  }
+  /** Subscribe to new pause requests. Returns an unsubscribe function. */
+  on(fn) {
+    this._listeners.add(fn);
+    return () => {
+      this._listeners.delete(fn);
+    };
+  }
+  /** Current pending request, if any (polling fallback). */
+  get current() {
+    for (const [, p] of this._pending) return p.request;
+    return null;
+  }
+};
+var pauseGate = new PauseGate();
+
 // src/hooks.ts
 import { spawn } from "child_process";
 import { existsSync, readFileSync } from "fs";
@@ -989,7 +1037,10 @@ var ToolRegistry = class {
       }
     }
     try {
-      const result = await tool.fn(args, { signal: opts.signal });
+      const result = await tool.fn(args, {
+        signal: opts.signal,
+        confirmationGate: opts.confirmationGate
+      });
       const str = typeof result === "string" ? result : JSON.stringify(result);
       let clipped = str;
       if (opts.maxResultTokens !== void 0) {
@@ -1193,98 +1244,6 @@ function blockToString(block) {
   return `[unknown block: ${JSON.stringify(block)}]`;
 }
 
-// src/memory/runtime.ts
-import { createHash } from "crypto";
-var ImmutablePrefix = class {
-  system;
-  /** Each `addTool` costs one cache-miss turn — DeepSeek's prefix cache is keyed by full tool list. */
-  _toolSpecs;
-  fewShots;
-  /** Invalidated only via `addTool`; bypassing it leaves cache stale → fingerprint diverges from sent prefix. */
-  _fingerprintCache = null;
-  constructor(opts) {
-    this.system = opts.system;
-    this._toolSpecs = [...opts.toolSpecs ?? []];
-    this.fewShots = Object.freeze([...opts.fewShots ?? []]);
-  }
-  get toolSpecs() {
-    return this._toolSpecs;
-  }
-  toMessages() {
-    return [{ role: "system", content: this.system }, ...this.fewShots.map((m) => ({ ...m }))];
-  }
-  tools() {
-    return this._toolSpecs.map((t) => structuredClone(t));
-  }
-  addTool(spec) {
-    const name = spec.function?.name;
-    if (!name) return false;
-    if (this._toolSpecs.some((t) => t.function?.name === name)) return false;
-    this._toolSpecs.push(spec);
-    this._fingerprintCache = null;
-    return true;
-  }
-  get fingerprint() {
-    if (this._fingerprintCache !== null) return this._fingerprintCache;
-    this._fingerprintCache = this.computeFingerprint();
-    return this._fingerprintCache;
-  }
-  /** Dev/test only — throws on cache drift, which always means a non-`addTool` mutation slipped in. */
-  verifyFingerprint() {
-    const fresh = this.computeFingerprint();
-    if (this._fingerprintCache !== null && this._fingerprintCache !== fresh) {
-      throw new Error(
-        `ImmutablePrefix fingerprint drift: cached=${this._fingerprintCache}, fresh=${fresh}. A mutation path bypassed addTool's cache invalidation \u2014 DeepSeek will see prefix churn that the TUI / transcript log don't know about.`
-      );
-    }
-    this._fingerprintCache = fresh;
-    return fresh;
-  }
-  computeFingerprint() {
-    const blob = JSON.stringify({
-      system: this.system,
-      tools: this._toolSpecs,
-      shots: this.fewShots
-    });
-    return createHash("sha256").update(blob).digest("hex").slice(0, 16);
-  }
-};
-var AppendOnlyLog = class {
-  _entries = [];
-  append(message) {
-    if (!message || typeof message !== "object" || !("role" in message)) {
-      throw new Error(`invalid log entry: ${JSON.stringify(message)}`);
-    }
-    this._entries.push(message);
-  }
-  extend(messages) {
-    for (const m of messages) this.append(m);
-  }
-  /** The one append-only-breaking path — reserved for `/compact` + recovery. Use `append()` otherwise. */
-  compactInPlace(replacement) {
-    this._entries = [...replacement];
-  }
-  get entries() {
-    return this._entries;
-  }
-  toMessages() {
-    return this._entries.map((e) => ({ ...e }));
-  }
-  get length() {
-    return this._entries.length;
-  }
-};
-var VolatileScratch = class {
-  reasoning = null;
-  planState = null;
-  notes = [];
-  reset() {
-    this.reasoning = null;
-    this.planState = null;
-    this.notes = [];
-  }
-};
-
 // src/memory/session.ts
 import { execFileSync } from "child_process";
 import {
@@ -1415,6 +1374,338 @@ function countLines(path2) {
   }
 }
 
+// src/telemetry/stats.ts
+var DEEPSEEK_PRICING = {
+  "deepseek-v4-flash": { inputCacheHit: 0.028, inputCacheMiss: 0.139, output: 0.278 },
+  "deepseek-v4-pro": { inputCacheHit: 0.139, inputCacheMiss: 1.667, output: 3.333 },
+  // Compat aliases — priced as v4-flash per the deprecation notice.
+  "deepseek-chat": { inputCacheHit: 0.028, inputCacheMiss: 0.139, output: 0.278 },
+  "deepseek-reasoner": { inputCacheHit: 0.028, inputCacheMiss: 0.139, output: 0.278 }
+};
+var CLAUDE_SONNET_PRICING = { input: 3, output: 15 };
+var DEEPSEEK_CONTEXT_TOKENS = {
+  "deepseek-v4-flash": 1e6,
+  "deepseek-v4-pro": 1e6,
+  "deepseek-chat": 1e6,
+  "deepseek-reasoner": 1e6
+};
+var DEFAULT_CONTEXT_TOKENS = 131072;
+function costUsd(model, usage) {
+  const p = DEEPSEEK_PRICING[model];
+  if (!p) return 0;
+  return (usage.promptCacheHitTokens * p.inputCacheHit + usage.promptCacheMissTokens * p.inputCacheMiss + usage.completionTokens * p.output) / 1e6;
+}
+function inputCostUsd(model, usage) {
+  const p = DEEPSEEK_PRICING[model];
+  if (!p) return 0;
+  return (usage.promptCacheHitTokens * p.inputCacheHit + usage.promptCacheMissTokens * p.inputCacheMiss) / 1e6;
+}
+function outputCostUsd(model, usage) {
+  const p = DEEPSEEK_PRICING[model];
+  if (!p) return 0;
+  return usage.completionTokens * p.output / 1e6;
+}
+function cacheSavingsUsd(model, hitTokens) {
+  if (hitTokens <= 0) return 0;
+  const p = DEEPSEEK_PRICING[model];
+  if (!p) return 0;
+  return hitTokens * (p.inputCacheMiss - p.inputCacheHit) / 1e6;
+}
+function claudeEquivalentCost(usage) {
+  return (usage.promptTokens * CLAUDE_SONNET_PRICING.input + usage.completionTokens * CLAUDE_SONNET_PRICING.output) / 1e6;
+}
+var SessionStats = class {
+  turns = [];
+  record(turn, model, usage) {
+    const cost = costUsd(model, usage);
+    const stats = {
+      turn,
+      model,
+      usage,
+      cost,
+      cacheHitRatio: usage.cacheHitRatio
+    };
+    this.turns.push(stats);
+    return stats;
+  }
+  get totalCost() {
+    return this.turns.reduce((sum, t) => sum + t.cost, 0);
+  }
+  get totalClaudeEquivalent() {
+    return this.turns.reduce((sum, t) => sum + claudeEquivalentCost(t.usage), 0);
+  }
+  get savingsVsClaude() {
+    const c = this.totalClaudeEquivalent;
+    return c > 0 ? 1 - this.totalCost / c : 0;
+  }
+  get totalInputCost() {
+    return this.turns.reduce((sum, t) => sum + inputCostUsd(t.model, t.usage), 0);
+  }
+  get totalOutputCost() {
+    return this.turns.reduce((sum, t) => sum + outputCostUsd(t.model, t.usage), 0);
+  }
+  get aggregateCacheHitRatio() {
+    let hit = 0;
+    let miss = 0;
+    for (const t of this.turns) {
+      hit += t.usage.promptCacheHitTokens;
+      miss += t.usage.promptCacheMissTokens;
+    }
+    const denom = hit + miss;
+    return denom > 0 ? hit / denom : 0;
+  }
+  summary() {
+    const last = this.turns[this.turns.length - 1];
+    return {
+      turns: this.turns.length,
+      totalCostUsd: round(this.totalCost, 6),
+      totalInputCostUsd: round(this.totalInputCost, 6),
+      totalOutputCostUsd: round(this.totalOutputCost, 6),
+      claudeEquivalentUsd: round(this.totalClaudeEquivalent, 6),
+      savingsVsClaudePct: round(this.savingsVsClaude * 100, 2),
+      cacheHitRatio: round(this.aggregateCacheHitRatio, 4),
+      lastPromptTokens: last?.usage.promptTokens ?? 0,
+      lastTurnCostUsd: round(last?.cost ?? 0, 6)
+    };
+  }
+};
+function round(n, digits) {
+  const f = 10 ** digits;
+  return Math.round(n * f) / f;
+}
+
+// src/context-manager.ts
+var HISTORY_FOLD_THRESHOLD = 0.5;
+var HISTORY_FOLD_TAIL_FRACTION = 0.2;
+var HISTORY_FOLD_AGGRESSIVE_THRESHOLD = 0.7;
+var HISTORY_FOLD_AGGRESSIVE_TAIL_FRACTION = 0.1;
+var HISTORY_FOLD_MIN_SAVINGS_FRACTION = 0.3;
+var FORCE_SUMMARY_THRESHOLD = 0.8;
+var PREFLIGHT_EMERGENCY_THRESHOLD = 0.95;
+var HISTORY_FOLD_MARKER = "[CONVERSATION HISTORY SUMMARY \u2014 earlier turns folded for context efficiency]\n\n";
+var ContextManager = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  /** Decision after a turn's response — fold, exit with summary, or carry on. */
+  decideAfterUsage(usage, model, alreadyFoldedThisTurn) {
+    const ctxMax = DEEPSEEK_CONTEXT_TOKENS[model] ?? DEFAULT_CONTEXT_TOKENS;
+    if (!usage) return { kind: "none", promptTokens: 0, ctxMax, ratio: 0 };
+    const ratio = usage.promptTokens / ctxMax;
+    const base = { promptTokens: usage.promptTokens, ctxMax, ratio };
+    if (ratio > FORCE_SUMMARY_THRESHOLD) {
+      return { kind: "exit-with-summary", ...base };
+    }
+    if (alreadyFoldedThisTurn) return { kind: "none", ...base };
+    if (ratio > HISTORY_FOLD_AGGRESSIVE_THRESHOLD) {
+      return {
+        kind: "fold",
+        ...base,
+        tailBudget: Math.floor(ctxMax * HISTORY_FOLD_AGGRESSIVE_TAIL_FRACTION),
+        aggressive: true
+      };
+    }
+    if (ratio > HISTORY_FOLD_THRESHOLD) {
+      return {
+        kind: "fold",
+        ...base,
+        tailBudget: Math.floor(ctxMax * HISTORY_FOLD_TAIL_FRACTION),
+        aggressive: false
+      };
+    }
+    return { kind: "none", ...base };
+  }
+  /** Local-side preflight before sending a request — catches oversized payloads early. */
+  decidePreflight(messages, toolSpecs, model) {
+    const ctxMax = DEEPSEEK_CONTEXT_TOKENS[model] ?? DEFAULT_CONTEXT_TOKENS;
+    const estimate = estimateRequestTokens(messages, toolSpecs ?? null);
+    return {
+      needsAction: estimate / ctxMax > PREFLIGHT_EMERGENCY_THRESHOLD,
+      estimateTokens: estimate,
+      ctxMax
+    };
+  }
+  /** Replace older turns with one summary message; keep tail within keepRecentTokens budget. */
+  async fold(model, opts) {
+    const ctxMax = DEEPSEEK_CONTEXT_TOKENS[model] ?? DEFAULT_CONTEXT_TOKENS;
+    const tailBudget = opts?.keepRecentTokens ?? Math.floor(ctxMax * HISTORY_FOLD_TAIL_FRACTION);
+    const all = this.deps.log.toMessages();
+    const noop = {
+      folded: false,
+      beforeMessages: all.length,
+      afterMessages: all.length,
+      summaryChars: 0
+    };
+    if (all.length === 0) return noop;
+    const tokenCounts = all.map((m) => estimateConversationTokens([m]));
+    const totalTokens = tokenCounts.reduce((a, b) => a + b, 0);
+    let cumTokens = 0;
+    let boundary = all.length;
+    for (let i = all.length - 1; i >= 0; i--) {
+      if (cumTokens + tokenCounts[i] > tailBudget) break;
+      cumTokens += tokenCounts[i];
+      if (all[i].role === "user") boundary = i;
+    }
+    if (boundary <= 0) return noop;
+    const head = all.slice(0, boundary);
+    const tail = all.slice(boundary);
+    const headTokens = totalTokens - cumTokens;
+    if (headTokens < totalTokens * HISTORY_FOLD_MIN_SAVINGS_FRACTION) return noop;
+    const summary = await this.summarizeForFold(head);
+    if (!summary) return noop;
+    const summaryMsg = {
+      role: "assistant",
+      content: HISTORY_FOLD_MARKER + summary
+    };
+    const replacement = [summaryMsg, ...tail];
+    this.deps.log.compactInPlace(replacement);
+    this.persistRewrite(replacement);
+    return {
+      folded: true,
+      beforeMessages: all.length,
+      afterMessages: replacement.length,
+      summaryChars: summary.length
+    };
+  }
+  /** Drop a trailing in-flight assistant-with-tool_calls before a forced summary. Tail-only mutation; prefix cache safe. */
+  trimTrailingToolCalls() {
+    const tail = this.deps.log.entries[this.deps.log.entries.length - 1];
+    if (!tail || tail.role !== "assistant" || !Array.isArray(tail.tool_calls) || tail.tool_calls.length === 0) {
+      return false;
+    }
+    const kept = this.deps.log.entries.slice(0, -1);
+    this.deps.log.compactInPlace([...kept]);
+    this.persistRewrite([...kept]);
+    return true;
+  }
+  async summarizeForFold(messagesToSummarize) {
+    const summaryModel = "deepseek-v4-flash";
+    const systemPrompt = "You compress conversation history for a coding agent. Output one prose recap that preserves: the user's overall goal, decisions and conclusions reached, files inspected or modified, important tool results still relevant to ongoing work, and any open todos. Skip turn-by-turn play-by-play. No tool calls, no markdown headings, no SEARCH/REPLACE blocks \u2014 plain prose only.";
+    const healed = healLoadedMessages(messagesToSummarize, DEFAULT_MAX_RESULT_CHARS).messages;
+    const messages = [
+      { role: "system", content: systemPrompt },
+      ...healed,
+      {
+        role: "user",
+        content: "Summarize the conversation above as plain prose. This summary replaces the original turns to free context \u2014 make it self-contained."
+      }
+    ];
+    try {
+      const resp = await this.deps.client.chat({
+        model: summaryModel,
+        messages,
+        signal: this.deps.getAbortSignal(),
+        thinking: thinkingModeForModel(summaryModel),
+        reasoningEffort: "high"
+      });
+      this.deps.stats.record(this.deps.getCurrentTurn(), summaryModel, resp.usage ?? new Usage());
+      return stripHallucinatedToolMarkup((resp.content ?? "").trim());
+    } catch {
+      return "";
+    }
+  }
+  persistRewrite(messages) {
+    if (!this.deps.sessionName) return;
+    try {
+      rewriteSession(this.deps.sessionName, messages);
+    } catch {
+    }
+  }
+};
+
+// src/memory/runtime.ts
+import { createHash } from "crypto";
+var ImmutablePrefix = class {
+  system;
+  /** Each `addTool` costs one cache-miss turn — DeepSeek's prefix cache is keyed by full tool list. */
+  _toolSpecs;
+  fewShots;
+  /** Invalidated only via `addTool`; bypassing it leaves cache stale → fingerprint diverges from sent prefix. */
+  _fingerprintCache = null;
+  constructor(opts) {
+    this.system = opts.system;
+    this._toolSpecs = [...opts.toolSpecs ?? []];
+    this.fewShots = Object.freeze([...opts.fewShots ?? []]);
+  }
+  get toolSpecs() {
+    return this._toolSpecs;
+  }
+  toMessages() {
+    return [{ role: "system", content: this.system }, ...this.fewShots.map((m) => ({ ...m }))];
+  }
+  tools() {
+    return this._toolSpecs.map((t) => structuredClone(t));
+  }
+  addTool(spec) {
+    const name = spec.function?.name;
+    if (!name) return false;
+    if (this._toolSpecs.some((t) => t.function?.name === name)) return false;
+    this._toolSpecs.push(spec);
+    this._fingerprintCache = null;
+    return true;
+  }
+  get fingerprint() {
+    if (this._fingerprintCache !== null) return this._fingerprintCache;
+    this._fingerprintCache = this.computeFingerprint();
+    return this._fingerprintCache;
+  }
+  /** Dev/test only — throws on cache drift, which always means a non-`addTool` mutation slipped in. */
+  verifyFingerprint() {
+    const fresh = this.computeFingerprint();
+    if (this._fingerprintCache !== null && this._fingerprintCache !== fresh) {
+      throw new Error(
+        `ImmutablePrefix fingerprint drift: cached=${this._fingerprintCache}, fresh=${fresh}. A mutation path bypassed addTool's cache invalidation \u2014 DeepSeek will see prefix churn that the TUI / transcript log don't know about.`
+      );
+    }
+    this._fingerprintCache = fresh;
+    return fresh;
+  }
+  computeFingerprint() {
+    const blob = JSON.stringify({
+      system: this.system,
+      tools: this._toolSpecs,
+      shots: this.fewShots
+    });
+    return createHash("sha256").update(blob).digest("hex").slice(0, 16);
+  }
+};
+var AppendOnlyLog = class {
+  _entries = [];
+  append(message) {
+    if (!message || typeof message !== "object" || !("role" in message)) {
+      throw new Error(`invalid log entry: ${JSON.stringify(message)}`);
+    }
+    this._entries.push(message);
+  }
+  extend(messages) {
+    for (const m of messages) this.append(m);
+  }
+  /** The one append-only-breaking path — reserved for `/compact` + recovery. Use `append()` otherwise. */
+  compactInPlace(replacement) {
+    this._entries = [...replacement];
+  }
+  get entries() {
+    return this._entries;
+  }
+  toMessages() {
+    return this._entries.map((e) => ({ ...e }));
+  }
+  get length() {
+    return this._entries.length;
+  }
+};
+var VolatileScratch = class {
+  reasoning = null;
+  planState = null;
+  notes = [];
+  reset() {
+    this.reasoning = null;
+    this.planState = null;
+    this.notes = [];
+  }
+};
+
 // src/repair/scavenge.ts
 function scavengeToolCalls(reasoningContent, opts) {
   if (!reasoningContent) return { calls: [], notes: [] };
@@ -1643,182 +1934,80 @@ function repairTruncatedJson(input) {
   }
   while (stack.length > 0) {
     const top = stack.pop();
-    if (top === "{") s += "}";
-    else if (top === "[") s += "]";
-    else if (top === '"') s += '"';
-  }
-  try {
-    JSON.parse(s);
-    return { repaired: s, changed: true, notes };
-  } catch (err) {
-    notes.push(`fallback to {}: ${err.message}`);
-    return { repaired: "{}", changed: true, notes };
-  }
-}
-
-// src/repair/index.ts
-var ToolCallRepair = class {
-  storm;
-  opts;
-  constructor(opts) {
-    this.opts = opts;
-    this.storm = new StormBreaker(opts.stormWindow ?? 6, opts.stormThreshold ?? 3, opts.isMutating);
-  }
-  /** Called at start of every user turn — fresh intent shouldn't inherit old repetition state. */
-  resetStorm() {
-    this.storm.reset();
-  }
-  process(declaredCalls, reasoningContent, content = null) {
-    const report = {
-      scavenged: 0,
-      truncationsFixed: 0,
-      stormsBroken: 0,
-      notes: []
-    };
-    const combined = [reasoningContent ?? "", content ?? ""].filter(Boolean).join("\n");
-    const scavenged = scavengeToolCalls(combined || null, {
-      allowedNames: this.opts.allowedToolNames,
-      maxCalls: this.opts.maxScavenge ?? 4
-    });
-    const seenSignatures = new Set(declaredCalls.map(signature));
-    const merged = [...declaredCalls];
-    for (const sc of scavenged.calls) {
-      if (!seenSignatures.has(signature(sc))) {
-        merged.push(sc);
-        report.scavenged++;
-        seenSignatures.add(signature(sc));
-      }
-    }
-    report.notes.push(...scavenged.notes);
-    for (const call of merged) {
-      const args = call.function?.arguments ?? "";
-      const r = repairTruncatedJson(args);
-      if (r.changed) {
-        call.function.arguments = r.repaired;
-        report.truncationsFixed++;
-        report.notes.push(...r.notes.map((n) => `[${call.function.name}] ${n}`));
-      }
-    }
-    const filtered = [];
-    for (const call of merged) {
-      const verdict = this.storm.inspect(call);
-      if (verdict.suppress) {
-        report.stormsBroken++;
-        if (verdict.reason) report.notes.push(verdict.reason);
-        continue;
-      }
-      filtered.push(call);
-    }
-    return { calls: filtered, report };
-  }
-};
-function signature(call) {
-  return `${call.function?.name ?? ""}::${call.function?.arguments ?? ""}`;
-}
-
-// src/telemetry/stats.ts
-var DEEPSEEK_PRICING = {
-  "deepseek-v4-flash": { inputCacheHit: 0.028, inputCacheMiss: 0.139, output: 0.278 },
-  "deepseek-v4-pro": { inputCacheHit: 0.139, inputCacheMiss: 1.667, output: 3.333 },
-  // Compat aliases — priced as v4-flash per the deprecation notice.
-  "deepseek-chat": { inputCacheHit: 0.028, inputCacheMiss: 0.139, output: 0.278 },
-  "deepseek-reasoner": { inputCacheHit: 0.028, inputCacheMiss: 0.139, output: 0.278 }
-};
-var CLAUDE_SONNET_PRICING = { input: 3, output: 15 };
-var DEEPSEEK_CONTEXT_TOKENS = {
-  "deepseek-v4-flash": 1e6,
-  "deepseek-v4-pro": 1e6,
-  "deepseek-chat": 1e6,
-  "deepseek-reasoner": 1e6
-};
-var DEFAULT_CONTEXT_TOKENS = 131072;
-function costUsd(model, usage) {
-  const p = DEEPSEEK_PRICING[model];
-  if (!p) return 0;
-  return (usage.promptCacheHitTokens * p.inputCacheHit + usage.promptCacheMissTokens * p.inputCacheMiss + usage.completionTokens * p.output) / 1e6;
-}
-function inputCostUsd(model, usage) {
-  const p = DEEPSEEK_PRICING[model];
-  if (!p) return 0;
-  return (usage.promptCacheHitTokens * p.inputCacheHit + usage.promptCacheMissTokens * p.inputCacheMiss) / 1e6;
-}
-function outputCostUsd(model, usage) {
-  const p = DEEPSEEK_PRICING[model];
-  if (!p) return 0;
-  return usage.completionTokens * p.output / 1e6;
-}
-function cacheSavingsUsd(model, hitTokens) {
-  if (hitTokens <= 0) return 0;
-  const p = DEEPSEEK_PRICING[model];
-  if (!p) return 0;
-  return hitTokens * (p.inputCacheMiss - p.inputCacheHit) / 1e6;
-}
-function claudeEquivalentCost(usage) {
-  return (usage.promptTokens * CLAUDE_SONNET_PRICING.input + usage.completionTokens * CLAUDE_SONNET_PRICING.output) / 1e6;
-}
-var SessionStats = class {
-  turns = [];
-  record(turn, model, usage) {
-    const cost = costUsd(model, usage);
-    const stats = {
-      turn,
-      model,
-      usage,
-      cost,
-      cacheHitRatio: usage.cacheHitRatio
-    };
-    this.turns.push(stats);
-    return stats;
-  }
-  get totalCost() {
-    return this.turns.reduce((sum, t) => sum + t.cost, 0);
-  }
-  get totalClaudeEquivalent() {
-    return this.turns.reduce((sum, t) => sum + claudeEquivalentCost(t.usage), 0);
-  }
-  get savingsVsClaude() {
-    const c = this.totalClaudeEquivalent;
-    return c > 0 ? 1 - this.totalCost / c : 0;
+    if (top === "{") s += "}";
+    else if (top === "[") s += "]";
+    else if (top === '"') s += '"';
   }
-  get totalInputCost() {
-    return this.turns.reduce((sum, t) => sum + inputCostUsd(t.model, t.usage), 0);
+  try {
+    JSON.parse(s);
+    return { repaired: s, changed: true, notes };
+  } catch (err) {
+    notes.push(`fallback to {}: ${err.message}`);
+    return { repaired: "{}", changed: true, notes };
   }
-  get totalOutputCost() {
-    return this.turns.reduce((sum, t) => sum + outputCostUsd(t.model, t.usage), 0);
+}
+
+// src/repair/index.ts
+var ToolCallRepair = class {
+  storm;
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+    this.storm = new StormBreaker(opts.stormWindow ?? 6, opts.stormThreshold ?? 3, opts.isMutating);
   }
-  get aggregateCacheHitRatio() {
-    let hit = 0;
-    let miss = 0;
-    for (const t of this.turns) {
-      hit += t.usage.promptCacheHitTokens;
-      miss += t.usage.promptCacheMissTokens;
-    }
-    const denom = hit + miss;
-    return denom > 0 ? hit / denom : 0;
+  /** Called at start of every user turn — fresh intent shouldn't inherit old repetition state. */
+  resetStorm() {
+    this.storm.reset();
   }
-  summary() {
-    const last = this.turns[this.turns.length - 1];
-    return {
-      turns: this.turns.length,
-      totalCostUsd: round(this.totalCost, 6),
-      totalInputCostUsd: round(this.totalInputCost, 6),
-      totalOutputCostUsd: round(this.totalOutputCost, 6),
-      claudeEquivalentUsd: round(this.totalClaudeEquivalent, 6),
-      savingsVsClaudePct: round(this.savingsVsClaude * 100, 2),
-      cacheHitRatio: round(this.aggregateCacheHitRatio, 4),
-      lastPromptTokens: last?.usage.promptTokens ?? 0,
-      lastTurnCostUsd: round(last?.cost ?? 0, 6)
+  process(declaredCalls, reasoningContent, content = null) {
+    const report = {
+      scavenged: 0,
+      truncationsFixed: 0,
+      stormsBroken: 0,
+      notes: []
     };
+    const combined = [reasoningContent ?? "", content ?? ""].filter(Boolean).join("\n");
+    const scavenged = scavengeToolCalls(combined || null, {
+      allowedNames: this.opts.allowedToolNames,
+      maxCalls: this.opts.maxScavenge ?? 4
+    });
+    const seenSignatures = new Set(declaredCalls.map(signature));
+    const merged = [...declaredCalls];
+    for (const sc of scavenged.calls) {
+      if (!seenSignatures.has(signature(sc))) {
+        merged.push(sc);
+        report.scavenged++;
+        seenSignatures.add(signature(sc));
+      }
+    }
+    report.notes.push(...scavenged.notes);
+    for (const call of merged) {
+      const args = call.function?.arguments ?? "";
+      const r = repairTruncatedJson(args);
+      if (r.changed) {
+        call.function.arguments = r.repaired;
+        report.truncationsFixed++;
+        report.notes.push(...r.notes.map((n) => `[${call.function.name}] ${n}`));
+      }
+    }
+    const filtered = [];
+    for (const call of merged) {
+      const verdict = this.storm.inspect(call);
+      if (verdict.suppress) {
+        report.stormsBroken++;
+        if (verdict.reason) report.notes.push(verdict.reason);
+        continue;
+      }
+      filtered.push(call);
+    }
+    return { calls: filtered, report };
   }
 };
-function round(n, digits) {
-  const f = 10 ** digits;
-  return Math.round(n * f) / f;
+function signature(call) {
+  return `${call.function?.name ?? ""}::${call.function?.arguments ?? ""}`;
 }
 
 // src/loop.ts
-var ARGS_COMPACT_THRESHOLD_TOKENS = 800;
-var TURN_END_RESULT_CAP_TOKENS = 3e3;
 var FAILURE_ESCALATION_THRESHOLD = 3;
 var ESCALATION_MODEL = "deepseek-v4-pro";
 var NEEDS_PRO_MARKER_PREFIX = "<<<NEEDS_PRO";
@@ -1849,6 +2038,8 @@ var CacheFirstLoop = class {
   sessionName;
   hooks;
   hookCwd;
+  /** PauseGate bridge — defaults to singleton, injectable for tests. */
+  confirmationGate;
   /** Number of messages that were pre-loaded from the session file. */
   resumedMessageCount;
   _turn = 0;
@@ -1860,6 +2051,8 @@ var CacheFirstLoop = class {
   _turnFailureCount = 0;
   _turnFailureTypes = {};
   _turnSelfCorrected = false;
+  _foldedThisTurn = false;
+  context;
   constructor(opts) {
     this.client = opts.client;
     this.prefix = opts.prefix;
@@ -1871,6 +2064,7 @@ var CacheFirstLoop = class {
     this.maxToolIters = opts.maxToolIters ?? 64;
     this.hooks = opts.hooks ?? [];
     this.hookCwd = opts.hookCwd ?? process.cwd();
+    this.confirmationGate = opts.confirmationGate ?? pauseGate;
     if (typeof opts.branch === "number") {
       this.branchOptions = { budget: opts.branch };
     } else if (opts.branch && typeof opts.branch === "object") {
@@ -1933,54 +2127,18 @@ var CacheFirstLoop = class {
     } else {
       this.resumedMessageCount = 0;
     }
+    this.context = new ContextManager({
+      client: this.client,
+      log: this.log,
+      stats: this.stats,
+      sessionName: this.sessionName,
+      getAbortSignal: () => this._turnAbort.signal,
+      getCurrentTurn: () => this._turn
+    });
   }
-  /** Shrink huge edit_file/write_file args post-dispatch — tool result already explains. */
-  compactToolCallArgsAfterResponse() {
-    const before = this.log.toMessages();
-    const { messages, healedCount } = shrinkOversizedToolCallArgsByTokens(
-      before,
-      ARGS_COMPACT_THRESHOLD_TOKENS
-    );
-    if (healedCount === 0) return;
-    this.log.compactInPlace(messages);
-    if (this.sessionName) {
-      try {
-        rewriteSession(this.sessionName, messages);
-      } catch {
-      }
-    }
-  }
-  /** Preventive end-of-turn shrink — trim big results before they ride into the next prompt. */
-  autoCompactToolResultsOnTurnEnd() {
-    const before = this.log.toMessages();
-    const shrunk = shrinkOversizedToolResultsByTokens(before, TURN_END_RESULT_CAP_TOKENS);
-    if (shrunk.healedCount === 0) return;
-    this.log.compactInPlace(shrunk.messages);
-    if (this.sessionName) {
-      try {
-        rewriteSession(this.sessionName, shrunk.messages);
-      } catch {
-      }
-    }
-  }
-  compact(maxTokens = 4e3) {
-    const before = this.log.toMessages();
-    const resultsPass = shrinkOversizedToolResultsByTokens(before, maxTokens);
-    const argsPass = shrinkOversizedToolCallArgsByTokens(resultsPass.messages, maxTokens);
-    const messages = argsPass.messages;
-    const healedCount = resultsPass.healedCount + argsPass.healedCount;
-    const tokensSaved = resultsPass.tokensSaved + argsPass.tokensSaved;
-    const charsSaved = resultsPass.charsSaved + argsPass.charsSaved;
-    if (healedCount > 0) {
-      this.log.compactInPlace(messages);
-      if (this.sessionName) {
-        try {
-          rewriteSession(this.sessionName, messages);
-        } catch {
-        }
-      }
-    }
-    return { healedCount, tokensSaved, charsSaved };
+  /** Replace older turns with one summary message; keep tail within keepRecentTokens budget. */
+  async compactHistory(opts) {
+    return this.context.fold(this.model, opts);
   }
   appendAndPersist(message) {
     this.log.append(message);
@@ -2178,6 +2336,7 @@ var CacheFirstLoop = class {
     this._turnFailureTypes = {};
     this._turnSelfCorrected = false;
     this._escalateThisTurn = false;
+    this._foldedThisTurn = false;
     let armedConsumed = false;
     if (this._proArmedForNextTurn) {
       this._escalateThisTurn = true;
@@ -2214,7 +2373,6 @@ var CacheFirstLoop = class {
           content: stoppedMsg,
           forcedSummary: true
         };
-        this.autoCompactToolResultsOnTurnEnd();
         yield { turn: this._turn, role: "done", content: stoppedMsg };
         this._turnAbort = new AbortController();
         return;
@@ -2236,26 +2394,31 @@ var CacheFirstLoop = class {
       }
       let messages = this.buildMessages(pendingUser);
       {
-        const ctxMax2 = DEEPSEEK_CONTEXT_TOKENS[this.model] ?? DEFAULT_CONTEXT_TOKENS;
-        const estimate = estimateRequestTokens(messages, this.prefix.toolSpecs);
-        if (estimate / ctxMax2 > 0.95) {
-          const result = this.compact(1e3);
-          if (result.healedCount > 0) {
+        const decision2 = this.context.decidePreflight(messages, this.prefix.toolSpecs, this.model);
+        if (decision2.needsAction) {
+          const { estimateTokens: estimate, ctxMax } = decision2;
+          yield {
+            turn: this._turn,
+            role: "status",
+            content: "preflight: context near full, attempting fold\u2026"
+          };
+          const result = await this.context.fold(this.model);
+          if (result.folded) {
             yield {
               turn: this._turn,
               role: "warning",
-              content: `preflight: request ~${estimate.toLocaleString()}/${ctxMax2.toLocaleString()} tokens (${Math.round(
-                estimate / ctxMax2 * 100
-              )}%) \u2014 pre-compacted ${result.healedCount} tool result(s), saved ${result.tokensSaved.toLocaleString()} tokens. Sending.`
+              content: `preflight: request ~${estimate.toLocaleString()}/${ctxMax.toLocaleString()} tokens (${Math.round(
+                estimate / ctxMax * 100
+              )}%) \u2014 folded ${result.beforeMessages} messages \u2192 ${result.afterMessages} (summary ${result.summaryChars} chars). Sending.`
             };
             messages = this.buildMessages(pendingUser);
           } else {
             yield {
               turn: this._turn,
               role: "warning",
-              content: `preflight: request ~${estimate.toLocaleString()}/${ctxMax2.toLocaleString()} tokens (${Math.round(
-                estimate / ctxMax2 * 100
-              )}%) and nothing to auto-compact \u2014 DeepSeek will likely 400. Run /forget or /clear to start fresh.`
+              content: `preflight: request ~${estimate.toLocaleString()}/${ctxMax.toLocaleString()} tokens (${Math.round(
+                estimate / ctxMax * 100
+              )}%) and nothing left to fold \u2014 DeepSeek will likely 400. Run /clear or /new to start fresh.`
             };
           }
         }
@@ -2450,7 +2613,6 @@ var CacheFirstLoop = class {
         }
       } catch (err) {
         if (signal.aborted) {
-          this.autoCompactToolResultsOnTurnEnd();
           yield { turn: this._turn, role: "done", content: "" };
           this._turnAbort = new AbortController();
           return;
@@ -2568,60 +2730,43 @@ var CacheFirstLoop = class {
           yield* this.forceSummaryAfterIterLimit({ reason: "stuck" });
           return;
         }
-        this.autoCompactToolResultsOnTurnEnd();
         yield { turn: this._turn, role: "done", content: assistantContent };
         return;
       }
-      const ctxMax = DEEPSEEK_CONTEXT_TOKENS[this.model] ?? DEFAULT_CONTEXT_TOKENS;
-      if (usage) {
-        const ratio = usage.promptTokens / ctxMax;
-        if (ratio > 0.4 && ratio <= 0.8) {
-          const before = usage.promptTokens;
-          const soft = this.compact(4e3);
-          if (soft.healedCount > 0) {
-            const after = Math.max(0, before - soft.tokensSaved);
-            yield {
-              turn: this._turn,
-              role: "warning",
-              content: `context ${before.toLocaleString()}/${ctxMax.toLocaleString()} (${Math.round(
-                ratio * 100
-              )}%) \u2014 proactively compacted ${soft.healedCount} tool result(s) to 4k tokens, saved ${soft.tokensSaved.toLocaleString()} tokens (now ~${after.toLocaleString()}). Staying ahead of the 80% guard.`
-            };
-          }
-        }
-      }
-      if (usage && usage.promptTokens / ctxMax > 0.8) {
-        const before = usage.promptTokens;
-        const compactResult = this.compact(1e3);
-        if (compactResult.healedCount > 0) {
-          const after = Math.max(0, before - compactResult.tokensSaved);
-          yield {
-            turn: this._turn,
-            role: "warning",
-            content: `context ${before.toLocaleString()}/${ctxMax.toLocaleString()} \u2014 auto-compacted ${compactResult.healedCount} oversized tool result(s), saved ${compactResult.tokensSaved.toLocaleString()} tokens (now ~${after.toLocaleString()}). Continuing.`
-          };
-        } else {
+      const decision = this.context.decideAfterUsage(usage, this.model, this._foldedThisTurn);
+      if (decision.kind === "fold") {
+        this._foldedThisTurn = true;
+        const before = decision.promptTokens;
+        const ctxMax = decision.ctxMax;
+        const aggressiveTag = decision.aggressive ? " (aggressive)" : "";
+        yield {
+          turn: this._turn,
+          role: "status",
+          content: `compacting history${aggressiveTag}\u2026`
+        };
+        const result = await this.compactHistory({ keepRecentTokens: decision.tailBudget });
+        if (result.folded) {
           yield {
             turn: this._turn,
             role: "warning",
             content: `context ${before.toLocaleString()}/${ctxMax.toLocaleString()} (${Math.round(
               before / ctxMax * 100
-            )}%) \u2014 nothing to auto-compact. Forcing summary from what was gathered.`
+            )}%) \u2014 ${decision.aggressive ? "aggressively folded" : "folded"} ${result.beforeMessages} messages \u2192 ${result.afterMessages} (summary ${result.summaryChars} chars). Continuing.`
           };
-          const tail = this.log.entries[this.log.entries.length - 1];
-          if (tail && tail.role === "assistant" && Array.isArray(tail.tool_calls) && tail.tool_calls.length > 0) {
-            const kept = this.log.entries.slice(0, -1);
-            this.log.compactInPlace([...kept]);
-            if (this.sessionName) {
-              try {
-                rewriteSession(this.sessionName, kept);
-              } catch {
-              }
-            }
-          }
-          yield* this.forceSummaryAfterIterLimit({ reason: "context-guard" });
-          return;
         }
+      } else if (decision.kind === "exit-with-summary") {
+        const before = decision.promptTokens;
+        const ctxMax = decision.ctxMax;
+        yield {
+          turn: this._turn,
+          role: "warning",
+          content: `context ${before.toLocaleString()}/${ctxMax.toLocaleString()} (${Math.round(
+            before / ctxMax * 100
+          )}%) \u2014 forcing summary from what was gathered. Run /compact, /clear, or /new to reset.`
+        };
+        this.context.trimTrailingToolCalls();
+        yield* this.forceSummaryAfterIterLimit({ reason: "context-guard" });
+        return;
       }
       for (const call of repairedCalls) {
         const name = call.function?.name ?? "";
@@ -2653,7 +2798,8 @@ ${reason}`;
         } else {
           result = await this.tools.dispatch(name, args, {
             signal,
-            maxResultTokens: DEFAULT_MAX_RESULT_TOKENS
+            maxResultTokens: DEFAULT_MAX_RESULT_TOKENS,
+            confirmationGate: this.confirmationGate
           });
           const postReport = await runHooks({
             hooks: this.hooks,
@@ -2673,7 +2819,6 @@ ${reason}`;
           name,
           content: result
         });
-        this.compactToolCallArgsAfterResponse();
         if (this.noteToolFailureSignal(result)) {
           yield {
             turn: this._turn,
@@ -2732,7 +2877,6 @@ ${summary}`;
         stats: summaryStats,
         forcedSummary: true
       };
-      this.autoCompactToolResultsOnTurnEnd();
       yield { turn: this._turn, role: "done", content: summary };
     } catch (err) {
       const label = errorLabelFor(opts.reason, this.maxToolIters);
@@ -2742,7 +2886,6 @@ ${summary}`;
         content: "",
         error: `${label} and the fallback summary call failed: ${err.message}. Run /clear and retry with a narrower question, or raise --max-tool-iters.`
       };
-      this.autoCompactToolResultsOnTurnEnd();
       yield { turn: this._turn, role: "done", content: "" };
     }
   }
@@ -2871,56 +3014,6 @@ function shrinkOversizedToolResultsByTokens(messages, maxTokens) {
   });
   return { messages: out, healedCount, tokensSaved, charsSaved };
 }
-function shrinkOversizedToolCallArgsByTokens(messages, maxTokens) {
-  let healedCount = 0;
-  let tokensSaved = 0;
-  let charsSaved = 0;
-  const out = messages.map((msg) => {
-    if (msg.role !== "assistant" || !Array.isArray(msg.tool_calls)) return msg;
-    let changed = false;
-    const newCalls = msg.tool_calls.map((call) => {
-      const args = call.function?.arguments;
-      if (typeof args !== "string" || args.length <= maxTokens) return call;
-      const beforeTokens = countTokens(args);
-      if (beforeTokens <= maxTokens) return call;
-      const shrunk = shrinkJsonLongStrings(args);
-      const afterTokens = countTokens(shrunk);
-      if (afterTokens >= beforeTokens) return call;
-      changed = true;
-      healedCount += 1;
-      tokensSaved += beforeTokens - afterTokens;
-      charsSaved += args.length - shrunk.length;
-      return { ...call, function: { ...call.function, arguments: shrunk } };
-    });
-    if (!changed) return msg;
-    return { ...msg, tool_calls: newCalls };
-  });
-  return { messages: out, healedCount, tokensSaved, charsSaved };
-}
-function shrinkJsonLongStrings(jsonStr) {
-  let parsed;
-  try {
-    parsed = JSON.parse(jsonStr);
-  } catch {
-    const head = jsonStr.slice(0, 200);
-    return `${head}\u2026[shrunk: ${jsonStr.length} chars, unparsed]`;
-  }
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    return jsonStr;
-  }
-  const LONG_THRESHOLD = 300;
-  const input = parsed;
-  const output = {};
-  for (const [k, v] of Object.entries(input)) {
-    if (typeof v === "string" && v.length > LONG_THRESHOLD) {
-      const newlines = v.match(/\n/g)?.length ?? 0;
-      output[k] = `[\u2026shrunk: ${v.length} chars, ${newlines} lines \u2014 tool already responded, see result]`;
-    } else {
-      output[k] = v;
-    }
-  }
-  return JSON.stringify(output);
-}
 function fixToolCallPairing(messages) {
   const out = [];
   let droppedAssistantCalls = 0;
@@ -4876,7 +4969,7 @@ function registerChoiceTool(registry, opts = {}) {
       },
       required: ["question", "options"]
     },
-    fn: async (args) => {
+    fn: async (args, ctx) => {
       const question = (args?.question ?? "").trim();
       if (!question) {
         throw new Error(
@@ -4896,7 +4989,13 @@ function registerChoiceTool(registry, opts = {}) {
       }
       const allowCustom = args?.allowCustom === true;
       opts.onChoiceRequested?.(question, options);
-      throw new ChoiceRequestedError(question, options, allowCustom);
+      const verdict = await (ctx?.confirmationGate ?? pauseGate).ask({
+        kind: "choice",
+        payload: { question, options, allowCustom }
+      });
+      if (verdict.type === "pick") return `user picked: ${verdict.optionId}`;
+      if (verdict.type === "text") return `user answered: ${verdict.text}`;
+      return "user cancelled the choice";
     }
   });
   return registry;
@@ -5013,7 +5112,7 @@ function registerSubmitPlan(registry, opts) {
       },
       required: ["plan"]
     },
-    fn: async (args) => {
+    fn: async (args, ctx) => {
       const plan = (args?.plan ?? "").trim();
       if (!plan) {
         throw new Error("submit_plan: empty plan \u2014 write a markdown plan and try again.");
@@ -5021,7 +5120,13 @@ function registerSubmitPlan(registry, opts) {
       const steps = sanitizeSteps(args?.steps);
       const summary = typeof args?.summary === "string" ? args.summary.trim() || void 0 : void 0;
       opts.onPlanSubmitted?.(plan, steps);
-      throw new PlanProposedError(plan, steps, summary);
+      const verdict = await (ctx?.confirmationGate ?? pauseGate).ask({
+        kind: "plan_proposed",
+        payload: { plan, steps, summary }
+      });
+      if (verdict.type === "approve") return "plan approved";
+      if (verdict.type === "refine") throw new Error("user requested refinement");
+      throw new Error("plan cancelled");
     }
   });
 }
@@ -5052,7 +5157,7 @@ function registerMarkStepComplete(registry, opts) {
       },
       required: ["stepId", "result"]
     },
-    fn: async (args) => {
+    fn: async (args, ctx) => {
       const stepId = (args?.stepId ?? "").trim();
       const result = (args?.result ?? "").trim();
       if (!stepId) {
@@ -5069,7 +5174,16 @@ function registerMarkStepComplete(registry, opts) {
       if (title) update.title = title;
       if (notes) update.notes = notes;
       opts.onStepCompleted?.(update);
-      return update;
+      const verdict = await (ctx?.confirmationGate ?? pauseGate).ask({
+        kind: "plan_checkpoint",
+        payload: { stepId, title, result, notes }
+      });
+      if (verdict.type === "continue") return JSON.stringify(update);
+      if (verdict.type === "revise") {
+        if (verdict.feedback) return `revision requested: ${verdict.feedback}`;
+        throw new Error("user requested revision at checkpoint");
+      }
+      throw new Error("user stopped at checkpoint");
     }
   });
 }
@@ -5097,7 +5211,7 @@ function registerRevisePlan(registry, opts) {
       },
       required: ["reason", "remainingSteps"]
     },
-    fn: async (args) => {
+    fn: async (args, ctx) => {
       const reason = (args?.reason ?? "").trim();
       if (!reason) {
         throw new Error(
@@ -5112,7 +5226,13 @@ function registerRevisePlan(registry, opts) {
       }
       const summary = typeof args?.summary === "string" ? args.summary.trim() || void 0 : void 0;
       opts.onPlanRevisionProposed?.(reason, remainingSteps, summary);
-      throw new PlanRevisionProposedError(reason, remainingSteps, summary);
+      const verdict = await (ctx?.confirmationGate ?? pauseGate).ask({
+        kind: "plan_revision",
+        payload: { reason, remainingSteps, summary }
+      });
+      if (verdict.type === "accepted") return "revision accepted";
+      if (verdict.type === "rejected") throw new Error("revision rejected");
+      throw new Error("revision cancelled");
     }
   });
 }
@@ -5371,6 +5491,60 @@ import { spawn as spawn4, spawnSync } from "child_process";
 import { existsSync as existsSync8, statSync as statSync4 } from "fs";
 import * as pathMod4 from "path";
 
+// src/config.ts
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync9, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir5 } from "os";
+import { dirname as dirname4, join as join9 } from "path";
+function defaultConfigPath() {
+  return join9(homedir5(), ".reasonix", "config.json");
+}
+function readConfig(path2 = defaultConfigPath()) {
+  try {
+    const raw = readFileSync9(path2, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object") return parsed;
+  } catch {
+  }
+  return {};
+}
+function writeConfig(cfg, path2 = defaultConfigPath()) {
+  mkdirSync3(dirname4(path2), { recursive: true });
+  writeFileSync3(path2, JSON.stringify(cfg, null, 2), "utf8");
+  try {
+    chmodSync2(path2, 384);
+  } catch {
+  }
+}
+function loadApiKey(path2 = defaultConfigPath()) {
+  if (process.env.DEEPSEEK_API_KEY) return process.env.DEEPSEEK_API_KEY;
+  return readConfig(path2).apiKey;
+}
+function saveApiKey(key, path2 = defaultConfigPath()) {
+  const cfg = readConfig(path2);
+  cfg.apiKey = key.trim();
+  writeConfig(cfg, path2);
+}
+function addProjectShellAllowed(rootDir, prefix, path2 = defaultConfigPath()) {
+  const trimmed = prefix.trim();
+  if (!trimmed) return;
+  const cfg = readConfig(path2);
+  if (!cfg.projects) cfg.projects = {};
+  if (!cfg.projects[rootDir]) cfg.projects[rootDir] = {};
+  const existing = cfg.projects[rootDir].shellAllowed ?? [];
+  if (existing.includes(trimmed)) return;
+  cfg.projects[rootDir].shellAllowed = [...existing, trimmed];
+  writeConfig(cfg, path2);
+}
+function isPlausibleKey(key) {
+  const trimmed = key.trim();
+  return /^sk-[A-Za-z0-9_-]{16,}$/.test(trimmed);
+}
+function redactKey(key) {
+  if (!key) return "";
+  if (key.length <= 12) return "****";
+  return `${key.slice(0, 6)}\u2026${key.slice(-4)}`;
+}
+
 // src/tools/jobs.ts
 import { spawn as spawn2 } from "child_process";
 import * as pathMod2 from "path";
@@ -6498,7 +6672,16 @@ function registerShellTools(registry, opts) {
       const cmd = args.command.trim();
       if (!cmd) throw new Error("run_command: empty command");
       if (!isAllowAll() && !isCommandAllowed(cmd, getExtraAllowed())) {
-        throw new NeedsConfirmationError(cmd);
+        const gate = ctx?.confirmationGate ?? pauseGate;
+        const choice = await gate.ask({ kind: "run_command", payload: { command: cmd } });
+        if (choice.type === "deny") {
+          throw new Error(
+            `user denied: ${cmd}${choice.denyContext ? ` \u2014 ${choice.denyContext}` : ""}`
+          );
+        }
+        if (choice.type === "always_allow") {
+          addProjectShellAllowed(rootDir, choice.prefix);
+        }
       }
       const effectiveTimeout = Math.max(1, Math.min(600, args.timeoutSec ?? timeoutSec));
       const result = await runCommand(cmd, {
@@ -6530,8 +6713,17 @@ function registerShellTools(registry, opts) {
     fn: async (args, ctx) => {
       const cmd = args.command.trim();
       if (!cmd) throw new Error("run_background: empty command");
-      if (!isAllowAll() && !isAllowed(cmd, getExtraAllowed())) {
-        throw new NeedsConfirmationError(cmd);
+      if (!isAllowAll() && !isCommandAllowed(cmd, getExtraAllowed())) {
+        const gate = ctx?.confirmationGate ?? pauseGate;
+        const choice = await gate.ask({ kind: "run_background", payload: { command: cmd } });
+        if (choice.type === "deny") {
+          throw new Error(
+            `user denied: ${cmd}${choice.denyContext ? ` \u2014 ${choice.denyContext}` : ""}`
+          );
+        }
+        if (choice.type === "always_allow") {
+          addProjectShellAllowed(rootDir, choice.prefix);
+        }
       }
       const result = await jobs.start(cmd, {
         cwd: rootDir,
@@ -6860,12 +7052,12 @@ ${i + 1}. ${r.title}`);
 }
 
 // src/env.ts
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 import { resolve as resolve8 } from "path";
 function loadDotenv(path2 = ".env") {
   let raw;
   try {
-    raw = readFileSync9(resolve8(process.cwd(), path2), "utf8");
+    raw = readFileSync10(resolve8(process.cwd(), path2), "utf8");
   } catch {
     return;
   }
@@ -6884,7 +7076,7 @@ function loadDotenv(path2 = ".env") {
 }
 
 // src/transcript/log.ts
-import { createWriteStream, readFileSync as readFileSync10 } from "fs";
+import { createWriteStream, readFileSync as readFileSync11 } from "fs";
 function recordFromLoopEvent(ev, extra) {
   const rec = {
     ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -6935,7 +7127,7 @@ function openTranscriptFile(path2, meta) {
   return stream;
 }
 function readTranscript(path2) {
-  const raw = readFileSync10(path2, "utf8");
+  const raw = readFileSync11(path2, "utf8");
   return parseTranscript(raw);
 }
 function isPlanStateEmptyShape(s) {
@@ -7382,25 +7574,25 @@ function truncate(s, n) {
 }
 
 // src/version.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync3, readFileSync as readFileSync11, writeFileSync as writeFileSync3 } from "fs";
-import { homedir as homedir5 } from "os";
-import { dirname as dirname4, join as join9 } from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync12, writeFileSync as writeFileSync4 } from "fs";
+import { homedir as homedir6 } from "os";
+import { dirname as dirname5, join as join10 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var REGISTRY_URL = "https://registry.npmjs.org/reasonix/latest";
 var LATEST_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 var LATEST_FETCH_TIMEOUT_MS = 2e3;
 function readPackageVersion() {
   try {
-    let dir = dirname4(fileURLToPath2(import.meta.url));
+    let dir = dirname5(fileURLToPath2(import.meta.url));
     for (let i = 0; i < 6; i++) {
-      const p = join9(dir, "package.json");
+      const p = join10(dir, "package.json");
       if (existsSync9(p)) {
-        const pkg = JSON.parse(readFileSync11(p, "utf8"));
+        const pkg = JSON.parse(readFileSync12(p, "utf8"));
         if (pkg?.name === "reasonix" && typeof pkg.version === "string") {
           return pkg.version;
         }
       }
-      const parent = dirname4(dir);
+      const parent = dirname5(dir);
       if (parent === dir) break;
       dir = parent;
     }
@@ -7410,11 +7602,11 @@ function readPackageVersion() {
 }
 var VERSION = readPackageVersion();
 function cachePath(homeDirOverride) {
-  return join9(homeDirOverride ?? homedir5(), ".reasonix", "version-cache.json");
+  return join10(homeDirOverride ?? homedir6(), ".reasonix", "version-cache.json");
 }
 function readCache(homeDirOverride) {
   try {
-    const raw = readFileSync11(cachePath(homeDirOverride), "utf8");
+    const raw = readFileSync12(cachePath(homeDirOverride), "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed.version === "string" && typeof parsed.checkedAt === "number") {
       return parsed;
@@ -7426,8 +7618,8 @@ function readCache(homeDirOverride) {
 function writeCache(entry, homeDirOverride) {
   try {
     const p = cachePath(homeDirOverride);
-    mkdirSync3(dirname4(p), { recursive: true });
-    writeFileSync3(p, JSON.stringify(entry), "utf8");
+    mkdirSync4(dirname5(p), { recursive: true });
+    writeFileSync4(p, JSON.stringify(entry), "utf8");
   } catch {
   }
 }
@@ -7653,9 +7845,12 @@ var McpClient = class {
         signal.addEventListener("abort", abortHandler, { once: true });
       }
     });
+    promise.catch(() => void 0);
     try {
-      await this.transport.send(frame);
+      await Promise.race([this.transport.send(frame), promise.then(() => void 0)]);
     } catch (err) {
+      const pending = this.pending.get(id);
+      if (pending) clearTimeout(pending.timeout);
       this.pending.delete(id);
       if (abortHandler && signal) signal.removeEventListener("abort", abortHandler);
       throw err;
@@ -8223,8 +8418,8 @@ async function trySection(load) {
 }
 
 // src/code/edit-blocks.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync4, readFileSync as readFileSync12, unlinkSync as unlinkSync3, writeFileSync as writeFileSync4 } from "fs";
-import { dirname as dirname5, resolve as resolve9 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync5, readFileSync as readFileSync13, unlinkSync as unlinkSync3, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname6, resolve as resolve9 } from "path";
 var BLOCK_RE = /^(\S[^\n]*)\n<{7} SEARCH\n([\s\S]*?)\n?={7}\n([\s\S]*?)\n?>{7} REPLACE/gm;
 function parseEditBlocks(text) {
   const out = [];
@@ -8262,11 +8457,11 @@ function applyEditBlock(block, rootDir) {
           message: "file does not exist; to create it, use an empty SEARCH block"
         };
       }
-      mkdirSync4(dirname5(absTarget), { recursive: true });
-      writeFileSync4(absTarget, block.replace, "utf8");
+      mkdirSync5(dirname6(absTarget), { recursive: true });
+      writeFileSync5(absTarget, block.replace, "utf8");
       return { path: block.path, status: "created" };
     }
-    const content = readFileSync12(absTarget, "utf8");
+    const content = readFileSync13(absTarget, "utf8");
     if (searchEmpty) {
       return {
         path: block.path,
@@ -8286,7 +8481,7 @@ function applyEditBlock(block, rootDir) {
       };
     }
     const replaced = `${content.slice(0, idx)}${adaptedReplace}${content.slice(idx + adaptedSearch.length)}`;
-    writeFileSync4(absTarget, replaced, "utf8");
+    writeFileSync5(absTarget, replaced, "utf8");
     return { path: block.path, status: "applied" };
   } catch (err) {
     return { path: block.path, status: "error", message: err.message };
@@ -8308,7 +8503,7 @@ function snapshotBeforeEdits(blocks, rootDir) {
       continue;
     }
     try {
-      snapshots.push({ path: b.path, prevContent: readFileSync12(abs, "utf8") });
+      snapshots.push({ path: b.path, prevContent: readFileSync13(abs, "utf8") });
     } catch {
       snapshots.push({ path: b.path, prevContent: null });
     }
@@ -8335,7 +8530,7 @@ function restoreSnapshots(snapshots, rootDir) {
           message: "removed (the edit had created it)"
         };
       }
-      writeFileSync4(abs, snap.prevContent, "utf8");
+      writeFileSync5(abs, snap.prevContent, "utf8");
       return {
         path: snap.path,
         status: "applied",
@@ -8354,8 +8549,8 @@ function lineEndingOf(text) {
 }
 
 // src/code/prompt.ts
-import { existsSync as existsSync11, readFileSync as readFileSync13 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync14 } from "fs";
+import { join as join11 } from "path";
 var CODE_SYSTEM_PROMPT = `You are Reasonix Code, a coding assistant. You have filesystem tools (read_file, write_file, edit_file, list_directory, directory_tree, search_files, search_content, get_file_info) rooted at the user's working directory, plus run_command / run_background for shell.
 
 # Cite or shut up \u2014 non-negotiable
@@ -8557,12 +8752,12 @@ If \`semantic_search\` returns nothing useful (low scores, off-topic), THEN fall
 function codeSystemPrompt(rootDir, opts = {}) {
   const base = opts.hasSemanticSearch ? `${CODE_SYSTEM_PROMPT}${SEMANTIC_SEARCH_ROUTING}` : CODE_SYSTEM_PROMPT;
   const withMemory = applyMemoryStack(base, rootDir);
-  const gitignorePath = join10(rootDir, ".gitignore");
+  const gitignorePath = join11(rootDir, ".gitignore");
   let result = withMemory;
   if (existsSync11(gitignorePath)) {
     let content;
     try {
-      content = readFileSync13(gitignorePath, "utf8");
+      content = readFileSync14(gitignorePath, "utf8");
     } catch {
     }
     if (content !== void 0) {
@@ -8592,49 +8787,6 @@ ${appendParts.join("\n\n")}`;
   return result;
 }
 
-// src/config.ts
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync5, readFileSync as readFileSync14, writeFileSync as writeFileSync5 } from "fs";
-import { homedir as homedir6 } from "os";
-import { dirname as dirname6, join as join11 } from "path";
-function defaultConfigPath() {
-  return join11(homedir6(), ".reasonix", "config.json");
-}
-function readConfig(path2 = defaultConfigPath()) {
-  try {
-    const raw = readFileSync14(path2, "utf8");
-    const parsed = JSON.parse(raw);
-    if (parsed && typeof parsed === "object") return parsed;
-  } catch {
-  }
-  return {};
-}
-function writeConfig(cfg, path2 = defaultConfigPath()) {
-  mkdirSync5(dirname6(path2), { recursive: true });
-  writeFileSync5(path2, JSON.stringify(cfg, null, 2), "utf8");
-  try {
-    chmodSync2(path2, 384);
-  } catch {
-  }
-}
-function loadApiKey(path2 = defaultConfigPath()) {
-  if (process.env.DEEPSEEK_API_KEY) return process.env.DEEPSEEK_API_KEY;
-  return readConfig(path2).apiKey;
-}
-function saveApiKey(key, path2 = defaultConfigPath()) {
-  const cfg = readConfig(path2);
-  cfg.apiKey = key.trim();
-  writeConfig(cfg, path2);
-}
-function isPlausibleKey(key) {
-  const trimmed = key.trim();
-  return /^sk-[A-Za-z0-9_-]{16,}$/.test(trimmed);
-}
-function redactKey(key) {
-  if (!key) return "";
-  if (key.length <= 12) return "****";
-  return `${key.slice(0, 6)}\u2026${key.slice(-4)}`;
-}
-
 // src/telemetry/usage.ts
 import {
   appendFileSync as appendFileSync2,