reasonix 0.5.0 → 0.5.3

package/dist/index.js

@@ -617,6 +617,170 @@ async function runHooks(opts) {
   return { event, outcomes, blocked };
 }
 
+// src/tokenizer.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { createRequire } from "module";
+import { dirname, join as join2 } from "path";
+import { fileURLToPath } from "url";
+import { gunzipSync } from "zlib";
+function buildByteToChar() {
+  const result = new Array(256);
+  const bs = [];
+  for (let b = 33; b <= 126; b++) bs.push(b);
+  for (let b = 161; b <= 172; b++) bs.push(b);
+  for (let b = 174; b <= 255; b++) bs.push(b);
+  const cs = bs.slice();
+  let n = 0;
+  for (let b = 0; b < 256; b++) {
+    if (!bs.includes(b)) {
+      bs.push(b);
+      cs.push(256 + n);
+      n++;
+    }
+  }
+  for (let i = 0; i < bs.length; i++) {
+    result[bs[i]] = String.fromCodePoint(cs[i]);
+  }
+  return result;
+}
+var cached = null;
+function resolveDataPath() {
+  if (process.env.REASONIX_TOKENIZER_PATH) return process.env.REASONIX_TOKENIZER_PATH;
+  try {
+    const here = dirname(fileURLToPath(import.meta.url));
+    return join2(here, "..", "data", "deepseek-tokenizer.json.gz");
+  } catch {
+    const req = createRequire(import.meta.url);
+    return join2(
+      dirname(req.resolve("reasonix/package.json")),
+      "data",
+      "deepseek-tokenizer.json.gz"
+    );
+  }
+}
+function loadTokenizer() {
+  if (cached) return cached;
+  const buf = readFileSync2(resolveDataPath());
+  const json = gunzipSync(buf).toString("utf8");
+  const data = JSON.parse(json);
+  const mergeRank = /* @__PURE__ */ new Map();
+  for (let i = 0; i < data.model.merges.length; i++) {
+    mergeRank.set(data.model.merges[i], i);
+  }
+  const splitRegexes = [];
+  for (const p of data.pre_tokenizer.pretokenizers) {
+    if (p.type === "Split") {
+      splitRegexes.push(new RegExp(p.pattern.Regex, "gu"));
+    }
+  }
+  const addedMap = /* @__PURE__ */ new Map();
+  const addedContents = [];
+  for (const t of data.added_tokens) {
+    if (!t.special) {
+      addedMap.set(t.content, t.id);
+      addedContents.push(t.content);
+    }
+  }
+  addedContents.sort((a, b) => b.length - a.length);
+  const addedPattern = addedContents.length ? new RegExp(addedContents.map(escapeRegex).join("|"), "g") : null;
+  cached = {
+    vocab: data.model.vocab,
+    mergeRank,
+    splitRegexes,
+    byteToChar: buildByteToChar(),
+    addedPattern,
+    addedMap
+  };
+  return cached;
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function applySplit(chunks, re) {
+  const out = [];
+  for (const chunk of chunks) {
+    if (!chunk) continue;
+    re.lastIndex = 0;
+    let last = 0;
+    for (const m of chunk.matchAll(re)) {
+      const idx = m.index ?? 0;
+      if (idx > last) out.push(chunk.slice(last, idx));
+      if (m[0].length > 0) out.push(m[0]);
+      last = idx + m[0].length;
+    }
+    if (last < chunk.length) out.push(chunk.slice(last));
+  }
+  return out;
+}
+function byteLevelEncode(s, byteToChar) {
+  const bytes = new TextEncoder().encode(s);
+  let out = "";
+  for (let i = 0; i < bytes.length; i++) out += byteToChar[bytes[i]];
+  return out;
+}
+function bpeEncode(piece, mergeRank) {
+  if (piece.length <= 1) return piece ? [piece] : [];
+  let word = Array.from(piece);
+  while (true) {
+    let bestIdx = -1;
+    let bestRank = Number.POSITIVE_INFINITY;
+    for (let i = 0; i < word.length - 1; i++) {
+      const pair = `${word[i]} ${word[i + 1]}`;
+      const rank = mergeRank.get(pair);
+      if (rank !== void 0 && rank < bestRank) {
+        bestRank = rank;
+        bestIdx = i;
+        if (rank === 0) break;
+      }
+    }
+    if (bestIdx < 0) break;
+    word = [
+      ...word.slice(0, bestIdx),
+      word[bestIdx] + word[bestIdx + 1],
+      ...word.slice(bestIdx + 2)
+    ];
+    if (word.length === 1) break;
+  }
+  return word;
+}
+function encode(text) {
+  if (!text) return [];
+  const t = loadTokenizer();
+  const ids = [];
+  const process2 = (segment) => {
+    if (!segment) return;
+    let chunks = [segment];
+    for (const re of t.splitRegexes) chunks = applySplit(chunks, re);
+    for (const chunk of chunks) {
+      if (!chunk) continue;
+      const byteLevel = byteLevelEncode(chunk, t.byteToChar);
+      const pieces = bpeEncode(byteLevel, t.mergeRank);
+      for (const p of pieces) {
+        const id = t.vocab[p];
+        if (id !== void 0) ids.push(id);
+      }
+    }
+  };
+  if (t.addedPattern) {
+    t.addedPattern.lastIndex = 0;
+    let last = 0;
+    for (const m of text.matchAll(t.addedPattern)) {
+      const idx = m.index ?? 0;
+      if (idx > last) process2(text.slice(last, idx));
+      const id = t.addedMap.get(m[0]);
+      if (id !== void 0) ids.push(id);
+      last = idx + m[0].length;
+    }
+    if (last < text.length) process2(text.slice(last));
+  } else {
+    process2(text);
+  }
+  return ids;
+}
+function countTokens(text) {
+  return encode(text).length;
+}
+
 // src/repair/flatten.ts
 function analyzeSchema(schema) {
   if (!schema) return { shouldFlatten: false, leafCount: 0, maxDepth: 0 };
@@ -767,7 +931,14 @@ var ToolRegistry = class {
     try {
       const result = await tool.fn(args, { signal: opts.signal });
       const str = typeof result === "string" ? result : JSON.stringify(result);
-      return opts.maxResultChars ? truncateForModel(str, opts.maxResultChars) : str;
+      let clipped = str;
+      if (opts.maxResultTokens !== void 0) {
+        clipped = truncateForModelByTokens(clipped, opts.maxResultTokens);
+      }
+      if (opts.maxResultChars !== void 0) {
+        clipped = truncateForModel(clipped, opts.maxResultChars);
+      }
+      return clipped;
     } catch (err) {
       const e = err;
       if (typeof e.toToolResult === "function") {
@@ -801,6 +972,7 @@ function hasDotKey(obj) {
 
 // src/mcp/registry.ts
 var DEFAULT_MAX_RESULT_CHARS = 32e3;
+var DEFAULT_MAX_RESULT_TOKENS = 8e3;
 async function bridgeMcpTools(client, opts = {}) {
   const registry = opts.registry ?? new ToolRegistry({ autoFlatten: opts.autoFlatten });
   const prefix = opts.namePrefix ?? "";
@@ -857,6 +1029,61 @@ function truncateForModel(s, maxChars) {
 
 ${tail}`;
 }
+function truncateForModelByTokens(s, maxTokens) {
+  if (maxTokens <= 0) return "";
+  if (s.length <= maxTokens) return s;
+  if (s.length <= maxTokens * 4) {
+    const tokens = countTokens(s);
+    if (tokens <= maxTokens) return s;
+  }
+  const markerOverhead = 48;
+  const contentBudget = Math.max(0, maxTokens - markerOverhead);
+  const tailBudget = Math.min(256, Math.floor(contentBudget * 0.1));
+  const headBudget = Math.max(0, contentBudget - tailBudget);
+  const head = sizePrefixToTokens(s, headBudget);
+  const tail = sizeSuffixToTokens(s, tailBudget);
+  const droppedChars = s.length - head.length - tail.length;
+  const headTokens = head ? countTokens(head) : 0;
+  const tailTokens = tail ? countTokens(tail) : 0;
+  const sampleChars = head.length + tail.length;
+  const sampleTokens = headTokens + tailTokens;
+  const ratio = sampleChars > 0 ? sampleTokens / sampleChars : 0.3;
+  const estTotalTokens = Math.ceil(s.length * ratio);
+  const droppedTokens = Math.max(0, estTotalTokens - sampleTokens);
+  return `${head}
+
+[\u2026truncated ~${droppedTokens} tokens (${droppedChars} chars) \u2014 raise BridgeOptions.maxResultTokens, or call the tool with a narrower scope (filter, head, pagination)\u2026]
+
+${tail}`;
+}
+function sizePrefixToTokens(s, budget) {
+  if (budget <= 0 || s.length === 0) return "";
+  let size = Math.min(s.length, budget * 4);
+  for (let iter = 0; iter < 6; iter++) {
+    if (size <= 0) return "";
+    const slice = s.slice(0, size);
+    const count = countTokens(slice);
+    if (count <= budget) return slice;
+    const next = Math.floor(size * (budget / count) * 0.95);
+    if (next >= size) return s.slice(0, Math.max(0, size - 1));
+    size = next;
+  }
+  return s.slice(0, Math.max(0, size));
+}
+function sizeSuffixToTokens(s, budget) {
+  if (budget <= 0 || s.length === 0) return "";
+  let size = Math.min(s.length, budget * 4);
+  for (let iter = 0; iter < 6; iter++) {
+    if (size <= 0) return "";
+    const slice = s.slice(-size);
+    const count = countTokens(slice);
+    if (count <= budget) return slice;
+    const next = Math.floor(size * (budget / count) * 0.95);
+    if (next >= size) return s.slice(-Math.max(0, size - 1));
+    size = next;
+  }
+  return s.slice(-Math.max(0, size));
+}
 function blockToString(block) {
   if (block.type === "text") return block.text;
   if (block.type === "image") return `[image ${block.mimeType}, ${block.data.length} chars base64]`;
@@ -1242,19 +1469,19 @@ import {
   chmodSync,
   existsSync as existsSync2,
   mkdirSync,
-  readFileSync as readFileSync2,
+  readFileSync as readFileSync3,
   readdirSync,
   statSync,
   unlinkSync,
   writeFileSync
 } from "fs";
 import { homedir as homedir2 } from "os";
-import { dirname, join as join2 } from "path";
+import { dirname as dirname2, join as join3 } from "path";
 function sessionsDir() {
-  return join2(homedir2(), ".reasonix", "sessions");
+  return join3(homedir2(), ".reasonix", "sessions");
 }
 function sessionPath(name) {
-  return join2(sessionsDir(), `${sanitizeName(name)}.jsonl`);
+  return join3(sessionsDir(), `${sanitizeName(name)}.jsonl`);
 }
 function sanitizeName(name) {
   const cleaned = name.replace(/[^\w\-\u4e00-\u9fa5]/g, "_").slice(0, 64);
@@ -1264,7 +1491,7 @@ function loadSessionMessages(name) {
   const path = sessionPath(name);
   if (!existsSync2(path)) return [];
   try {
-    const raw = readFileSync2(path, "utf8");
+    const raw = readFileSync3(path, "utf8");
     const out = [];
     for (const line of raw.split(/\r?\n/)) {
       const trimmed = line.trim();
@@ -1282,7 +1509,7 @@ function loadSessionMessages(name) {
 }
 function appendSessionMessage(name, message) {
   const path = sessionPath(name);
-  mkdirSync(dirname(path), { recursive: true });
+  mkdirSync(dirname2(path), { recursive: true });
   appendFileSync(path, `${JSON.stringify(message)}
 `, "utf8");
   try {
@@ -1296,7 +1523,7 @@ function listSessions() {
   try {
     const files = readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
     return files.map((file) => {
-      const path = join2(dir, file);
+      const path = join3(dir, file);
       const stat = statSync(path);
       const name = file.replace(/\.jsonl$/, "");
       const messageCount = countLines(path);
@@ -1317,7 +1544,7 @@ function deleteSession(name) {
 }
 function rewriteSession(name, messages) {
   const path = sessionPath(name);
-  mkdirSync(dirname(path), { recursive: true });
+  mkdirSync(dirname2(path), { recursive: true });
   const body = messages.map((m) => JSON.stringify(m)).join("\n");
   writeFileSync(path, body ? `${body}
 ` : "", "utf8");
@@ -1328,7 +1555,7 @@ function rewriteSession(name, messages) {
 }
 function countLines(path) {
   try {
-    const raw = readFileSync2(path, "utf8");
+    const raw = readFileSync3(path, "utf8");
     return raw.split(/\r?\n/).filter((l) => l.trim()).length;
   } catch {
     return 0;
@@ -1510,20 +1737,26 @@ var CacheFirstLoop = class {
   }
   /**
    * Shrink the log by re-truncating oversized tool results to a tighter
-   * cap, and persist the result back to disk so the next launch doesn't
-   * re-inherit a fat session file. Returns a summary the TUI can
-   * display.
+   * token cap, and persist the result back to disk so the next launch
+   * doesn't re-inherit a fat session file. Returns a summary the TUI
+   * can display.
+   *
+   * The cap is in DeepSeek V3 tokens (not chars) — so CJK text gets
+   * capped at the same effective context footprint as English instead
+   * of slipping past a char cap at 2× the token cost. Default 4000
+   * tokens, matching the token-aware dispatch cap from 0.5.2.
    *
    * Only tool-role messages are touched (same rationale as
    * {@link healLoadedMessages}). User and assistant messages carry
    * authored intent we can't mechanically shrink without losing
    * meaning.
    */
-  compact(tightCapChars = 4e3) {
+  compact(maxTokens = 4e3) {
     const before = this.log.toMessages();
-    const { messages, healedCount, healedFrom } = shrinkOversizedToolResults(before, tightCapChars);
-    const afterBytes = messages.filter((m) => m.role === "tool").reduce((s, m) => s + (typeof m.content === "string" ? m.content.length : 0), 0);
-    const charsSaved = healedFrom - afterBytes;
+    const { messages, healedCount, tokensSaved, charsSaved } = shrinkOversizedToolResultsByTokens(
+      before,
+      maxTokens
+    );
     if (healedCount > 0) {
       this.log.compactInPlace(messages);
       if (this.sessionName) {
@@ -1533,7 +1766,7 @@ var CacheFirstLoop = class {
         }
       }
     }
-    return { healedCount, charsSaved };
+    return { healedCount, tokensSaved, charsSaved };
   }
   appendAndPersist(message) {
     this.log.append(message);
@@ -1897,30 +2130,28 @@ var CacheFirstLoop = class {
         const ratio = usage.promptTokens / ctxMax;
         if (ratio > 0.6 && ratio <= 0.8) {
           const before = usage.promptTokens;
-          const soft = this.compact(16e3);
+          const soft = this.compact(4e3);
           if (soft.healedCount > 0) {
-            const approxSaved = Math.round(soft.charsSaved / 4);
-            const after = Math.max(0, before - approxSaved);
+            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 16k, saved ~${approxSaved.toLocaleString()} tokens (now ~${after.toLocaleString()}). Staying ahead of the 80% guard.`
+              )}%) \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(4e3);
+        const compactResult = this.compact(1e3);
         if (compactResult.healedCount > 0) {
-          const approxSaved = Math.round(compactResult.charsSaved / 4);
-          const after = before - approxSaved;
+          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 ~${approxSaved.toLocaleString()} tokens (now ~${after.toLocaleString()}). Continuing.`
+            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 {
           yield {
@@ -1975,7 +2206,7 @@ ${reason}`;
         } else {
           result = await this.tools.dispatch(name, args, {
             signal,
-            maxResultChars: DEFAULT_MAX_RESULT_CHARS
+            maxResultTokens: DEFAULT_MAX_RESULT_TOKENS
           });
           const postReport = await runHooks({
             hooks: this.hooks,
@@ -2121,6 +2352,25 @@ function shrinkOversizedToolResults(messages, maxChars) {
   });
   return { messages: out, healedCount, healedFrom };
 }
+function shrinkOversizedToolResultsByTokens(messages, maxTokens) {
+  let healedCount = 0;
+  let tokensSaved = 0;
+  let charsSaved = 0;
+  const out = messages.map((msg) => {
+    if (msg.role !== "tool") return msg;
+    const content = typeof msg.content === "string" ? msg.content : "";
+    if (content.length <= maxTokens) return msg;
+    const beforeTokens = countTokens(content);
+    if (beforeTokens <= maxTokens) return msg;
+    const truncated = truncateForModelByTokens(content, maxTokens);
+    const afterTokens = countTokens(truncated);
+    healedCount += 1;
+    tokensSaved += Math.max(0, beforeTokens - afterTokens);
+    charsSaved += Math.max(0, content.length - truncated.length);
+    return { ...msg, content: truncated };
+  });
+  return { messages: out, healedCount, tokensSaved, charsSaved };
+}
 function healLoadedMessages(messages, maxChars) {
   const shrunk = shrinkOversizedToolResults(messages, maxChars);
   let healedCount = shrunk.healedCount;
@@ -2177,16 +2427,16 @@ function formatLoopError(err) {
 }
 
 // src/project-memory.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync4 } from "fs";
+import { join as join4 } from "path";
 var PROJECT_MEMORY_FILE = "REASONIX.md";
 var PROJECT_MEMORY_MAX_CHARS = 8e3;
 function readProjectMemory(rootDir) {
-  const path = join3(rootDir, PROJECT_MEMORY_FILE);
+  const path = join4(rootDir, PROJECT_MEMORY_FILE);
   if (!existsSync3(path)) return null;
   let raw;
   try {
-    raw = readFileSync3(path, "utf8");
+    raw = readFileSync4(path, "utf8");
   } catch {
     return null;
   }
@@ -2224,18 +2474,18 @@ import { createHash as createHash2 } from "crypto";
 import {
   existsSync as existsSync5,
   mkdirSync as mkdirSync2,
-  readFileSync as readFileSync5,
+  readFileSync as readFileSync6,
   readdirSync as readdirSync3,
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync2
 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join5, resolve as resolve2 } from "path";
+import { join as join6, resolve as resolve2 } from "path";
 
 // src/skills.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync5, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join4, resolve } from "path";
+import { join as join5, resolve } from "path";
 var SKILLS_DIRNAME = "skills";
 var SKILL_FILE = "SKILL.md";
 var SKILLS_INDEX_MAX_CHARS = 4e3;
@@ -2282,11 +2532,11 @@ var SkillStore = class {
     const out = [];
     if (this.projectRoot) {
       out.push({
-        dir: join4(this.projectRoot, ".reasonix", SKILLS_DIRNAME),
+        dir: join5(this.projectRoot, ".reasonix", SKILLS_DIRNAME),
         scope: "project"
       });
     }
-    out.push({ dir: join4(this.homeDir, ".reasonix", SKILLS_DIRNAME), scope: "global" });
+    out.push({ dir: join5(this.homeDir, ".reasonix", SKILLS_DIRNAME), scope: "global" });
     return out;
   }
   /**
@@ -2322,11 +2572,11 @@ var SkillStore = class {
     if (!isValidSkillName(name)) return null;
     for (const { dir, scope } of this.roots()) {
       if (!existsSync4(dir)) continue;
-      const dirCandidate = join4(dir, name, SKILL_FILE);
+      const dirCandidate = join5(dir, name, SKILL_FILE);
       if (existsSync4(dirCandidate) && statSync2(dirCandidate).isFile()) {
         return this.parse(dirCandidate, name, scope);
       }
-      const flatCandidate = join4(dir, `${name}.md`);
+      const flatCandidate = join5(dir, `${name}.md`);
       if (existsSync4(flatCandidate) && statSync2(flatCandidate).isFile()) {
         return this.parse(flatCandidate, name, scope);
       }
@@ -2341,21 +2591,21 @@ var SkillStore = class {
   readEntry(dir, scope, entry) {
     if (entry.isDirectory()) {
       if (!isValidSkillName(entry.name)) return null;
-      const file = join4(dir, entry.name, SKILL_FILE);
+      const file = join5(dir, entry.name, SKILL_FILE);
       if (!existsSync4(file)) return null;
       return this.parse(file, entry.name, scope);
     }
     if (entry.isFile() && entry.name.endsWith(".md")) {
       const stem = entry.name.slice(0, -3);
       if (!isValidSkillName(stem)) return null;
-      return this.parse(join4(dir, entry.name), stem, scope);
+      return this.parse(join5(dir, entry.name), stem, scope);
     }
     return null;
   }
   parse(path, stem, scope) {
     let raw;
     try {
-      raw = readFileSync4(path, "utf8");
+      raw = readFileSync5(path, "utf8");
     } catch {
       return null;
     }
@@ -2487,12 +2737,12 @@ function projectHash(rootDir) {
 }
 function scopeDir(opts) {
   if (opts.scope === "global") {
-    return join5(opts.homeDir, USER_MEMORY_DIR, "global");
+    return join6(opts.homeDir, USER_MEMORY_DIR, "global");
   }
   if (!opts.projectRoot) {
     throw new Error("scope=project requires a projectRoot on MemoryStore");
   }
-  return join5(opts.homeDir, USER_MEMORY_DIR, projectHash(opts.projectRoot));
+  return join6(opts.homeDir, USER_MEMORY_DIR, projectHash(opts.projectRoot));
 }
 function ensureDir(p) {
   if (!existsSync5(p)) mkdirSync2(p, { recursive: true });
@@ -2540,7 +2790,7 @@ var MemoryStore = class {
   homeDir;
   projectRoot;
   constructor(opts = {}) {
-    this.homeDir = opts.homeDir ?? join5(homedir4(), ".reasonix");
+    this.homeDir = opts.homeDir ?? join6(homedir4(), ".reasonix");
     this.projectRoot = opts.projectRoot ? resolve2(opts.projectRoot) : void 0;
   }
   /** Directory this store writes `scope` files into, creating it if needed. */
@@ -2551,7 +2801,7 @@ var MemoryStore = class {
   }
   /** Absolute path to a memory file (no existence check). */
   pathFor(scope, name) {
-    return join5(this.dir(scope), `${sanitizeMemoryName(name)}.md`);
+    return join6(this.dir(scope), `${sanitizeMemoryName(name)}.md`);
   }
   /** True iff this store is configured with a project scope available. */
   hasProjectScope() {
@@ -2563,14 +2813,14 @@ var MemoryStore = class {
    */
   loadIndex(scope) {
     if (scope === "project" && !this.projectRoot) return null;
-    const file = join5(
+    const file = join6(
       scopeDir({ homeDir: this.homeDir, scope, projectRoot: this.projectRoot }),
       MEMORY_INDEX_FILE
     );
     if (!existsSync5(file)) return null;
     let raw;
     try {
-      raw = readFileSync5(file, "utf8");
+      raw = readFileSync6(file, "utf8");
     } catch {
       return null;
     }
@@ -2588,7 +2838,7 @@ var MemoryStore = class {
     if (!existsSync5(file)) {
       throw new Error(`memory not found: scope=${scope} name=${name}`);
     }
-    const raw = readFileSync5(file, "utf8");
+    const raw = readFileSync6(file, "utf8");
     const { data, body } = parseFrontmatter2(raw);
     return {
       name: data.name ?? name,
@@ -2650,7 +2900,7 @@ var MemoryStore = class {
       createdAt: todayIso()
     };
     const dir = this.dir(input.scope);
-    const file = join5(dir, `${name}.md`);
+    const file = join6(dir, `${name}.md`);
     const content = `${formatFrontmatter(entry)}${body}
 `;
     writeFileSync2(file, content, "utf8");
@@ -2684,7 +2934,7 @@ var MemoryStore = class {
       return;
     }
     const mdFiles = files.filter((f) => f !== MEMORY_INDEX_FILE && f.endsWith(".md")).sort((a, b) => a.localeCompare(b));
-    const indexPath = join5(dir, MEMORY_INDEX_FILE);
+    const indexPath = join6(dir, MEMORY_INDEX_FILE);
     if (mdFiles.length === 0) {
       if (existsSync5(indexPath)) unlinkSync2(indexPath);
       return;
@@ -3717,6 +3967,50 @@ function tokenizeCommand(cmd) {
   if (cur.length > 0) out.push(cur);
   return out;
 }
+function detectShellOperator(cmd) {
+  const opPrefix = /^(?:2>&1|&>|\|{1,2}|&{1,2}|2>{1,2}|>{1,2}|<{1,2})/;
+  let cur = "";
+  let curQuoted = false;
+  let quote = null;
+  const check = () => {
+    if (cur.length === 0 && !curQuoted) return null;
+    if (!curQuoted) {
+      const m = opPrefix.exec(cur);
+      if (m) return m[0] ?? null;
+    }
+    return null;
+  };
+  for (let i = 0; i < cmd.length; i++) {
+    const ch = cmd[i];
+    if (quote) {
+      if (ch === quote) {
+        quote = null;
+      } else if (ch === "\\" && quote === '"' && i + 1 < cmd.length) {
+        cur += cmd[++i];
+        curQuoted = true;
+      } else {
+        cur += ch;
+        curQuoted = true;
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      curQuoted = true;
+      continue;
+    }
+    if (ch === " " || ch === "	") {
+      const op = check();
+      if (op) return op;
+      cur = "";
+      curQuoted = false;
+      continue;
+    }
+    cur += ch;
+  }
+  if (quote) return null;
+  return check();
+}
 function isAllowed(cmd, extra = []) {
   const normalized = cmd.trim().replace(/\s+/g, " ");
   const allowlist = [...BUILTIN_ALLOWLIST, ...extra];
@@ -3729,6 +4023,12 @@ function isAllowed(cmd, extra = []) {
 async function runCommand(cmd, opts) {
   const argv = tokenizeCommand(cmd);
   if (argv.length === 0) throw new Error("run_command: empty command");
+  const operator = detectShellOperator(cmd);
+  if (operator !== null) {
+    throw new Error(
+      `run_command: shell operator "${operator}" is not supported \u2014 this tool spawns one process, no shell expansion. Split into separate run_command calls and combine the output in your reasoning (e.g. instead of \`grep foo *.ts | wc -l\`, call \`grep -c foo *.ts\` or two separate commands). To pass "${operator}" as a literal argument, wrap it in quotes.`
+    );
+  }
   const timeoutMs = (opts.timeoutSec ?? DEFAULT_TIMEOUT_SEC) * 1e3;
   const maxChars = opts.maxOutputChars ?? DEFAULT_MAX_OUTPUT_CHARS;
   const spawnOpts = {
@@ -3906,7 +4206,7 @@ function registerShellTools(registry, opts) {
       properties: {
         command: {
           type: "string",
-          description: "Full command line. Tokenized with POSIX-ish quoting; no shell expansion, no pipes, no redirects."
+          description: 'Full command line. Tokenized with POSIX-ish quoting; no shell expansion. Pipes (`|`), redirects (`>`, `<`, `2>`), and `&&`/`||` chaining are rejected with an error \u2014 split into separate calls instead. To pass an operator character as a literal argument (e.g. a regex), wrap it in quotes: `grep "a|b" file.txt`.'
         },
         timeoutSec: {
           type: "integer",
@@ -4125,12 +4425,12 @@ ${i + 1}. ${r.title}`);
 }
 
 // src/env.ts
-import { readFileSync as readFileSync6 } from "fs";
+import { readFileSync as readFileSync7 } from "fs";
 import { resolve as resolve5 } from "path";
 function loadDotenv(path = ".env") {
   let raw;
   try {
-    raw = readFileSync6(resolve5(process.cwd(), path), "utf8");
+    raw = readFileSync7(resolve5(process.cwd(), path), "utf8");
   } catch {
     return;
   }
@@ -4149,7 +4449,7 @@ function loadDotenv(path = ".env") {
 }
 
 // src/transcript.ts
-import { createWriteStream, readFileSync as readFileSync7 } from "fs";
+import { createWriteStream, readFileSync as readFileSync8 } from "fs";
 function recordFromLoopEvent(ev, extra) {
   const rec = {
     ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -4200,7 +4500,7 @@ function openTranscriptFile(path, meta) {
   return stream;
 }
 function readTranscript(path) {
-  const raw = readFileSync7(path, "utf8");
+  const raw = readFileSync8(path, "utf8");
   return parseTranscript(raw);
 }
 function isPlanStateEmptyShape(s) {
@@ -5255,8 +5555,8 @@ async function trySection(load) {
 }
 
 // src/code/edit-blocks.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync8, unlinkSync as unlinkSync3, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname3, resolve as resolve6 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync9, unlinkSync as unlinkSync3, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname4, resolve as resolve6 } 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 = [];
@@ -5294,11 +5594,11 @@ function applyEditBlock(block, rootDir) {
           message: "file does not exist; to create it, use an empty SEARCH block"
         };
       }
-      mkdirSync3(dirname3(absTarget), { recursive: true });
+      mkdirSync3(dirname4(absTarget), { recursive: true });
       writeFileSync3(absTarget, block.replace, "utf8");
       return { path: block.path, status: "created" };
     }
-    const content = readFileSync8(absTarget, "utf8");
+    const content = readFileSync9(absTarget, "utf8");
     if (searchEmpty) {
       return {
         path: block.path,
@@ -5337,7 +5637,7 @@ function snapshotBeforeEdits(blocks, rootDir) {
       continue;
     }
     try {
-      snapshots.push({ path: b.path, prevContent: readFileSync8(abs, "utf8") });
+      snapshots.push({ path: b.path, prevContent: readFileSync9(abs, "utf8") });
     } catch {
       snapshots.push({ path: b.path, prevContent: null });
     }
@@ -5380,8 +5680,8 @@ function sep() {
 }
 
 // src/code/prompt.ts
-import { existsSync as existsSync8, readFileSync as readFileSync9 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync10 } from "fs";
+import { join as join8 } from "path";
 var CODE_SYSTEM_PROMPT = `You are Reasonix Code, a coding assistant. You have filesystem tools (read_file, write_file, list_directory, search_files, etc.) rooted at the user's working directory.
 
 # Cite or shut up \u2014 non-negotiable
@@ -5502,11 +5802,11 @@ Two different rules depending on which tool:
 `;
 function codeSystemPrompt(rootDir) {
   const withMemory = applyMemoryStack(CODE_SYSTEM_PROMPT, rootDir);
-  const gitignorePath = join7(rootDir, ".gitignore");
+  const gitignorePath = join8(rootDir, ".gitignore");
   if (!existsSync8(gitignorePath)) return withMemory;
   let content;
   try {
-    content = readFileSync9(gitignorePath, "utf8");
+    content = readFileSync10(gitignorePath, "utf8");
   } catch {
     return withMemory;
   }
@@ -5526,15 +5826,15 @@ ${truncated}
 }
 
 // src/config.ts
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync10, writeFileSync as writeFileSync4 } from "fs";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync11, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir5 } from "os";
-import { dirname as dirname4, join as join8 } from "path";
+import { dirname as dirname5, join as join9 } from "path";
 function defaultConfigPath() {
-  return join8(homedir5(), ".reasonix", "config.json");
+  return join9(homedir5(), ".reasonix", "config.json");
 }
 function readConfig(path = defaultConfigPath()) {
   try {
-    const raw = readFileSync10(path, "utf8");
+    const raw = readFileSync11(path, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object") return parsed;
   } catch {
@@ -5542,7 +5842,7 @@ function readConfig(path = defaultConfigPath()) {
   return {};
 }
 function writeConfig(cfg, path = defaultConfigPath()) {
-  mkdirSync4(dirname4(path), { recursive: true });
+  mkdirSync4(dirname5(path), { recursive: true });
   writeFileSync4(path, JSON.stringify(cfg, null, 2), "utf8");
   try {
     chmodSync2(path, 384);
@@ -5569,25 +5869,25 @@ function redactKey(key) {
 }
 
 // src/version.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync12, writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir6 } from "os";
-import { dirname as dirname5, join as join9 } from "path";
-import { fileURLToPath } from "url";
+import { dirname as dirname6, 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 = dirname5(fileURLToPath(import.meta.url));
+    let dir = dirname6(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 = dirname5(dir);
+      const parent = dirname6(dir);
       if (parent === dir) break;
       dir = parent;
     }
@@ -5597,11 +5897,11 @@ function readPackageVersion() {
 }
 var VERSION = readPackageVersion();
 function cachePath(homeDirOverride) {
-  return join9(homeDirOverride ?? homedir6(), ".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;
@@ -5613,7 +5913,7 @@ function readCache(homeDirOverride) {
 function writeCache(entry, homeDirOverride) {
   try {
     const p = cachePath(homeDirOverride);
-    mkdirSync5(dirname5(p), { recursive: true });
+    mkdirSync5(dirname6(p), { recursive: true });
     writeFileSync5(p, JSON.stringify(entry), "utf8");
   } catch {
   }
@@ -5621,8 +5921,8 @@ function writeCache(entry, homeDirOverride) {
 async function getLatestVersion(opts = {}) {
   const ttl = opts.ttlMs ?? LATEST_CACHE_TTL_MS;
   if (!opts.force) {
-    const cached = readCache(opts.homeDir);
-    if (cached && Date.now() - cached.checkedAt < ttl) return cached.version;
+    const cached2 = readCache(opts.homeDir);
+    if (cached2 && Date.now() - cached2.checkedAt < ttl) return cached2.version;
   }
   const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
   if (!fetchImpl) return null;
@@ -5670,11 +5970,11 @@ function isNpxInstall() {
 }
 
 // src/usage.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync12, statSync as statSync4 } from "fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync13, statSync as statSync4 } from "fs";
 import { homedir as homedir7 } from "os";
-import { dirname as dirname6, join as join10 } from "path";
+import { dirname as dirname7, join as join11 } from "path";
 function defaultUsageLogPath(homeDirOverride) {
-  return join10(homeDirOverride ?? homedir7(), ".reasonix", "usage.jsonl");
+  return join11(homeDirOverride ?? homedir7(), ".reasonix", "usage.jsonl");
 }
 function appendUsage(input) {
   const record = {
@@ -5690,7 +5990,7 @@ function appendUsage(input) {
   };
   const path = input.path ?? defaultUsageLogPath();
   try {
-    mkdirSync6(dirname6(path), { recursive: true });
+    mkdirSync6(dirname7(path), { recursive: true });
     appendFileSync2(path, `${JSON.stringify(record)}
 `, "utf8");
   } catch {
@@ -5701,7 +6001,7 @@ function readUsageLog(path = defaultUsageLogPath()) {
   if (!existsSync10(path)) return [];
   let raw;
   try {
-    raw = readFileSync12(path, "utf8");
+    raw = readFileSync13(path, "utf8");
   } catch {
     return [];
   }
@@ -5799,6 +6099,7 @@ export {
   CODE_SYSTEM_PROMPT,
   CacheFirstLoop,
   DEFAULT_MAX_RESULT_CHARS,
+  DEFAULT_MAX_RESULT_TOKENS,
   DeepSeekClient,
   HOOK_EVENTS,
   HOOK_SETTINGS_DIRNAME,
@@ -5848,6 +6149,7 @@ export {
   defaultSelector,
   defaultUsageLogPath,
   deleteSession,
+  detectShellOperator,
   diffTranscripts,
   emptyPlanState,
   fetchWithRetry,
@@ -5922,6 +6224,7 @@ export {
   stripHallucinatedToolMarkup,
   tokenizeCommand,
   truncateForModel,
+  truncateForModelByTokens,
   webFetch,
   webSearch,
   withUtf8Codepage,