@hizliemre/horse-code 0.3.0 → 0.4.0

package/dist/research-MHBNZ6SA.js

@@ -0,0 +1,111 @@
+import {
+  createWebFetchTool,
+  readOnlyRegistry
+} from "./chunk-NBTH2VVI.js";
+import "./chunk-ZSQ24YDJ.js";
+import "./chunk-MZM24M5M.js";
+import {
+  defaultGitRunner
+} from "./chunk-LPQU436C.js";
+import "./chunk-BFIZMM4G.js";
+import "./chunk-CYLPQWIF.js";
+import "./chunk-63E73TGI.js";
+import "./chunk-6S4WWQMN.js";
+import {
+  runToCompletion
+} from "./chunk-JLWQCA7B.js";
+import "./chunk-ZPJP2VH5.js";
+import "./chunk-4M6LXNG2.js";
+import "./chunk-6W4UH2BQ.js";
+
+// src/engine/research.ts
+import { mkdir, writeFile } from "fs/promises";
+import { dirname, join, relative } from "path";
+import { existsSync } from "fs";
+var RESEARCH_MAX_TURNS = 120;
+function researchDir(trackedFiles2) {
+  const known = [/^docs\/research\//i, /^docs\/adr\//i, /^docs\/decisions\//i, /^research\//i, /^\.planning\//i];
+  for (const re of known) {
+    const hit = trackedFiles2.find((f) => re.test(f.replace(/\\/g, "/")));
+    if (hit) return dirname(hit.replace(/\\/g, "/"));
+  }
+  return "docs/research";
+}
+function reportName(title, now = /* @__PURE__ */ new Date()) {
+  const slug = (title || "research").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
+  const day = now.toISOString().slice(0, 10);
+  return `${day}-${slug || "research"}.md`;
+}
+var researchRule = "You are researching a question and writing ONE document. You are not changing this project: you have no tool that writes a file, and the report is your final answer \u2014 horse-code writes it down.\n\nGround the answer in THIS repository before anything else. Read the code that the question is about; a recommendation that ignores what is already here is a recommendation for a different project.\n\nThe document must contain, in this order:\n1. The question, restated in one or two sentences as you understood it.\n2. What this project does today in the area concerned, with file paths \u2014 the starting position.\n3. The options, one section each. For every option: how it would work here, what it costs, and what it rules out. An option nobody would pick is still worth a paragraph saying why not.\n4. A comparison table across the dimensions that actually decide this one. Choose the dimensions from the question rather than from habit.\n5. A recommendation, with the condition that would change it. A recommendation that nothing could overturn is a preference wearing a suit.\n6. What you could not establish, and what it would take to settle. Say it plainly \u2014 an unexamined assumption presented as a finding is the one failure this document cannot recover from.\n\nWrite markdown. Cite file paths for claims about this project and URLs for claims about the world. Where you are reasoning from your own knowledge rather than from something you read, say so.";
+async function runResearch(opts) {
+  const { deps, workdir } = opts;
+  const dir = researchDir(opts.trackedFiles ?? await trackedFiles(workdir));
+  const rel = join(dir, reportName(opts.title));
+  const tools = readOnlyRegistry(deps, { remember: true });
+  tools.register(createWebFetchTool());
+  const language = opts.language ? `
+
+Write the document in ${opts.language}. Keep file paths, identifiers and URLs exactly as they are.` : "";
+  const rules = deps.roleRegistry.ruleSuffix();
+  const last = await runToCompletion({
+    ...deps.roleRegistry.fallbackOpts("analyst"),
+    systemPrompt: researchRule + language + rules,
+    messages: [{ role: "user", content: opts.prompt }],
+    tools,
+    maxTurns: RESEARCH_MAX_TURNS,
+    provider: deps.provider,
+    permission: deps.permission,
+    approve: deps.approve,
+    cwd: workdir,
+    signal: deps.signal,
+    onActivity: deps.onActivity,
+    onLiveActivity: deps.onLiveActivity,
+    inbox: deps.inbox,
+    ...opts.note ? { onSay: opts.note } : {}
+  });
+  const body = (last.content ?? "").trim();
+  if (!body) return { reportPath: rel, written: false, committed: false };
+  const abs = join(workdir, rel);
+  await mkdir(dirname(abs), { recursive: true });
+  await writeFile(abs, `${body}
+`, "utf8");
+  return { reportPath: rel, written: true, committed: await commitReport(workdir, rel, opts.title) };
+}
+async function trackedFiles(cwd) {
+  try {
+    const r = await defaultGitRunner(["ls-files"], cwd);
+    return r.code === 0 ? r.stdout.split("\n").filter(Boolean) : [];
+  } catch {
+    return [];
+  }
+}
+async function commitReport(workdir, rel, title) {
+  if (!existsSync(join(workdir, ".git")) && !existsSync(join(workdir, rel))) return false;
+  const add = await defaultGitRunner(["add", "--", rel], workdir);
+  if (add.code !== 0) return false;
+  const staged = await defaultGitRunner(["diff", "--cached", "--quiet", "--", rel], workdir);
+  if (staged.code === 0) return false;
+  const r = await defaultGitRunner(["commit", "-m", `docs(research): ${title || "findings"}`, "--", rel], workdir);
+  return r.code === 0;
+}
+function describeResearch(r, branch) {
+  if (!r.written) return "The research produced no document \u2014 nothing was written.";
+  const where = r.committed ? `Committed on \`${branch}\`.` : "Written, but not committed \u2014 it is in the working tree.";
+  return `\u{1F4C4} **Research report:** \`${r.reportPath}\`
+${where}
+
+_No code was changed: the lane runs without a write tool at all._`;
+}
+function plannedPath(title, trackedFiles2) {
+  return relative(".", join(researchDir(trackedFiles2), reportName(title))).replace(/\\/g, "/");
+}
+export {
+  RESEARCH_MAX_TURNS,
+  commitReport,
+  describeResearch,
+  plannedPath,
+  reportName,
+  researchDir,
+  researchRule,
+  runResearch
+};

package/dist/run-V5ZLZ3LS.js

@@ -0,0 +1,274 @@
+import {
+  MAX_RULES,
+  consolidateRules,
+  discover,
+  extractAll,
+  groupForReview,
+  hasAnything,
+  summarize
+} from "./chunk-QJYVZPLG.js";
+import {
+  loadMigrated,
+  recordMigrated
+} from "./chunk-63E73TGI.js";
+import "./chunk-6W4UH2BQ.js";
+
+// src/migrate/run.ts
+import { cp, lstat, mkdir, readFile, readlink, rm } from "fs/promises";
+import { dirname, join, resolve } from "path";
+var YES = /^(yes|import|copy|evet)/i;
+function countKind(store, kind) {
+  return store.all().filter((m) => (m.kind ?? "fact") === kind).length;
+}
+var SAMPLE = 6;
+function sample(items) {
+  return items.slice(0, SAMPLE).map((c) => `- ${c.text}`).join("\n") + (items.length > SAMPLE ? `
+- _\u2026and ${items.length - SAMPLE} more_` : "");
+}
+async function runMigration(deps) {
+  const result = { rules: 0, facts: 0, skills: 0, skipped: 0, declined: [], failedBatches: 0, removed: 0 };
+  const findings = [...await discover({ cwd: deps.cwd, home: deps.home }), ...deps.extra ?? []];
+  if (!hasAnything(findings)) {
+    deps.note("No configuration from another coding tool was found here \u2014 nothing to migrate.");
+    return result;
+  }
+  deps.note(`**Found in this project:**
+${summarize(findings)}`);
+  const prose = findings.filter((f) => (f.kind === "rules" || f.kind === "memory") && f.text);
+  if (prose.length) {
+    deps.note(`Reading ${prose.length} file(s) to work out which instructions still apply here. _This is the part that costs tokens; nothing is imported until you say so._`);
+    deps.busy?.("reading instructions", deps.models[0]);
+    const extraction = await extractAll({
+      provider: deps.provider,
+      models: deps.models,
+      findings: prose,
+      ...deps.signal ? { signal: deps.signal } : {},
+      onProgress: (done, total, source) => deps.progress?.(
+        "read",
+        `\u{1F4D6} Reading **${done}/${total}** \u2014 _${source}_`
+      )
+    });
+    deps.idle?.();
+    result.failedBatches = extraction.failed.length;
+    if (extraction.failed.length) {
+      const reasons = [...new Set(extraction.failed.map((f) => f.error))].slice(0, 3);
+      deps.note(`\u26A0\uFE0F **${extraction.failed.length} batch(es) could not be read** \u2014 ` + reasons.map((r) => `\`${r.slice(0, 160)}\``).join("; ") + `
+
+_Nothing from those files was imported. Re-run \`/migrate\` once the cause above is cleared._`);
+    }
+    const raw = groupForReview(extraction);
+    result.skipped = raw.skipped.length;
+    let rules = raw.rules;
+    const facts = [...raw.facts];
+    if (rules.length > MAX_RULES) {
+      deps.note(`${rules.length} rule candidates \u2014 consolidating, since every rule is inlined into every prompt forever.`);
+      deps.busy?.("consolidating rules", deps.models[0]);
+      const c = await consolidateRules({
+        provider: deps.provider,
+        models: deps.models,
+        candidates: rules,
+        ...deps.signal ? { signal: deps.signal } : {}
+      });
+      deps.idle?.();
+      if (c.rules.length < rules.length) {
+        deps.note(`Consolidated **${rules.length} \u2192 ${c.rules.length}** rules${c.demoted.length ? `, kept ${c.demoted.length} as fact(s)` : ""}${c.dropped.length ? `, dropped ${c.dropped.length} describing a workflow horse-code replaces` : ""}.`);
+        rules = c.rules;
+        facts.push(...c.demoted);
+        result.skipped += c.dropped.length;
+      } else {
+        deps.note(`\u26A0\uFE0F Consolidation did not run \u2014 you are being asked about all ${rules.length} candidates.`);
+      }
+    }
+    if (rules.length) {
+      const answer = await deps.ask(
+        `**${rules.length} standing rule(s)**. A rule goes into EVERY agent's instructions, for every task, permanently.
+
+${sample(rules)}
+
+Import them?`,
+        { options: [
+          { label: "Yes \u2014 import all", description: `${rules.length} rules become permanent memory` },
+          { label: "No", description: "Nothing is written; you can re-run /migrate later" }
+        ] }
+      );
+      if (YES.test(answer.trim())) {
+        const before = countKind(deps.memStore, "rule");
+        for (const c of rules) await deps.memStore.add(c.text, "rule");
+        result.rules = countKind(deps.memStore, "rule") - before;
+      } else result.declined.push("rules");
+    }
+    if (facts.length) {
+      const answer = await deps.ask(
+        `**${facts.length} project fact(s)** were found \u2014 recalled when relevant rather than always.
+
+${sample(facts)}
+
+Import them?`,
+        { options: [
+          { label: "Yes \u2014 import all", description: `${facts.length} facts become memory` },
+          { label: "No", description: "Nothing is written" }
+        ] }
+      );
+      if (YES.test(answer.trim())) {
+        const before = countKind(deps.memStore, "fact");
+        for (const c of facts) await deps.memStore.add(c.text, "fact");
+        result.facts = countKind(deps.memStore, "fact") - before;
+      } else result.declined.push("facts");
+    }
+    if (raw.skipped.length) {
+      const skipped = raw.skipped;
+      const why = skipped.slice(0, SAMPLE).map((c) => `- ~~${c.text.slice(0, 90)}~~ \u2014 ${c.reason}`).join("\n");
+      deps.note(`**Left behind (${skipped.length})** \u2014 these only meant something in the original tool:
+${why}` + (skipped.length > SAMPLE ? `
+- _\u2026and ${skipped.length - SAMPLE} more_` : "") + `
+
+_If one of these should have transferred, add it with \`/memory add\`._`);
+    }
+  }
+  const existing = new Set(deps.existingSkills?.() ?? []);
+  const allSkills = findings.filter((f) => f.kind === "skill");
+  const skills = allSkills.filter((f) => !existing.has(f.label.split("/").pop()));
+  const alreadyHave = allSkills.length - skills.length;
+  if (alreadyHave) deps.note(`${alreadyHave} skill(s) are ones horse-code already ships \u2014 left alone.`);
+  if (skills.length) {
+    const answer = await deps.ask(
+      `**${skills.length} skill(s)** were found. The format is the same as ours, so they transfer as they are:
+${skills.slice(0, SAMPLE).map((s) => `- \`${s.label.split("/").pop()}\``).join("\n")}${skills.length > SAMPLE ? `
+- _\u2026and ${skills.length - SAMPLE} more_` : ""}
+
+Copy them into this project?`,
+      { options: [
+        { label: "Yes \u2014 copy all", description: "Copied to .horsecode/skills/, then routed per task" },
+        { label: "No", description: "They stay where they are" }
+      ] }
+    );
+    if (YES.test(answer.trim())) {
+      const copied = [];
+      for (const [i, s] of skills.entries()) {
+        const name = s.label.split("/").pop();
+        deps.progress?.("copy", `\u{1F4E6} Copying **${i + 1}/${skills.length}** \u2014 \`${name}\``);
+        const dest = join(deps.cwd, ".horsecode", "skills", name);
+        try {
+          await mkdir(dirname(dest), { recursive: true });
+          await cp(dirname(s.path), dest, { recursive: true, dereference: true });
+          copied.push(name);
+          result.skills++;
+        } catch {
+        }
+      }
+      if (copied.length) {
+        const removable = [];
+        for (const s of skills) {
+          const name = s.label.split("/").pop();
+          if (!copied.includes(name)) continue;
+          const dir = dirname(s.path);
+          const paths = [dir];
+          try {
+            if ((await lstat(dir)).isSymbolicLink()) paths.push(resolve(dirname(dir), await readlink(dir)));
+          } catch {
+          }
+          removable.push({ name, paths });
+        }
+        const answer2 = await deps.ask(
+          `**${removable.length} skill(s)** are now in \`.horsecode/skills/\` AND still at their old path.
+
+Remove the originals? horse-code reads its own directory, so the old copies are twins that will drift \u2014 but OTHER tools in this project read them too.
+
+_Removed from: ${[...new Set(removable.flatMap((r) => r.paths.map((p) => dirname(p).replace(deps.cwd, "."))))].join(", ")}_`,
+          { options: [
+            { label: "No \u2014 keep them", description: "Nothing is deleted; the two copies can diverge" },
+            { label: "Yes \u2014 remove the originals", description: `${removable.length} directory(ies) deleted from their old location` }
+          ] }
+        );
+        if (YES.test(answer2.trim())) {
+          for (const [i, r] of removable.entries()) {
+            deps.progress?.("remove", `\u{1F9F9} Removing **${i + 1}/${removable.length}** \u2014 \`${r.name}\``);
+            for (const path of r.paths) {
+              try {
+                await rm(path, { recursive: true, force: true });
+                result.removed++;
+              } catch {
+              }
+            }
+          }
+          deps.note(`\u{1F9F9} Removed ${result.removed} original skill location(s). _Both skill trees are usually tracked by git \u2014 \`git checkout\` brings them back if this was wrong._`);
+        } else result.declined.push("removing the originals");
+      }
+      if (copied.length && deps.assignSkills) {
+        deps.note(`Working out which roles should carry ${copied.length} newly installed skill(s)\u2026`);
+        deps.busy?.("assigning skills", deps.models[0]);
+        try {
+          const assigned = await deps.assignSkills(copied);
+          deps.idle?.();
+          deps.note(assigned || "No role needed one of them permanently \u2014 every agent can still fetch them on demand.");
+        } catch (e) {
+          deps.idle?.();
+          deps.note(`Skill assignment did not run (${e instanceof Error ? e.message : String(e)}) \u2014 run \`/roles adjust\` to do it.`);
+        }
+      }
+    } else result.declined.push("skills");
+  }
+  const mcp = await mcpServers(findings);
+  if (mcp.length) {
+    deps.note(`**${mcp.length} MCP server(s)** are configured for the other tool: ${mcp.map((m) => `\`${m}\``).join(", ")}.
+
+_These are not imported automatically \u2014 add the ones you want under \`mcp\` in your config, and mark a read-only server \`"readOnly": true\` so every agent can use it._`);
+  }
+  const migratedRules = findings.filter((f) => f.kind === "rules" && !f.own && !f.label.startsWith("~/")).map((f) => f.label);
+  if (migratedRules.length) {
+    const already = (await loadMigrated(deps.cwd))?.files ?? [];
+    const unrecorded = migratedRules.filter((f) => !already.includes(f));
+    const stop = result.rules > 0 ? unrecorded.length > 0 : unrecorded.length > 0 && countKind(deps.memStore, "rule") > 0 && /^y/i.test(await deps.ask(
+      `${unrecorded.map((f) => `\`${f}\``).join(", ")} ${unrecorded.length === 1 ? "was" : "were"} left in place, and this project already has rules in memory \u2014 so ${unrecorded.length === 1 ? "it was" : "they were"} most likely migrated already. Stop reading ${unrecorded.length === 1 ? "it" : "them"} as this project's rules?`,
+      { options: [
+        { label: "Yes \u2014 the rules are in memory", description: "An agent that opens the file is told where the rules went" },
+        { label: "No \u2014 keep reading them", description: "The file stays a source of rules alongside memory" }
+      ] }
+    ));
+    if (stop) {
+      await recordMigrated(deps.cwd, unrecorded).catch(() => {
+      });
+      deps.note(`\u{1F512} ${unrecorded.map((f) => `\`${f}\``).join(", ")} ${unrecorded.length === 1 ? "is" : "are"} no longer read as rules \u2014 their content is in this project's memory, and an agent that opens one is told where the rules went.`);
+    }
+  }
+  return result;
+}
+async function mcpServers(findings) {
+  const names = /* @__PURE__ */ new Set();
+  for (const f of findings.filter((x) => x.kind === "mcp")) {
+    try {
+      const raw = f.text ?? await readFile(f.path, "utf8");
+      const parsed = JSON.parse(raw);
+      for (const key of Object.keys(parsed.mcpServers ?? parsed.servers ?? {})) names.add(key);
+    } catch {
+    }
+  }
+  return [...names];
+}
+function describeResult(r) {
+  const bits = [];
+  if (r.rules) bits.push(`**${r.rules} rule(s)** \u2014 now in every agent's instructions`);
+  if (r.facts) bits.push(`**${r.facts} fact(s)** \u2014 recalled when relevant`);
+  if (r.skills) {
+    bits.push(`**${r.skills} skill(s)** \u2014 copied to \`.horsecode/skills/\`` + (r.removed ? `, and ${r.removed} old location(s) removed` : ""));
+  }
+  const failed = r.failedBatches ? `
+
+\u26A0\uFE0F **${r.failedBatches} batch(es) failed to read** \u2014 the instructions and remembered facts in them were NOT imported. Re-run \`/migrate\` once that is cleared.` : "";
+  if (!bits.length) {
+    return `Nothing was imported.${r.declined.length ? ` You declined: ${r.declined.join(", ")}.` : ""}${failed}`;
+  }
+  const declined = r.declined.length ? `
+
+_Declined: ${r.declined.join(", ")} \u2014 re-run \`/migrate\` to revisit._` : "";
+  const left = r.skipped ? `
+
+${r.skipped} instruction(s) were left behind as tool-specific.` : "";
+  const head = r.failedBatches ? "**Migration finished with failures.**" : "**Migration complete.**";
+  return `${head}
+${bits.map((b) => `- ${b}`).join("\n")}${left}${declined}${failed}`;
+}
+export {
+  describeResult,
+  runMigration
+};

package/dist/{save-skills-ZW5GY6KV.js → save-skills-NPKTYNAF.js}

@@ -3,9 +3,9 @@ import {
   saveMcpServer,
   saveRoleSkills,
   saveSkillSource
-} from "./chunk-EAF22QIG.js";
-import "./chunk-G45RWL7S.js";
+} from "./chunk-JR2JLRE3.js";
 import "./chunk-H2FDGPVW.js";
+import "./chunk-G45RWL7S.js";
 export {
   removeSkillSource,
   saveMcpServer,

package/dist/{trace-X6TU3AG6.js → trace-UVMZZRA5.js}

@@ -29,7 +29,7 @@ import {
   traceRootRel,
   traceState,
   traceable
-} from "./chunk-KAGKX2YT.js";
+} from "./chunk-ZPJP2VH5.js";
 import "./chunk-6W4UH2BQ.js";
 export {
   GITIGNORE_MARKER,

package/dist/{trace-adopt-URECQWJV.js → trace-adopt-7HWELJFE.js}

@@ -2,7 +2,7 @@ import {
   hashContent,
   traceDir,
   traceRootRel
-} from "./chunk-KAGKX2YT.js";
+} from "./chunk-ZPJP2VH5.js";
 import "./chunk-6W4UH2BQ.js";
 
 // src/engine/trace-adopt.ts

package/dist/{trace-run-7U4WJZ3V.js → trace-run-OBOD552Q.js}

@@ -1,4 +1,5 @@
 import {
+  SpentSources,
   TRACE_CONCURRENCY,
   buildBrief,
   coverageFor,
@@ -6,13 +7,17 @@ import {
   planFor,
   runTraces,
   traceableFiles
-} from "./chunk-MRZVA5JB.js";
+} from "./chunk-ACTVFJRW.js";
+import "./chunk-MZM24M5M.js";
+import "./chunk-G45RWL7S.js";
 import "./chunk-LPQU436C.js";
-import "./chunk-6OSEQOYY.js";
-import "./chunk-KAGKX2YT.js";
-import "./chunk-XEGQT5EN.js";
+import "./chunk-6S4WWQMN.js";
+import "./chunk-JLWQCA7B.js";
+import "./chunk-ZPJP2VH5.js";
+import "./chunk-4M6LXNG2.js";
 import "./chunk-6W4UH2BQ.js";
 export {
+  SpentSources,
   TRACE_CONCURRENCY,
   buildBrief,
   coverageFor,

package/dist/{triage-FCYHD2AQ.js → triage-IFCVL5MA.js}

@@ -8,13 +8,14 @@ import {
   describeSizeDoubt,
   sizeRequest,
   triageFinding
-} from "./chunk-LNW557IO.js";
-import "./chunk-LLL7QWXB.js";
+} from "./chunk-372X5HHU.js";
+import "./chunk-BFIZMM4G.js";
+import "./chunk-CYLPQWIF.js";
 import "./chunk-63E73TGI.js";
-import "./chunk-AE36LLL2.js";
-import "./chunk-6OSEQOYY.js";
-import "./chunk-KAGKX2YT.js";
-import "./chunk-XEGQT5EN.js";
+import "./chunk-6S4WWQMN.js";
+import "./chunk-JLWQCA7B.js";
+import "./chunk-ZPJP2VH5.js";
+import "./chunk-4M6LXNG2.js";
 import "./chunk-6W4UH2BQ.js";
 export {
   RequestSizeSchema,

package/dist/{verify-LC57A6H2.js → verify-2DTBG6RG.js}

@@ -3,40 +3,44 @@ import {
   describeFix,
   dirtyPaths,
   runFix
-} from "./chunk-YPZP7LYL.js";
+} from "./chunk-UANNVVIU.js";
 import {
   respondIn
 } from "./chunk-M2RKCIGV.js";
+import {
+  askInUserLanguage,
+  inUserLanguage
+} from "./chunk-UTHLEW5V.js";
 import {
   buildAskUserTool,
+  editFileTool,
+  refreshAfterChange,
+  shellTool,
+  writeFileTool
+} from "./chunk-PIG54WFU.js";
+import {
   buildRememberTool,
-  buildSkillTool,
   constitutionNote,
   createWebFetchTool,
   deferMcp,
-  editFileTool,
   featureSlugFor,
   gitTool,
-  refreshAfterChange,
-  shellTool,
   specsDir,
-  verifyPaths,
-  writeFileTool
-} from "./chunk-UEWVVN5L.js";
-import {
-  askInUserLanguage,
-  inUserLanguage
-} from "./chunk-UGESK765.js";
+  verifyPaths
+} from "./chunk-NBTH2VVI.js";
 import "./chunk-ZSQ24YDJ.js";
+import "./chunk-ACTVFJRW.js";
+import {
+  buildSkillTool
+} from "./chunk-MZM24M5M.js";
 import "./chunk-G45RWL7S.js";
-import "./chunk-MRZVA5JB.js";
 import {
   defaultGitRunner
 } from "./chunk-LPQU436C.js";
 import {
   describeEscalation,
   triageFinding
-} from "./chunk-LNW557IO.js";
+} from "./chunk-372X5HHU.js";
 import {
   BATCH_TOOLS_NOTE,
   contextTools,
@@ -46,18 +50,20 @@ import {
   projectToolsNote,
   readFileTool,
   reinforceUsed
-} from "./chunk-LLL7QWXB.js";
+} from "./chunk-BFIZMM4G.js";
+import {
+  ToolRegistry
+} from "./chunk-CYLPQWIF.js";
 import "./chunk-63E73TGI.js";
+import "./chunk-6S4WWQMN.js";
 import {
-  ToolRegistry,
   handedOver,
   runToCompletion
-} from "./chunk-AE36LLL2.js";
-import "./chunk-6OSEQOYY.js";
-import "./chunk-KAGKX2YT.js";
+} from "./chunk-JLWQCA7B.js";
+import "./chunk-ZPJP2VH5.js";
 import {
   loadGraphSync
-} from "./chunk-XEGQT5EN.js";
+} from "./chunk-4M6LXNG2.js";
 import {
   sessionBase
 } from "./chunk-6W4UH2BQ.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hizliemre/horse-code",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Terminal coding agent: one sentence to reviewed, committed code — in its own git worktree",
   "license": "MIT",
   "author": "Emre Hızlı <hizliemre@gmail.com>",