@hizliemre/horse-code 0.1.2 → 0.3.0

package/dist/{chunk-2SVAHH5N.js → chunk-63E73TGI.js}

@@ -1,9 +1,7 @@
 import {
-  stateRoot
-} from "./chunk-SSDLHWSF.js";
-import {
+  stateRoot,
   writeAtomic
-} from "./chunk-B67BK5GQ.js";
+} from "./chunk-6W4UH2BQ.js";
 
 // src/migrate/migrated.ts
 import { readFile, mkdir } from "fs/promises";

package/dist/{chunk-DTWKSZXY.js → chunk-6OSEQOYY.js}

@@ -1,7 +1,7 @@
 import {
   hashContent,
   traceDir
-} from "./chunk-FFYBY2NA.js";
+} from "./chunk-KAGKX2YT.js";
 
 // src/engine/project-brief.ts
 import { readFile, writeFile, mkdir } from "fs/promises";
@@ -70,7 +70,7 @@ async function gatherBriefInput(cwd, files) {
 async function ourOwnOutput(cwd) {
   const out = /* @__PURE__ */ new Set();
   try {
-    const { loadTraceIndex, traceRootRel } = await import("./trace-ZMB7LT7W.js");
+    const { loadTraceIndex, traceRootRel } = await import("./trace-X6TU3AG6.js");
     const root = traceRootRel().replace(/\\/g, "/");
     out.add(`${root}/PROJECT.md`);
     out.add(`${root}/PROJECT.json`);

package/dist/{chunk-SSDLHWSF.js → chunk-6W4UH2BQ.js}

@@ -27,9 +27,41 @@ function inLinkedWorktree(cwd, run) {
   return resolve(dir) !== resolve(common);
 }
 
+// src/session/atomic.ts
+import { rename, rm, writeFile } from "fs/promises";
+import { renameSync, rmSync, writeFileSync } from "fs";
+var seq = 0;
+var tmpName = (path) => `${path}.${process.pid}.${seq++}.tmp`;
+async function writeAtomic(path, data) {
+  const tmp = tmpName(path);
+  try {
+    await writeFile(tmp, data, "utf8");
+    await rename(tmp, path);
+  } catch (e) {
+    await rm(tmp, { force: true }).catch(() => {
+    });
+    throw e;
+  }
+}
+function writeAtomicSync(path, data) {
+  const tmp = tmpName(path);
+  try {
+    writeFileSync(tmp, data, "utf8");
+    renameSync(tmp, path);
+  } catch (e) {
+    try {
+      rmSync(tmp, { force: true });
+    } catch {
+    }
+    throw e;
+  }
+}
+
 export {
   sessionBase,
   stateRoot,
   writableStateRoot,
-  inLinkedWorktree
+  inLinkedWorktree,
+  writeAtomic,
+  writeAtomicSync
 };

package/dist/{chunk-VPAWRRHL.js → chunk-AE36LLL2.js}

@@ -1,3 +1,7 @@
+import {
+  sessionBase
+} from "./chunk-6W4UH2BQ.js";
+
 // src/tui/format.ts
 function fmtTokens(n) {
   if (n >= 1e9) return `${(n / 1e9).toFixed(1)}B`;
@@ -443,22 +447,6 @@ function recallNote(tool, subject, turn, authored = false) {
 }
 
 // src/core/surrogates.ts
-var LONE_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;
-var REPLACEMENT = "\uFFFD";
-function stripLoneSurrogates(text) {
-  LONE_SURROGATE.lastIndex = 0;
-  return LONE_SURROGATE.test(text) ? text.replace(LONE_SURROGATE, REPLACEMENT) : text;
-}
-function sanitizeForJson(value) {
-  if (typeof value === "string") return stripLoneSurrogates(value);
-  if (Array.isArray(value)) return value.map((v) => sanitizeForJson(v));
-  if (value && typeof value === "object") {
-    const out = {};
-    for (const [k, v] of Object.entries(value)) out[k] = sanitizeForJson(v);
-    return out;
-  }
-  return value;
-}
 function truncateSafe(text, max) {
   if (text.length <= max || max <= 0) return text;
   const code = text.charCodeAt(max - 1);
@@ -983,15 +971,19 @@ function shieldToolOutput(text) {
 }
 
 // src/agent/loop.ts
+var DELEGATED_TOOL_NAMES = { file_change: "Write", command_execution: "Bash" };
 function fmtChars(n) {
   return n >= 1e3 ? `${(n / 1e3).toFixed(1)}k chars` : `${n} chars`;
 }
 function workingDirectoryNote(cwd) {
-  return `
+  const here = `
 
 # Working directory
 
 You are already in \`${cwd}\`. Every relative path resolves from here, and every tool runs here \u2014 do not \`cd\` elsewhere, and do not go looking for the repository.`;
+  return sessionBase(cwd) === void 0 ? here : `${here}
+
+This is a fresh git worktree, so everything git ignores is absent: no \`node_modules\`, no build output, no package caches. Source, tests and configuration are all here and current.`;
 }
 var COMPACT_KEYS_LOGGED = 24;
 var agentSeq = 0;
@@ -1067,6 +1059,16 @@ async function* runRoleAgent(opts) {
           toolCalls.push(ev.toolCall);
         } else if (ev.type === "tool-progress") {
           if (ev.path) opts.onLiveActivity?.(`writing ${ev.path.split("/").pop()} \xB7 ${fmtChars(ev.chars)}`);
+        } else if (ev.type === "activity") {
+          const what = ev.target ? ev.target.split("/").pop() ?? ev.target : "";
+          opts.onActivity?.({
+            tool: DELEGATED_TOOL_NAMES[ev.tool] ?? ev.tool,
+            target: what,
+            lines: 0,
+            // Only a failure is worth a suffix. "done" on every row is the bullet said twice.
+            summary: ev.ok === false ? "failed" : "",
+            ok: ev.ok !== false
+          });
         } else if (ev.type === "usage") {
           yield { type: "usage", promptTokens: ev.promptTokens, completionTokens: ev.completionTokens };
           opts.onUsage?.({ promptTokens: ev.promptTokens, completionTokens: ev.completionTokens, model: activeModel });
@@ -1082,7 +1084,7 @@ async function* runRoleAgent(opts) {
         break;
       }
       if (errored.retryable && !errored.capability && !errored.noBench) opts.onExhausted?.(activeModel, errored.message);
-      if (errored.retryable && !streamed && chainIdx < chain.length - 1) {
+      if (errored.retryable && chainIdx < chain.length - 1) {
         const next = chain[chainIdx + 1];
         opts.onFallback?.(activeModel, next, errored.message);
         chainIdx++;
@@ -1240,6 +1242,10 @@ var ToolRegistry = class {
   }
 };
 
+// src/core/types.ts
+var DEADLINE_MESSAGE = "the model did not answer within its deadline";
+var CHAIN_BUDGET_MESSAGE = "the chain's total budget ran out before this model was given a fair turn";
+
 // src/agent/structured.ts
 function valueAt(args, path) {
   let cur = args;
@@ -1255,6 +1261,11 @@ function whatWasWrong(issues, args) {
     const got = valueAt(args, i.path);
     const shown = got === void 0 ? "nothing" : JSON.stringify(got);
     const head = where ? `${where}: ${i.message}` : i.message;
+    if (got === void 0 && /received\s+(undefined|null|nothing)/i.test(i.message)) {
+      const parent = i.path.length > 1 ? valueAt(args, i.path.slice(0, -1)) : args;
+      const sent = parent && typeof parent === "object" ? Object.keys(parent) : [];
+      return sent.length ? `${head} \u2014 you sent only ${sent.map((k) => `\`${k}\``).join(", ")}` : head;
+    }
     return `${head} \u2014 got ${shown.length > 120 ? `${shown.slice(0, 120)}\u2026` : shown}`;
   }).join("; ");
 }
@@ -1323,7 +1334,7 @@ async function runStructuredRole(opts, schema, maxAttempts = 2) {
         }
         if (ev.type === "abort") {
           if (opts.signal.aborted) throw new Error("cancelled");
-          errored = total?.aborted ? "the chain's total budget ran out before this model was given a fair turn" : "the model did not answer within its deadline";
+          errored = total?.aborted ? CHAIN_BUDGET_MESSAGE : DEADLINE_MESSAGE;
           break;
         }
         if (ev.type === "message.done") lastText = ev.message.content ?? lastText;
@@ -1356,13 +1367,12 @@ async function runStructuredRole(opts, schema, maxAttempts = 2) {
 }
 
 export {
-  sanitizeForJson,
-  truncateSafe,
   fmtTokens,
   fmtDuration,
   relTime,
   stripThinking,
   handedOver,
+  truncateSafe,
   Telemetry,
   sampleMemory,
   estimateFreezeSeconds,

package/dist/{chunk-4EWK7HWQ.js → chunk-EAF22QIG.js}

@@ -1,3 +1,6 @@
+import {
+  CLI_KINDS
+} from "./chunk-G45RWL7S.js";
 import {
   arrayField,
   objectField,
@@ -18,6 +21,7 @@ var DEFAULT_CONFIG = {
   specKit: { version: "v0.13.2" },
   mcp: {},
   modelSources: [],
+  accounts: [],
   traceDir: "",
   /**
    * Shipped as a REFERENCE, not a copy, for the reasons skills/README.md gives for exactly this shape: it is
@@ -60,6 +64,33 @@ var fileSchema = z.object({
   council: z.object({ members: z.array(reviewerSchema) }).optional(),
   specKit: z.object({ version: z.string() }).optional(),
   modelSources: z.array(z.string()).optional(),
+  /**
+   * Logged-in profile directories, in spill order. A path each, never a credential.
+   *
+   * Two things here were wrong in a way that could not be seen from this file, and both were found by
+   * connecting a real account.
+   *
+   * The kinds were spelled out — `["claude", "codex"]` — and every entry of a kind added since was
+   * rejected. `CLI_KINDS` is where they are declared, so this reads them rather than repeating them, and a
+   * fifth subscription cannot be half-added again.
+   *
+   * `configDir` was REQUIRED, and the signed-in default is precisely the entry that has none: `withAmbient`
+   * records it without a directory, deliberately, because Claude Code keeps that session in the Keychain
+   * and naming a directory switches it to file credentials. So the one entry written to stop a second
+   * account quietly retiring the first was itself unloadable.
+   *
+   * `.catch([])` bounds what a bad row can cost. The loader reads `parsed.success ? parsed.data : {}`, so
+   * a single rejected entry did not merely drop that account — it discarded the WHOLE global config.
+   * Measured on a live one: the file held 64 role chains and an API key, and with one z.ai entry present
+   * `loadConfig` returned zero roles and no key, silently, for every session since it was connected.
+   */
+  accounts: z.array(z.object({
+    kind: z.enum(CLI_KINDS),
+    name: z.string(),
+    configDir: z.string().optional(),
+    email: z.string().optional(),
+    plan: z.string().optional()
+  })).catch([]).optional(),
   traceDir: z.string().optional(),
   // where /graph trace writes; empty = .horsecode/traces
   mainBranch: z.string().optional(),
@@ -103,6 +134,7 @@ function loadConfig(opts) {
   merged.roles = { ...global.roles ?? {}, ...projectSafe.roles ?? {} };
   merged.mcp = { ...global.mcp ?? {}, ...projectSafe.mcp ?? {} };
   merged.modelSources = projectSafe.modelSources ?? global.modelSources ?? [];
+  merged.accounts = global.accounts ?? [];
   merged.maxParallel = projectSafe.maxParallel ?? global.maxParallel ?? DEFAULT_CONFIG.maxParallel;
   merged.telemetry = projectSafe.telemetry ?? global.telemetry ?? DEFAULT_CONFIG.telemetry;
   const spoken = global.skillSources !== void 0 || projectSafe.skillSources !== void 0;

package/dist/chunk-G45RWL7S.js

@@ -0,0 +1,289 @@
+// src/agents/cli-auth.ts
+import { spawnSync } from "child_process";
+
+// src/agents/cli-agent.ts
+import { spawn } from "child_process";
+var CLI_KINDS = ["claude", "codex", "grok", "zai"];
+function cliBinary(kind) {
+  return kind === "zai" ? "claude" : kind;
+}
+var CLI_ERROR_UNSPOKEN = "the CLI reported an error";
+function cliArgs(kind, prompt, extra = []) {
+  if (kind === "claude" || kind === "zai") {
+    return ["--output-format", "stream-json", "--verbose", ...extra, "-p", "--", prompt];
+  }
+  if (kind === "codex") {
+    return ["exec", "--json", "--skip-git-repo-check", ...extra, "--", prompt];
+  }
+  return ["--output-format", "streaming-messages-json", ...extra, `--single=${prompt}`];
+}
+function decodeClaudeEvent(line) {
+  let e;
+  try {
+    e = JSON.parse(line);
+  } catch {
+    return void 0;
+  }
+  const type = e.type;
+  if (type === "rate_limit_event") {
+    const info = e.rate_limit_info ?? {};
+    const status = String(info.status ?? "unknown");
+    const raw = info.unifiedWindows ?? {};
+    const windows = {};
+    for (const [name, w] of Object.entries(raw)) windows[name] = w?.utilization ?? 0;
+    const quota = {
+      status,
+      windows,
+      ...typeof info.resetsAt === "number" ? { resetsAt: info.resetsAt } : {}
+    };
+    return status.startsWith("allowed") ? { quota } : {
+      quota,
+      /**
+       * The reset time rides along, as an ISO instant rather than prose.
+       *
+       * A spent five-hour window reopens; without saying when, the only safe bench is "the rest of the
+       * run", which on a ten-hour board writes off a subscription for hours after it recovered. The
+       * gateway's wordings said "reset after 4h" and nothing ever parsed them — see `quotaResetAt`.
+       */
+      rateLimited: `${status} \u2014 ${describeWindows(windows)}` + (quota.resetsAt ? ` (resets ${new Date(quota.resetsAt * 1e3).toISOString()})` : "")
+    };
+  }
+  if (type === "assistant") {
+    const msg = e.message;
+    const parts = Array.isArray(msg?.content) ? msg.content : [];
+    const text = parts.filter((b) => typeof b === "object" && b !== null && b.type === "text").map((b) => b.text).join("");
+    const tool = parts.find((b) => typeof b === "object" && b !== null && b.type === "tool_use");
+    return {
+      ...text ? { text } : {},
+      ...msg?.model ? { served: msg.model } : {},
+      ...tool ? { tool: { name: tool.name, ...targetOf(tool.input) ? { target: targetOf(tool.input) } : {} } } : {}
+    };
+  }
+  if (type === "user") {
+    const parts = e.message?.content;
+    const failed = (Array.isArray(parts) ? parts : []).find(
+      (b) => typeof b === "object" && b !== null && b.type === "tool_result" && b.is_error === true
+    );
+    return failed ? { tool: { name: "tool", ok: false } } : void 0;
+  }
+  if (type === "result") {
+    const u = e.usage ?? {};
+    const cost = e.total_cost_usd;
+    return {
+      usage: {
+        freshTokens: u.input_tokens ?? 0,
+        cachedTokens: u.cache_read_input_tokens ?? 0,
+        cacheWriteTokens: u.cache_creation_input_tokens ?? 0,
+        outputTokens: u.output_tokens ?? 0,
+        ...cost !== void 0 ? { costUsd: cost } : {}
+      },
+      ...e.subtype === "error_during_execution" ? { error: String(e.result ?? CLI_ERROR_UNSPOKEN) } : {}
+    };
+  }
+  return void 0;
+}
+function decodeCodexEvent(line) {
+  let e;
+  try {
+    e = JSON.parse(line);
+  } catch {
+    return void 0;
+  }
+  const type = String(e.type ?? "");
+  if (/rate.?limit/i.test(type)) return { rateLimited: String(e.message ?? "rate limited by the CLI") };
+  if (type === "item.completed") {
+    const item = e.item;
+    if (item?.type === "agent_message" && item.text) return { text: item.text };
+    if (item?.type && item.type !== "agent_message") {
+      const changes = item.changes;
+      const first = Array.isArray(changes) ? changes.find((c) => typeof c?.path === "string")?.path : void 0;
+      const more = Array.isArray(changes) && changes.length > 1 ? ` +${changes.length - 1}` : "";
+      return {
+        tool: {
+          name: item.name ?? item.type,
+          ...first ? { target: `${first}${more}` } : {}
+        }
+      };
+    }
+    return void 0;
+  }
+  if (type === "turn.completed") {
+    const u = e.usage ?? {};
+    return {
+      usage: {
+        freshTokens: u.input_tokens ?? 0,
+        cachedTokens: u.cached_input_tokens ?? 0,
+        cacheWriteTokens: u.cache_write_input_tokens ?? 0,
+        outputTokens: u.output_tokens ?? 0
+      }
+    };
+  }
+  if (type === "turn.failed" || type === "error") {
+    return { error: String(e.message ?? "codex reported an error") };
+  }
+  return void 0;
+}
+function describeWindows(windows) {
+  const parts = Object.entries(windows).map(([k, v]) => `${k} ${Math.round(v * 100)}%`);
+  return parts.length ? parts.join(", ") : "no window reported";
+}
+var SYNTHETIC = "<synthetic>";
+function targetOf(input) {
+  for (const k of ["file_path", "path", "filePath", "notebook_path"]) {
+    const v = input?.[k];
+    if (typeof v === "string" && v) return v;
+  }
+  return void 0;
+}
+function makeStreamReader(decode, onEvent) {
+  let pending = "";
+  const drain = (upToNewline) => {
+    const lines = pending.split("\n");
+    pending = upToNewline ? lines.pop() ?? "" : "";
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      const ev = decode(line);
+      if (ev) onEvent(ev);
+    }
+  };
+  return {
+    push(chunk) {
+      pending += chunk;
+      drain(true);
+    },
+    end() {
+      if (pending.trim()) drain(false);
+    }
+  };
+}
+function reportedError(decoded, stderr, exitCode) {
+  if (decoded && decoded !== CLI_ERROR_UNSPOKEN) return decoded;
+  const spoken = exitCode !== 0 ? stderr.trim().slice(0, 500) : "";
+  return spoken || decoded || void 0;
+}
+async function runCliAgent(run) {
+  const decode = run.kind === "codex" ? decodeCodexEvent : decodeClaudeEvent;
+  const args = cliArgs(run.kind, run.prompt, run.args ?? []);
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn(cliBinary(run.kind), args, {
+        cwd: run.cwd,
+        signal: run.signal,
+        stdio: ["ignore", "pipe", "pipe"],
+        ...run.configDir ? { env: { ...process.env, ...profileEnv(run.kind, run.configDir) } } : {}
+      });
+    } catch (e) {
+      resolve({ text: "", error: e instanceof Error ? e.message : String(e), exitCode: -1 });
+      return;
+    }
+    let text = "";
+    let usage;
+    let rateLimited;
+    let served;
+    let quota;
+    let error;
+    let stderr = "";
+    const reader = makeStreamReader(decode, (ev) => {
+      if (ev.text) text += ev.text;
+      if (ev.usage) usage = ev.usage;
+      if (ev.rateLimited) rateLimited = ev.rateLimited;
+      if (ev.served) served = ev.served;
+      if (ev.quota) quota = ev.quota;
+      if (ev.error) error = ev.error;
+      run.onEvent?.(ev);
+    });
+    child.stdout?.on("data", (d) => reader.push(d.toString()));
+    child.stderr?.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("error", (e) => resolve({ text, ...usage ? { usage } : {}, error: e.message, exitCode: -1 }));
+    child.on("close", (code) => {
+      reader.end();
+      const reported = reportedError(error, stderr, code ?? -1);
+      resolve({
+        text,
+        ...usage ? { usage } : {},
+        ...rateLimited ? { rateLimited } : {},
+        ...quota ? { quota } : {},
+        ...served ? { served } : {},
+        ...reported ? { error: reported } : {},
+        exitCode: code ?? -1
+      });
+    });
+  });
+}
+
+// src/agents/cli-auth.ts
+function profileEnv(kind, configDir) {
+  if (!configDir) return {};
+  if (kind === "claude" || kind === "zai") return { CLAUDE_CONFIG_DIR: configDir };
+  if (kind === "codex") return { CODEX_HOME: configDir };
+  return { GROK_HOME: configDir };
+}
+function readAuthStatus(kind, out) {
+  if (kind === "grok") {
+    const m = /you are logged in with\s+(.+)/i.exec(out);
+    if (!m) return { loggedIn: false };
+    const plan = m[1].trim().replace(/\.$/, "");
+    return { loggedIn: true, ...plan ? { plan } : {} };
+  }
+  if (kind === "codex") {
+    const m = /logged in(?: using (.+))?/i.exec(out);
+    if (!m || /not logged in/i.test(out)) return { loggedIn: false };
+    const plan = m[1]?.trim();
+    return { loggedIn: true, ...plan ? { plan } : {} };
+  }
+  try {
+    const j = JSON.parse(out);
+    if (!j.loggedIn) return { loggedIn: false };
+    return {
+      loggedIn: true,
+      ...j.email ? { email: j.email } : {},
+      ...j.subscriptionType ? { plan: j.subscriptionType } : {}
+    };
+  } catch {
+    return { loggedIn: false };
+  }
+}
+function statusArgs(kind) {
+  if (kind === "claude" || kind === "zai") return ["auth", "status"];
+  if (kind === "codex") return ["login", "status"];
+  return ["models"];
+}
+function loginArgs(kind) {
+  return kind === "claude" ? ["auth", "login"] : ["login"];
+}
+function checkProfile(kind, configDir) {
+  if (kind === "zai" && !configDir) return { loggedIn: false };
+  const r = spawnSync(cliBinary(kind), statusArgs(kind), {
+    env: { ...process.env, ...profileEnv(kind, configDir) },
+    encoding: "utf8",
+    // A status check that hangs must not hang the startup summary with it.
+    timeout: 2e4
+  });
+  if (r.error) return { loggedIn: false };
+  return readAuthStatus(kind, `${r.stdout ?? ""}${r.stderr ?? ""}`);
+}
+function runLogin(kind, configDir) {
+  if (kind === "zai") {
+    return { ok: false, error: "z.ai has no sign-in \u2014 a profile is connected by writing its settings file" };
+  }
+  const r = spawnSync(cliBinary(kind), loginArgs(kind), {
+    env: { ...process.env, ...profileEnv(kind, configDir) },
+    stdio: "inherit"
+  });
+  if (r.error) {
+    const e = r.error;
+    return e.code === "ENOENT" ? { ok: false, error: `\`${kind}\` is not installed, or not on PATH` } : { ok: false, error: e.message };
+  }
+  return { ok: r.status === 0 };
+}
+
+export {
+  checkProfile,
+  runLogin,
+  CLI_KINDS,
+  SYNTHETIC,
+  runCliAgent
+};

package/dist/{chunk-FFYBY2NA.js → chunk-KAGKX2YT.js}

@@ -1,9 +1,7 @@
 import {
-  stateRoot
-} from "./chunk-SSDLHWSF.js";
-import {
+  stateRoot,
   writeAtomic
-} from "./chunk-B67BK5GQ.js";
+} from "./chunk-6W4UH2BQ.js";
 
 // src/engine/trace.ts
 import { readFile, writeFile, mkdir, rm } from "fs/promises";

package/dist/{chunk-DRZSUQ7Q.js → chunk-LLL7QWXB.js}

@@ -2,21 +2,21 @@ import {
   isMigrated,
   loadMigratedSync,
   migratedNotice
-} from "./chunk-2SVAHH5N.js";
+} from "./chunk-63E73TGI.js";
 import {
   telemetry
-} from "./chunk-VPAWRRHL.js";
+} from "./chunk-AE36LLL2.js";
 import {
   readBriefSync
-} from "./chunk-DTWKSZXY.js";
+} from "./chunk-6OSEQOYY.js";
 import {
   everTraceable,
   readTraceSync
-} from "./chunk-FFYBY2NA.js";
+} from "./chunk-KAGKX2YT.js";
 import {
   areaOf,
   loadGraphSync
-} from "./chunk-PGOYDOI4.js";
+} from "./chunk-XEGQT5EN.js";
 
 // src/tools/read.ts
 import { readFile } from "fs/promises";
@@ -948,9 +948,20 @@ ${core.join("\n")}`;
 );
 var graphTraceTool = {
   name: "graph_trace",
-  description: `What a source file is responsible for and what to be careful of when changing it, in the product's terms. Far cheaper than reading the file. Use it to orient before opening unfamiliar code. Pass "project" instead of a path to get the project brief: what the product is, its domain vocabulary, and the business rules the code must not violate. Read that FIRST in an unfamiliar codebase.`,
+  /**
+   * The limit is stated HERE because this is the only place an agent reads before calling.
+   *
+   * Measured live in one run: four different lenses — `risk-judge`, `plan-observability`,
+   * `plan-architecture` and one more — each asked for a trace of `spec.md` or `plan.md`. The error they got
+   * back is a good one and says the failure is permanent, so none of them asked twice; but each learned it
+   * separately, at a turn apiece, because a lens has its own memo and cannot be told by the last one. An
+   * error teaches one agent after the fact. A description tells every agent before.
+   */
+  description: `What a source file is responsible for and what to be careful of when changing it, in the product's terms. Far cheaper than reading the file. Use it to orient before opening unfamiliar code. SOURCE CODE ONLY (.ts, .cs, .py, .go, \u2026): a .md, .json or .txt path has no trace and never will \u2014 read documents with read_file. Pass "project" instead of a path to get the project brief: what the product is, its domain vocabulary, and the business rules the code must not violate. Read that FIRST in an unfamiliar codebase.`,
   permissionLevel: "safe",
-  parameters: z4.object({ file: z4.string().describe('Repo-relative path, e.g. "src/config/config.ts"') }),
+  parameters: z4.object({
+    file: z4.string().describe('Repo-relative path to SOURCE code, e.g. "src/config/config.ts". Not a document.')
+  }),
   describe: (args) => ({ allowKey: "graph:trace", preview: `graph_trace ${JSON.stringify(args)}`.slice(0, 120) }),
   async run(args, ctx) {
     const file = String(args.file ?? "");

package/dist/{chunk-WYQBRCKY.js → chunk-LNW557IO.js}

@@ -5,11 +5,11 @@ import {
   memoryHints,
   readFileTool,
   reinforceUsed
-} from "./chunk-DRZSUQ7Q.js";
+} from "./chunk-LLL7QWXB.js";
 import {
   ToolRegistry,
   runStructuredRole
-} from "./chunk-VPAWRRHL.js";
+} from "./chunk-AE36LLL2.js";
 
 // src/engine/triage.ts
 import { z } from "zod";

package/dist/{chunk-IW2KBAVZ.js → chunk-LPQU436C.js}

@@ -15,7 +15,18 @@ var defaultGitRunner = (args, cwd) => new Promise((resolve) => {
   child.on("error", (e) => resolve({ stdout, stderr: stderr + e.message, code: -1 }));
   child.on("close", (code) => resolve({ stdout, stderr, code: code ?? -1 }));
 });
+var TAKES_A_VALUE = /* @__PURE__ */ new Set(["-c", "-C", "--git-dir", "--work-tree", "--namespace", "--exec-path", "--config-env"]);
+function gitVerb(args) {
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === void 0) continue;
+    if (!a.startsWith("-")) return a;
+    if (TAKES_A_VALUE.has(a)) i++;
+  }
+  return void 0;
+}
 
 export {
-  defaultGitRunner
+  defaultGitRunner,
+  gitVerb
 };

package/dist/chunk-M2RKCIGV.js

@@ -0,0 +1,11 @@
+// src/engine/language.ts
+function respondIn(language) {
+  if (!language || /^english$/i.test(language)) return "";
+  return `
+
+Respond to the user in ${language}: everything you say to them, and every question you ask, is in ${language}. Code, identifiers, logs and commit messages keep whatever language the project uses.`;
+}
+
+export {
+  respondIn
+};

package/dist/{chunk-NNTIACT4.js → chunk-MRZVA5JB.js}

@@ -1,13 +1,13 @@
 import {
   defaultGitRunner
-} from "./chunk-IW2KBAVZ.js";
+} from "./chunk-LPQU436C.js";
 import {
   briefForPrompt,
   briefPrompt,
   briefStatus,
   gatherBriefInput,
   saveBrief
-} from "./chunk-DTWKSZXY.js";
+} from "./chunk-6OSEQOYY.js";
 import {
   ensureGitignore,
   loadTraceIndex,
@@ -19,10 +19,10 @@ import {
   tracePrompt,
   traceRootRel,
   traceable
-} from "./chunk-FFYBY2NA.js";
+} from "./chunk-KAGKX2YT.js";
 import {
   loadGraph
-} from "./chunk-PGOYDOI4.js";
+} from "./chunk-XEGQT5EN.js";
 
 // src/engine/trace-run.ts
 async function traceableFiles(cwd, opts) {