@hizliemre/horse-code 0.2.0 → 0.3.1

package/dist/{chunk-23CLQ2KO.js → chunk-2WXG35EM.js}

@@ -5,10 +5,8 @@ import {
   Board,
   LONG_CALL_MS,
   WHAT_IT_COST,
-  applySkills,
   buildAskUserTool,
   buildRememberTool,
-  buildSkillTool,
   changedByMerge,
   commitFile,
   commitStep,
@@ -22,7 +20,6 @@ import {
   hasWorkAgainst,
   nextFeatureSlug,
   normalizeQuestion,
-  placedSkills,
   readOnlyRegistry,
   refreshAfterChange,
   routeSkills,
@@ -37,20 +34,25 @@ import {
   worktreeState,
   writeFileTool,
   writerRegistry
-} from "./chunk-7JMWPTJ5.js";
+} from "./chunk-27F44PBD.js";
 import {
   resolveMainBranch
 } from "./chunk-QF4MP6BS.js";
 import {
   askInUserLanguage,
   inUserLanguage
-} from "./chunk-UGESK765.js";
+} from "./chunk-UTHLEW5V.js";
 import {
   clearCheckpoint,
   isContinuePrompt,
   readCheckpoint,
   writeCheckpoint
 } from "./chunk-ZSQ24YDJ.js";
+import {
+  applySkills,
+  buildSkillTool,
+  placedSkills
+} from "./chunk-YULQ4URQ.js";
 import {
   defaultGitRunner
 } from "./chunk-LPQU436C.js";
@@ -72,25 +74,27 @@ import {
   relationStrength,
   supersedes,
   verifyAnchors
-} from "./chunk-LLL7QWXB.js";
+} from "./chunk-BFIZMM4G.js";
 import {
   ToolRegistry,
+  runStructuredRole
+} from "./chunk-CYLPQWIF.js";
+import {
   handedOver,
-  runStructuredRole,
   runToCompletion,
   stripThinking,
   telemetry
-} from "./chunk-AE36LLL2.js";
+} from "./chunk-JLWQCA7B.js";
 import {
   TRACE_INDEX,
   mergeTraceIndexes,
   parseTraceIndex,
   serializeTraceIndex,
   traceRootRel
-} from "./chunk-KAGKX2YT.js";
+} from "./chunk-ZPJP2VH5.js";
 import {
   loadGraphSync
-} from "./chunk-XEGQT5EN.js";
+} from "./chunk-4M6LXNG2.js";
 import {
   inLinkedWorktree,
   sessionBase,
@@ -3217,7 +3221,7 @@ async function runUpstream(deps, ensureWorktree, prompt, askUser, maxRounds, his
     emitPhase("verify");
     const cwd = await documentWorkdir(process.cwd(), prompt, ensureWorktree, r.title);
     laneCheckpoint(cwd, "verify", resume, prompt, r);
-    const { runVerify, describeVerify, currentBranchOf } = await import("./verify-6SC4I77M.js");
+    const { runVerify, describeVerify, currentBranchOf } = await import("./verify-HWZBTK5X.js");
     const branch = await currentBranchOf(cwd);
     const res = await runVerify({
       deps,
@@ -3260,11 +3264,11 @@ async function runUpstream(deps, ensureWorktree, prompt, askUser, maxRounds, his
   if (!resume && !hasPreservedWork && routeIntent(r.intent) === "pipeline") {
     const cwd = workingIn?.() ?? process.cwd();
     emitPhase("sizing");
-    const { sizeRequest } = await import("./triage-FCYHD2AQ.js");
+    const { sizeRequest } = await import("./triage-IFCVL5MA.js");
     const size = await sizeRequest(deps, cwd, r.refinedPrompt);
     let small = size.verdict === "small";
     if (size.verdict === "unsure") {
-      const { describeSizeDoubt } = await import("./triage-FCYHD2AQ.js");
+      const { describeSizeDoubt } = await import("./triage-IFCVL5MA.js");
       const answer = await askInUserLanguage(
         deps,
         askUser,
@@ -3282,8 +3286,8 @@ Which is it?`,
     if (small) {
       emitPhase("small change");
       emit({ kind: "note", text: `\u26A1 Small change \u2014 ${size.reason}. No branch, no spec, no plan.` });
-      const { runSmallChange, describeSmallChange } = await import("./fix-JOIXQFVP.js");
-      const { currentBranchOf } = await import("./verify-6SC4I77M.js");
+      const { runSmallChange, describeSmallChange } = await import("./fix-QCL5AITT.js");
+      const { currentBranchOf } = await import("./verify-HWZBTK5X.js");
       const res = await runSmallChange(deps, cwd, r.title, r.refinedPrompt, size);
       return {
         intent: r.intent,

package/dist/{chunk-LNW557IO.js → chunk-372X5HHU.js}

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

package/dist/{chunk-5ZV42XGJ.js → chunk-3ACDNDCG.js}

@@ -2,7 +2,7 @@ import {
   Board,
   refreshAfterChange,
   runTaskCycle
-} from "./chunk-7JMWPTJ5.js";
+} from "./chunk-27F44PBD.js";
 import {
   defaultGitRunner
 } from "./chunk-LPQU436C.js";

package/dist/{chunk-XEGQT5EN.js → chunk-4M6LXNG2.js}

@@ -300,7 +300,7 @@ function pruneTooling(doc, alsoDrop = /* @__PURE__ */ new Set()) {
 async function writtenTracePaths(cwd) {
   const out = /* @__PURE__ */ new Set();
   try {
-    const { loadTraceIndex, traceRootRel } = await import("./trace-X6TU3AG6.js");
+    const { loadTraceIndex, traceRootRel } = await import("./trace-UVMZZRA5.js");
     const index = await loadTraceIndex(cwd);
     const root = traceRootRel().replace(/\\/g, "/");
     for (const [file, rec] of Object.entries(index.traces)) {

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

@@ -1,7 +1,7 @@
 import {
   hashContent,
   traceDir
-} from "./chunk-KAGKX2YT.js";
+} from "./chunk-ZPJP2VH5.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-X6TU3AG6.js");
+    const { loadTraceIndex, traceRootRel } = await import("./trace-UVMZZRA5.js");
     const root = traceRootRel().replace(/\\/g, "/");
     out.add(`${root}/PROJECT.md`);
     out.add(`${root}/PROJECT.json`);

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

@@ -3,20 +3,20 @@ import {
   loadMigratedSync,
   migratedNotice
 } from "./chunk-63E73TGI.js";
-import {
-  telemetry
-} from "./chunk-AE36LLL2.js";
 import {
   readBriefSync
-} from "./chunk-6OSEQOYY.js";
+} from "./chunk-6S4WWQMN.js";
+import {
+  telemetry
+} from "./chunk-JLWQCA7B.js";
 import {
   everTraceable,
   readTraceSync
-} from "./chunk-KAGKX2YT.js";
+} from "./chunk-ZPJP2VH5.js";
 import {
   areaOf,
   loadGraphSync
-} from "./chunk-XEGQT5EN.js";
+} from "./chunk-4M6LXNG2.js";
 
 // src/tools/read.ts
 import { readFile } from "fs/promises";

package/dist/chunk-CYLPQWIF.js

@@ -0,0 +1,214 @@
+import {
+  runRoleAgent
+} from "./chunk-JLWQCA7B.js";
+
+// src/tools/registry.ts
+import { z } from "zod";
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  /**
+   * Registered and callable, but whose SCHEMA is withheld until something asks for it.
+   *
+   * A schema is paid for on every turn, whether or not the tool is ever used. Measured across twelve runs:
+   * 49 MCP tool schemas came to 86,620 characters (~21,655 tokens), 242 calls carried them, and that is
+   * ~5.2M of the 21.7M input tokens billed — 24% of everything — for FIVE tool calls, of two distinct tools.
+   * The catalogue that names them costs 900 characters (see MAX_TOOL_NOTE_CHARS); it is the schemas that are
+   * expensive, and a schema nobody is about to use buys nothing.
+   */
+  deferred = /* @__PURE__ */ new Set();
+  /** Bumped by anything that changes what `schemas()` would return, so the derivation can be cached. */
+  version = 0;
+  cached;
+  register(tool) {
+    this.tools.set(tool.name, tool);
+    this.deferred.delete(tool.name);
+    this.version++;
+  }
+  /** Callable by name from the moment it is registered; sent to the model only once {@link surface}d. */
+  registerDeferred(tool) {
+    this.tools.set(tool.name, tool);
+    this.deferred.add(tool.name);
+    this.version++;
+  }
+  /**
+   * Hands over the schemas for these names, from the next turn onward.
+   *
+   * Returns the ones that were actually withheld, so a caller can say what it just made available and stay
+   * quiet about what was already there.
+   */
+  surface(names) {
+    const opened = names.filter((n) => this.deferred.has(n));
+    for (const n of opened) this.deferred.delete(n);
+    if (opened.length) this.version++;
+    return opened;
+  }
+  /** Everything still withheld — what a search tool searches. */
+  deferredTools() {
+    return [...this.deferred].map((n) => this.tools.get(n)).filter((t) => t !== void 0);
+  }
+  /**
+   * A withheld tool is still CALLABLE.
+   *
+   * A model that reads the catalogue and calls the name straight off is right, and refusing it to enforce a
+   * search step would spend a turn teaching it a rule that exists for our benefit, not its.
+   */
+  get(name) {
+    return this.tools.get(name);
+  }
+  list() {
+    return [...this.tools.values()];
+  }
+  /**
+   * Tool schemas to send to the LLM: zod parameters → JSON Schema (zod 4 native). Withheld ones are omitted.
+   *
+   * …and so is a tool that has withdrawn itself. `Tool.broken` was documented as being read "where tools are
+   * OFFERED, so a broken one stops being handed to fresh agents" — and only `find_tool` ever read it, which
+   * covers the deferred tools and not the ones already on the list.
+   *
+   * Measured on one run: `mcp__angular-cli__list_projects` answered its first caller with a reply that failed
+   * its own declared output schema and withdrew itself. It was then offered to seventeen more agents, who
+   * called it twenty-eight more times. Every one of those was answered instantly, without touching the
+   * server — and still cost a whole model turn to learn what the run already knew.
+   */
+  schemas() {
+    const withdrawn = this.list().reduce((n, t) => n + (t.broken === void 0 ? 0 : 1), 0);
+    if (this.cached?.version === this.version && this.cached.withdrawn === withdrawn) return this.cached.schemas;
+    const schemas = this.list().filter((t) => !this.deferred.has(t.name) && t.broken === void 0).map((t) => ({
+      name: t.name,
+      description: t.description,
+      // MCP tools already carry a JSON Schema; everyone else derives it from their zod parameters.
+      parameters: t.rawSchema ?? z.toJSONSchema(t.parameters, { target: "draft-7" })
+    }));
+    this.cached = { version: this.version, withdrawn, schemas };
+    return schemas;
+  }
+};
+
+// 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;
+  for (const key of path) {
+    if (typeof cur !== "object" || cur === null) return void 0;
+    cur = cur[key];
+  }
+  return cur;
+}
+function whatWasWrong(issues, args) {
+  return issues.map((i) => {
+    const where = i.path.length ? i.path.join(".") : void 0;
+    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("; ");
+}
+function buildSubmitTool(schema) {
+  let box;
+  const tool = {
+    name: "submit",
+    description: "When you are done, submit your result in structured form with this tool.",
+    permissionLevel: "safe",
+    parameters: schema,
+    run: async (rawArgs) => {
+      const parsed = schema.safeParse(rawArgs);
+      if (!parsed.success) {
+        return { content: `submit: invalid output: ${whatWasWrong(parsed.error.issues, rawArgs)}`, isError: true };
+      }
+      box = { value: parsed.data };
+      return { content: "received", isError: false };
+    }
+  };
+  return { tool, result: () => box };
+}
+function extractStructured(text, schema) {
+  const trimmed = text.trim();
+  if (!trimmed) return void 0;
+  const candidates = [trimmed];
+  const block = trimmed.match(/\{[\s\S]*\}/);
+  if (block) candidates.push(block[0]);
+  for (const c of candidates) {
+    try {
+      const parsed = schema.safeParse(JSON.parse(c));
+      if (parsed.success) return parsed.data;
+    } catch {
+    }
+  }
+  return void 0;
+}
+var TURN_LIMIT_RE = /maximum turn count exceeded/i;
+async function runStructuredRole(opts, schema, maxAttempts = 2) {
+  const handle = buildSubmitTool(schema);
+  const registry = new ToolRegistry();
+  for (const t of opts.tools.list()) registry.register(t);
+  registry.register(handle.tool);
+  const chain = [opts.model, ...opts.fallbacks ?? []];
+  const total = opts.totalMs ? AbortSignal.timeout(opts.totalMs) : void 0;
+  const outOfTime = () => total?.aborted === true;
+  const signalFor = () => {
+    const parts = [opts.signal];
+    if (total) parts.push(total);
+    if (opts.perAttemptMs) parts.push(AbortSignal.timeout(opts.perAttemptMs));
+    return parts.length === 1 ? opts.signal : AbortSignal.any(parts);
+  };
+  let lastError;
+  for (let ci = 0; ci < chain.length; ci++) {
+    const model = chain[ci];
+    if (ci > 0) opts.onFallback?.(chain[ci - 1], model, "structured: previous model returned no valid result");
+    const messages = [...opts.messages];
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      if (opts.signal.aborted) throw new Error("cancelled");
+      if (outOfTime()) break;
+      let lastText = "";
+      let errored;
+      for await (const ev of runRoleAgent({ ...opts, model, fallbacks: [], messages, tools: registry, signal: signalFor() })) {
+        if (ev.type === "error") {
+          errored = ev.message;
+          break;
+        }
+        if (ev.type === "abort") {
+          if (opts.signal.aborted) throw new Error("cancelled");
+          errored = total?.aborted ? CHAIN_BUDGET_MESSAGE : DEADLINE_MESSAGE;
+          break;
+        }
+        if (ev.type === "message.done") lastText = ev.message.content ?? lastText;
+        if (handle.result() !== void 0) break;
+      }
+      const r = handle.result();
+      if (r !== void 0) return r.value;
+      const salvaged = extractStructured(lastText, schema);
+      if (salvaged !== void 0) return salvaged;
+      if (errored !== void 0) {
+        if (TURN_LIMIT_RE.test(errored) && attempt < maxAttempts - 1) {
+          messages.push({ role: "assistant", content: lastText });
+          messages.push({ role: "user", content: "You have used your entire tool-call budget. Call `submit` NOW with the findings you already have. Do not read, grep or inspect anything else." });
+          continue;
+        }
+        lastError = errored;
+        break;
+      }
+      messages.push({ role: "assistant", content: lastText });
+      messages.push({
+        role: "user",
+        content: "You did not call the `submit` tool. Call `submit` now with your result as structured arguments \u2014 do not answer in prose."
+      });
+    }
+    if (opts.signal.aborted) throw new Error("cancelled");
+    if (outOfTime()) throw new Error("the model chain did not produce a result within its total budget");
+    opts.onStructuralFailure?.(model, "answered in prose instead of calling submit");
+  }
+  throw new Error(lastError ?? "structured role: submit was not called (whole model chain tried)");
+}
+
+export {
+  ToolRegistry,
+  runStructuredRole
+};