reasonix 0.30.3 → 0.30.5

package/dist/index.js

@@ -1480,6 +1480,10 @@ var SessionStats = class {
   _carryoverCost = 0;
   /** Turn count from prior runs of a resumed session. */
   _carryoverTurns = 0;
+  _carryoverCacheHit = 0;
+  _carryoverCacheMiss = 0;
+  /** Last turn's promptTokens before exit — surfaced via summary() until the next live turn lands. */
+  _carryoverLastPromptTokens = 0;
   /** Seed totals from a resumed session's persisted meta — only call once at construction. */
   seedCarryover(opts) {
     if (typeof opts.totalCostUsd === "number" && opts.totalCostUsd > 0) {
@@ -1488,6 +1492,15 @@ var SessionStats = class {
     if (typeof opts.turnCount === "number" && opts.turnCount > 0) {
       this._carryoverTurns = opts.turnCount;
     }
+    if (typeof opts.cacheHitTokens === "number" && opts.cacheHitTokens > 0) {
+      this._carryoverCacheHit = opts.cacheHitTokens;
+    }
+    if (typeof opts.cacheMissTokens === "number" && opts.cacheMissTokens > 0) {
+      this._carryoverCacheMiss = opts.cacheMissTokens;
+    }
+    if (typeof opts.lastPromptTokens === "number" && opts.lastPromptTokens > 0) {
+      this._carryoverLastPromptTokens = opts.lastPromptTokens;
+    }
   }
   record(turn, model, usage) {
     const cost = costUsd(model, usage);
@@ -1518,8 +1531,8 @@ var SessionStats = class {
     return this.turns.reduce((sum, t) => sum + outputCostUsd(t.model, t.usage), 0);
   }
   get aggregateCacheHitRatio() {
-    let hit = 0;
-    let miss = 0;
+    let hit = this._carryoverCacheHit;
+    let miss = this._carryoverCacheMiss;
     for (const t of this.turns) {
       hit += t.usage.promptCacheHitTokens;
       miss += t.usage.promptCacheMissTokens;
@@ -1537,7 +1550,7 @@ var SessionStats = class {
       claudeEquivalentUsd: round(this.totalClaudeEquivalent, 6),
       savingsVsClaudePct: round(this.savingsVsClaude * 100, 2),
       cacheHitRatio: round(this.aggregateCacheHitRatio, 4),
-      lastPromptTokens: last?.usage.promptTokens ?? 0,
+      lastPromptTokens: last?.usage.promptTokens ?? this._carryoverLastPromptTokens,
       lastTurnCostUsd: round(last?.cost ?? 0, 6)
     };
   }
@@ -2269,15 +2282,18 @@ var StormBreaker = class {
   windowSize;
   threshold;
   isMutating;
+  isStormExempt;
   recent = [];
-  constructor(windowSize = 6, threshold = 3, isMutating) {
+  constructor(windowSize = 6, threshold = 3, isMutating, isStormExempt) {
     this.windowSize = windowSize;
     this.threshold = threshold;
     this.isMutating = isMutating;
+    this.isStormExempt = isStormExempt;
   }
   inspect(call) {
     const name = call.function?.name;
     if (!name) return { suppress: false };
+    if (this.isStormExempt?.(call)) return { suppress: false };
     const args = call.function?.arguments ?? "";
     const mutating = this.isMutating ? this.isMutating(call) : false;
     const readOnly = !mutating;
@@ -2378,7 +2394,12 @@ var ToolCallRepair = class {
   opts;
   constructor(opts) {
     this.opts = opts;
-    this.storm = new StormBreaker(opts.stormWindow ?? 6, opts.stormThreshold ?? 3, opts.isMutating);
+    this.storm = new StormBreaker(
+      opts.stormWindow ?? 6,
+      opts.stormThreshold ?? 3,
+      opts.isMutating,
+      opts.isStormExempt
+    );
   }
   /** Called at start of every user turn — fresh intent shouldn't inherit old repetition state. */
   resetStorm() {
@@ -2521,9 +2542,15 @@ var CacheFirstLoop = class {
       }
       return def.readOnly !== true;
     };
+    const isStormExempt = (call) => {
+      const name = call.function?.name;
+      if (!name) return false;
+      return registry.get(name)?.stormExempt === true;
+    };
     this.repair = new ToolCallRepair({
       allowedToolNames: allowedNames,
       isMutating,
+      isStormExempt,
       stormThreshold: parsePositiveIntEnv(process.env.REASONIX_STORM_THRESHOLD),
       stormWindow: parsePositiveIntEnv(process.env.REASONIX_STORM_WINDOW)
     });
@@ -2541,7 +2568,10 @@ var CacheFirstLoop = class {
         const meta = loadSessionMeta(this.sessionName);
         this.stats.seedCarryover({
           totalCostUsd: meta.totalCostUsd,
-          turnCount: meta.turnCount
+          turnCount: meta.turnCount,
+          cacheHitTokens: meta.cacheHitTokens,
+          cacheMissTokens: meta.cacheMissTokens,
+          lastPromptTokens: meta.lastPromptTokens
         });
       }
       if (healedCount > 0) {
@@ -3637,19 +3667,19 @@ ${mem.content}
 import { createHash as createHash2 } from "crypto";
 import {
   existsSync as existsSync7,
-  mkdirSync as mkdirSync2,
+  mkdirSync as mkdirSync3,
   readFileSync as readFileSync8,
   readdirSync as readdirSync4,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync2
+  writeFileSync as writeFileSync3
 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join7, resolve as resolve3 } from "path";
 
 // src/skills.ts
-import { existsSync as existsSync6, readFileSync as readFileSync7, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync7, readdirSync as readdirSync3, statSync as statSync3, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join6, resolve as resolve2 } from "path";
+import { dirname as dirname3, join as join6, resolve as resolve2 } from "path";
 
 // src/prompt-fragments.ts
 var TUI_FORMATTING_RULES = `Formatting (rendered in a TUI with a real markdown renderer):
@@ -3754,6 +3784,31 @@ var SkillStore = class {
     }
     return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
   }
+  /** Scaffold a new skill stub at the chosen scope. Refuses to overwrite. */
+  create(name, scope) {
+    if (!isValidSkillName(name)) {
+      return { error: `invalid skill name: "${name}" \u2014 use letters, digits, _, -, .` };
+    }
+    if (scope === "project" && !this.projectRoot) {
+      return { error: "project scope requires a workspace \u2014 run from `reasonix code`" };
+    }
+    const root = scope === "project" ? join6(this.projectRoot ?? "", ".reasonix", SKILLS_DIRNAME) : join6(this.homeDir, ".reasonix", SKILLS_DIRNAME);
+    const flat = join6(root, `${name}.md`);
+    const folder = join6(root, name, SKILL_FILE);
+    if (existsSync6(folder)) {
+      return { error: `skill "${name}" already exists at ${folder}` };
+    }
+    mkdirSync2(dirname3(flat), { recursive: true });
+    try {
+      writeFileSync2(flat, skillStubBody(name), { encoding: "utf8", flag: "wx" });
+    } catch (err) {
+      if (err.code === "EEXIST") {
+        return { error: `skill "${name}" already exists at ${flat}` };
+      }
+      throw err;
+    }
+    return { path: flat };
+  }
   /** Resolve one skill by name. Returns `null` if not found or malformed. */
   read(name) {
     if (!isValidSkillName(name)) return null;
@@ -3813,6 +3868,22 @@ var SkillStore = class {
 function parseRunAs(raw) {
   return raw?.trim() === "subagent" ? "subagent" : "inline";
 }
+function skillStubBody(name) {
+  return `---
+name: ${name}
+description: One-liner \u2014 what does this skill do?
+---
+
+# ${name}
+
+Replace this body with the playbook the model should follow when this skill is invoked.
+
+Tips:
+- Reference tools by name (run_command, edit_file, search_content, ...)
+- Add \`runAs: subagent\` to frontmatter to spawn an isolated subagent loop
+- Add \`allowed-tools: read_file, search_content\` to scope a subagent's tools
+`;
+}
 function skillIndexLine(s) {
   const safeDesc = s.description.replace(/\n/g, " ").trim();
   const tag = s.runAs === "subagent" ? " [\u{1F9EC} subagent]" : "";
@@ -4055,7 +4126,7 @@ function scopeDir(opts) {
   return join7(opts.homeDir, USER_MEMORY_DIR, projectHash(opts.projectRoot));
 }
 function ensureDir(p) {
-  if (!existsSync7(p)) mkdirSync2(p, { recursive: true });
+  if (!existsSync7(p)) mkdirSync3(p, { recursive: true });
 }
 function parseFrontmatter2(raw) {
   const lines = raw.split(/\r?\n/);
@@ -4200,7 +4271,7 @@ var MemoryStore = class {
     const file = join7(dir, `${name}.md`);
     const content = `${formatFrontmatter(entry)}${body}
 `;
-    writeFileSync2(file, content, "utf8");
+    writeFileSync3(file, content, "utf8");
     this.regenerateIndex(input.scope);
     return file;
   }
@@ -4241,7 +4312,7 @@ var MemoryStore = class {
         lines.push(`- [${name}](${name}.md) \u2014 (malformed, check frontmatter)`);
       }
     }
-    writeFileSync2(indexPath, `${lines.join("\n")}
+    writeFileSync3(indexPath, `${lines.join("\n")}
 `, "utf8");
   }
 };
@@ -4662,7 +4733,9 @@ function registerFilesystemTools(registry, opts) {
     const normRoot = pathMod3.resolve(rootDir);
     const rel = pathMod3.relative(normRoot, resolved);
     if (rel.startsWith("..") || pathMod3.isAbsolute(rel)) {
-      throw new Error(`path escapes sandbox root (${normRoot}): ${raw}`);
+      throw new Error(
+        `path escapes sandbox root (${normRoot}): ${raw} \u2014 workspace is pinned at launch; quit and relaunch with \`reasonix code --dir <path>\` to work in a different folder`
+      );
     }
     return resolved;
   };
@@ -4675,6 +4748,7 @@ function registerFilesystemTools(registry, opts) {
   - range: "A-B"  \u2192 inclusive line range A..B, 1-indexed (e.g. "120-180" around an edit site)
 When none of these is given AND the file is longer than ${DEFAULT_AUTO_PREVIEW_LINES} lines, the tool auto-returns a head+tail preview with an "N lines omitted" marker rather than dumping everything. If you need the middle, re-call with a range. Prefer search_content to locate a symbol first, then read_file with a range around the hit \u2014 one scoped read beats three full-file reads.`,
     readOnly: true,
+    stormExempt: true,
     parameters: {
       type: "object",
       properties: {
@@ -4755,6 +4829,7 @@ ${slice.join("\n")}`;
     parallelSafe: true,
     description: "List entries in a directory under the sandbox root. Returns one line per entry, marking directories with a trailing slash. Not recursive \u2014 use directory_tree for that.",
     readOnly: true,
+    stormExempt: true,
     parameters: {
       type: "object",
       properties: {
@@ -5856,9 +5931,9 @@ function forkRegistryWithAllowList(parent, allow, alsoExclude) {
 import * as pathMod7 from "path";
 
 // src/config.ts
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync9, writeFileSync as writeFileSync3 } from "fs";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync9, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir5 } from "os";
-import { dirname as dirname4, join as join10 } from "path";
+import { dirname as dirname5, join as join10 } from "path";
 function defaultConfigPath() {
   return join10(homedir5(), ".reasonix", "config.json");
 }
@@ -5872,8 +5947,8 @@ function readConfig(path2 = defaultConfigPath()) {
   return {};
 }
 function writeConfig(cfg, path2 = defaultConfigPath()) {
-  mkdirSync3(dirname4(path2), { recursive: true });
-  writeFileSync3(path2, JSON.stringify(cfg, null, 2), "utf8");
+  mkdirSync4(dirname5(path2), { recursive: true });
+  writeFileSync4(path2, JSON.stringify(cfg, null, 2), "utf8");
   try {
     chmodSync2(path2, 384);
   } catch {
@@ -6015,7 +6090,8 @@ var JobRegistry = class {
         },
         closedPromise: Promise.resolve(),
         signalClosed: () => {
-        }
+        },
+        outputWaiters: /* @__PURE__ */ new Set()
       };
       this.jobs.set(id2, job2);
       return {
@@ -6051,7 +6127,8 @@ var JobRegistry = class {
       readyPromise,
       signalReady: readyResolve,
       closedPromise,
-      signalClosed: closedResolve
+      signalClosed: closedResolve,
+      outputWaiters: /* @__PURE__ */ new Set()
     };
     this.jobs.set(id, job);
     let readyMatched = false;
@@ -6078,6 +6155,11 @@ ${job.output.slice(start)}`;
           }
         }
       }
+      if (job.outputWaiters.size > 0) {
+        const waiters = [...job.outputWaiters];
+        job.outputWaiters.clear();
+        for (const wake of waiters) wake();
+      }
     };
     child.stdout?.on("data", onData);
     child.stderr?.on("data", onData);
@@ -6139,6 +6221,39 @@ ${job.output.slice(start)}`;
       spawnError: job.spawnError
     };
   }
+  async waitForJob(id, opts = {}) {
+    const job = this.jobs.get(id);
+    if (!job) return null;
+    if (!job.running) {
+      return {
+        exited: true,
+        exitCode: job.exitCode,
+        latestOutput: job.output
+      };
+    }
+    const timeoutMs = Math.max(0, Math.min(3e4, opts.timeoutMs ?? 5e3));
+    const startOutput = job.output;
+    let wakeOutput = null;
+    const outputPromise = new Promise((resolve10) => {
+      wakeOutput = resolve10;
+      job.outputWaiters.add(resolve10);
+    });
+    let timer = null;
+    await Promise.race([
+      job.closedPromise,
+      outputPromise,
+      new Promise((resolve10) => {
+        timer = setTimeout(resolve10, timeoutMs);
+      })
+    ]);
+    if (timer) clearTimeout(timer);
+    if (wakeOutput) job.outputWaiters.delete(wakeOutput);
+    return {
+      exited: !job.running,
+      exitCode: job.exitCode,
+      latestOutput: latestOutputSince(startOutput, job.output)
+    };
+  }
   /** SIGTERM, wait graceMs, then SIGKILL. Idempotent on already-exited jobs. */
   async stop(id, opts = {}) {
     const job = this.jobs.get(id);
@@ -6218,6 +6333,11 @@ function snapshot(job) {
     spawnError: job.spawnError
   };
 }
+function latestOutputSince(before, after) {
+  if (!before) return after;
+  if (after.startsWith(before)) return after.slice(before.length);
+  return after;
+}
 
 // src/tools/shell/exec.ts
 import { spawn as spawn4, spawnSync } from "child_process";
@@ -7197,6 +7317,7 @@ function registerShellTools(registry, opts) {
     description: "Read the latest output of a background job started with `run_background`. By default returns the tail of the buffer (last 80 lines). Pass `since` (the `byteLength` from a previous call) to stream only new content incrementally. Tells you whether the job is still running, so you can stop polling when it's done.",
     readOnly: true,
     parallelSafe: true,
+    stormExempt: true,
     parameters: {
       type: "object",
       properties: {
@@ -7221,6 +7342,32 @@ function registerShellTools(registry, opts) {
       return formatJobRead(args.jobId, out);
     }
   });
+  registry.register({
+    name: "wait_for_job",
+    description: "Block until a background job exits or produces new output, bounded by `timeoutMs`. Use this instead of polling `job_output` with identical args when you're intentionally waiting for state to change. Returns JSON with `exited`, `exitCode`, and `latestOutput`.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        jobId: { type: "integer", description: "Job id returned by run_background." },
+        timeoutMs: {
+          type: "integer",
+          description: "Max time to block before returning if nothing changes. Clamped to 0..30000. Default 5000."
+        }
+      },
+      required: ["jobId"]
+    },
+    fn: async (args) => {
+      const out = await jobs.waitForJob(args.jobId, { timeoutMs: args.timeoutMs });
+      if (!out) return `job ${args.jobId}: not found (use list_jobs)`;
+      return {
+        jobId: args.jobId,
+        exited: out.exited,
+        exitCode: out.exitCode,
+        latestOutput: out.latestOutput
+      };
+    }
+  });
   registry.register({
     name: "stop_job",
     description: "Stop a background job started with `run_background`. SIGTERM first; SIGKILL after a short grace period if it doesn't exit cleanly. Returns the final output + exit code. Safe to call on an already-exited job.",
@@ -7242,6 +7389,7 @@ function registerShellTools(registry, opts) {
     description: "List every background job started this session \u2014 running and exited \u2014 with id, command, pid, status. Use when you've lost track of which job_id corresponds to which process, or to see what's still alive.",
     readOnly: true,
     parallelSafe: true,
+    stormExempt: true,
     parameters: { type: "object", properties: {} },
     fn: async () => {
       const all = jobs.list();
@@ -8174,16 +8322,16 @@ function truncate(s, n) {
 }
 
 // src/version.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync12, writeFileSync as writeFileSync4 } 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 join11 } from "path";
+import { dirname as dirname6, join as join11 } 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(fileURLToPath2(import.meta.url));
+    let dir = dirname6(fileURLToPath2(import.meta.url));
     for (let i = 0; i < 6; i++) {
       const p = join11(dir, "package.json");
       if (existsSync9(p)) {
@@ -8192,7 +8340,7 @@ function readPackageVersion() {
           return pkg.version;
         }
       }
-      const parent = dirname5(dir);
+      const parent = dirname6(dir);
       if (parent === dir) break;
       dir = parent;
     }
@@ -8218,8 +8366,8 @@ function readCache(homeDirOverride) {
 function writeCache(entry, homeDirOverride) {
   try {
     const p = cachePath(homeDirOverride);
-    mkdirSync4(dirname5(p), { recursive: true });
-    writeFileSync4(p, JSON.stringify(entry), "utf8");
+    mkdirSync5(dirname6(p), { recursive: true });
+    writeFileSync5(p, JSON.stringify(entry), "utf8");
   } catch {
   }
 }
@@ -9023,15 +9171,15 @@ import {
   existsSync as existsSync10,
   fstatSync,
   ftruncateSync,
-  mkdirSync as mkdirSync5,
+  mkdirSync as mkdirSync6,
   openSync as openSync2,
   readFileSync as readFileSync13,
   readSync,
   unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync5,
+  writeFileSync as writeFileSync6,
   writeSync
 } from "fs";
-import { dirname as dirname6, resolve as resolve9 } from "path";
+import { dirname as dirname7, 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 = [];
@@ -9061,7 +9209,7 @@ function applyEditBlock(block, rootDir) {
   const searchEmpty = block.search.length === 0;
   if (searchEmpty) {
     try {
-      mkdirSync5(dirname6(absTarget), { recursive: true });
+      mkdirSync6(dirname7(absTarget), { recursive: true });
       const fd = openSync2(absTarget, "wx");
       try {
         writeSync(fd, block.replace);
@@ -9176,7 +9324,7 @@ function restoreSnapshots(snapshots, rootDir) {
           message: "removed (the edit had created it)"
         };
       }
-      writeFileSync5(abs, snap.prevContent, "utf8");
+      writeFileSync6(abs, snap.prevContent, "utf8");
       return {
         path: snap.path,
         status: "applied",
@@ -9352,6 +9500,7 @@ You have TWO tools for running shell commands, and picking the right one is non-
 
 After \`run_background\`, tools available to you:
 - \`job_output(jobId, tailLines?)\` \u2014 read recent logs to verify startup / debug errors.
+- \`wait_for_job(jobId, timeoutMs?)\` \u2014 block until the job exits or emits new output. Prefer this over repeating identical \`job_output\` calls while you're intentionally waiting.
 - \`list_jobs\` \u2014 see every job this session (running + exited).
 - \`stop_job(jobId)\` \u2014 SIGTERM \u2192 SIGKILL after grace. Stop before switching port / config.
 
@@ -9439,17 +9588,17 @@ import {
   closeSync as closeSync3,
   existsSync as existsSync12,
   fstatSync as fstatSync2,
-  mkdirSync as mkdirSync6,
+  mkdirSync as mkdirSync7,
   openSync as openSync3,
   readFileSync as readFileSync15,
   readSync as readSync2,
   renameSync as renameSync2,
   statSync as statSync5,
   unlinkSync as unlinkSync4,
-  writeFileSync as writeFileSync6
+  writeFileSync as writeFileSync7
 } from "fs";
 import { homedir as homedir7 } from "os";
-import { dirname as dirname7, join as join13 } from "path";
+import { dirname as dirname8, join as join13 } from "path";
 function defaultUsageLogPath(homeDirOverride) {
   return join13(homeDirOverride ?? homedir7(), ".reasonix", "usage.jsonl");
 }
@@ -9490,7 +9639,7 @@ function compactUsageLogIfLarge(path2, now) {
   if (kept.length === lines.filter((l) => l.trim()).length) return;
   const tmp = `${path2}.compacting`;
   try {
-    writeFileSync6(tmp, kept.length > 0 ? `${kept.join("\n")}
+    writeFileSync7(tmp, kept.length > 0 ? `${kept.join("\n")}
 ` : "", "utf8");
     renameSync2(tmp, path2);
   } catch {
@@ -9516,7 +9665,7 @@ function appendUsage(input) {
   if (input.subagent) record.subagent = input.subagent;
   const path2 = input.path ?? defaultUsageLogPath();
   try {
-    mkdirSync6(dirname7(path2), { recursive: true });
+    mkdirSync7(dirname8(path2), { recursive: true });
     appendFileSync2(path2, `${JSON.stringify(record)}
 `, "utf8");
     compactUsageLogIfLarge(path2, record.ts);