reasonix 0.4.24 → 0.4.26

package/dist/cli/index.js

@@ -7,7 +7,7 @@ import {
   memoryEnabled,
   readProjectMemory,
   sanitizeMemoryName
-} from "./chunk-K6MR4SWS.js";
+} from "./chunk-2BYEKJHX.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
@@ -1893,6 +1893,10 @@ var CacheFirstLoop = class {
           usage = resp.usage;
         }
       } catch (err) {
+        if (signal.aborted) {
+          yield { turn: this._turn, role: "done", content: "" };
+          return;
+        }
         yield {
           turn: this._turn,
           role: "error",
@@ -2212,6 +2216,74 @@ import { promises as fs } from "fs";
 import * as pathMod from "path";
 var DEFAULT_MAX_READ_BYTES = 2 * 1024 * 1024;
 var DEFAULT_MAX_LIST_BYTES = 256 * 1024;
+var SKIP_DIR_NAMES = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".hg",
+  ".svn",
+  "dist",
+  "build",
+  "out",
+  ".next",
+  ".nuxt",
+  "target",
+  // Rust / Java
+  ".venv",
+  "venv",
+  "__pycache__",
+  ".pytest_cache",
+  ".mypy_cache",
+  ".cache",
+  "coverage"
+]);
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".bmp",
+  ".ico",
+  ".webp",
+  ".tiff",
+  ".pdf",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".bz2",
+  ".xz",
+  ".7z",
+  ".rar",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".bin",
+  ".class",
+  ".jar",
+  ".war",
+  ".o",
+  ".obj",
+  ".lib",
+  ".a",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".otf",
+  ".eot",
+  ".mp3",
+  ".mp4",
+  ".mov",
+  ".avi",
+  ".webm",
+  ".wasm",
+  ".pyc",
+  ".pyo"
+]);
+function isLikelyBinaryByName(name) {
+  const dot = name.lastIndexOf(".");
+  if (dot < 0) return false;
+  return BINARY_EXTENSIONS.has(name.slice(dot).toLowerCase());
+}
 function registerFilesystemTools(registry, opts) {
   const rootDir = pathMod.resolve(opts.rootDir);
   const allowWriting = opts.allowWriting !== false;
@@ -2221,7 +2293,12 @@ function registerFilesystemTools(registry, opts) {
     if (typeof raw !== "string" || raw.length === 0) {
       throw new Error("path must be a non-empty string");
     }
-    const resolved = pathMod.resolve(rootDir, raw);
+    let normalized = raw;
+    while (normalized.startsWith("/") || normalized.startsWith("\\")) {
+      normalized = normalized.slice(1);
+    }
+    if (normalized.length === 0) normalized = ".";
+    const resolved = pathMod.resolve(rootDir, normalized);
     const normRoot = pathMod.resolve(rootDir);
     const rel = pathMod.relative(normRoot, resolved);
     if (rel.startsWith("..") || pathMod.isAbsolute(rel)) {
@@ -2387,6 +2464,114 @@ function registerFilesystemTools(registry, opts) {
       return matches.length === 0 ? "(no matches)" : matches.join("\n");
     }
   });
+  registry.register({
+    name: "search_content",
+    description: "Recursively grep file CONTENTS for a substring or regex. This is the right tool for 'find all places that call X', 'where is Y referenced', 'what files contain Z'. Different from search_files (which matches FILE NAMES). Returns one match per line in 'path:line: text' format. Skips dependency / VCS / build directories (node_modules, .git, dist, build, .next, target, .venv) and binary files by default.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        pattern: {
+          type: "string",
+          description: "Substring (or regex) to search file contents for."
+        },
+        path: {
+          type: "string",
+          description: "Directory to start the search at (default: sandbox root)."
+        },
+        glob: {
+          type: "string",
+          description: "Optional file-name suffix or substring filter. Examples: '.ts' (only TypeScript), 'test' (any file with 'test' in the name). Reduces noise when you know the file shape."
+        },
+        case_sensitive: {
+          type: "boolean",
+          description: "When true, match case exactly. Default false (case-insensitive)."
+        },
+        include_deps: {
+          type: "boolean",
+          description: "When true, also search inside node_modules / .git / dist / build / etc. Off by default \u2014 most exploration questions are about the user's own code."
+        }
+      },
+      required: ["pattern"]
+    },
+    fn: async (args) => {
+      const startAbs = safePath(args.path ?? ".");
+      const caseSensitive = args.case_sensitive === true;
+      const includeDeps = args.include_deps === true;
+      const nameFilter = typeof args.glob === "string" ? args.glob.toLowerCase() : null;
+      let re = null;
+      try {
+        re = new RegExp(args.pattern, caseSensitive ? "" : "i");
+      } catch {
+        re = null;
+      }
+      const needle = caseSensitive ? args.pattern : args.pattern.toLowerCase();
+      const matches = [];
+      let totalBytes = 0;
+      let scanned = 0;
+      let truncated = false;
+      const walk2 = async (dir) => {
+        if (truncated) return;
+        let entries;
+        try {
+          entries = await fs.readdir(dir, { withFileTypes: true });
+        } catch {
+          return;
+        }
+        for (const e of entries) {
+          if (truncated) return;
+          if (e.isDirectory()) {
+            if (!includeDeps && SKIP_DIR_NAMES.has(e.name)) continue;
+            await walk2(pathMod.join(dir, e.name));
+            continue;
+          }
+          if (!e.isFile()) continue;
+          if (nameFilter && !e.name.toLowerCase().includes(nameFilter)) continue;
+          if (isLikelyBinaryByName(e.name)) continue;
+          const full = pathMod.join(dir, e.name);
+          let stat;
+          try {
+            stat = await fs.stat(full);
+          } catch {
+            continue;
+          }
+          if (stat.size > 2 * 1024 * 1024) continue;
+          let raw;
+          try {
+            raw = await fs.readFile(full);
+          } catch {
+            continue;
+          }
+          const firstNul = raw.indexOf(0);
+          if (firstNul !== -1 && firstNul < 8 * 1024) continue;
+          const text = raw.toString("utf8");
+          const rel = pathMod.relative(rootDir, full);
+          const lines = text.split(/\r?\n/);
+          for (let li = 0; li < lines.length; li++) {
+            const line = lines[li];
+            const lineForCheck = caseSensitive ? line : line.toLowerCase();
+            const hit = re ? re.test(line) : lineForCheck.includes(needle);
+            if (!hit) continue;
+            const display = line.length > 200 ? `${line.slice(0, 200)}\u2026` : line;
+            const out = `${rel}:${li + 1}: ${display}`;
+            if (totalBytes + out.length + 1 > maxListBytes) {
+              matches.push(`[\u2026 truncated at ${maxListBytes} bytes \u2014 refine pattern or path \u2026]`);
+              truncated = true;
+              return;
+            }
+            matches.push(out);
+            totalBytes += out.length + 1;
+          }
+          scanned++;
+        }
+      };
+      await walk2(startAbs);
+      if (matches.length === 0) {
+        return scanned === 0 ? "(no files scanned \u2014 path empty or all files filtered out)" : `(no matches across ${scanned} file${scanned === 1 ? "" : "s"})`;
+      }
+      return matches.join("\n");
+    }
+  });
   registry.register({
     name: "get_file_info",
     description: "Stat a path under the sandbox root. Returns type (file|directory|symlink), size in bytes, mtime in ISO-8601.",
@@ -2713,6 +2898,127 @@ function registerPlanTool(registry, opts = {}) {
   return registry;
 }
 
+// src/tools/subagent.ts
+var DEFAULT_MAX_RESULT_CHARS2 = 8e3;
+var DEFAULT_MAX_ITERS = 16;
+var DEFAULT_SUBAGENT_MODEL = "deepseek-chat";
+var SUBAGENT_TOOL_NAME = "spawn_subagent";
+var NEVER_INHERITED_TOOLS = /* @__PURE__ */ new Set([SUBAGENT_TOOL_NAME, "submit_plan"]);
+async function spawnSubagent(opts) {
+  const model = opts.model ?? DEFAULT_SUBAGENT_MODEL;
+  const maxToolIters = opts.maxToolIters ?? DEFAULT_MAX_ITERS;
+  const maxResultChars = opts.maxResultChars ?? DEFAULT_MAX_RESULT_CHARS2;
+  const sink = opts.sink;
+  const startedAt = Date.now();
+  const taskPreview = opts.task.length > 30 ? `${opts.task.slice(0, 30)}\u2026` : opts.task;
+  sink?.current?.({
+    kind: "start",
+    task: taskPreview,
+    iter: 0,
+    elapsedMs: 0
+  });
+  const childTools = forkRegistryExcluding(opts.parentRegistry, NEVER_INHERITED_TOOLS);
+  const childPrefix = new ImmutablePrefix({
+    system: opts.system,
+    toolSpecs: childTools.specs()
+  });
+  const childLoop = new CacheFirstLoop({
+    client: opts.client,
+    prefix: childPrefix,
+    tools: childTools,
+    model,
+    maxToolIters,
+    hooks: [],
+    stream: false
+  });
+  const onParentAbort = () => childLoop.abort();
+  opts.parentSignal?.addEventListener("abort", onParentAbort, { once: true });
+  let final = "";
+  let errorMessage;
+  let toolIter = 0;
+  try {
+    for await (const ev of childLoop.step(opts.task)) {
+      if (ev.role === "tool") {
+        toolIter++;
+        sink?.current?.({
+          kind: "progress",
+          task: taskPreview,
+          iter: toolIter,
+          elapsedMs: Date.now() - startedAt
+        });
+      }
+      if (ev.role === "assistant_final") {
+        final = ev.content ?? "";
+      }
+      if (ev.role === "error") {
+        errorMessage = ev.error ?? "subagent error";
+      }
+    }
+  } catch (err) {
+    errorMessage = err.message;
+  } finally {
+    opts.parentSignal?.removeEventListener("abort", onParentAbort);
+  }
+  if (!errorMessage && !final) {
+    errorMessage = opts.parentSignal?.aborted ? "subagent aborted before producing an answer" : "subagent ended without producing an answer";
+  }
+  const elapsedMs = Date.now() - startedAt;
+  const turns = childLoop.stats.turns.length;
+  const costUsd2 = childLoop.stats.totalCost;
+  const truncated = final.length > maxResultChars ? `${final.slice(0, maxResultChars)}
+
+[\u2026truncated ${final.length - maxResultChars} chars; ask the subagent for a tighter summary if you need more.]` : final;
+  sink?.current?.({
+    kind: "end",
+    task: taskPreview,
+    iter: toolIter,
+    elapsedMs,
+    summary: errorMessage ? void 0 : truncated.slice(0, 120),
+    error: errorMessage,
+    turns
+  });
+  return {
+    success: !errorMessage,
+    output: errorMessage ? "" : truncated,
+    error: errorMessage,
+    turns,
+    toolIters: toolIter,
+    elapsedMs,
+    costUsd: costUsd2
+  };
+}
+function formatSubagentResult(r) {
+  if (!r.success) {
+    return JSON.stringify({
+      success: false,
+      error: r.error ?? "unknown subagent error",
+      turns: r.turns,
+      tool_iters: r.toolIters,
+      elapsed_ms: r.elapsedMs
+    });
+  }
+  return JSON.stringify({
+    success: true,
+    output: r.output,
+    turns: r.turns,
+    tool_iters: r.toolIters,
+    elapsed_ms: r.elapsedMs,
+    cost_usd: r.costUsd
+  });
+}
+function forkRegistryExcluding(parent, exclude) {
+  const child = new ToolRegistry();
+  for (const spec of parent.specs()) {
+    const name = spec.function.name;
+    if (exclude.has(name)) continue;
+    const def = parent.get(name);
+    if (!def) continue;
+    child.register(def);
+  }
+  if (parent.planMode) child.setPlanMode(true);
+  return child;
+}
+
 // src/tools/shell.ts
 import { spawn as spawn2 } from "child_process";
 import { existsSync as existsSync3, statSync as statSync2 } from "fs";
@@ -2910,7 +3216,7 @@ function prepareSpawn(argv, opts = {}) {
     const cmdline = [resolved, ...tail].map(quoteForCmdExe).join(" ");
     return {
       bin: "cmd.exe",
-      args: ["/d", "/s", "/c", cmdline],
+      args: ["/d", "/s", "/c", withUtf8Codepage(cmdline)],
       // windowsVerbatimArguments prevents Node from re-quoting the /c
       // payload — we've already composed an exact cmd.exe command
       // line. Without this Node wraps our already-quoted string in
@@ -2922,12 +3228,36 @@ function prepareSpawn(argv, opts = {}) {
     const cmdline = [head, ...tail].map(quoteForCmdExe).join(" ");
     return {
       bin: "cmd.exe",
-      args: ["/d", "/s", "/c", cmdline],
+      args: ["/d", "/s", "/c", withUtf8Codepage(cmdline)],
       spawnOverrides: { windowsVerbatimArguments: true }
     };
   }
+  if (isPowerShellExe(resolved)) {
+    const patched = injectPowerShellUtf8(tail);
+    if (patched) {
+      return { bin: resolved, args: patched, spawnOverrides: {} };
+    }
+  }
   return { bin: resolved, args: [...tail], spawnOverrides: {} };
 }
+function isPowerShellExe(resolved) {
+  return /(?:^|[\\/])(?:powershell|pwsh)(?:\.exe)?$/i.test(resolved);
+}
+function injectPowerShellUtf8(args) {
+  const prelude = "[Console]::OutputEncoding=[System.Text.Encoding]::UTF8;$OutputEncoding=[System.Text.Encoding]::UTF8;";
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i] ?? "";
+    if (/^-(?:Command|c)$/i.test(a) && i + 1 < args.length) {
+      const out = [...args];
+      out[i + 1] = `${prelude}${args[i + 1] ?? ""}`;
+      return out;
+    }
+  }
+  return null;
+}
+function withUtf8Codepage(cmdline) {
+  return `chcp 65001 >nul & ${cmdline}`;
+}
 function isBareWindowsName(s) {
   if (!s) return false;
   if (s.includes("/") || s.includes("\\")) return false;
@@ -4713,23 +5043,32 @@ import { existsSync as existsSync8, statSync as statSync4 } from "fs";
 import { render } from "ink";
 import React15, { useState as useState7 } from "react";
 
+// src/cli/ui/App.tsx
+import { Box as Box11, Static, Text as Text11, useApp, useInput as useInput4 } from "ink";
+import React12, { useCallback, useEffect as useEffect2, useMemo, useRef as useRef2, useState as useState5 } from "react";
+
 // src/tools/skills.ts
 function registerSkillTools(registry, opts = {}) {
-  const store = new SkillStore({ homeDir: opts.homeDir, projectRoot: opts.projectRoot });
+  const store = new SkillStore({
+    homeDir: opts.homeDir,
+    projectRoot: opts.projectRoot,
+    disableBuiltins: opts.disableBuiltins
+  });
+  const subagentRunner = opts.subagentRunner;
   registry.register({
     name: "run_skill",
-    description: "Load the full body of a user-defined skill into this conversation. Call when the pinned Skills index (in the system prompt) lists a skill whose description matches what's being asked. Returns the skill's markdown instructions \u2014 read them and continue the loop, calling whatever filesystem / shell / web tools the skill's prose requires. Skills are user content; follow their instructions, but keep Reasonix's own safety rules (no destructive ops without confirmation, etc.).",
+    description: "Invoke a playbook from the Skills index pinned in the system prompt. Each entry is a self-contained instruction block. Skills marked with \u{1F9EC} in the index spawn an isolated subagent \u2014 only the final distilled answer comes back, the model's tool calls + reasoning during the run never enter your context. Plain skills are inlined: the body becomes a tool result you read and follow. For \u{1F9EC} subagent skills, supply 'arguments' describing the concrete task \u2014 they'll be the only context the subagent has.",
     readOnly: true,
     parameters: {
       type: "object",
       properties: {
         name: {
           type: "string",
-          description: "Skill identifier as it appears in the pinned Skills index (e.g. 'review', 'security-review'). Case-sensitive."
+          description: "Skill identifier as it appears in the pinned Skills index (e.g. 'explore', 'review', 'security-review'). Case-sensitive."
         },
         arguments: {
           type: "string",
-          description: "Optional free-form arguments the caller wants the skill to act on. Forwarded verbatim as an 'Arguments:' line appended to the skill body; the skill's own instructions decide how to consume them."
+          description: "Free-form arguments the skill should act on. For inline skills: appended to the body as an 'Arguments:' line; the skill's own instructions decide how to consume them. For \u{1F9EC} subagent skills: REQUIRED \u2014 becomes the entire task description the subagent receives, since it has no other context."
         }
       },
       required: ["name"]
@@ -4748,6 +5087,19 @@ function registerSkillTools(registry, opts = {}) {
         });
       }
       const rawArgs = typeof args.arguments === "string" ? args.arguments.trim() : "";
+      if (skill.runAs === "subagent") {
+        if (!subagentRunner) {
+          return JSON.stringify({
+            error: `run_skill: skill ${JSON.stringify(name)} is marked runAs=subagent but no subagent runner is configured for this session. Skill authors who need isolation should run inside reasonix code (or a library setup that passes subagentRunner to registerSkillTools).`
+          });
+        }
+        if (!rawArgs) {
+          return JSON.stringify({
+            error: `run_skill: skill ${JSON.stringify(name)} is a subagent and requires 'arguments' \u2014 the subagent has no other context, so describe the concrete task in the arguments field.`
+          });
+        }
+        return subagentRunner(skill, rawArgs);
+      }
       const header2 = [
         `# Skill: ${skill.name}`,
         skill.description ? `> ${skill.description}` : "",
@@ -4764,10 +5116,6 @@ ${skill.body}${argsBlock}`;
   return registry;
 }
 
-// src/cli/ui/App.tsx
-import { Box as Box11, Static, Text as Text11, useApp, useInput as useInput4 } from "ink";
-import React12, { useCallback, useEffect as useEffect2, useMemo, useRef as useRef2, useState as useState5 } from "react";
-
 // src/cli/ui/EventLog.tsx
 import { Box as Box3, Text as Text3 } from "ink";
 import React4 from "react";
@@ -4840,7 +5188,7 @@ function stripMath(s) {
   ).replace(/\\sqrt\s*\{([^{}]+)\}/g, (_m, g) => `\u221A(${g.trim()})`).replace(/\\boxed\s*\{([^{}]+)\}/g, (_m, g) => `\u3010${g.trim()}\u3011`).replace(/\\text\s*\{([^{}]+)\}/g, (_m, g) => g.trim()).replace(/\\overline\s*\{([^{}]+)\}/g, (_m, g) => `${g.trim()}\u0304`).replace(/\\hat\s*\{([^{}]+)\}/g, (_m, g) => `${g.trim()}\u0302`).replace(/\\vec\s*\{([^{}]+)\}/g, (_m, g) => `\u2192${g.trim()}`).replace(/\\cdot/g, "\xB7").replace(/\\times/g, "\xD7").replace(/\\div/g, "\xF7").replace(/\\pm/g, "\xB1").replace(/\\mp/g, "\u2213").replace(/\\leq/g, "\u2264").replace(/\\geq/g, "\u2265").replace(/\\neq/g, "\u2260").replace(/\\approx/g, "\u2248").replace(/\\in\b/g, "\u2208").replace(/\\notin\b/g, "\u2209").replace(/\\infty/g, "\u221E").replace(/\\sum\b/g, "\u03A3").replace(/\\prod\b/g, "\u03A0").replace(/\\int\b/g, "\u222B").replace(/\\alpha/g, "\u03B1").replace(/\\beta/g, "\u03B2").replace(/\\gamma/g, "\u03B3").replace(/\\delta/g, "\u03B4").replace(/\\theta/g, "\u03B8").replace(/\\lambda/g, "\u03BB").replace(/\\mu/g, "\u03BC").replace(/\\pi/g, "\u03C0").replace(/\\sigma/g, "\u03C3").replace(/\\phi/g, "\u03C6").replace(/\\omega/g, "\u03C9").replace(/\\implies\b/g, "\u21D2").replace(/\\iff\b/g, "\u21D4").replace(/\\to\b/g, "\u2192").replace(/\\rightarrow/g, "\u2192").replace(/\\Rightarrow/g, "\u21D2").replace(/\\leftarrow/g, "\u2190").replace(/\\Leftarrow/g, "\u21D0").replace(/\\ldots/g, "\u2026").replace(/\\cdots/g, "\u22EF").replace(/\\quad/g, "  ").replace(/\\qquad/g, "    ").replace(/\\,/g, " ").replace(/\\;/g, " ").replace(/\\!/g, "").replace(/\\\\/g, "\n").replace(/\^\{([\w+-]+)\}/g, (_m, g) => toSuperscript(g)).replace(/\^([0-9+\-n])/g, (_m, g) => toSuperscript(g)).replace(/_\{([\w+-]+)\}/g, (_m, g) => toSubscript(g)).replace(/_([0-9+\-])/g, (_m, g) => toSubscript(g)).replace(/\\[a-zA-Z]+\s*\{([^{}]+)\}\s*\{([^{}]+)\}/g, "($1)/($2)").replace(/\\[a-zA-Z]+\s*\{([^{}]+)\}/g, "$1").replace(/\\[a-zA-Z]+/g, "").replace(/[ \t]{2,}/g, " ");
 }
 var INLINE_RE = /(\*\*([^*\n]+?)\*\*|```([^\n]+?)```|`([^`\n]+?)`|(?<![*\w])\*([^*\n]+?)\*(?!\w))/g;
-function InlineMd({ text }) {
+function InlineMd({ text, padTo }) {
   const parts = [];
   let last = 0;
   let idx = 0;
@@ -4872,8 +5220,20 @@ function InlineMd({ text }) {
   if (last < text.length) {
     parts.push(/* @__PURE__ */ React2.createElement(Text2, { key: `t${idx++}` }, text.slice(last)));
   }
+  if (padTo !== void 0) {
+    const seen = visibleWidth(text);
+    if (seen < padTo) {
+      parts.push(/* @__PURE__ */ React2.createElement(Text2, { key: `pad${idx++}` }, " ".repeat(padTo - seen)));
+    }
+  }
   return /* @__PURE__ */ React2.createElement(Text2, null, parts);
 }
+function stripInlineMarkup(s) {
+  return s.replace(/\*\*([^*\n]+?)\*\*/g, "$1").replace(/```([^\n]+?)```/g, (_m, c) => c.replace(/^(\w+)\s+/, "")).replace(/`([^`\n]+?)`/g, "$1").replace(/(?<![*\w])\*([^*\n]+?)\*(?!\w)/g, "$1");
+}
+function visibleWidth(s) {
+  return displayWidth(stripInlineMarkup(s));
+}
 function parseBlocks(raw) {
   const lines = raw.split(/\r?\n/);
   const out = [];
@@ -4980,17 +5340,47 @@ function parseBlocks(raw) {
       out.push({ kind: "heading", level: hm[1].length, text: hm[2].trim() });
       continue;
     }
-    if (line.includes("|")) {
+    if (/^\s*┌─+┐\s*$/.test(line)) {
+      let j = i + 1;
+      const bodyLines = [];
+      while (j < lines.length && !/^\s*└─+┘\s*$/.test(lines[j])) {
+        const inner = lines[j];
+        const m = inner.match(/^\s*│\s?(.*?)\s?│\s*$/);
+        bodyLines.push(m ? m[1] ?? "" : inner);
+        j++;
+      }
+      if (j < lines.length) {
+        flushPara();
+        flushList();
+        out.push({ kind: "code", lang: "", text: bodyLines.join("\n") });
+        i = j;
+        continue;
+      }
+    }
+    if (line.includes("|") || line.includes("\u2502")) {
       const next = (lines[i + 1] ?? "").trim();
-      if (/^\|?\s*:?-{2,}:?\s*(\|\s*:?-{2,}:?\s*)+\|?\s*$/.test(next)) {
+      const isGfmSep = /^\|?\s*:?-{2,}:?\s*(\|\s*:?-{2,}:?\s*)+\|?\s*$/.test(next);
+      const isBoxSep = /^[│─┼┬┴┌┐└┘├┤\s]+$/.test(next) && /─{2,}/.test(next);
+      if (isGfmSep || isBoxSep) {
         flushPara();
         flushList();
         const header2 = splitTableRow(line);
+        const colCount = header2.length;
         const rows = [];
         let j = i + 2;
         while (j < lines.length) {
           const r = lines[j].replace(/\s+$/g, "");
-          if (r.trim() === "" || !r.includes("|")) break;
+          if (r.trim() === "") break;
+          if (!r.includes("|") && !r.includes("\u2502")) {
+            const prev = rows[rows.length - 1];
+            if (prev && prev.length === colCount) {
+              const lastIdx = prev.length - 1;
+              prev[lastIdx] = `${prev[lastIdx] ?? ""} ${r.trim()}`;
+              j++;
+              continue;
+            }
+            break;
+          }
           rows.push(splitTableRow(r));
           j++;
         }
@@ -5049,7 +5439,7 @@ function BlockView({ block }) {
 }
 function splitTableRow(line) {
   const SENTINEL = "\0";
-  const masked = line.replace(/\\\|/g, SENTINEL);
+  const masked = line.replace(/\\\|/g, SENTINEL).replace(/│/g, "|");
   const trimmed = masked.trim().replace(/^\||\|$/g, "");
   return trimmed.split("|").map((c) => c.trim().replace(new RegExp(SENTINEL, "g"), "|"));
 }
@@ -5057,24 +5447,19 @@ function TableBlockRow({ block }) {
   const colCount = Math.max(block.header.length, ...block.rows.map((r) => r.length));
   const widths = [];
   for (let c = 0; c < colCount; c++) {
-    const cellLengths = [displayWidth(block.header[c] ?? "")];
-    for (const r of block.rows) cellLengths.push(displayWidth(r[c] ?? ""));
+    const cellLengths = [visibleWidth(block.header[c] ?? "")];
+    for (const r of block.rows) cellLengths.push(visibleWidth(r[c] ?? ""));
     widths.push(Math.min(40, Math.max(3, ...cellLengths)));
   }
-  const pad3 = (s, w) => {
-    const dw = displayWidth(s);
-    if (dw >= w) return s;
-    return s + " ".repeat(w - dw);
-  };
   const separator = widths.map((w) => "\u2500".repeat(w)).join("\u2500\u253C\u2500");
   return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column" }, /* @__PURE__ */ React2.createElement(Box2, null, block.header.map((cell, ci) => (
     // biome-ignore lint/suspicious/noArrayIndexKey: table columns never reorder — derived from a static header array
-    /* @__PURE__ */ React2.createElement(Text2, { key: `h-${ci}`, bold: true, color: "cyan" }, pad3(cell, widths[ci] ?? 3), ci < colCount - 1 ? " \u2502 " : "")
+    /* @__PURE__ */ React2.createElement(Text2, { key: `h-${ci}`, bold: true, color: "cyan" }, /* @__PURE__ */ React2.createElement(InlineMd, { text: cell, padTo: widths[ci] ?? 3 }), ci < colCount - 1 ? " \u2502 " : "")
   ))), /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, separator), block.rows.map((row2, ri) => (
     // biome-ignore lint/suspicious/noArrayIndexKey: table rows render in source order and don't reorder
     /* @__PURE__ */ React2.createElement(Box2, { key: `r-${ri}` }, Array.from({ length: colCount }).map((_, ci) => (
       // biome-ignore lint/suspicious/noArrayIndexKey: same — column axis is fixed by the table shape
-      /* @__PURE__ */ React2.createElement(Text2, { key: `c-${ri}-${ci}` }, pad3(row2[ci] ?? "", widths[ci] ?? 3), ci < colCount - 1 ? " \u2502 " : "")
+      /* @__PURE__ */ React2.createElement(Text2, { key: `c-${ri}-${ci}` }, /* @__PURE__ */ React2.createElement(InlineMd, { text: row2[ci] ?? "", padTo: widths[ci] ?? 3 }), ci < colCount - 1 ? " \u2502 " : "")
     )))
   )));
 }
@@ -6710,6 +7095,7 @@ function App({
   const abortedThisTurn = useRef2(false);
   const [ongoingTool, setOngoingTool] = useState5(null);
   const [toolProgress, setToolProgress] = useState5(null);
+  const [subagentActivity, setSubagentActivity] = useState5(null);
   const [statusLine, setStatusLine] = useState5(null);
   const [balance, setBalance] = useState5(null);
   const [latestVersion, setLatestVersion] = useState5(null);
@@ -6766,9 +7152,30 @@ function App({
     });
   }, [slashMatches]);
   const loopRef = useRef2(null);
+  const subagentSinkRef = useRef2({ current: null });
   const loop = useMemo(() => {
     if (loopRef.current) return loopRef.current;
     const client = new DeepSeekClient();
+    if (tools && !tools.has("run_skill")) {
+      registerSkillTools(tools, {
+        projectRoot: codeMode?.rootDir,
+        subagentRunner: async (skill, task) => {
+          const result = await spawnSubagent({
+            client,
+            parentRegistry: tools,
+            // Skill body is the subagent's persona/playbook; the user-
+            // supplied task is what to actually do inside it.
+            system: skill.body,
+            task,
+            // Per-skill model override (frontmatter `model: ...`),
+            // else falls through to spawnSubagent's default.
+            model: skill.model,
+            sink: subagentSinkRef.current
+          });
+          return formatSubagentResult(result);
+        }
+      });
+    }
     const prefix = new ImmutablePrefix({
       system,
       toolSpecs: tools?.specs()
@@ -6786,7 +7193,7 @@ function App({
     });
     loopRef.current = l;
     return l;
-  }, [model, system, harvest2, branch, session, tools]);
+  }, [model, system, harvest2, branch, session, tools, codeMode]);
   useEffect2(() => {
     loop.hooks = hookList;
   }, [loop, hookList]);
@@ -6826,6 +7233,40 @@ function App({
       if (progressSink.current) progressSink.current = null;
     };
   }, [progressSink]);
+  useEffect2(() => {
+    subagentSinkRef.current.current = (ev) => {
+      if (ev.kind === "start") {
+        setSubagentActivity({
+          task: ev.task,
+          iter: ev.iter ?? 0,
+          elapsedMs: ev.elapsedMs ?? 0
+        });
+        return;
+      }
+      if (ev.kind === "progress") {
+        setSubagentActivity({
+          task: ev.task,
+          iter: ev.iter ?? 0,
+          elapsedMs: ev.elapsedMs ?? 0
+        });
+        return;
+      }
+      setSubagentActivity(null);
+      const seconds = ((ev.elapsedMs ?? 0) / 1e3).toFixed(1);
+      const summary2 = ev.error ? `\u{1F9EC} subagent "${ev.task}" failed after ${seconds}s \xB7 ${ev.iter ?? 0} tool call(s) \u2014 ${ev.error}` : `\u{1F9EC} subagent "${ev.task}" done in ${seconds}s \xB7 ${ev.iter ?? 0} tool call(s) \xB7 ${ev.turns ?? 0} turn(s)`;
+      setHistorical((prev) => [
+        ...prev,
+        {
+          id: `subagent-end-${Date.now()}`,
+          role: "info",
+          text: summary2
+        }
+      ]);
+    };
+    return () => {
+      subagentSinkRef.current.current = null;
+    };
+  }, []);
   const sessionBannerShown = useRef2(false);
   useEffect2(() => {
     if (sessionBannerShown.current) return;
@@ -7436,7 +7877,7 @@ Stay in plan mode \u2014 address the feedback (explore more if needed), then sub
       balance,
       updateAvailable
     }
-  ), /* @__PURE__ */ React12.createElement(Static, { items: historical }, (item) => /* @__PURE__ */ React12.createElement(EventRow, { key: item.id, event: item })), !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && streaming ? /* @__PURE__ */ React12.createElement(Box11, { marginY: 1 }, /* @__PURE__ */ React12.createElement(EventRow, { event: streaming })) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && ongoingTool ? /* @__PURE__ */ React12.createElement(OngoingToolRow, { tool: ongoingTool, progress: toolProgress }) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && !ongoingTool && statusLine ? /* @__PURE__ */ React12.createElement(StatusRow, { text: statusLine }) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && busy && !streaming && !ongoingTool && !statusLine ? /* @__PURE__ */ React12.createElement(StatusRow, { text: "processing\u2026" }) : null, stagedInput ? /* @__PURE__ */ React12.createElement(
+  ), /* @__PURE__ */ React12.createElement(Static, { items: historical }, (item) => /* @__PURE__ */ React12.createElement(EventRow, { key: item.id, event: item })), !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && streaming ? /* @__PURE__ */ React12.createElement(Box11, { marginY: 1 }, /* @__PURE__ */ React12.createElement(EventRow, { event: streaming })) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && ongoingTool ? /* @__PURE__ */ React12.createElement(OngoingToolRow, { tool: ongoingTool, progress: toolProgress }) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && subagentActivity ? /* @__PURE__ */ React12.createElement(SubagentRow, { activity: subagentActivity }) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && !ongoingTool && statusLine ? /* @__PURE__ */ React12.createElement(StatusRow, { text: statusLine }) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && busy && !streaming && !ongoingTool && !statusLine ? /* @__PURE__ */ React12.createElement(StatusRow, { text: "processing\u2026" }) : null, stagedInput ? /* @__PURE__ */ React12.createElement(
     PlanRefineInput,
     {
       mode: stagedInput.mode,
@@ -7466,6 +7907,13 @@ function StatusRow({ text }) {
   const elapsed = useElapsedSeconds();
   return /* @__PURE__ */ React12.createElement(Box11, { marginY: 1 }, /* @__PURE__ */ React12.createElement(Text11, { color: "magenta" }, SPINNER_FRAMES[tick % SPINNER_FRAMES.length]), /* @__PURE__ */ React12.createElement(Text11, { color: "magenta" }, ` ${text}`), /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, ` ${elapsed}s`));
 }
+function SubagentRow({
+  activity
+}) {
+  const tick = useTick();
+  const seconds = (activity.elapsedMs / 1e3).toFixed(1);
+  return /* @__PURE__ */ React12.createElement(Box11, { paddingLeft: 2 }, /* @__PURE__ */ React12.createElement(Text11, { color: "magenta" }, SPINNER_FRAMES[tick % SPINNER_FRAMES.length]), /* @__PURE__ */ React12.createElement(Text11, { color: "magenta" }, ` \u{1F9EC} subagent: ${activity.task}`), /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, ` \xB7 iter ${activity.iter} \xB7 ${seconds}s`));
+}
 function OngoingToolRow({
   tool,
   progress
@@ -7784,7 +8232,6 @@ async function chatCommand(opts) {
   if (!opts.seedTools) {
     if (!tools) tools = new ToolRegistry();
     registerMemoryTools(tools, {});
-    registerSkillTools(tools);
   }
   let sessionPreview;
   if (opts.session && !opts.forceResume && !opts.forceNew) {
@@ -7824,7 +8271,7 @@ async function chatCommand(opts) {
 // src/cli/commands/code.tsx
 import { basename, resolve as resolve5 } from "path";
 async function codeCommand(opts = {}) {
-  const { codeSystemPrompt: codeSystemPrompt2 } = await import("./prompt-VDN5U3YE.js");
+  const { codeSystemPrompt: codeSystemPrompt2 } = await import("./prompt-6DMLWG2H.js");
   const rootDir = resolve5(opts.dir ?? process.cwd());
   const session = opts.noSession ? void 0 : `code-${sanitizeName(basename(rootDir))}`;
   const tools = new ToolRegistry();
@@ -7840,7 +8287,6 @@ async function codeCommand(opts = {}) {
   });
   registerPlanTool(tools);
   registerMemoryTools(tools, { projectRoot: rootDir });
-  registerSkillTools(tools, { projectRoot: rootDir });
   process.stderr.write(
     `\u25B8 reasonix code: rooted at ${rootDir}, session "${session ?? "(ephemeral)"}" \xB7 ${tools.size} native tool(s)
 `