pi-supernova 0.0.15 → 0.1.0

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## [Unreleased]
 
+## [0.1.0] - 2026-09-04
+
+### Fixed
+
+- Each program uses a separate worker and transaction. Late callbacks, idle worker errors, concurrent runs, startup cancellation, and startup deadlines no longer share state.
+- Command deadlines stop descendants. Signal exits report failure. Native commits recover partial replacements; writes reject missing content and edits reject overlapping matches.
+- Unified patches handle zero-context insertions, empty files, final-newline changes, and CRLF. Reads see external changes; evidence search includes staged files.
+- OMP tool calls use the current session’s enabled, permission-aware registry. Discovery supplies complete schemas. Batch options, failure envelopes, scheduling, and call identifiers remain consistent.
+- Output limits cover aggregate batch text, markers, and spill footers. Details remain valid JSON; logs report truncation. DataView ranges and own `__proto__` values survive serialization.
+
+### Changed
+
+- Acorn parses supported function and body forms. Return hints ignore comments and nested callbacks. Invalid collection arguments report errors.
+- The result ledger checks text equality, retains explicit-read pins across aliases, expires source records, and accepts a zero window.
+- Terminal width checks use Unicode graphemes. Expanded cards wrap all bounded result and log text without a preview-line limit.
+- Pi 0.85.0 native adapters respect active-tool changes. Pi has no cross-extension execution API; the README states this limit.
+- Live checks cover Pi 0.85.0 and OMP 18.1.10, including expanded terminal output.
+
 ## [0.0.15] - 2026-09-04
 
 ### Removed

package/README.md

@@ -12,7 +12,13 @@ pi install npm:pi-supernova
 omp install npm:pi-supernova
 ```
 
-Load **before** other tool-owning packages so `registerTool` capture works. Restart the host after install.
+Restart the host after install. OMP uses the current session’s enabled tool registry, independent of extension load order.
+
+Pi 0.85.0 supplies tool schemas but has no cross-extension execution API. Supernova uses native adapters and executors registered through its API instance.
+
+An unrelated Pi extension’s tools are not callable through Supernova. OMP 18.1.10 supports those calls through its session registry.
+
+The runtime, transaction, patch, output-limit, and renderer fixes share the same code on both hosts. Disabled configured tools are not callable.
 
 ---
 
@@ -25,7 +31,11 @@ Load **before** other tool-owning packages so `registerTool` capture works. Rest
 | Parallel reads | Ad hoc | `callMany` Auto / `parallel()` |
 | Hosts | Separate packages | Same tarball for Pi **and** OMP |
 
-Guest code runs as an `AsyncFunction` in a worker thread (same trust class as host `bash`), not an OS/VM sandbox. Tool calls go through `nova.call` RPC to the host thread; a hard timeout, abort, `process.exit`, or a memory blow-up terminates the worker without touching the harness.
+Guest code runs as an `AsyncFunction` in a new worker for each program. It has the same trust level as host `bash`.
+
+The host parses the bounded source with Acorn before execution. Tool calls use RPC. Deadlines and cancellation cover worker startup, tool discovery, and execution.
+
+A completed worker cannot supply callbacks or globals to another program. Concurrent programs have separate transactions, traces, cancellation signals, and call budgets.
 
 ---
 
@@ -69,7 +79,9 @@ Unified Pi/OMP card: one aligned row per call (status · tool · duration · tar
 ╰───────────────────────────────────────────────────────────────╯
 ```
 
-Multi-line commands show their first line plus a hidden-line count. Press Enter for a larger hunk budget, the full returned value, and logs.
+Multi-line commands show their first line and a hidden-line count. Expand the card to show the complete bounded return value and logs.
+
+Expanded text wraps at the terminal width without a preview-line limit. Operation lists and mutation diffs keep their separate 24-row budgets.
 
 ---
 
@@ -78,7 +90,7 @@ Multi-line commands show their first line plus a hidden-line count. Press Enter
 | API | Role |
 |-----|------|
 | `nova.search(query, limit?)` | Thin catalog hits |
-| `nova.describe(name)` | Parameter summary on demand |
+| `nova.describe(name)` | Complete JSON input schema on demand; explicit failure when no usable schema is available |
 | `nova.call(name, args)` | Host tool or native adapter |
 | `nova.callMany([{name,args}])` | Auto parallel wave; iterable array with `.mode` / `.results` |
 | `nova.evidence(query, {k?, path?, maxChars?})` | Top-K source spans (path, lines, verbatim text) that answer a question. Zero-token evidence selection after Zero-Mem; ~68% fewer tokens than reading the files |
@@ -86,9 +98,15 @@ Multi-line commands show their first line plus a hidden-line count. Press Enter
 | `nova.surface(path)` | Structural outline for a source file |
 | `nova.snap(query, searchRoot?)` | Defining file (workspace-relative), line, signature, confidence, and context for a concept; served from the in-process index in well under 1ms |
 | `nova.has(name)` | Whether a catalog or native tool is callable (sync) |
-| `parallel(thunks)` / `pipeline(items, …stages)` | Raw `Promise.all` helpers |
+| `parallel(thunks)` / `pipeline(items, …stages)` | Array-based helpers; pipeline stages must be functions |
 | `nova.speculate(fn)` | Counterfactual branch (rollback / commit) |
 
+`nova.call` returns an explicit `{ok, value}` envelope. Convenience helpers throw when a host tool reports failure.
+
+`callMany` runs known read-only tools concurrently. Unknown tools and mutating actions run in order, including LSP rename operations.
+
+`nova.describe` preserves required fields, unions, enums, nested objects, and numeric constraints. OMP ArkType and Zod schemas convert to JSON Schema.
+
 Root Snap searches ignore hidden files. Passing a hidden search root includes hidden files beneath that root; Git metadata is always excluded.
 
 ---
@@ -112,11 +130,17 @@ Optional `~/.pi/agent/supernova.json` or `~/.omp/agent/supernova.json`
 }
 ```
 
+`maxCallResultChars` bounds text per call. A batch shares one text budget across all items; it does not repeat a joined copy.
+
+Envelope fields and JSON encoding add overhead. Details have a separate 2,000-character JSON budget. Truncation flags cover returns, raw objects, and logs.
+
+An optional `spillDir` retains complete truncated text. Inline spill footers and truncation markers fit within the configured text limit.
+
 `seenWindow` is how many programs back the seen-ledger remembers (set 0 to disable collapsing). `maxHeapMb` caps the guest worker heap (V8 `resourceLimits` on Node) and arms a process-RSS watchdog that terminates a runaway program on both Node and Bun.
 
 Defaults also set `excludeTools` (includes `supernova` and DCE helpers). An empty `"excludeTools": []` **replaces** those defaults, so omit the key unless you mean that.
 
-Slash command `/supernova`: catalog size, captured executors, and session token stats.
+Slash command `/supernova`: callable catalog size, external tools, native adapters, and session token stats.
 
 ---
 
@@ -141,8 +165,8 @@ Pair with DCE last if you use it: `omp install npm:pi-deferred-context-engine`.
 
 | Symptom | Fix |
 |---------|-----|
-| `unknown tool "…"` | Follow the `Did you mean` hint, or `nova.search("")`; for host tools install supernova **first**; restart; `/supernova` |
-| `Rendered line exceeds terminal width` | ≥0.0.1 and restart so `render.js` reloads |
+| `unknown tool "…"` | Use `nova.search("")` and `/supernova`. Enable the tool in the current session. Restart after package changes. |
+| `Rendered line exceeds terminal width` | Install the current package and restart so the Unicode width code reloads. |
 | `callMany` / not iterable | ≥0.0.1; the return is an array with `.mode` / `.results` |
 | Extension missing on OMP | `omp install npm:pi-supernova` (needs `"omp".extensions`) |
 
@@ -152,9 +176,16 @@ Pair with DCE last if you use it: `omp install npm:pi-deferred-context-engine`.
 
 - Guest JS is **unsandboxed**. Adapter path jails are not a boundary against `import("node:fs")`. The worker only contains hangs, exits, and memory, not intent.
 - Guest error messages carry `(line:col)` on Node; Bun's engine does not expose guest-relative positions.
-- `bash` / mutating tools flush speculative writes (transaction barrier); error rollback cannot undo that.
-- The workspace index refreshes its file list every 10s or on any supernova mutation; a file created by an external process can take up to 10s to appear in `glob`/`snap` (`read` is never stale).
-- Pre-1.0 package: APIs and TUI may still evolve between minor releases.
+
+## Transactions and file freshness
+
+- `bash` and mutating host tools commit pending writes before execution. Later rollback cannot undo those changes or external effects.
+- Native commits stage replacements and backups before installation. A commit failure restores earlier replacements; a recovery failure reports retained backup paths.
+- A nested `nova.speculate` branch cannot call external mutators. Await each branch before returning.
+- Native reads use current disk content unless a staged write replaces it. Evidence search includes new staged files.
+- Workspace file-list updates use filesystem watchers. Without a working watcher, external new files can take 10 seconds to appear in indexed searches.
+
+This is a pre-1.0 package. APIs and the terminal display can change between minor releases.
 
 ## Research and prior art
 

package/bottleneck.js

@@ -4,120 +4,121 @@ import { randomUUID } from "node:crypto";
 import { isString, isObject } from "./decode.js";
 import { truncateChars, formatValue } from "./format.js";
 
-function serializeBounded(value, maxChars, label = "value") {
-  let serialized;
-  try {
-    serialized = isString(value) ? value : JSON.stringify(value);
-  } catch {
-    serialized = String(value);
-  }
-  if (serialized === undefined) serialized = "null";
-  return truncateChars(serialized, maxChars, label);
+function json(value) {
+  try { return JSON.stringify(value) ?? "null"; } catch { return JSON.stringify(String(value)); }
 }
-
-function extractContentText(content) {
-  if (!Array.isArray(content)) return "";
-  return content
-    .filter((part) => part && isObject(part) && part.type === "text" && isString(part.text))
-    .map((part) => part.text)
-    .join("\n");
+function detailsOf(raw) {
+  const details = raw?.details;
+  if (!isString(details)) return details;
+  try { return JSON.parse(details); } catch { return details; }
 }
-
-function extractRawString(raw, maxChars) {
+export function hostResultFailed(raw) {
+  const details = detailsOf(raw);
+  return raw?.isError === true || details?.ok === false || (Number.isInteger(details?.exitCode) && details.exitCode !== 0);
+}
+function extractRawString(raw) {
   if (raw == null) return "";
   if (isString(raw)) return raw;
   if (!isObject(raw)) return String(raw);
-  if (Array.isArray(raw.content)) return extractContentText(raw.content);
+  if (Array.isArray(raw.content)) return raw.content.filter(part => part?.type === "text" && isString(part.text)).map(part => part.text).join("\n");
   if (isString(raw.text)) return raw.text;
-  return serializeBounded(raw, maxChars, "host-result").text;
-}
-
-function summarizeDetails(details, maxChars) {
-  return serializeBounded(details, maxChars, "details").text;
+  return json(raw);
 }
 
-function maybeSpill(cappedText, fullText, config) {
-  if (fullText.length <= (config.maxCallResultChars ?? 65536)) return null;
-  if (!isString(config.spillDir) || config.spillDir.length === 0) return null;
-  try {
-    const dir = config.spillDir;
-    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
-    const filePath = path.join(dir, `${Date.now()}-${randomUUID().slice(0, 8)}.txt`);
-    fs.writeFileSync(filePath, fullText, { encoding: "utf8", mode: 0o600 });
-    return { pointer: filePath };
-  } catch {
-    return null;
-  }
-}
-
-function batchItems(details, maxChars) {
-  if (!isObject(details) || details.batch !== true) return undefined;
-  if (!Array.isArray(details.items)) return undefined;
-  return details.items.map((item) => truncateChars(item, maxChars, "host-result").text);
+/** Bound JSON before serialization; preserve small scalar fields such as exitCode. */
+function summarizeDetails(value, budget = 2000) {
+  const encoded = json(value);
+  if (encoded.length <= budget) return encoded;
+  const snapshot = JSON.parse(encoded);
+  const fit = (input, limit) => {
+    const serialized = json(input);
+    if (serialized.length <= limit) return input;
+    if (isString(input)) {
+      let low = 0;
+      let high = Math.min(input.length, limit);
+      while (low < high) {
+        const mid = Math.ceil((low + high) / 2);
+        if (json(truncateChars(input, mid).text).length <= limit) low = mid;
+        else high = mid - 1;
+      }
+      return truncateChars(input, low).text;
+    }
+    if (!isObject(input) && !Array.isArray(input)) return null;
+    const out = Array.isArray(input) ? [] : { truncated: true };
+    const entries = Object.entries(input);
+    if (!Array.isArray(input)) entries.sort((a, b) => json(a[1]).length - json(b[1]).length);
+    for (const [key, child] of entries) {
+      const used = json(out).length;
+      const overhead = Array.isArray(out) ? 1 : json(key).length + 2;
+      const available = limit - used - overhead;
+      if (available < 4) break;
+      const bounded = fit(child, available);
+      if (Array.isArray(out)) out.push(bounded);
+      else Object.defineProperty(out, key, { value: bounded, enumerable: true, configurable: true });
+      if (json(out).length > limit) {
+        if (Array.isArray(out)) out.pop();
+        else delete out[key];
+      }
+    }
+    return out;
+  };
+  return json(fit(snapshot, budget));
 }
 
-function spillSuffix(capped, text, config) {
-  const spill = maybeSpill(capped.text, text, config);
-  if (!spill?.pointer) return { spill, value: capped.text };
-  return { spill, value: `${capped.text}\n\n[full output spilled to ${spill.pointer}]` };
+function spill(fullText, config) {
+  if (!isString(config.spillDir) || !config.spillDir) return undefined;
+  fs.mkdirSync(config.spillDir, { recursive: true, mode: 0o700 });
+  const file = path.join(config.spillDir, Date.now() + "-" + randomUUID().slice(0, 8) + ".txt");
+  fs.writeFileSync(file, fullText, { encoding: "utf8", mode: 0o600, flag: "wx" });
+  return file;
 }
 
 export function packageHostResult(raw, config) {
   const maxChars = config.maxCallResultChars ?? 65536;
-  const isError = isObject(raw) && raw.isError === true;
-  const details = isObject(raw) ? raw.details : undefined;
-  const upstreamTruncated = isObject(details) && details.outputTruncated === true;
-  const text = extractRawString(raw, maxChars);
-  const items = batchItems(details, maxChars);
-  // Batch items travel as their own field; keep the details summary small and parseable.
-  const summarizedDetails =
-    details === undefined ? undefined : summarizeDetails(items ? { ...details, items: undefined } : details, 2000);
-
+  const details = detailsOf(raw);
+  const batch = details?.batch === true && Array.isArray(details.items) ? details.items : undefined;
+  const text = batch ? "" : extractRawString(raw);
   const capped = truncateChars(text, maxChars, "host-result");
-  if (!capped.truncated) {
-    return {
-      ok: !isError,
-      value: capped.text,
-      truncated: upstreamTruncated,
-      details: summarizedDetails,
-      items,
-    };
+  let truncated = capped.truncated || details?.outputTruncated === true;
+  const result = { ok: !hostResultFailed(raw), value: capped.text, truncated };
+  if (details !== undefined) result.details = summarizeDetails(batch ? { ...details, items: undefined } : details);
+  if (batch) {
+    let remaining = maxChars;
+    result.items = batch.map((item, index) => {
+      const bounded = truncateChars(item, Math.floor(remaining / (batch.length - index)), "host-result");
+      remaining -= bounded.text.length;
+      truncated ||= bounded.truncated;
+      return bounded.text;
+    });
   }
-
-  const { spill, value } = spillSuffix(capped, text, config);
-
-  return {
-    ok: !isError,
-    value,
-    truncated: true,
-    originalChars: capped.originalChars,
-    spill: spill?.pointer,
-    details: summarizedDetails,
-    items,
-  };
-}
-
-function clipLogs(logs, config) {
-  const logLines = Array.isArray(logs) ? logs : [];
-  const maxLogLines = config.maxLogLines ?? 100;
-  const maxLogLineChars = config.maxLogLineChars ?? 4096;
-  const clippedLogs = logLines.slice(0, maxLogLines).map((line) => {
-    const s = isString(line) ? line : String(line);
-    if (s.length <= maxLogLineChars) return s;
-    return s.slice(0, maxLogLineChars) + "…";
-  });
-  return { clippedLogs, logTruncated: logLines.length > maxLogLines };
+  result.truncated = truncated;
+  if (truncated) {
+    result.originalChars = batch ? batch.reduce((sum, item) => sum + String(item).length, 0) : text.length;
+    if (config.spillDir) {
+      const pointer = spill(batch ? batch.join("\n---\n") : text, config);
+      if (pointer) {
+        result.spill = pointer;
+        if (!batch) {
+          const footer = "\n[full output spilled to " + pointer + "]";
+          result.value = footer.length <= maxChars
+            ? truncateChars(text, maxChars - footer.length, "host-result").text + footer
+            : capped.text;
+        }
+      }
+    }
+  }
+  return result;
 }
 
 export function packageFinalReturn(value, logs, config) {
-  const maxReturn = config.maxReturnChars ?? 32000;
-  const serialized = truncateChars(isString(value) ? value.replace(/\n+$/, "") : formatValue(value), maxReturn, "return");
-  const { clippedLogs, logTruncated } = clipLogs(logs, config);
-  return {
-    returnValue: serialized.truncated ? serialized.text : value,
-    returnText: serialized.text,
-    returnTruncated: serialized.truncated,
-    logs: clippedLogs,
-    logTruncated,
-  };
+  const serialized = truncateChars(isString(value) ? value : formatValue(value), config.maxReturnChars ?? 32000, "return");
+  const maxLines = config.maxLogLines ?? 100;
+  let logTruncated = logs.length > maxLines;
+  const clipped = logs.slice(0, maxLines).map(line => {
+    const result = truncateChars(line, config.maxLogLineChars ?? 4096, "log");
+    logTruncated ||= result.truncated;
+    return result.text;
+  });
+  return { returnValue: serialized.truncated ? serialized.text : value, returnText: serialized.text,
+    returnTruncated: serialized.truncated, logs: clipped, logTruncated };
 }

package/catalog.js

@@ -6,7 +6,7 @@ const NATIVE_TOOL_DEFINITIONS = [
     name: "read",
     description: "Read UTF-8 workspace files by path, or resolve a concept query to source. Supports path arrays, offset, and limit.",
     parameters: { type: "object", properties: {
-      path: { type: "string", description: "Workspace-relative file path or concept query" },
+      path: { anyOf: [{ type: "string" }, { type: "array", items: { type: "string" } }], description: "Workspace-relative file path, concept query, or array of paths" },
       target: { anyOf: [{ type: "string" }, { type: "array" }], description: "File path/query or array of paths" },
       offset: { type: "number", description: "One-based starting line" },
       limit: { type: "number", description: "Maximum lines to return" },
@@ -110,6 +110,7 @@ function normalizeTool(tool) {
     description,
     descLower: description.toLowerCase(),
     parameters: tool.parameters,
+    schemaError: tool.schemaError,
     sourcePath: sourcePathOf(tool),
   };
 }
@@ -158,33 +159,6 @@ export function searchCatalog(catalog, query, limit = 12) {
   return scored.slice(0, Math.max(1, limit)).map(({ score: _s, ...hit }) => hit);
 }
 
-function fieldSummary(key, schema, required) {
-  const s = schema && isObject(schema) ? schema : {};
-  // Only signal-bearing keys: `required:false` and empty descriptions cost tokens and say nothing.
-  return {
-    type: s.type || (Array.isArray(s.anyOf) ? "union" : "unknown"),
-    required: required.has(key) || undefined,
-    description: isString(s.description) ? s.description.slice(0, 120) : undefined,
-  };
-}
-
-function schemaSummary(parameters) {
-  if (!parameters || !isObject(parameters)) return { type: "unknown" };
-  const props = parameters.properties;
-  if (!props || !isObject(props)) {
-    return {
-      type: parameters.type || "object",
-      note: "schema present (no enumerable properties)",
-    };
-  }
-  const required = new Set(Array.isArray(parameters.required) ? parameters.required : []);
-  const fields = {};
-  for (const [key, schema] of Object.entries(props)) {
-    fields[key] = fieldSummary(key, schema, required);
-  }
-  return { type: "object", fields };
-}
-
 /** Optimal string alignment distance: insert/delete/substitute/adjacent-transpose cost 1. */
 function editDistance(a, b) {
   const rows = Array.from({ length: a.length + 1 }, (_, i) => [i, ...new Array(b.length).fill(0)]);
@@ -232,12 +206,13 @@ export function describeTool(catalog, name) {
   if (!row) {
     return { ok: false, error: unknownToolMessage(name, catalog.map((t) => t.name)) };
   }
+  if (!isObject(row.parameters)) return { ok: false, name, error: "tool schema unavailable: " + (row.schemaError ?? name) };
   if (!row._described) {
     row._described = {
       ok: true,
       name: row.name,
       description: row.description,
-      parameters: schemaSummary(row.parameters),
+      parameters: row.parameters,
       sourcePath: row.sourcePath,
     };
   }

package/config.js

@@ -8,7 +8,7 @@ const require = createRequire(import.meta.url);
 const DEFAULTS = require("./config.default.json");
 
 const KNOWN_KEYS = new Set(Object.keys(DEFAULTS));
-const NONNEGATIVE_INTEGER_KEYS = new Set(["maxLogLines"]);
+const NONNEGATIVE_INTEGER_KEYS = new Set(["maxLogLines", "seenWindow"]);
 const POSITIVE_INTEGER_KEYS = new Set([
   "timeoutMs",
   "maxCodeChars",
@@ -18,7 +18,6 @@ const POSITIVE_INTEGER_KEYS = new Set([
   "maxLogLineChars",
   "maxSearchResults",
   "maxHeapMb",
-  "seenWindow",
 ]);
 
 const VALIDATORS = {

package/decode.js

@@ -4,3 +4,64 @@ export const isString = (v) => toStr.call(v) === "[object String]";
 export const isObject = (v) => toStr.call(v) === "[object Object]";
 export const isFunction = (v) => toStr.call(v) === "[object Function]" || v instanceof Function;
 export const isNumber = (v) => toStr.call(v) === "[object Number]" && Number.isFinite(v);
+
+const MAX_DEPTH = 64;
+const MAX_TYPED_ARRAY = 4096;
+
+function plainFromBinary(value) {
+  const bytes = value.byteLength;
+  if (value instanceof ArrayBuffer) value = new Uint8Array(value);
+  else if (value instanceof DataView) value = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  if (value.length > MAX_TYPED_ARRAY) return "[" + value.constructor.name + " " + bytes + " bytes]";
+  return value instanceof BigInt64Array || value instanceof BigUint64Array
+    ? Array.from(value, x => x.toString() + "n")
+    : Array.from(value);
+}
+
+function plainFromMap(value, seen, depth) {
+  const allStringKeys = [...value.keys()].every(isString);
+  if (!allStringKeys) return [...value].map(([k, v]) => [toPlain(k, seen, depth + 1), toPlain(v, seen, depth + 1)]);
+  const out = Object.create(null);
+  for (const [k, v] of value) out[k] = toPlain(v, seen, depth + 1);
+  return out;
+}
+
+function plainFromCollection(value, seen, depth) {
+  if (Array.isArray(value)) return value.map((x) => toPlain(x, seen, depth + 1));
+  if (value instanceof Set) return [...value].map((x) => toPlain(x, seen, depth + 1));
+  if (value instanceof Map) return plainFromMap(value, seen, depth);
+  const out = Object.create(null);
+  for (const k of Object.keys(value)) out[k] = toPlain(value[k], seen, depth + 1);
+  return out;
+}
+
+/** Convert any guest value to structured-clone-safe, JSON-shaped data. */
+export function toPlain(value, seen = new Set(), depth = 0) {
+  if (value === null || value === undefined) return value;
+  const tag = toStr.call(value);
+  if (tag === "[object String]" || tag === "[object Number]" || tag === "[object Boolean]") return value.valueOf();
+  if (tag === "[object BigInt]") return value.toString() + "n";
+  if (isFunction(value)) return "[Function" + (value.name ? " " + value.name : "") + "]";
+  if (tag === "[object Symbol]") return value.toString();
+  if (depth > MAX_DEPTH) return "[Depth]";
+  if (seen.has(value)) return "[Circular]";
+  if (value instanceof Date) return Number.isNaN(value.getTime()) ? "Invalid Date" : value.toISOString();
+  if (value instanceof RegExp) return value.toString();
+  if (value instanceof Error) {
+    const out = { name: value.name, message: value.message };
+    if (value.cause !== undefined) out.cause = toPlain(value.cause, seen, depth + 1);
+    return out;
+  }
+  if (value instanceof Promise) return "[Promise]";
+  if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) return plainFromBinary(value);
+  if (isFunction(value.toJSON)) return toPlain(value.toJSON(), seen, depth + 1);
+  seen.add(value);
+  try {
+    return plainFromCollection(value, seen, depth);
+  } finally {
+    seen.delete(value);
+  }
+}
+
+// ---- RPC to the host thread ----
+

package/evidence.js

@@ -309,7 +309,7 @@ function normalize(scores) {
 
 // ---- candidate files (boundary + topology + entity hits) ----
 
-function candidateFiles(files, profile, index, limit) {
+function candidateFiles(files, profile, index, limit, overlayText) {
   const scored = [];
   for (const f of files) {
     const s = scorePathTopology(f, profile.keywords, profile.flags);
@@ -318,7 +318,11 @@ function candidateFiles(files, profile, index, limit) {
   scored.sort((a, b) => b.s - a.s);
   const chosen = new Set(scored.slice(0, limit).map(({ f }) => f));
   const anchors = (profile.subjects.length ? profile.subjects : profile.keywords).map((a) => a.toLowerCase()).filter((a) => a.length > 2);
-  const hits = anchors.length ? index.filesContaining(files, anchors, true) : [];
+  const pendingHits = files.filter(file => {
+    const pending = overlayText(file);
+    return pending !== undefined && anchors.some(anchor => pending.toLowerCase().includes(anchor));
+  });
+  const hits = anchors.length ? [...new Set([...pendingHits, ...index.filesContaining(files, anchors, true)])] : [];
   for (const f of hits) {
     if (chosen.size >= limit) break;
     if (profile.flags.wantsTest || scorePathTopology(f, profile.keywords, profile.flags) > -50) chosen.add(f);
@@ -385,14 +389,19 @@ function render(spans, picks, fused, opts, root) {
  * R(q): top-K provenance-bearing source spans for a concept query, selected without any model call.
  * @returns {{ route: string, spans: Array<{path, lines, name, kind, why, text}> }}
  */
-export async function selectEvidence({ query, root, searchDir, index, overlayText = () => undefined, options = {} }) {
+export async function selectEvidence({ query, root, searchDir, index, overlayText = () => undefined, pendingPaths = [], options = {} }) {
   const opts = { ...EVIDENCE_DEFAULTS, ...options };
   const profile = profileQuery(query);
   if (profile.keywords.length === 0) throw new Error("evidence requires at least one searchable concept keyword");
-  const files = await index.files(searchDir || root);
+  const searchRoot = path.resolve(searchDir || root);
+  const staged = pendingPaths.filter(file => {
+    const relative = path.relative(searchRoot, file);
+    return relative !== ".." && !relative.startsWith(".." + path.sep) && !path.isAbsolute(relative);
+  });
+  const files = [...new Set([...await index.files(searchRoot), ...staged])];
   if (files.length === 0) throw new Error(`no files found to search in ${searchDir || root}`);
 
-  const { files: chosenFiles, fileScores } = candidateFiles(files, profile, index, opts.maxCandidateFiles);
+  const { files: chosenFiles, fileScores } = candidateFiles(files, profile, index, opts.maxCandidateFiles, overlayText);
   const spans = [];
   for (const f of chosenFiles) {
     const pending = overlayText(f);

package/format.js

@@ -1,4 +1,4 @@
-import { isString } from "./decode.js";
+import { isString, isObject } from "./decode.js";
 
 export function truncateChars(text, maxChars, label = "value") {
   const normalized = isString(text) ? text : String(text ?? "");
@@ -12,22 +12,21 @@ export function truncateChars(text, maxChars, label = "value") {
       originalChars: normalized.length,
     };
   }
-  const head = headEnd(normalized, Math.floor(limit * 0.7));
-  let tail = Math.max(0, limit - head);
+  let head = headEnd(normalized, Math.floor(limit * 0.7));
+  let tail = 0;
   let marker = "";
-  let previousTail = -1;
-  while (tail !== previousTail) {
-    previousTail = tail;
+  for (;;) {
     const omitted = normalized.length - head - tail;
-    marker = `\n…[${label} truncated ${omitted} chars]…\n`;
-    tail = Math.max(0, limit - head - marker.length);
+    marker = "\n…[" + label + " truncated " + omitted + " chars]…\n";
+    if (marker.length > limit) return { text: normalized.slice(0, headEnd(normalized, limit)), truncated: true, originalChars: normalized.length };
+    const budget = limit - marker.length;
+    const nextHead = headEnd(normalized, Math.min(head, budget));
+    const nextTail = normalized.length - tailStartIndex(normalized, Math.max(0, budget - nextHead));
+    if (nextHead === head && nextTail === tail) break;
+    head = nextHead;
+    tail = nextTail;
   }
-  const tailStart = tailStartIndex(normalized, tail);
-  return {
-    text: normalized.slice(0, head) + marker + normalized.slice(tailStart),
-    truncated: true,
-    originalChars: normalized.length,
-  };
+  return { text: normalized.slice(0, head) + marker + normalized.slice(normalized.length - tail), truncated: true, originalChars: normalized.length };
 }
 
 // Lone surrogates in a tool result make the message invalid UTF-8 at the API
@@ -53,7 +52,7 @@ function formatKey(key) {
 
 function formatPrimitive(value) {
   if (value === undefined) return "undefined";
-  if (typeof value === "number" && !Number.isFinite(value)) return String(value);
+  if (Number.isNaN(value) || value === Infinity || value === -Infinity) return String(value);
   return JSON.stringify(value) ?? String(value);
 }
 
@@ -65,7 +64,7 @@ function formatFlatList(value) {
 }
 
 function formatFlat(value) {
-  if (value === null || typeof value !== "object") return formatPrimitive(value);
+  if ((!isObject(value) && !Array.isArray(value))) return formatPrimitive(value);
   if (Array.isArray(value)) return formatFlatList(value);
   let out = "";
   for (const key of Object.keys(value)) {
@@ -83,7 +82,7 @@ function formatFlat(value) {
  */
 export function formatValue(value, indent = "", width = FORMAT_WIDTH) {
   const flat = formatFlat(value);
-  if (value === null || typeof value !== "object" || flat.length + indent.length <= width) return flat;
+  if ((!isObject(value) && !Array.isArray(value)) || flat.length + indent.length <= width) return flat;
   const pad = indent + " ";
   if (Array.isArray(value)) {
     if (value.length === 0) return "[]";