@hizliemre/horse-code 0.3.0 → 0.3.1

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-CZWEZ4R6.js}

@@ -1,4 +1,5 @@
 import {
+  SpentSources,
   TRACE_CONCURRENCY,
   buildBrief,
   coverageFor,
@@ -6,13 +7,16 @@ import {
   planFor,
   runTraces,
   traceableFiles
-} from "./chunk-MRZVA5JB.js";
+} from "./chunk-YULQ4URQ.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-63E73TGI.js";
-import "./chunk-AE36LLL2.js";
-import "./chunk-6OSEQOYY.js";
-import "./chunk-KAGKX2YT.js";
-import "./chunk-XEGQT5EN.js";
+import "./chunk-CYLPQWIF.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-HWZBTK5X.js}

@@ -3,14 +3,13 @@ import {
   describeFix,
   dirtyPaths,
   runFix
-} from "./chunk-YPZP7LYL.js";
+} from "./chunk-3ACDNDCG.js";
 import {
   respondIn
 } from "./chunk-M2RKCIGV.js";
 import {
   buildAskUserTool,
   buildRememberTool,
-  buildSkillTool,
   constitutionNote,
   createWebFetchTool,
   deferMcp,
@@ -22,21 +21,23 @@ import {
   specsDir,
   verifyPaths,
   writeFileTool
-} from "./chunk-UEWVVN5L.js";
+} from "./chunk-27F44PBD.js";
 import {
   askInUserLanguage,
   inUserLanguage
-} from "./chunk-UGESK765.js";
+} from "./chunk-UTHLEW5V.js";
 import "./chunk-ZSQ24YDJ.js";
+import {
+  buildSkillTool
+} from "./chunk-YULQ4URQ.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 +47,20 @@ import {
   projectToolsNote,
   readFileTool,
   reinforceUsed
-} from "./chunk-LLL7QWXB.js";
+} from "./chunk-BFIZMM4G.js";
 import "./chunk-63E73TGI.js";
 import {
-  ToolRegistry,
+  ToolRegistry
+} from "./chunk-CYLPQWIF.js";
+import "./chunk-6S4WWQMN.js";
+import {
   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.3.1",
   "description": "Terminal coding agent: one sentence to reviewed, committed code — in its own git worktree",
   "license": "MIT",
   "author": "Emre Hızlı <hizliemre@gmail.com>",

package/dist/chunk-MRZVA5JB.js

@@ -1,163 +0,0 @@
-import {
-  defaultGitRunner
-} from "./chunk-LPQU436C.js";
-import {
-  briefForPrompt,
-  briefPrompt,
-  briefStatus,
-  gatherBriefInput,
-  saveBrief
-} from "./chunk-6OSEQOYY.js";
-import {
-  ensureGitignore,
-  loadTraceIndex,
-  planTraces,
-  pruneTraces,
-  saveTrace,
-  saveTraceIndex,
-  traceCoverage,
-  tracePrompt,
-  traceRootRel,
-  traceable
-} from "./chunk-KAGKX2YT.js";
-import {
-  loadGraph
-} from "./chunk-XEGQT5EN.js";
-
-// src/engine/trace-run.ts
-async function traceableFiles(cwd, opts) {
-  const r = await defaultGitRunner(["ls-files", "--cached", "--others", "--exclude-standard"], cwd);
-  return traceable(r.stdout.split("\n").filter(Boolean), opts);
-}
-async function coverageFor(cwd) {
-  return traceCoverage(cwd, await traceableFiles(cwd), await loadTraceIndex(cwd));
-}
-var TRACE_CONCURRENCY = 6;
-var INDEX_CHECKPOINT = 25;
-function describePlan(plan, model) {
-  if (!plan.jobs.length) {
-    return plan.upToDate ? `All ${plan.upToDate} traces are current \u2014 nothing to write, nothing to spend.` : "No files to trace.";
-  }
-  const kIn = Math.round(plan.estimatedInputTokens / 1e3);
-  const kOut = Math.round(plan.estimatedOutputTokens / 1e3);
-  const skipped = plan.skipped.length ? `
-
-${plan.skipped.length} file(s) skipped as too large to trace economically (e.g. ${plan.skipped.slice(0, 3).map((s) => `\`${s.file}\``).join(", ")}${plan.skipped.length > 3 ? ", \u2026" : ""}).` : "";
-  const cached = plan.upToDate ? `
-${plan.upToDate} file(s) already have a current trace and will be left alone.` : "";
-  return `**Tracing ${plan.jobs.length} file(s)** with \`${model}\`.
-
-This is the part of understanding your project that costs tokens \u2014 the graph was free, this is not. Each file is read once and described in ~150 words.
-
-Rough cost: **~${kIn}k input + ~${kOut}k output tokens**.${cached}${skipped}`;
-}
-async function traceOne(provider, model, job, signal, brief) {
-  const req = {
-    model,
-    messages: [
-      { role: "system", content: "You write terse, factual reference notes about source files. You never speculate." },
-      { role: "user", content: tracePrompt(job, brief) }
-    ],
-    tools: []
-  };
-  let out = "";
-  for await (const ev of provider.chat(req, signal)) {
-    if (ev.type === "text-delta") out += ev.text;
-    else if (ev.type === "error") throw new Error(ev.message);
-  }
-  const body = out.replace(/<\/?think>/gi, "").trim();
-  if (!body) throw new Error("empty response");
-  return body;
-}
-async function runTraces(opts) {
-  const { cwd, plan } = opts;
-  const signal = opts.signal ?? new AbortController().signal;
-  const index = await loadTraceIndex(cwd);
-  const brief = briefForPrompt(cwd);
-  const failed = [];
-  let written = 0;
-  let done = 0;
-  const queue = [...plan.jobs];
-  const worker = async () => {
-    for (; ; ) {
-      const job = queue.shift();
-      if (!job || signal.aborted) return;
-      let wroteTo;
-      let words;
-      let error;
-      try {
-        const body = await traceOne(opts.provider, opts.model, job, signal, brief);
-        const rec = await saveTrace(cwd, job, body, opts.model);
-        index.traces[job.file] = rec;
-        wroteTo = `${traceRootRel()}/${job.file}.md`;
-        words = body.split(/\s+/).filter(Boolean).length;
-        written++;
-        if (written % INDEX_CHECKPOINT === 0) await saveTraceIndex(cwd, index);
-      } catch (e) {
-        if (signal.aborted) return;
-        error = e instanceof Error ? e.message : String(e);
-        failed.push({ file: job.file, error });
-      }
-      opts.onProgress?.({
-        done: ++done,
-        total: plan.jobs.length,
-        file: job.file,
-        ...wroteTo !== void 0 && { wroteTo },
-        ...words !== void 0 && { words },
-        ...error !== void 0 && { error }
-      });
-    }
-  };
-  await Promise.all(Array.from({ length: Math.min(TRACE_CONCURRENCY, queue.length) }, worker));
-  const pruned = opts.liveFiles ? await pruneTraces(cwd, opts.liveFiles, index) : [];
-  await saveTraceIndex(cwd, index);
-  const wroteGitignore = written > 0 && await ensureGitignore(cwd);
-  return { written, failed, pruned, upToDate: plan.upToDate, cancelled: signal.aborted, wroteGitignore };
-}
-async function planFor(cwd, files) {
-  return planTraces(cwd, files, await loadGraph(cwd), await loadTraceIndex(cwd));
-}
-async function buildBrief(opts) {
-  if (!opts.force) {
-    const st = await briefStatus(opts.cwd, opts.files);
-    if (st.built && !st.stale) {
-      return { ok: true, skipped: true, message: `Project brief is current (${st.sources.length} document(s)) \u2014 not rewritten.` };
-    }
-  }
-  const input = await gatherBriefInput(opts.cwd, opts.files);
-  if (!input) {
-    return { ok: false, message: "No documentation found (README, docs/, specs/) \u2014 traces will describe the code without product context." };
-  }
-  const signal = opts.signal ?? new AbortController().signal;
-  const req = {
-    model: opts.model,
-    messages: [
-      { role: "system", content: "You write factual project briefings from documentation. You never invent facts the documents do not state." },
-      { role: "user", content: briefPrompt(input) }
-    ],
-    tools: []
-  };
-  let out = "";
-  try {
-    for await (const ev of opts.provider.chat(req, signal)) {
-      if (ev.type === "text-delta") out += ev.text;
-      else if (ev.type === "error") throw new Error(ev.message);
-    }
-  } catch (e) {
-    return { ok: false, message: `Project brief failed (${e instanceof Error ? e.message : String(e)}) \u2014 tracing can still run without it.` };
-  }
-  const body = out.replace(/<\/?think>/gi, "").trim();
-  if (!body) return { ok: false, message: "The brief came back empty \u2014 tracing can still run without it." };
-  await saveBrief(opts.cwd, body, { hash: input.hash, sources: input.sources.map((s) => s.file), writtenAt: Date.now(), model: opts.model });
-  return { ok: true, message: `**Project brief** written from ${input.sources.length} document(s): ${input.sources.slice(0, 6).map((s) => `\`${s.file}\``).join(", ")}` };
-}
-
-export {
-  traceableFiles,
-  coverageFor,
-  TRACE_CONCURRENCY,
-  describePlan,
-  runTraces,
-  planFor,
-  buildBrief
-};

package/dist/{chunk-EAF22QIG.js → chunk-JR2JLRE3.js}

@@ -1,11 +1,11 @@
-import {
-  CLI_KINDS
-} from "./chunk-G45RWL7S.js";
 import {
   arrayField,
   objectField,
   patchConfig
 } from "./chunk-H2FDGPVW.js";
+import {
+  CLI_KINDS
+} from "./chunk-G45RWL7S.js";
 
 // src/config/config.ts
 import { z } from "zod";