@a-company/gnomon 0.0.0-stage → 8.0.2

package/dist/gnomon-local/cli.js

@@ -0,0 +1,897 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { readFileSync } from "node:fs";
+
+// src/rpc.ts
+import { realpathSync } from "node:fs";
+
+// src/agent.ts
+import { createHash } from "node:crypto";
+
+// src/compat.ts
+var preset = (o) => Object.freeze({ api: "openai-completions", developerRole: false, store: false, maxTokensField: "max_tokens", thinkingKwarg: false, slots: false, platforms: Object.freeze(["darwin", "win32", "linux"]), ...o });
+var COMPAT_ALLOWLIST = Object.freeze({
+  "llama.cpp": preset({ thinkingKwarg: true, slots: true }),
+  ollama: preset({}),
+  "lm-studio": preset({}),
+  vllm: preset({ platforms: Object.freeze(["linux", "win32"]) }),
+  "mlx-lm": preset({ platforms: Object.freeze(["darwin"]) })
+});
+function surfaceTools(tools, surface) {
+  if (surface === "none") return [];
+  if (surface === "full") return tools.map((t) => ({ ...t }));
+  return tools.map((t) => {
+    const props = t.parameters.properties ?? {};
+    const compact = {};
+    for (const [k, v] of Object.entries(props)) compact[k] = { type: typeof v?.type === "string" ? v.type : "string" };
+    return { name: t.name, description: t.description.split("\n")[0].slice(0, 120), parameters: { type: "object", properties: compact, required: t.parameters.required ?? [] } };
+  });
+}
+function buildRequest(profile, i) {
+  const messages = i.messages.map((m) => ({ ...m, role: m.role === "developer" ? "system" : m.role }));
+  const body = { model: i.model, messages, [profile.maxTokensField]: i.maxTokens, stream: i.stream, temperature: 0 };
+  if (i.stream) body.stream_options = { include_usage: true };
+  const tools = i.nativeTools ? surfaceTools(i.tools, i.surface) : [];
+  if (tools.length) body.tools = tools.map((t) => ({ type: "function", function: t }));
+  if (profile.thinkingKwarg && i.thinking !== void 0) body.chat_template_kwargs = { enable_thinking: i.thinking };
+  return body;
+}
+
+// src/endpoint.ts
+import net from "node:net";
+var ANTHROPIC = /(^|\.)(anthropic\.com|claude\.ai|claude\.com)$/i;
+function v4Class(h) {
+  const [a, b] = h.split(".").map(Number);
+  if (a === 127) return "loopback";
+  if (a === 0) return "unspecified";
+  if (a === 10 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168) return "lan";
+  if (a === 169 && b === 254) return "link-local";
+  return "public";
+}
+function v6Class(h) {
+  const x = h.toLowerCase();
+  if (x === "::1") return "loopback";
+  if (x === "::") return "unspecified";
+  const mapped = /^::ffff:(\d+\.\d+\.\d+\.\d+)$/.exec(x);
+  if (mapped) return v4Class(mapped[1]);
+  const hex = /^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/.exec(x);
+  if (hex) {
+    const hi = parseInt(hex[1], 16);
+    const lo = parseInt(hex[2], 16);
+    return v4Class(`${hi >> 8}.${hi & 255}.${lo >> 8}.${lo & 255}`);
+  }
+  if (/^f[cd][0-9a-f]{2}:/.test(x)) return "lan";
+  if (/^fe[89ab][0-9a-f]:/.test(x)) return "link-local";
+  return "public";
+}
+function classifyEndpoint(base, forbiddenPorts = []) {
+  let u;
+  try {
+    u = new URL(base);
+  } catch {
+    return { ok: false, why: "malformed", host: null };
+  }
+  const host = u.hostname.replace(/^\[|\]$/g, "");
+  if (u.protocol !== "http:" && u.protocol !== "https:") return { ok: false, why: "scheme", host };
+  if (u.username || u.password) return { ok: false, why: "userinfo", host };
+  const port = u.port ? Number(u.port) : u.protocol === "https:" ? 443 : 80;
+  let cls;
+  const ip = net.isIP(host);
+  if (ip === 4) cls = v4Class(host);
+  else if (ip === 6) cls = v6Class(host);
+  else if (host.toLowerCase() === "localhost") cls = "loopback";
+  else return { ok: false, why: ANTHROPIC.test(host) ? "anthropic-host" : "hostname", host };
+  if (cls === "link-local" || cls === "unspecified" || cls === "public") return { ok: false, why: cls, host };
+  if (!Number.isInteger(port) || port <= 0 || port > 65535 || forbiddenPorts.includes(port)) return { ok: false, why: "port", host };
+  const path2 = u.pathname.replace(/\/+$/, "");
+  return { ok: true, base: `${u.protocol}//${u.host}${path2}`, host, port, class: cls };
+}
+
+// src/client.ts
+var CAPS = Object.freeze({ sseLine: 1 << 20, content: 1 << 20, toolArgs: 256 * 1024, errorBody: 4 * 1024, body: 2 << 20, stream: 8 << 20 });
+var EndpointRefused = class extends Error {
+  constructor(why) {
+    super(`endpoint refused: ${why} (loopback/LAN only, law 7)`);
+    this.why = why;
+  }
+  why;
+};
+async function* chunksOf(res) {
+  for await (const part of res.body) yield part;
+}
+async function readCapped(res, cap) {
+  const dec = new TextDecoder();
+  let out = "";
+  let n = 0;
+  for await (const part of chunksOf(res)) {
+    n += part.length;
+    if (n > cap) {
+      out += dec.decode(part.subarray(0, Math.max(0, part.length - (n - cap))));
+      break;
+    }
+    out += dec.decode(part, { stream: true });
+  }
+  return out;
+}
+var usageOf = (u) => u && (typeof u.prompt_tokens === "number" || typeof u.completion_tokens === "number") ? { input: u.prompt_tokens ?? 0, output: u.completion_tokens ?? 0 } : null;
+async function complete(base, body, o = {}) {
+  const v = classifyEndpoint(base, o.forbiddenPorts);
+  if (!v.ok) throw new EndpointRefused(v.why);
+  const ctl = new AbortController();
+  const outer = o.signal;
+  const onOuter = () => ctl.abort(outer?.reason);
+  if (outer?.aborted) ctl.abort(outer.reason);
+  outer?.addEventListener("abort", onOuter, { once: true });
+  const idleMs = o.idleMs ?? 12e4;
+  let idle = setTimeout(() => ctl.abort(new Error(`idle > ${idleMs} ms`)), idleMs);
+  const touch = () => {
+    clearTimeout(idle);
+    idle = setTimeout(() => ctl.abort(new Error(`idle > ${idleMs} ms`)), idleMs);
+  };
+  try {
+    return await completeInner(v.base, body, o, ctl.signal, touch);
+  } finally {
+    clearTimeout(idle);
+    outer?.removeEventListener("abort", onOuter);
+  }
+}
+async function completeInner(vbase, body, o, signal, touch) {
+  const res = await fetch(`${vbase}/v1/chat/completions`, {
+    method: "POST",
+    headers: { "content-type": "application/json", accept: body.stream ? "text/event-stream" : "application/json" },
+    body: JSON.stringify(body),
+    redirect: "error",
+    signal
+  });
+  touch();
+  if (!res.ok) throw new Error(`completion failed: HTTP ${res.status} ${(await readCapped(res, CAPS.errorBody).catch(() => "")).slice(0, 200)}`);
+  if (!body.stream) {
+    const j = JSON.parse(await readCapped(res, CAPS.body));
+    if (j.error !== void 0) throw new Error(`completion error: ${JSON.stringify(j.error).slice(0, 200)}`);
+    const m = j.choices?.[0]?.message;
+    return {
+      content: m?.content ?? "",
+      toolCalls: (m?.tool_calls ?? []).map((t, i) => ({ id: t.id ?? `call-${i + 1}`, name: t.function?.name ?? "", arguments: typeof t.function?.arguments === "string" ? t.function.arguments : JSON.stringify(t.function?.arguments ?? {}) })),
+      usage: usageOf(j.usage),
+      finishReason: j.choices?.[0]?.finish_reason ?? null
+    };
+  }
+  const out = { content: "", toolCalls: [], usage: null, finishReason: null };
+  const byIndex = /* @__PURE__ */ new Map();
+  const decoder = new TextDecoder();
+  let buf = "";
+  const onData = (data) => {
+    if (data === "[DONE]") return;
+    let c;
+    try {
+      c = JSON.parse(data);
+    } catch {
+      return;
+    }
+    if (c.error !== void 0) throw new Error(`stream error: ${JSON.stringify(c.error).slice(0, 200)}`);
+    const u = usageOf(c.usage);
+    if (u) out.usage = u;
+    const ch = c.choices?.[0];
+    if (!ch) return;
+    if (ch.finish_reason) out.finishReason = ch.finish_reason;
+    const d = ch.delta;
+    if (d?.content) {
+      if (out.content.length + d.content.length > CAPS.content) throw new Error("content cap exceeded");
+      out.content += d.content;
+      o.onDelta?.(d.content);
+    }
+    for (const t of d?.tool_calls ?? []) {
+      const idx = typeof t.index === "number" ? t.index : byIndex.size;
+      const cur = byIndex.get(idx) ?? { id: t.id ?? `call-${idx + 1}`, name: "", arguments: "" };
+      if (t.id) cur.id = t.id;
+      if (t.function?.name) cur.name += t.function.name;
+      if (t.function?.arguments) {
+        if (cur.arguments.length + t.function.arguments.length > CAPS.toolArgs) throw new Error("tool-call arguments cap exceeded");
+        cur.arguments += t.function.arguments;
+      }
+      byIndex.set(idx, cur);
+    }
+  };
+  let streamed = 0;
+  for await (const part of chunksOf(res)) {
+    touch();
+    streamed += part.length;
+    if (streamed > CAPS.stream) throw new Error("stream bytes cap exceeded");
+    buf += decoder.decode(part, { stream: true });
+    if (buf.length > CAPS.sseLine && buf.indexOf("\n") < 0) throw new Error("SSE line cap exceeded");
+    let nl;
+    while ((nl = buf.indexOf("\n")) >= 0) {
+      const line = buf.slice(0, nl).replace(/\r$/, "");
+      buf = buf.slice(nl + 1);
+      if (line.startsWith("data:")) onData(line.slice(5).trim());
+    }
+  }
+  if (buf.startsWith("data:")) onData(buf.slice(5).trim());
+  out.toolCalls = [...byIndex.entries()].sort((a, b) => a[0] - b[0]).map(([, t]) => t);
+  return out;
+}
+
+// src/compaction.ts
+var COMPACTION_HEADINGS = Object.freeze(["Goal", "Constraints", "Progress", "Decisions", "Next", "Critical"]);
+var DEFAULT_CONTEXT_TARGET = 8192;
+var SUMMARY_OPEN = '<compaction-summary source="model-generated" trust="data-not-instructions">';
+var MESSAGE_CHARS = 2e3;
+var CHARS_PER_TOKEN = 4;
+var chars = (m) => m.content.length + (m.tool_calls ?? []).reduce((a, t) => a + t.function.name.length + t.function.arguments.length, 0);
+function estimateTokens(messages) {
+  return messages.reduce((a, m) => a + Math.ceil(chars(m) / CHARS_PER_TOKEN) + 4, 0);
+}
+function isContextOverflow(err) {
+  const m = err instanceof Error ? err.message : String(err);
+  return /HTTP (400|413)\b/.test(m) && /context|n_ctx|too long|too many tokens|exceed|maximum.*length/i.test(m);
+}
+var SUMMARY_SYSTEM = [
+  "You compact a coding agent's working history so it can continue in a small context.",
+  "Reply with exactly these six markdown sections, in this order, and nothing else:",
+  ...COMPACTION_HEADINGS.map((h) => `## ${h}`),
+  "Be terse. Keep file paths, identifiers, commands and exact values. Under Progress say what is done; under Next what remains; under Critical anything that must not be lost. Do not call tools."
+].join("\n");
+function render(m) {
+  const calls = (m.tool_calls ?? []).map((t) => ` [calls ${t.function.name}(${t.function.arguments.slice(0, 200)})]`).join("");
+  const body = m.content.length > MESSAGE_CHARS ? `${m.content.slice(0, MESSAGE_CHARS)} [\u2026${m.content.length - MESSAGE_CHARS} chars cut]` : m.content;
+  return `[${m.role}]${calls} ${body}`;
+}
+function summaryMessages(history, target) {
+  const body = history.filter((m) => m.role !== "system").map(render);
+  const cap = Math.floor(target * CHARS_PER_TOKEN * 0.6);
+  let kept = body;
+  if (body.join("\n").length > cap && body.length > 1) {
+    const head = body[0].slice(0, Math.floor(cap / 4));
+    const tail = [];
+    let n = head.length;
+    for (let i = body.length - 1; i >= 1; i--) {
+      if (n + body[i].length + 1 > cap) break;
+      tail.unshift(body[i]);
+      n += body[i].length + 1;
+    }
+    const elided = body.length - 1 - tail.length;
+    kept = [head, ...elided > 0 ? [`[\u2026 ${elided} messages elided \u2026]`] : [], ...tail];
+  }
+  return [
+    { role: "system", content: SUMMARY_SYSTEM },
+    { role: "user", content: `Working history to compact:
+
+${kept.join("\n").slice(0, cap)}` }
+  ];
+}
+function normaliseSummary(text, maxChars = DEFAULT_CONTEXT_TARGET) {
+  const sections = new Map(COMPACTION_HEADINGS.map((h) => [h, []]));
+  let cur = null;
+  const loose = [];
+  const NAME = "(goal|constraints|progress|decisions|next|critical)";
+  const FORMS = [new RegExp(`^\\s{0,3}#{1,6}\\s*${NAME}\\s*:?\\s*$`, "i"), new RegExp(`^\\s*\\*\\*${NAME}\\s*:?\\*\\*\\s*:?\\s*(.*)$`, "i"), new RegExp(`^\\s*${NAME}\\s*:\\s*(.*)$`, "i")];
+  for (const line of text.split(/\r?\n/)) {
+    const m = FORMS.map((f) => f.exec(line)).find((x) => x !== null);
+    if (m) {
+      cur = COMPACTION_HEADINGS.find((h) => h.toLowerCase() === m[1].toLowerCase());
+      if (m[2]) sections.get(cur).push(m[2]);
+      continue;
+    }
+    (cur ? sections.get(cur) : loose).push(line);
+  }
+  if (loose.join("").trim()) sections.get("Progress").unshift(...loose);
+  const out = COMPACTION_HEADINGS.map((h) => {
+    const body = sections.get(h).join("\n").trim().replace(/&/g, "&amp;").replace(/</g, "&lt;");
+    return `## ${h}
+${body || "(none)"}`;
+  }).join("\n\n");
+  return out.length > maxChars ? `${out.slice(0, maxChars)}
+[summary cut]` : out;
+}
+function compactedHistory(history, summary, tailTokens) {
+  const system = history[0]?.role === "system" ? history[0] : null;
+  const rest = system ? history.slice(1) : history.slice();
+  let start = rest.length;
+  let sum = 0;
+  for (let i = rest.length - 1; i >= 0; i--) {
+    sum += estimateTokens([rest[i]]);
+    if (sum > tailTokens) break;
+    if (rest[i].role === "user" && !rest[i].content.startsWith("<tool_result") || rest[i].role === "assistant") start = i;
+  }
+  const tail = rest.slice(start);
+  const kept = tail.length;
+  const block = `${SUMMARY_OPEN}
+${summary}
+</compaction-summary>`;
+  const lead = tail[0]?.role === "user" ? { role: "user", content: `${block}
+
+${tail.shift().content}` } : { role: "user", content: `${block}
+
+Continue from Next.` };
+  return { messages: [...system ? [system] : [], lead, ...tail], kept };
+}
+
+// src/repair.ts
+function tryObject(s) {
+  try {
+    let v = JSON.parse(s);
+    if (typeof v === "string") v = JSON.parse(v);
+    return v !== null && typeof v === "object" && !Array.isArray(v) ? v : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function balance(s) {
+  const stack = [];
+  let inStr = false;
+  let esc = false;
+  for (const ch of s) {
+    if (inStr) {
+      if (esc) esc = false;
+      else if (ch === "\\") esc = true;
+      else if (ch === '"') inStr = false;
+      continue;
+    }
+    if (ch === '"') inStr = true;
+    else if (ch === "{") stack.push("}");
+    else if (ch === "[") stack.push("]");
+    else if ((ch === "}" || ch === "]") && stack[stack.length - 1] === ch) stack.pop();
+  }
+  return (inStr ? `${s}"` : s) + stack.reverse().join("");
+}
+var STEPS = [
+  ["fence", (s) => s.replace(/^\s*```[a-z]*\s*/i, "").replace(/\s*```\s*$/, "")],
+  ["smart-quotes", (s) => s.replace(/[“”]/g, '"').replace(/[‘’]/g, "'")],
+  ["single-quotes", (s) => s.replace(/'((?:[^'\\]|\\.)*)'/g, (_m, inner) => JSON.stringify(inner.replace(/\\'/g, "'")))],
+  ["unquoted-keys", (s) => s.replace(/([{,]\s*)([A-Za-z_$][\w$-]*)\s*:/g, '$1"$2":')],
+  ["trailing-commas", (s) => s.replace(/,\s*([}\]])/g, "$1")],
+  ["balance", balance]
+];
+function repairArguments(raw) {
+  if (raw !== null && typeof raw === "object" && !Array.isArray(raw)) return { ok: true, value: raw, repaired: false, steps: [] };
+  if (typeof raw !== "string") return { ok: false, repaired: false, steps: [] };
+  const direct = tryObject(raw.trim() === "" ? "{}" : raw);
+  if (direct) return { ok: true, value: direct, repaired: false, steps: [] };
+  let s = raw.trim();
+  const steps = [];
+  for (const [name, f] of STEPS) {
+    const next = f(s);
+    if (next !== s) {
+      steps.push(name);
+      s = next;
+    }
+    const v = tryObject(s);
+    if (v) return { ok: true, value: v, repaired: true, steps };
+  }
+  return { ok: false, repaired: false, steps };
+}
+function textToolPrompt(tools) {
+  if (!tools.length) return "";
+  const lines = tools.map((t) => `- ${t.name}: ${t.description.split("\n")[0]} \u2014 arguments: ${JSON.stringify(t.parameters.properties ?? {})}`);
+  return [
+    "You can call tools. To call one, reply with exactly one block per call:",
+    '<tool_call>{"name": "<tool name>", "arguments": { ... }}</tool_call>',
+    "Tool results come back in <tool_result> blocks. Available tools:",
+    ...lines
+  ].join("\n");
+}
+function parseTextToolCalls(text) {
+  const calls = [];
+  const rest = text.replace(/<tool_call>([\s\S]*?)(<\/tool_call>|$)/g, (_m, body) => {
+    const r = repairArguments(body);
+    if (r.ok && typeof r.value?.name === "string") calls.push({ id: `text-${calls.length + 1}`, name: r.value.name, arguments: r.value.arguments ?? r.value.args ?? {} });
+    return "";
+  });
+  return { calls, rest: rest.trim() };
+}
+
+// src/tools.ts
+import { constants, promises as fsp } from "node:fs";
+import * as path from "node:path";
+
+// src/protect.ts
+var PROTECTED_PREFIX = "protected-input:";
+var ProtectedRefused = class extends Error {
+};
+function protectGlob(glob) {
+  const g = glob.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, "");
+  let re = "";
+  let wild = false;
+  for (let i = 0; i < g.length; i++) {
+    const c = g[i];
+    if (c === "*") {
+      wild = true;
+      if (g[i + 1] === "*") {
+        i++;
+        if (g[i + 1] === "/") {
+          i++;
+          re += "(?:.*/)?";
+        } else re += ".*";
+      } else re += "[^/]*";
+    } else if (c === "?") {
+      wild = true;
+      re += "[^/]";
+    } else if (c === "{" && g.indexOf("}", i) > i) {
+      wild = true;
+      const end = g.indexOf("}", i);
+      re += `(?:${g.slice(i + 1, end).split(",").map((s) => s.replace(/[.+^${}()|[\]\\*?]/g, "\\$&")).join("|")})`;
+      i = end;
+    } else re += c.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  }
+  return new RegExp(wild ? `^${re}$` : `^${re}(?:/.*)?$`, "i");
+}
+function protectedHit(rel, globs) {
+  if (rel.split("/").some((c) => c.toLowerCase().replace(/[. ]+$/, "") === "node_modules")) return true;
+  return globs.some((re) => re.test(rel));
+}
+
+// src/tools.ts
+var MAX_READ = 256 * 1024;
+var PathRefused = class extends Error {
+};
+function isDotGit(component) {
+  const c = component.toLowerCase().replace(/[. ]+$/, "");
+  return c === ".git" || c === "git~1";
+}
+var str = (v, name) => {
+  if (typeof v !== "string" || v.length === 0) throw new Error(`${name} must be a non-empty string`);
+  return v;
+};
+var PATH_CASE_INSENSITIVE = Object.freeze({ win32: true });
+var PATH_SEP = Object.freeze({ win32: "\\", darwin: "/", linux: "/" });
+var fold = (p, platform) => PATH_CASE_INSENSITIVE[platform] ? p.toLowerCase() : p;
+function insideRoots(p, roots, platform = process.platform) {
+  const fp = fold(p, platform);
+  for (const r of roots) {
+    const fr = fold(r, platform);
+    const sep2 = PATH_SEP[platform] ?? path.sep;
+    if (fp === fr || fp.startsWith(fr.endsWith(sep2) ? fr : fr + sep2)) return r;
+  }
+  return null;
+}
+var inside = (p, roots) => insideRoots(p, roots);
+async function canonRoots(roots) {
+  return Promise.all(roots.map((r) => fsp.realpath(r).catch(() => r)));
+}
+async function resolveRead(raw, ctx) {
+  const real = await fsp.realpath(path.resolve(ctx.cwd, raw));
+  if (!inside(real, await canonRoots(ctx.roots))) throw new PathRefused(`path is outside the session roots: ${raw.slice(0, 200)}`);
+  const st = await fsp.stat(real);
+  if (st.isFile() && st.nlink > 1) throw new PathRefused("a file with more than one hard link is refused");
+  return real;
+}
+async function resolveWrite(raw, ctx) {
+  const abs = path.resolve(ctx.cwd, raw);
+  let anc = abs;
+  const rest = [];
+  for (; ; ) {
+    try {
+      anc = await fsp.realpath(anc);
+      break;
+    } catch {
+      const parent = path.dirname(anc);
+      if (parent === anc) throw new PathRefused("no existing ancestor");
+      rest.unshift(path.basename(anc));
+      anc = parent;
+    }
+  }
+  const target = path.join(anc, ...rest);
+  const root = inside(target, await canonRoots(ctx.roots));
+  if (!root || target === root) throw new PathRefused(`write outside the session roots is refused (slice 1): ${raw.slice(0, 200)}`);
+  if (target.slice(root.length).split(/[\\/]/).some(isDotGit)) throw new PathRefused("writes under .git are refused");
+  if (target.slice(root.length).split(/[\\/]/).some((c) => /[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/u.test(c) || Buffer.byteLength(c, "utf8") > 255)) throw new PathRefused("a path component with control, format or bidi characters, or over 255 bytes, is refused");
+  if (ctx.protect) {
+    const rel = target.slice(root.length).split(/[\\/]/).filter(Boolean).join("/");
+    if (protectedHit(rel, ctx.protect)) throw new ProtectedRefused(`${PROTECTED_PREFIX} ${rel.slice(0, 200)} is a protected goal input of this loop (no edit, no card)`);
+  }
+  try {
+    const st = await fsp.lstat(target);
+    if (st.isSymbolicLink()) throw new PathRefused("the final path component is a symlink");
+    if (st.nlink > 1) throw new PathRefused("a file with more than one hard link is refused");
+  } catch (err) {
+    if (err instanceof PathRefused || err instanceof ProtectedRefused) throw err;
+  }
+  return target;
+}
+var TOOLS = Object.freeze([
+  {
+    name: "read_file",
+    description: "Read a UTF-8 text file (path relative to the working directory).",
+    parameters: { type: "object", properties: { path: { type: "string" } }, required: ["path"] },
+    run: async (a, ctx) => {
+      const fh = await fsp.open(await resolveRead(str(a.path, "path"), ctx), constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+      try {
+        const buf = Buffer.alloc(MAX_READ);
+        const { bytesRead } = await fh.read(buf, 0, MAX_READ, 0);
+        return { content: buf.subarray(0, bytesRead).toString("utf8"), isError: false };
+      } finally {
+        await fh.close();
+      }
+    }
+  },
+  {
+    name: "write_file",
+    description: "Write a UTF-8 text file, creating parent directories (path relative to the working directory).",
+    parameters: { type: "object", properties: { path: { type: "string" }, content: { type: "string" } }, required: ["path", "content"] },
+    run: async (a, ctx) => {
+      if (typeof a.content !== "string") throw new Error("content must be a string");
+      const p = await resolveWrite(str(a.path, "path"), ctx);
+      await fsp.mkdir(path.dirname(p), { recursive: true });
+      if (!inside(await fsp.realpath(path.dirname(p)), await canonRoots(ctx.roots))) throw new PathRefused("the parent moved outside the session roots");
+      const fh = await fsp.open(p, constants.O_WRONLY | constants.O_CREAT | (constants.O_NOFOLLOW ?? 0), 420);
+      try {
+        if ((await fh.stat()).nlink > 1) throw new PathRefused("a file with more than one hard link is refused");
+        await fh.truncate(0);
+        await fh.writeFile(a.content);
+      } finally {
+        await fh.close();
+      }
+      return { content: `wrote ${Buffer.byteLength(a.content)} bytes to ${path.relative(ctx.cwd, p) || p}`, isError: false };
+    }
+  },
+  {
+    name: "list_dir",
+    description: 'List a directory (path relative to the working directory; default ".").',
+    parameters: { type: "object", properties: { path: { type: "string" } }, required: [] },
+    run: async (a, ctx) => {
+      const p = await resolveRead(typeof a.path === "string" && a.path ? a.path : ".", ctx);
+      const ents = await fsp.readdir(p, { withFileTypes: true });
+      return { content: ents.map((e) => e.isDirectory() ? `${e.name}/` : e.name).sort().join("\n"), isError: false };
+    }
+  }
+]);
+async function runTool(name, args, ctx) {
+  const t = TOOLS.find((x) => x.name === name && (!ctx.allow || ctx.allow.includes(x.name)));
+  if (!t) return { content: `unknown tool ${name.slice(0, 64)}`, isError: true };
+  try {
+    return await t.run(args, ctx);
+  } catch (err) {
+    return { content: err.message.slice(0, 500), isError: true };
+  }
+}
+
+// src/agent.ts
+var TARGET_HEADROOM = 0.85;
+var MAX_TOOL_CALLS_PER_TURN = 32;
+var Agent = class {
+  #o;
+  /** the tools offered (all, or a loop act session's allowed ones) */
+  #tools;
+  #messages = [];
+  #steer = [];
+  #follow = [];
+  #abort = null;
+  #running = false;
+  /** sticky until the run ends: an abort during tools or steering is never lost */
+  #aborted = false;
+  #turn = 0;
+  #compactions = 0;
+  constructor(o) {
+    this.#o = o;
+    this.#tools = o.allowTools ? TOOLS.filter((t) => o.allowTools.includes(t.name)) : TOOLS;
+    const sys = [o.systemPrompt ?? "You are a careful coding agent working in the user's project.", !o.nativeTools && o.surface !== "none" ? textToolPrompt(this.#tools) : ""].filter(Boolean).join("\n\n");
+    this.#messages.push({ role: "system", content: sys });
+  }
+  get running() {
+    return this.#running;
+  }
+  state() {
+    return { running: this.#running, turns: this.#turn, messages: this.#messages.length, compactions: this.#compactions, contextTarget: this.#target, queued: { steer: this.#steer.length, followUp: this.#follow.length } };
+  }
+  get #target() {
+    return this.#o.contextTarget ?? DEFAULT_CONTEXT_TARGET;
+  }
+  /** tokens the history + reply may use: target × 0.85 minus the tools schema sent natively */
+  get #budget() {
+    const schema = this.#o.nativeTools ? Math.ceil(JSON.stringify(surfaceTools(this.#tools, this.#o.surface)).length / 4) : 0;
+    return Math.floor(this.#target * TARGET_HEADROOM) - schema;
+  }
+  #request() {
+    this.#abort = new AbortController();
+    const body = buildRequest(this.#o.profile, { model: this.#o.model, messages: this.#messages, tools: this.#tools, nativeTools: this.#o.nativeTools, surface: this.#o.surface, maxTokens: this.#o.maxTokens, stream: true });
+    return complete(this.#o.base, body, { signal: this.#abort.signal, onDelta: (delta) => this.#o.emit({ type: "message_update", delta }), ...this.#o.forbiddenPorts ? { forbiddenPorts: this.#o.forbiddenPorts } : {} });
+  }
+  /** One summarising completion, then the history is replaced by system + summary + a safe tail (compaction.ts). */
+  async #compact(reason, total) {
+    const tokensBefore = estimateTokens(this.#messages);
+    this.#o.emit({ type: "compaction_start", reason, tokensBefore });
+    this.#abort = new AbortController();
+    const budget = Math.max(this.#budget, 256);
+    const body = buildRequest(this.#o.profile, { model: this.#o.model, messages: summaryMessages(this.#messages, budget), tools: [], nativeTools: false, surface: "none", maxTokens: Math.min(1024, Math.max(256, Math.floor(budget / 8))), stream: false });
+    let c;
+    try {
+      c = await complete(this.#o.base, body, { signal: this.#abort.signal, ...this.#o.forbiddenPorts ? { forbiddenPorts: this.#o.forbiddenPorts } : {} });
+    } catch (err) {
+      this.#o.emit({ type: "compaction_end", reason, tokensBefore, error: err.message.slice(0, 500) });
+      throw err;
+    }
+    this.#abort = null;
+    if (c.usage) {
+      total.input += c.usage.input;
+      total.output += c.usage.output;
+    }
+    const summary = normaliseSummary(c.content, budget);
+    const { messages, kept } = compactedHistory(this.#messages, summary, Math.floor(budget / 4));
+    this.#messages.splice(0, this.#messages.length, ...messages);
+    this.#compactions++;
+    this.#o.emit({ type: "compaction_end", reason, tokensBefore, tokensAfter: estimateTokens(this.#messages), kept, usage: c.usage, summaryHash: `sha256:${createHash("sha256").update(summary).digest("hex")}`, summaryBytes: Buffer.byteLength(summary, "utf8") });
+  }
+  steer(text) {
+    this.#steer.push(text);
+  }
+  followUp(text) {
+    if (this.#running) this.#follow.push(text);
+    else void this.prompt(text);
+  }
+  abort() {
+    if (this.#running) this.#aborted = true;
+    this.#abort?.abort();
+  }
+  async prompt(text) {
+    if (this.#running) throw new Error("agent is busy (use steer or follow_up)");
+    this.#running = true;
+    this.#aborted = false;
+    this.#messages.push({ role: "user", content: text });
+    const total = { input: 0, output: 0 };
+    let stopReason = "stop";
+    let error;
+    this.#o.emit({ type: "agent_start" });
+    try {
+      for (let step = 0; ; step++) {
+        if (this.#aborted) {
+          stopReason = "aborted";
+          break;
+        }
+        if (step >= this.#o.maxSteps) {
+          stopReason = "max_steps";
+          break;
+        }
+        const turn = ++this.#turn;
+        this.#o.emit({ type: "turn_start", turn });
+        let compacted = false;
+        if (this.#messages.length > 2 && estimateTokens(this.#messages) + this.#o.maxTokens > this.#budget) {
+          await this.#compact("threshold", total);
+          compacted = true;
+          if (estimateTokens(this.#messages) + this.#o.maxTokens > this.#budget) throw new Error(`history is still over the context budget after compaction (${estimateTokens(this.#messages)} + ${this.#o.maxTokens} > ${this.#budget} tokens)`);
+        }
+        let c;
+        try {
+          c = await this.#request();
+        } catch (err) {
+          if (this.#aborted || !isContextOverflow(err)) throw err;
+          if (compacted) throw new Error(`the endpoint still refuses the prompt as too long after this step's compaction: ${err.message.slice(0, 200)}`);
+          await this.#compact("overflow", total);
+          c = await this.#request();
+        }
+        this.#abort = null;
+        const textCalls = !this.#o.nativeTools && this.#o.surface !== "none" ? parseTextToolCalls(c.content) : { calls: [], rest: c.content };
+        const calls = this.#o.surface === "none" ? [] : this.#o.nativeTools ? c.toolCalls.map((t) => ({ id: t.id, name: t.name, arguments: t.arguments })) : textCalls.calls;
+        if (c.usage) {
+          total.input += c.usage.input;
+          total.output += c.usage.output;
+        }
+        this.#messages.push({
+          role: "assistant",
+          content: c.content,
+          ...this.#o.nativeTools && calls.length ? { tool_calls: calls.map((t) => ({ id: t.id, type: "function", function: { name: t.name, arguments: typeof t.arguments === "string" ? t.arguments : JSON.stringify(t.arguments) } })) } : {}
+        });
+        this.#o.emit({ type: "message_end", message: { role: "assistant", content: c.content, toolCalls: calls.map((t) => ({ id: t.id, name: t.name })) }, usage: c.usage, finishReason: c.finishReason });
+        if (calls.length > MAX_TOOL_CALLS_PER_TURN) throw new Error(`${calls.length} tool calls in one turn (cap ${MAX_TOOL_CALLS_PER_TURN})`);
+        const results = await Promise.all(
+          calls.map(async (t) => {
+            const r = repairArguments(t.arguments);
+            if (r.repaired) this.#o.emit({ type: "model_repair", toolCallId: t.id, toolName: t.name, steps: r.steps });
+            this.#o.emit({ type: "tool_execution_start", toolCallId: t.id, toolName: t.name, args: r.ok ? r.value : null });
+            const res = r.ok ? await runTool(t.name, r.value, { cwd: this.#o.cwd, roots: this.#o.roots, ...this.#o.allowTools ? { allow: this.#o.allowTools } : {}, ...this.#o.protect ? { protect: this.#o.protect } : {} }) : { content: "arguments are not a JSON object (repair failed)", isError: true };
+            this.#o.emit({ type: "tool_execution_end", toolCallId: t.id, toolName: t.name, isError: res.isError, result: res.content.slice(0, 4096) });
+            return { t, res };
+          })
+        );
+        for (const { t, res } of results) {
+          if (this.#o.nativeTools) this.#messages.push({ role: "tool", tool_call_id: t.id, content: res.content });
+          else this.#messages.push({ role: "user", content: `<tool_result name="${t.name}"${res.isError ? ' error="true"' : ""}>
+${res.content}
+</tool_result>` });
+        }
+        this.#o.emit({ type: "turn_end", turn, usage: c.usage });
+        const steering = this.#steer.splice(0);
+        for (const s of steering) this.#messages.push({ role: "user", content: s });
+        if (!calls.length && !steering.length) break;
+      }
+    } catch (err) {
+      this.#abort = null;
+      stopReason = this.#aborted || err.name === "AbortError" ? "aborted" : "error";
+      error = err.message.slice(0, 500);
+    }
+    if (this.#aborted) stopReason = "aborted";
+    this.#running = false;
+    this.#aborted = false;
+    this.#o.emit({ type: "agent_end", stopReason, usage: total, ...error ? { error } : {} });
+    const next = this.#follow.shift();
+    if (next !== void 0) await this.prompt(next);
+  }
+};
+
+// src/rpc.ts
+var ConfigError = class extends Error {
+};
+var SURFACES = ["none", "compact", "full"];
+function parseSessionConfig(text) {
+  let c;
+  try {
+    c = JSON.parse(text);
+  } catch {
+    throw new ConfigError("config is not the JSON subset of YAML");
+  }
+  const ep = c.endpoint;
+  const caps = c.capabilities;
+  if (c.schemaVersion !== "gnomon-local-session:v1") throw new ConfigError("schemaVersion must be gnomon-local-session:v1");
+  if (typeof c.session !== "string" || typeof c.cwd !== "string") throw new ConfigError("session and cwd are required");
+  if (!ep || typeof ep.base !== "string" || typeof ep.model !== "string" || typeof ep.compat !== "string") throw new ConfigError("endpoint{base, model, compat} is required");
+  if (!Object.hasOwn(COMPAT_ALLOWLIST, ep.compat)) throw new ConfigError(`compat ${ep.compat.slice(0, 32)} is not in the local allowlist`);
+  const forbiddenPorts = Array.isArray(c.forbiddenPorts) ? c.forbiddenPorts.filter((p) => Number.isInteger(p)) : [];
+  const v = classifyEndpoint(ep.base, forbiddenPorts);
+  if (!v.ok) throw new ConfigError(`endpoint refused: ${v.why} (loopback/LAN only, law 7)`);
+  if (!caps || typeof caps.tools !== "boolean") throw new ConfigError("capabilities{tools} is required");
+  const surface = typeof c.surface === "string" && SURFACES.includes(c.surface) ? c.surface : "compact";
+  const real = (p) => {
+    try {
+      return realpathSync.native(p);
+    } catch {
+      throw new ConfigError(`root ${p.slice(0, 200)} does not exist`);
+    }
+  };
+  const rawRoots = Array.isArray(c.roots) && c.roots.length ? c.roots : [c.cwd];
+  if (rawRoots.some((r) => typeof r !== "string" || !r.startsWith("/") && !/^[A-Za-z]:[\\/]/.test(r))) throw new ConfigError("roots must be absolute paths");
+  const roots = rawRoots.map(real);
+  const int = (x, d, max) => Number.isInteger(x) && x > 0 ? Math.min(x, max) : d;
+  const maxTokens = int(c.maxTokens, 1024, 32768);
+  const contextTarget = Math.max(int(c.contextTarget, 8192, 131072), 1024);
+  if (maxTokens >= 0.85 * contextTarget) throw new ConfigError(`maxTokens ${maxTokens} leaves no room under 0.85 x contextTarget ${contextTarget}`);
+  return {
+    schemaVersion: "gnomon-local-session:v1",
+    session: c.session,
+    cwd: c.cwd,
+    roots,
+    endpoint: { base: v.base, model: ep.model, compat: ep.compat },
+    capabilities: { tools: caps.tools, nCtx: typeof caps.nCtx === "number" ? caps.nCtx : null },
+    surface,
+    maxSteps: int(c.maxSteps, 16, 128),
+    maxTokens,
+    contextTarget,
+    forbiddenPorts,
+    ...typeof c.systemPrompt === "string" ? { systemPrompt: c.systemPrompt } : {},
+    ...strList(c.tools, "tools", (t) => TOOLS.some((x) => x.name === t)),
+    ...strList(c.protect, "protect", (g) => g.length > 0 && g.length <= 512)
+  };
+}
+function strList(v, key, ok) {
+  if (v === void 0) return {};
+  if (!Array.isArray(v) || v.length > 4096 || v.some((x) => typeof x !== "string" || !ok(x))) throw new ConfigError(`${key} must be a list of valid strings`);
+  return { [key]: [...v] };
+}
+function rpcSession(cfg, emit2) {
+  const agent = new Agent({
+    base: cfg.endpoint.base,
+    model: cfg.endpoint.model,
+    profile: COMPAT_ALLOWLIST[cfg.endpoint.compat],
+    nativeTools: cfg.capabilities.tools,
+    surface: cfg.surface,
+    cwd: cfg.cwd,
+    roots: cfg.roots,
+    maxSteps: cfg.maxSteps,
+    maxTokens: cfg.maxTokens,
+    contextTarget: cfg.contextTarget,
+    forbiddenPorts: cfg.forbiddenPorts,
+    ...cfg.systemPrompt !== void 0 ? { systemPrompt: cfg.systemPrompt } : {},
+    ...cfg.tools ? { allowTools: cfg.tools } : {},
+    ...cfg.protect ? { protect: cfg.protect.map(protectGlob) } : {},
+    emit: emit2
+  });
+  emit2({ type: "model_capabilities", backend: "local", model: cfg.endpoint.model, compat: cfg.endpoint.compat, tools: cfg.capabilities.tools, ctx: cfg.capabilities.nCtx, surface: cfg.surface, textTools: !cfg.capabilities.tools && cfg.surface !== "none", contextTarget: cfg.contextTarget });
+  const onLine = (line) => {
+    let cmd;
+    try {
+      cmd = JSON.parse(line);
+    } catch {
+      emit2({ type: "response", command: "unknown", success: false, error: "malformed line" });
+      return;
+    }
+    const id = typeof cmd.id === "string" ? { id: cmd.id } : {};
+    const command = typeof cmd.type === "string" ? cmd.type : "unknown";
+    const ok = (data) => emit2({ type: "response", ...id, command, success: true, ...data !== void 0 ? { data } : {} });
+    const no = (error) => emit2({ type: "response", ...id, command, success: false, error });
+    const msg = typeof cmd.message === "string" && cmd.message.length > 0 ? cmd.message : null;
+    switch (command) {
+      case "prompt":
+        if (!msg) return no("message is required");
+        if (agent.running) return no("agent is busy (use steer or follow_up)");
+        ok();
+        void agent.prompt(msg);
+        return;
+      case "steer":
+        if (!msg) return no("message is required");
+        if (!agent.running) return no("agent is idle (nothing to steer)");
+        agent.steer(msg);
+        return ok();
+      case "follow_up":
+        if (!msg) return no("message is required");
+        agent.followUp(msg);
+        return ok();
+      case "abort":
+        agent.abort();
+        return ok();
+      case "get_state":
+        return ok(agent.state());
+      default:
+        return no(`unknown command ${command.slice(0, 32)}`);
+    }
+  };
+  return { onLine, agent };
+}
+
+// src/cli.ts
+var emit = (ev) => {
+  process.stdout.write(`${JSON.stringify(ev)}
+`);
+};
+var Fatal = class extends Error {
+  constructor(error, code) {
+    super(error);
+    this.error = error;
+    this.code = code;
+  }
+  error;
+  code;
+};
+var RUNNER_MARKER = "gnomon-local-runner:v1";
+function fatal(error, code) {
+  throw new Fatal(error, code);
+}
+function main(argv) {
+  const args = /* @__PURE__ */ new Map();
+  for (let i = 0; i < argv.length; i += 2) {
+    const k = argv[i];
+    const v = argv[i + 1];
+    if (!["--mode", "--config", "--session"].includes(k) || v === void 0 || args.has(k)) fatal(`bad argv near ${k.slice(0, 32)} (gnomon-local --mode rpc --config <local.yaml> --session <hsid>; ${RUNNER_MARKER})`, 2);
+    args.set(k, v);
+  }
+  if (args.get("--mode") !== "rpc") fatal("only --mode rpc is served", 2);
+  const cfgPath = args.get("--config");
+  if (!cfgPath) fatal("--config is required", 2);
+  let cfg;
+  try {
+    cfg = parseSessionConfig(readFileSync(cfgPath, "utf8"));
+  } catch (err) {
+    fatal(err instanceof ConfigError ? err.message : `cannot read config: ${err.message.slice(0, 200)}`, 3);
+  }
+  if (args.has("--session") && args.get("--session") !== cfg.session) fatal("--session does not match the config", 2);
+  const { onLine, agent } = rpcSession(cfg, emit);
+  let buf = "";
+  let ended = false;
+  process.stdin.setEncoding("utf8");
+  process.stdin.on("data", (d) => {
+    buf += d;
+    let nl;
+    while ((nl = buf.indexOf("\n")) >= 0) {
+      const line = buf.slice(0, nl).trim();
+      buf = buf.slice(nl + 1);
+      if (line) onLine(line);
+    }
+  });
+  process.stdin.on("end", () => {
+    ended = true;
+  });
+  const t = setInterval(() => {
+    if (ended && !agent.running) {
+      clearInterval(t);
+      process.exitCode = 0;
+      process.stdin.destroy();
+    }
+  }, 50);
+}
+try {
+  main(process.argv.slice(2));
+} catch (err) {
+  emit({ type: "fatal", error: err instanceof Fatal ? err.error : err.message.slice(0, 200) });
+  process.exitCode = err instanceof Fatal ? err.code : 1;
+}
+export {
+  RUNNER_MARKER
+};