@hizliemre/horse-code 0.1.0

package/dist/run-LQOZ5I7Z.js

@@ -0,0 +1,610 @@
+import {
+  loadMigrated,
+  recordMigrated
+} from "./chunk-2SVAHH5N.js";
+import "./chunk-SSDLHWSF.js";
+import "./chunk-B67BK5GQ.js";
+
+// src/migrate/run.ts
+import { cp, lstat, mkdir, readFile as readFile2, readlink, rm } from "fs/promises";
+import { dirname, join as join2, resolve } from "path";
+
+// src/migrate/discover.ts
+import { readFile, readdir, stat } from "fs/promises";
+import { join } from "path";
+var RULE_FILES = [
+  { file: "CLAUDE.md", tool: "Claude Code" },
+  { file: "CLAUDE.local.md", tool: "Claude Code" },
+  { file: "AGENTS.md", tool: "Codex / OpenAI" },
+  { file: "GEMINI.md", tool: "Gemini CLI" },
+  { file: ".cursorrules", tool: "Cursor" },
+  { file: ".windsurfrules", tool: "Windsurf" },
+  { file: ".clinerules", tool: "Cline" },
+  { file: ".continuerules", tool: "Continue" },
+  { file: ".aider.conf.yml", tool: "Aider" },
+  { file: "CONVENTIONS.md", tool: "Aider" },
+  { file: ".rules", tool: "Zed" },
+  { file: ".github/copilot-instructions.md", tool: "GitHub Copilot" },
+  /**
+   * Not a tool's files — the project's own product and design context, which several skills read as their
+   * source of truth. They come as a PAIR: the skill that consumes them prints "the project's PRODUCT.md (and
+   * DESIGN.md when present)", so taking one without the other imports half a brief.
+   *
+   * They are here because they are instruction material by any test that matters: a real project's DESIGN.md
+   * held 17 KB of binding conventions (tokens, type scale, spacing, what never to do) and its PRODUCT.md the
+   * register those conventions serve. Leaving them behind meant every agent rebuilt its taste from scratch
+   * while the answer sat in the repo root.
+   */
+  { file: "PRODUCT.md", tool: "project convention", own: true },
+  { file: "DESIGN.md", tool: "project convention", own: true }
+];
+var RULE_DIRS = [
+  { dir: ".cursor/rules", tool: "Cursor", ext: /\.mdc?$/ },
+  { dir: ".github/instructions", tool: "GitHub Copilot", ext: /\.md$/ }
+];
+var MAX_FINDING_BYTES = 6e4;
+function claudeProjectSlug(cwd) {
+  return cwd.replace(/\//g, "-");
+}
+async function read(path) {
+  try {
+    const s = await stat(path);
+    if (!s.isFile() || s.size === 0) return void 0;
+    if (s.size > MAX_FINDING_BYTES) return { bytes: s.size };
+    return { bytes: s.size, text: await readFile(path, "utf8") };
+  } catch {
+    return void 0;
+  }
+}
+async function listDir(dir) {
+  try {
+    return (await readdir(dir, { withFileTypes: true })).filter((e) => e.isFile()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+async function discover(opts) {
+  const { cwd, home } = opts;
+  const out = [];
+  const push = async (kind, tool, path, label, own = false) => {
+    const r = await read(path);
+    if (r) out.push({ kind, tool, path, label, bytes: r.bytes, ...own ? { own } : {}, ...r.text ? { text: r.text } : {} });
+  };
+  for (const { file, tool, own } of RULE_FILES) await push("rules", tool, join(cwd, file), file, own);
+  await push("rules", "Claude Code (user-level)", join(home, ".claude", "CLAUDE.md"), "~/.claude/CLAUDE.md");
+  await push("rules", "Codex (user-level)", join(home, ".codex", "AGENTS.md"), "~/.codex/AGENTS.md");
+  for (const { dir, tool, ext } of RULE_DIRS) {
+    for (const name of await listDir(join(cwd, dir))) {
+      if (ext.test(name)) await push("rules", tool, join(cwd, dir, name), `${dir}/${name}`);
+    }
+  }
+  const memDir = join(home, ".claude", "projects", claudeProjectSlug(cwd), "memory");
+  for (const name of await listDir(memDir)) {
+    if (!name.endsWith(".md") || name === "MEMORY.md") continue;
+    await push("memory", "Claude Code", join(memDir, name), `memory/${name}`);
+  }
+  const seenSkills = /* @__PURE__ */ new Set();
+  for (const [rel, tool] of [[".claude/skills", "Claude Code"], [".agents/skills", "agent skills"]]) {
+    const skillsDir = join(cwd, rel);
+    let entries;
+    try {
+      entries = await readdir(skillsDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      if (seenSkills.has(e.name)) continue;
+      if (!e.isDirectory()) {
+        if (!e.isSymbolicLink()) continue;
+        try {
+          if (!(await stat(join(skillsDir, e.name))).isDirectory()) continue;
+        } catch {
+          continue;
+        }
+      }
+      const before = out.length;
+      await push("skill", tool, join(skillsDir, e.name, "SKILL.md"), `${rel}/${e.name}`);
+      if (out.length > before) seenSkills.add(e.name);
+    }
+  }
+  for (const [file, tool] of [[".mcp.json", "Claude Code"], [".cursor/mcp.json", "Cursor"], [".vscode/mcp.json", "VS Code"]]) {
+    await push("mcp", tool, join(cwd, file), file);
+  }
+  for (const settings of [".claude/settings.json", ".claude/settings.local.json"]) {
+    await push("mcp", "Claude Code", join(cwd, settings), settings);
+  }
+  for (const [dir, kind] of [[".claude/agents", "agent"], [".claude/commands", "command"]]) {
+    for (const name of await listDir(join(cwd, dir))) {
+      if (name.endsWith(".md")) await push(kind, "Claude Code", join(cwd, dir, name), `${dir}/${name}`);
+    }
+  }
+  return out;
+}
+function summarize(findings) {
+  if (!findings.length) return "No configuration from another coding tool was found in this project.";
+  const byKind = /* @__PURE__ */ new Map();
+  for (const f of findings) {
+    const list = byKind.get(f.kind);
+    if (list) list.push(f);
+    else byKind.set(f.kind, [f]);
+  }
+  const LABEL = {
+    rules: "Instruction files",
+    memory: "Remembered facts",
+    skill: "Skills",
+    mcp: "MCP / settings",
+    agent: "Subagents",
+    command: "Slash commands"
+  };
+  const rows = [];
+  for (const kind of ["rules", "memory", "skill", "mcp", "agent", "command"]) {
+    const list = byKind.get(kind);
+    if (!list?.length) continue;
+    const tools = [...new Set(list.map((f) => f.tool))].join(", ");
+    const files = list.slice(0, 4).map((f) => `\`${f.label}\``).join(", ");
+    const more = list.length > 4 ? ` +${list.length - 4} more` : "";
+    rows.push(`- **${LABEL[kind]}** (${list.length}, from ${tools}): ${files}${more}`);
+  }
+  return rows.join("\n");
+}
+function hasAnything(findings) {
+  return findings.some((f) => f.kind === "rules" || f.kind === "memory" || f.kind === "skill" || f.kind === "mcp");
+}
+
+// src/migrate/extract.ts
+var BATCH = 20;
+var SYSTEM = "You migrate instructions from one coding assistant to another. You are precise about what does and does not transfer, and you never invent an instruction that was not there.";
+var CLASSIFY = (body) => `Below is instruction material from a project that was developed with another coding assistant. It is being moved into a different assistant, which has its OWN tools, commands and agent model.
+
+Classify every distinct instruction into exactly one of:
+
+**rule** \u2014 a standing directive that must be obeyed on EVERY task, forever. Before choosing this, apply the test: would this still need saying on a task that has nothing to do with the section it came from? Language requirements, commit conventions, things never to do, security mandates pass that test. Process detail does NOT: "in phase 3 the implementer does X", "the plan document contains these sections", "run this before that" describe a procedure, and a procedure belongs in the knowledge that is recalled when relevant, not in the instructions of every agent on every task.
+A rule is inlined into every prompt permanently, so a long list of them is itself a defect: expect only a handful from any document, and classify the rest as fact.
+**fact** \u2014 durable knowledge about this project or user, INCLUDING its processes and conventions: stack, architecture decisions, workflow phases, service names, preferences. Recalled when relevant. This is the right home for most of what looks instructional.
+**skip** \u2014 two kinds of thing.
+  (a) Anything that only means something in the original tool: named tools, slash commands, subagent types, file paths of that tool's own config, its plugin or hook system. Also anything stale, empty, or purely descriptive of the document itself.
+  (b) ORCHESTRATION \u2014 how work is sequenced and gated. The receiving assistant runs its own fixed pipeline (brainstorm \u2192 specification \u2192 clarification \u2192 plan \u2192 task breakdown \u2192 parallel implementation waves \u2192 multi-lens review \u2192 council \u2192 judge \u2192 acceptance gate), and it cannot be reconfigured by an imported instruction. So numbered phases ("Phase 0 \u2026 Phase 7"), what happens in which phase, phase entry/exit gates, when to branch or open a worktree, when review runs, who approves what, and the order of any of it are SUPERSEDED \u2014 not merely irrelevant. Importing them would leave agents following two different workflows at once. Skip them even when they are stated as mandatory, and even as a fact: a remembered description of a competing workflow is still a competing workflow.
+  What a phase PRODUCES can still be a rule if it stands alone: "every requirement must be testable" survives without the phase it was written in; "in Phase 1 the analyst writes the spec" does not.
+
+Rules for your output:
+- REWRITE each kept item so it stands alone, in English, without referring to the original tool. If it cannot survive that rewrite, it is a skip.
+- Do NOT merge distinct instructions, and do NOT invent any that are not present.
+- For every skip, say in one short phrase WHAT made it tool-specific \u2014 the user decides whether to disagree, and cannot do that without the reason.
+- Prefer skip when unsure. A wrong rule is applied to every task forever; a missed one can be added later.
+
+Answer with a fenced json block:
+{"items":[{"text":"...","disposition":"rule|fact|skip","reason":"..."}]}
+
+Material:
+
+${body}`;
+function parseItems(text) {
+  const fence = /```(?:json)?\s*([\s\S]*?)```/.exec(text);
+  const raw = fence ? fence[1] : text.slice(text.indexOf("{"));
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed.items)) return void 0;
+    return parsed.items.filter((i) => typeof i === "object" && i !== null && typeof i.text === "string" && typeof i.disposition === "string");
+  } catch {
+    return void 0;
+  }
+}
+async function ask(provider, model, prompt, signal) {
+  const req = {
+    model,
+    messages: [{ role: "system", content: SYSTEM }, { role: "user", content: prompt }],
+    tools: []
+  };
+  let out = "";
+  for await (const ev of provider.chat(req, signal ?? new AbortController().signal)) {
+    if (ev.type === "text-delta") out += ev.text;
+    else if (ev.type === "error") throw new Error(ev.message);
+  }
+  return out;
+}
+async function askChain(provider, models, dead, prompt, signal) {
+  const usable = models.filter((m) => m && !dead.has(m));
+  const chain = usable.length ? usable : models.filter(Boolean);
+  if (!chain.length) throw new Error("no model is configured for the migration");
+  let last;
+  for (const m of chain) {
+    try {
+      return await ask(provider, m, prompt, signal);
+    } catch (e) {
+      last = e;
+      dead.add(m);
+    }
+  }
+  throw last instanceof Error ? last : new Error(String(last));
+}
+var DISPOSITIONS = /* @__PURE__ */ new Set(["rule", "fact", "skip"]);
+async function classify(opts) {
+  const text = await askChain(opts.provider, opts.models, opts.dead ?? /* @__PURE__ */ new Set(), CLASSIFY(opts.body), opts.signal);
+  const items = parseItems(text);
+  if (!items) throw new Error("the classification could not be read");
+  return items.filter((i) => i.text.trim()).map((i) => ({
+    text: i.text.trim(),
+    disposition: DISPOSITIONS.has(i.disposition) ? i.disposition : "skip",
+    reason: (i.reason ?? "").trim() || "no reason given",
+    source: opts.source
+  }));
+}
+var MAX_CHUNK_CHARS = 8e3;
+function chunkProse(text, max = MAX_CHUNK_CHARS) {
+  const parts = text.split(/\n(?=#{1,3} )/);
+  const out = [];
+  let buf = "";
+  for (const part of parts) {
+    if (part.length >= max) {
+      if (buf.trim()) {
+        out.push(buf);
+        buf = "";
+      }
+      out.push(part.slice(0, max * 2));
+      continue;
+    }
+    if (buf.length + part.length > max) {
+      out.push(buf);
+      buf = part;
+    } else buf += (buf ? "\n" : "") + part;
+  }
+  if (buf.trim()) out.push(buf);
+  return out.filter((c) => c.trim());
+}
+function batches(findings, size = BATCH) {
+  const out = [];
+  for (const f of findings.filter((x) => x.kind === "rules" && x.text)) {
+    const chunks = chunkProse(f.text);
+    chunks.forEach((body, i) => out.push({
+      body: `### ${f.label}${chunks.length > 1 ? ` (part ${i + 1}/${chunks.length})` : ""}
+${body}`,
+      source: f.label
+    }));
+  }
+  const mem = findings.filter((x) => x.kind === "memory" && x.text);
+  for (let i = 0; i < mem.length; i += size) {
+    const chunk = mem.slice(i, i + size);
+    out.push({
+      body: chunk.map((f) => `### ${f.label}
+${f.text}`).join("\n\n"),
+      source: `${chunk.length} remembered facts`
+    });
+  }
+  return out;
+}
+async function extractAll(opts) {
+  const jobs = batches(opts.findings);
+  const dead = /* @__PURE__ */ new Set();
+  const candidates = [];
+  const failed = [];
+  let done = 0;
+  const queue = [...jobs];
+  const worker = async () => {
+    for (; ; ) {
+      const job = queue.shift();
+      if (!job || opts.signal?.aborted) return;
+      try {
+        candidates.push(...await classify({ ...opts, dead, body: job.body, source: job.source }));
+      } catch (e) {
+        failed.push({ source: job.source, error: e instanceof Error ? e.message : String(e) });
+      }
+      opts.onProgress?.(++done, jobs.length, job.source);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(opts.concurrency ?? 5, queue.length) }, worker));
+  return { candidates, failed };
+}
+function groupForReview(e) {
+  return {
+    rules: e.candidates.filter((c) => c.disposition === "rule"),
+    facts: e.candidates.filter((c) => c.disposition === "fact"),
+    skipped: e.candidates.filter((c) => c.disposition === "skip")
+  };
+}
+var MAX_RULES = 25;
+var CONSOLIDATE = (items, max) => `Below are ${items.length} candidate standing rules extracted from one project's instruction documents. They overlap heavily and many are procedure rather than principle.
+
+Produce AT MOST ${max} rules. Each one is inlined into every agent's instructions on every task, forever, so the list is a permanent cost and must earn its size.
+
+How to decide:
+- MERGE candidates that say the same thing differently into one rule that covers both. Losing a distinction that matters is worse than a slightly longer rule.
+- KEEP what would still need saying on a task unrelated to where it came from: language requirements, commit and branch conventions, security mandates, review standards, things never to do.
+- DEMOTE domain and project detail that is real knowledge but does not belong in every prompt \u2014 say which ones, and they are kept as facts rather than discarded.
+- DROP anything describing HOW WORK IS SEQUENCED: numbered phases, phase gates, what runs before what, when review or branching happens. The receiving assistant has its own fixed pipeline and cannot adopt another one, so keeping such an item \u2014 even as a fact \u2014 leaves agents holding two workflows. List these under "dropped".
+- Do NOT invent a rule that is not in the list, and do not weaken one into a vague slogan.
+
+Answer with a fenced json block:
+{"rules":["<the consolidated rule>", \u2026],"demoted":["<the exact original text>", \u2026],"dropped":["<the exact original text>", \u2026]}
+
+Candidates:
+${items.map((t, i) => `${i + 1}. ${t}`).join("\n")}`;
+async function consolidateRules(opts) {
+  const max = opts.max ?? MAX_RULES;
+  if (opts.candidates.length <= max) return { rules: opts.candidates, demoted: [], dropped: [] };
+  const texts = opts.candidates.map((c) => c.text);
+  try {
+    const out = await askChain(opts.provider, opts.models, /* @__PURE__ */ new Set(), CONSOLIDATE(texts, max), opts.signal);
+    const fence = /```(?:json)?\s*([\s\S]*?)```/.exec(out);
+    const parsed = JSON.parse(fence ? fence[1] : out.slice(out.indexOf("{")));
+    const rules = Array.isArray(parsed.rules) ? parsed.rules.filter((r) => typeof r === "string") : [];
+    if (!rules.length) throw new Error("no rules came back");
+    const named = (key) => new Set(
+      Array.isArray(parsed[key]) ? parsed[key].filter((d) => typeof d === "string") : []
+    );
+    const demotedText = named("demoted");
+    const droppedText = named("dropped");
+    return {
+      // The consolidated text is new, so the source is the whole set rather than any one file.
+      rules: rules.slice(0, max).map((text) => ({
+        text,
+        disposition: "rule",
+        reason: "consolidated",
+        source: "migration"
+      })),
+      // Anything the model named as demoted is kept as a fact; anything it simply did not mention was
+      // merged into a surviving rule and is already represented.
+      demoted: opts.candidates.filter((c) => demotedText.has(c.text) && !droppedText.has(c.text)).map((c) => ({ ...c, disposition: "fact", reason: "project detail, kept as knowledge" })),
+      dropped: opts.candidates.filter((c) => droppedText.has(c.text)).map((c) => ({ ...c, disposition: "skip", reason: "describes a workflow this pipeline replaces" }))
+    };
+  } catch {
+    return { rules: opts.candidates, demoted: [], dropped: [] };
+  }
+}
+
+// src/migrate/run.ts
+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 });
+  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 = join2(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 readFile2(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-OHYGVTQ4.js

@@ -0,0 +1,13 @@
+import {
+  removeSkillSource,
+  saveMcpServer,
+  saveRoleSkills,
+  saveSkillSource
+} from "./chunk-DKVIN43T.js";
+import "./chunk-H2FDGPVW.js";
+export {
+  removeSkillSource,
+  saveMcpServer,
+  saveRoleSkills,
+  saveSkillSource
+};

package/dist/source-cache-XEK5WN7I.js

@@ -0,0 +1,29 @@
+// src/session/source-cache.ts
+import { readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { createHash } from "crypto";
+var cachePath = (home) => join(home, ".horsecode", "sources.json");
+var keyFor = (baseUrl) => createHash("sha256").update(baseUrl).digest("hex").slice(0, 12);
+function loadSourceCache(home, baseUrl) {
+  try {
+    const data = JSON.parse(readFileSync(cachePath(home), "utf8"));
+    return data[keyFor(baseUrl)]?.sources;
+  } catch {
+    return void 0;
+  }
+}
+function saveSourceCache(home, baseUrl, sources, now = Date.now()) {
+  const path = cachePath(home);
+  let data = {};
+  try {
+    data = JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+  }
+  data[keyFor(baseUrl)] = { sources, at: now };
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(data), "utf8");
+}
+export {
+  loadSourceCache,
+  saveSourceCache
+};