@hizliemre/horse-code 0.1.0

package/dist/cli.js

@@ -0,0 +1,1495 @@
+#!/usr/bin/env node
+import {
+  MAX_PARALLEL_TASKS,
+  MemoryStore,
+  OmniRouteProvider,
+  Timings,
+  autonomousAskHuman,
+  defaultCmdRunner,
+  detectPlatform,
+  makeApprove,
+  makeAskUser,
+  makePRAdapter,
+  nodeLineReader,
+  restoreTerminal,
+  runJob,
+  sttySane
+} from "./chunk-2DGO2BUB.js";
+import {
+  listOmniRouteModels
+} from "./chunk-O74BDQKS.js";
+import "./chunk-F2IALVBU.js";
+import {
+  CODE_TEAM,
+  DEFAULT_COUNCIL,
+  DEFAULT_PROMPTS,
+  DEFAULT_ROLE_SKILLS,
+  PLAN_TEAM,
+  REQUIRED_ROLES,
+  RoleFitness,
+  RoleRegistry,
+  SPEC_TEAM,
+  WorktreeManager,
+  buildCouncilRegistry,
+  buildTeamRegistry,
+  mainWorktreeRoot,
+  toSlug
+} from "./chunk-3XVZXTB6.js";
+import "./chunk-QF4MP6BS.js";
+import "./chunk-HBSC2HT2.js";
+import "./chunk-FGVJFMK5.js";
+import {
+  parseFrontmatter
+} from "./chunk-BY4DP7IE.js";
+import {
+  saveSkillSource
+} from "./chunk-DKVIN43T.js";
+import "./chunk-H2FDGPVW.js";
+import {
+  buildBrief,
+  describePlan,
+  planFor,
+  runTraces,
+  traceableFiles
+} from "./chunk-NNTIACT4.js";
+import {
+  defaultGitRunner
+} from "./chunk-IW2KBAVZ.js";
+import {
+  InjectionLog,
+  memoryNote
+} from "./chunk-TOPZL5SU.js";
+import "./chunk-2SVAHH5N.js";
+import {
+  Telemetry,
+  clearPerfMarks,
+  sampleMemory,
+  setTelemetry,
+  stripThinking,
+  telemetry,
+  writeHeapSnapshot
+} from "./chunk-YILDXPSI.js";
+import {
+  briefStatus
+} from "./chunk-DTWKSZXY.js";
+import {
+  discoverTraceRoot,
+  setTraceRoot
+} from "./chunk-FFYBY2NA.js";
+import {
+  buildProjectGraph,
+  graphStatus,
+  graphifyPython
+} from "./chunk-PGOYDOI4.js";
+import {
+  sessionBase
+} from "./chunk-SSDLHWSF.js";
+import "./chunk-B67BK5GQ.js";
+
+// src/cli.ts
+import { execFileSync } from "child_process";
+import { readFileSync as readFileSync3, existsSync as existsSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, realpathSync } from "fs";
+import { join as join8, dirname as dirname4 } from "path";
+import { pathToFileURL } from "url";
+
+// src/config/config.ts
+import { z } from "zod";
+var UNSET_MODEL = "default";
+var DEFAULT_CONFIG = {
+  baseUrl: "http://localhost:20128",
+  model: UNSET_MODEL,
+  // acceptEdits: auto-approve file writes/edits (the pipeline builds in an isolated worktree → reviewed as a
+  // PR), still prompt for shell/exec. Keeps the automated build flowing without an approval per file.
+  mode: "acceptEdits",
+  allowlist: [],
+  roles: {},
+  specKit: { version: "v0.13.2" },
+  mcp: {},
+  modelSources: [],
+  traceDir: "",
+  skillSources: [],
+  maxParallel: 8,
+  telemetry: true
+};
+var reviewerSchema = z.object({ name: z.string(), perspective: z.string(), models: z.array(z.string()) });
+var fileSchema = z.object({
+  apiKey: z.string().optional(),
+  baseUrl: z.string().optional(),
+  model: z.string().optional(),
+  mode: z.enum(["ask", "acceptEdits", "auto"]).optional(),
+  allowlist: z.array(z.string()).optional(),
+  roles: z.record(
+    z.string(),
+    z.object({
+      models: z.array(z.string()),
+      systemPrompt: z.string().optional(),
+      skills: z.array(z.string()).optional(),
+      // Anthropic models only — see RoleConfig.effort. Unknown keys are stripped, so without this line a
+      // level written into the config would be silently discarded on the way in.
+      effort: z.enum(["low", "medium", "high", "xhigh", "max"]).optional()
+    })
+  ).optional(),
+  // The review team's finder lenses, one set per stage (any omitted set falls back to the built-in default).
+  team: z.object({
+    spec: z.array(reviewerSchema).optional(),
+    plan: z.array(reviewerSchema).optional(),
+    code: z.array(reviewerSchema).optional()
+  }).optional(),
+  council: z.object({ members: z.array(reviewerSchema) }).optional(),
+  specKit: z.object({ version: z.string() }).optional(),
+  modelSources: z.array(z.string()).optional(),
+  traceDir: z.string().optional(),
+  // where /graph trace writes; empty = .horsecode/traces
+  mainBranch: z.string().optional(),
+  // the branch a resumed session syncs from; asked once, then remembered
+  // Bounded: below 1 nothing runs; above 32 the git merge lock, not the models, becomes the limit.
+  maxParallel: z.number().int().min(1).max(32).optional(),
+  telemetry: z.boolean().optional(),
+  skillSources: z.array(z.object({
+    name: z.string(),
+    repo: z.string(),
+    path: z.string().optional(),
+    ref: z.string().optional()
+  })).optional(),
+  mcp: z.record(
+    z.string(),
+    z.union([
+      z.object({ command: z.array(z.string()).min(1), env: z.record(z.string(), z.string()).optional(), readOnly: z.boolean().optional() }),
+      z.object({ url: z.string(), headers: z.record(z.string(), z.string()).optional(), readOnly: z.boolean().optional() })
+    ])
+  ).optional()
+}).partial();
+function parseFile(raw) {
+  if (!raw) return {};
+  try {
+    const parsed = fileSchema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : {};
+  } catch {
+    return {};
+  }
+}
+function loadConfig(opts) {
+  const global = parseFile(opts.readFile(`${opts.home}/.horsecode/config.json`));
+  const project = parseFile(opts.readFile(`${opts.cwd}/.horsecode/config.json`));
+  const { apiKey: _leak, ...projectSafe } = project;
+  const merged = {
+    ...DEFAULT_CONFIG,
+    ...global,
+    ...projectSafe
+  };
+  merged.allowlist = projectSafe.allowlist ?? global.allowlist ?? [];
+  merged.roles = { ...global.roles ?? {}, ...projectSafe.roles ?? {} };
+  merged.mcp = { ...global.mcp ?? {}, ...projectSafe.mcp ?? {} };
+  merged.modelSources = projectSafe.modelSources ?? global.modelSources ?? [];
+  merged.maxParallel = projectSafe.maxParallel ?? global.maxParallel ?? DEFAULT_CONFIG.maxParallel;
+  merged.telemetry = projectSafe.telemetry ?? global.telemetry ?? DEFAULT_CONFIG.telemetry;
+  const byName = new Map((global.skillSources ?? []).map((s) => [s.name, s]));
+  for (const s of projectSafe.skillSources ?? []) byName.set(s.name, s);
+  merged.skillSources = [...byName.values()];
+  merged.specKit = projectSafe.specKit ?? global.specKit ?? DEFAULT_CONFIG.specKit;
+  const team = {
+    spec: projectSafe.team?.spec ?? global.team?.spec,
+    plan: projectSafe.team?.plan ?? global.team?.plan,
+    code: projectSafe.team?.code ?? global.team?.code
+  };
+  merged.team = team.spec || team.plan || team.code ? team : void 0;
+  const councilMembers = projectSafe.council?.members ?? global.council?.members;
+  merged.council = councilMembers ? { members: councilMembers } : void 0;
+  if (opts.env.OMNIROUTE_API_KEY) merged.apiKey = opts.env.OMNIROUTE_API_KEY;
+  if (opts.env.OMNIROUTE_BASE_URL) merged.baseUrl = opts.env.OMNIROUTE_BASE_URL;
+  return merged;
+}
+
+// src/skills/registry.ts
+import { readdir, readFile } from "fs/promises";
+import { join } from "path";
+var SkillRegistry = class {
+  skills = /* @__PURE__ */ new Map();
+  register(skill) {
+    this.skills.set(skill.name, skill);
+  }
+  get(name) {
+    return this.skills.get(name);
+  }
+  list() {
+    return [...this.skills.values()].map((s) => ({ name: s.name, description: s.description }));
+  }
+  async loadFromDir(dir) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (!e.isDirectory()) continue;
+      let raw;
+      try {
+        raw = await readFile(join(dir, e.name, "SKILL.md"), "utf8");
+      } catch {
+        continue;
+      }
+      const { name, description, body } = parseFrontmatter(raw);
+      if (!name || !description) {
+        throw new Error(`skill ${e.name}: missing frontmatter (name/description)`);
+      }
+      this.register({ name, description, content: body, dir: join(dir, e.name) });
+    }
+  }
+};
+
+// src/skills/builtin.ts
+import { readdir as readdir2, readFile as readFile2 } from "fs/promises";
+import { dirname, join as join2, resolve } from "path";
+import { fileURLToPath } from "url";
+function candidates() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  return [
+    resolve(here, "..", "skills"),
+    // bundled: dist/… → <repo>/skills
+    resolve(here, "..", "..", "skills"),
+    // source: src/skills/… → <repo>/skills
+    resolve(here, "..", "..", "..", "skills")
+  ];
+}
+async function registerBuiltinSkills(registry, dirs = candidates()) {
+  for (const dir of dirs) {
+    try {
+      const entries = await readdir2(dir, { withFileTypes: true });
+      const found = [];
+      for (const e of entries) {
+        if (!e.isDirectory()) continue;
+        let raw;
+        try {
+          raw = await readFile2(join2(dir, e.name, "SKILL.md"), "utf8");
+        } catch {
+          continue;
+        }
+        const { parseFrontmatter: parseFrontmatter2 } = await import("./frontmatter-UNIPNLLO.js");
+        const { name, description, body } = parseFrontmatter2(raw);
+        if (!name || !description) continue;
+        found.push({ name, description, content: body, dir: join2(dir, e.name) });
+      }
+      if (!found.length) continue;
+      for (const s of found) registry.register(s);
+      return found.length;
+    } catch {
+      continue;
+    }
+  }
+  return 0;
+}
+
+// src/skills/external.ts
+import { mkdir, rm, readFile as readFile3, writeFile, readdir as readdir3, cp } from "fs/promises";
+import { existsSync } from "fs";
+import { join as join3 } from "path";
+import { spawn } from "child_process";
+import { tmpdir } from "os";
+var PROVENANCE = ".horsecode-source.json";
+function externalSkillsDir(home) {
+  return join3(home, ".horsecode", "skills");
+}
+function validName(name) {
+  return /^[A-Za-z0-9._-]+$/.test(name) && !name.includes("..");
+}
+function validRepo(repo) {
+  return /^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/.test(repo);
+}
+function parseSkillUrl(url) {
+  const m = url.trim().replace(/\/+$/, "").match(/^(?:https?:\/\/)?(?:www\.)?github\.com\/([^/]+)\/([^/]+)(?:\/(?:tree|blob)\/([^/]+)(?:\/(.*))?)?$/i);
+  if (!m) return void 0;
+  const [, owner, repoName, ref, rawPath] = m;
+  const repo = `${owner}/${repoName.replace(/\.git$/, "")}`;
+  const path = (rawPath ?? "").replace(/\/?SKILL\.md$/i, "");
+  const name = path ? path.split("/").filter(Boolean).pop() : repoName.replace(/\.git$/, "");
+  return {
+    name,
+    repo,
+    ...path ? { path } : {},
+    // A branch name in a tree URL is where the user was browsing, not necessarily a pin they want. Only keep
+    // it when it is not the obvious default, so "update" keeps following the branch.
+    ...ref && ref !== "main" && ref !== "master" && ref !== "HEAD" ? { ref } : {}
+  };
+}
+function run(cmd, args, cwd) {
+  return new Promise((resolve2) => {
+    const child = spawn(cmd, args, { ...cwd ? { cwd } : {}, stdio: ["ignore", "ignore", "pipe"] });
+    let err = "";
+    child.stderr?.on("data", (d) => err += d.toString());
+    child.on("error", (e) => resolve2({ code: 1, err: e.message }));
+    child.on("close", (code) => resolve2({ code: code ?? 1, err }));
+  });
+}
+async function resolveSha(src, deps) {
+  const f = deps.fetch ?? globalThis.fetch;
+  const ref = src.ref ?? "HEAD";
+  const res = await f(`https://api.github.com/repos/${src.repo}/commits/${ref}`, {
+    headers: { Accept: "application/vnd.github.sha" }
+  });
+  if (!res.ok) throw new Error(`cannot resolve ${src.repo}@${ref} (HTTP ${res.status})`);
+  return (await res.text()).trim();
+}
+async function installedSource(home, name) {
+  try {
+    return JSON.parse(await readFile3(join3(externalSkillsDir(home), name, PROVENANCE), "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+async function installSkillSource(home, src, deps = {}) {
+  if (!validName(src.name)) throw new Error(`skill source name is not a valid directory name: ${src.name}`);
+  if (!validRepo(src.repo)) throw new Error(`skill source repo must be "owner/repo": ${src.repo}`);
+  if (src.path?.includes("..")) throw new Error(`skill source path may not contain "..": ${src.path}`);
+  const sha = await resolveSha(src, deps);
+  const dest = join3(externalSkillsDir(home), src.name);
+  const current = await installedSource(home, src.name);
+  if (current?.sha === sha && existsSync(join3(dest, "SKILL.md"))) {
+    return { name: src.name, sha, changed: false };
+  }
+  const staging = join3(tmpdir(), `hc-skill-${src.name}-${sha.slice(0, 8)}`);
+  await rm(staging, { recursive: true, force: true });
+  await mkdir(staging, { recursive: true });
+  try {
+    const url = `https://codeload.github.com/${src.repo}/tar.gz/${sha}`;
+    const dl = await run("sh", ["-c", `curl -fsSL --max-time 120 ${JSON.stringify(url)} | tar xz -C ${JSON.stringify(staging)} --strip-components=1`]);
+    if (dl.code !== 0) throw new Error(`download failed for ${src.repo}@${sha.slice(0, 8)}: ${dl.err.trim().slice(0, 200)}`);
+    const from = src.path ? join3(staging, src.path) : staging;
+    if (!existsSync(join3(from, "SKILL.md"))) {
+      throw new Error(`${src.repo}${src.path ? `/${src.path}` : ""} has no SKILL.md`);
+    }
+    await rm(dest, { recursive: true, force: true });
+    await mkdir(dest, { recursive: true });
+    await cp(from, dest, { recursive: true });
+    const record = { ...src, sha, installedAt: (deps.now ?? Date.now)() };
+    await writeFile(join3(dest, PROVENANCE), `${JSON.stringify(record, null, 2)}
+`, "utf8");
+    return { name: src.name, sha, changed: true };
+  } finally {
+    await rm(staging, { recursive: true, force: true });
+  }
+}
+async function syncSkillSources(home, sources, deps = {}) {
+  const ok = [];
+  const failed = [];
+  for (const src of sources) {
+    try {
+      ok.push(await installSkillSource(home, src, deps));
+    } catch (e) {
+      failed.push({ name: src.name, error: e instanceof Error ? e.message : String(e) });
+    }
+  }
+  return { ok, failed };
+}
+
+// src/permission/rules.ts
+import picomatch from "picomatch";
+var DANGEROUS_PATTERNS = [
+  /\brm\s+(-[a-z]*r[a-z]*f|-[a-z]*f[a-z]*r)\b.*\s\/(\*|\s|$)/,
+  // rm -rf / or /*
+  /\brm\s+-rf\s+\/(\*|$)/,
+  /:\(\)\s*\{.*\|.*&.*\}\s*;/,
+  // fork bomb :(){ :|:& };:
+  /\bmkfs\b/,
+  /\bdd\s+.*of=\/dev\/(sd|hd|nvme)/,
+  /\b(sudo\s+)?chmod\s+-R\s+000\s+\//,
+  /\s>\s*\/dev\/sd[a-z]/
+];
+function isDangerous(command) {
+  return DANGEROUS_PATTERNS.some((re) => re.test(command));
+}
+var READ_ONLY_BINS = /* @__PURE__ */ new Set([
+  "pwd",
+  "ls",
+  "cat",
+  "head",
+  "tail",
+  "wc",
+  "file",
+  "stat",
+  "du",
+  "df",
+  "tree",
+  "find",
+  "grep",
+  "egrep",
+  "fgrep",
+  "rg",
+  "ag",
+  "echo",
+  "printf",
+  "sort",
+  "uniq",
+  "cut",
+  "tr",
+  "diff",
+  "cmp",
+  "basename",
+  "dirname",
+  "realpath",
+  "readlink",
+  "date",
+  "whoami",
+  "hostname",
+  "uname",
+  "which",
+  "type",
+  "env",
+  "printenv",
+  "true",
+  "false",
+  "seq",
+  "yes",
+  "column",
+  "jq",
+  "xxd",
+  "od",
+  "md5",
+  "shasum",
+  "sha256sum",
+  "nl",
+  "expr",
+  "test"
+]);
+var READ_ONLY_GIT = /* @__PURE__ */ new Set([
+  "status",
+  "log",
+  "diff",
+  "show",
+  "branch",
+  "ls-tree",
+  "ls-files",
+  "rev-parse",
+  "rev-list",
+  "describe",
+  "blame",
+  "cat-file",
+  "shortlog",
+  "reflog",
+  "tag",
+  "remote",
+  "worktree",
+  "grep",
+  "whatchanged",
+  "count-objects"
+]);
+var READ_ONLY_PAIRS = /* @__PURE__ */ new Set([
+  "npm ls",
+  "npm list",
+  "npm view",
+  "npm outdated",
+  "pnpm ls",
+  "pnpm list",
+  "yarn list",
+  "node --version",
+  "npm --version",
+  "python --version",
+  "python3 --version",
+  "go version",
+  "cargo --version",
+  "tsc --version"
+]);
+var WRITE_FLAGS = /(^|\s)(-i|--in-place|-i\.\w+|--output|-o)(\s|=|$)/;
+var REDIRECT = /(^|[^0-9<>])>{1,2}[^&]|(^|\s)(tee|dd|sudo|doas)(\s|$)/;
+function maskQuoted(cmd) {
+  let out = "";
+  let quote;
+  for (const ch of cmd) {
+    if (quote) {
+      out += ch === quote ? ch : "x";
+      if (ch === quote) quote = void 0;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      quote = ch;
+      out += ch;
+      continue;
+    }
+    out += ch;
+  }
+  return quote ? void 0 : out;
+}
+function splitSegments(cmd, masked) {
+  const cuts = [];
+  for (let i = 0; i < masked.length; i++) {
+    const two = masked.slice(i, i + 2);
+    if (two === "&&" || two === "||") {
+      cuts.push({ at: i, len: 2 });
+      i++;
+      continue;
+    }
+    if (masked[i] === "|" || masked[i] === ";") cuts.push({ at: i, len: 1 });
+  }
+  const out = [];
+  let from = 0;
+  for (const c of cuts) {
+    out.push(cmd.slice(from, c.at));
+    from = c.at + c.len;
+  }
+  out.push(cmd.slice(from));
+  return out;
+}
+function segmentIsReadOnly(seg) {
+  const s = seg.trim();
+  if (!s) return false;
+  if (WRITE_FLAGS.test(s)) return false;
+  const words = s.split(/\s+/);
+  const bin = words[0].replace(/^.*\//, "");
+  if (bin === "git") {
+    const sub = words.slice(1).find((w) => !w.startsWith("-"));
+    if (sub === "worktree") return words.includes("list");
+    if (sub === "remote") return words.length === 2 || words.includes("-v") || words.includes("show");
+    if (sub === "tag") return words.includes("-l") || words.includes("--list") || words.length === 2;
+    return sub !== void 0 && READ_ONLY_GIT.has(sub);
+  }
+  if (bin === "sed") return words.includes("-n");
+  if (bin === "awk") return true;
+  if (READ_ONLY_PAIRS.has(`${bin} ${words[1] ?? ""}`)) return true;
+  return READ_ONLY_BINS.has(bin);
+}
+function isReadOnly(command) {
+  const c = command.trim();
+  if (!c) return false;
+  const masked = maskQuoted(c);
+  if (masked === void 0) return false;
+  if (/\$\(|`|\$\{|<\(/.test(masked)) return false;
+  if (REDIRECT.test(masked)) return false;
+  const segments = splitSegments(c, masked);
+  return segments.length > 0 && segments.every(segmentIsReadOnly);
+}
+var SHELL_METACHARACTERS = /[;&|`\n<>${}()]/;
+function matchesAllowlist(allowKey, rules, kind) {
+  if (kind === "prefix" && SHELL_METACHARACTERS.test(allowKey)) return false;
+  for (const rule of rules) {
+    if (kind === "glob") {
+      if (picomatch(rule)(allowKey)) return true;
+    } else {
+      if (allowKey === rule || allowKey.startsWith(rule + " ")) return true;
+    }
+  }
+  return false;
+}
+
+// src/permission/engine.ts
+var PermissionEngine = class {
+  _mode;
+  allowlist;
+  constructor(opts) {
+    this._mode = opts.mode;
+    this.allowlist = [...opts.allowlist];
+  }
+  get mode() {
+    return this._mode;
+  }
+  setMode(m) {
+    this._mode = m;
+  }
+  addAllow(rule) {
+    if (!this.allowlist.includes(rule)) this.allowlist.push(rule);
+  }
+  check(req) {
+    if (req.level === "safe") return "allow";
+    const isExec = req.level === "exec";
+    const dangerous = isExec && isDangerous(req.allowKey);
+    if (isExec && !dangerous && isReadOnly(req.allowKey)) return "allow";
+    const kind = req.level === "write" ? "glob" : "prefix";
+    if (!dangerous && matchesAllowlist(req.allowKey, this.allowlist, kind)) {
+      return "allow";
+    }
+    switch (this._mode) {
+      case "ask":
+        return "ask";
+      case "acceptEdits":
+        return req.level === "write" ? "allow" : "ask";
+      case "auto":
+        return dangerous ? "ask" : "allow";
+    }
+  }
+};
+
+// src/engine/memory-proposals.ts
+var MAX_PROPOSALS = 60;
+var MAX_PROPOSAL_CHARS = 400;
+function key(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s]+/g, " ").replace(/\s+/g, " ").trim();
+}
+var ProposalQueue = class {
+  items = [];
+  seen = /* @__PURE__ */ new Set();
+  dropped = 0;
+  /** Returns false when the proposal was rejected outright (empty, duplicate, or past the cap). */
+  add(text, kind, proposedBy) {
+    const t = text.trim().slice(0, MAX_PROPOSAL_CHARS);
+    if (!t) return false;
+    const k = key(t);
+    if (this.seen.has(k)) return false;
+    if (this.items.length >= MAX_PROPOSALS) {
+      this.dropped++;
+      return false;
+    }
+    this.seen.add(k);
+    this.items.push({ text: t, kind, proposedBy });
+    return true;
+  }
+  list() {
+    return [...this.items];
+  }
+  /** How many proposals were refused because the queue was already full (reported, never silent). */
+  overflow() {
+    return this.dropped;
+  }
+  size() {
+    return this.items.length;
+  }
+  /** Empties the queue — called once the curator has ruled on its contents. */
+  drain() {
+    const out = this.list();
+    this.items.length = 0;
+    this.seen.clear();
+    this.dropped = 0;
+    return out;
+  }
+};
+
+// src/speckit/templates.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join as join4, dirname as dirname2 } from "path";
+var TEMPLATE_FILES = {
+  spec: "spec-template.md",
+  plan: "plan-template.md",
+  tasks: "tasks-template.md",
+  constitution: "constitution-template.md",
+  checklist: "checklist-template.md"
+};
+var COMMAND_FILES = {
+  constitution: "commands/constitution.md",
+  specify: "commands/specify.md",
+  clarify: "commands/clarify.md",
+  plan: "commands/plan.md",
+  tasks: "commands/tasks.md"
+};
+var RAW_BASE = "https://raw.githubusercontent.com/github/spec-kit";
+async function loadSpecKit(opts) {
+  if (!/^[A-Za-z0-9._-]+$/.test(opts.version) || opts.version.includes("..")) {
+    throw new Error(
+      `spec-kit version "${opts.version}" is not a valid spec-kit release tag (expected only letters, digits, dots, underscores, and hyphens, with no ".." segment).`
+    );
+  }
+  const fetchFn = opts.fetch ?? globalThis.fetch;
+  const cacheDir = join4(opts.home, ".horsecode", "spec-kit", opts.version, "templates");
+  const get = async (relPath) => {
+    const cachePath = join4(cacheDir, relPath);
+    if (existsSync2(cachePath)) return readFileSync(cachePath, "utf8");
+    const url = `${RAW_BASE}/${opts.version}/templates/${relPath}`;
+    const res = await fetchFn(url);
+    if (!res.ok) {
+      throw new Error(
+        `spec-kit template fetch failed (${res.status}): ${url}
+Check your network or set specKit.version to a valid tag.`
+      );
+    }
+    const text = await res.text();
+    mkdirSync(dirname2(cachePath), { recursive: true });
+    writeFileSync(cachePath, text, "utf8");
+    return text;
+  };
+  const templates = {};
+  for (const [name, file] of Object.entries(TEMPLATE_FILES)) templates[name] = await get(file);
+  const commands = {};
+  for (const [name, file] of Object.entries(COMMAND_FILES)) commands[name] = await get(file);
+  return {
+    version: opts.version,
+    template: (name) => templates[name],
+    command: (name) => commands[name]
+  };
+}
+
+// src/wiring.ts
+import { homedir } from "os";
+import { join as join5 } from "path";
+async function buildJobDeps(opts) {
+  const { config } = opts;
+  const roles = {};
+  const sessionChain = config.model === UNSET_MODEL ? [] : [config.model];
+  for (const name of REQUIRED_ROLES) {
+    const cfg = config.roles[name];
+    const declared = cfg?.skills;
+    const skills = (declared ?? DEFAULT_ROLE_SKILLS[name] ?? []).filter((s) => opts.skillRegistry.get(s));
+    roles[name] = { ...cfg ?? { models: sessionChain }, ...skills.length ? { skills } : { skills: [] } };
+  }
+  const roleRegistry = new RoleRegistry(roles, DEFAULT_PROMPTS, opts.skillRegistry);
+  const fillModels = (r) => ({
+    ...r,
+    models: r.models.length > 0 ? r.models : config.roles[r.name]?.models ?? sessionChain
+  });
+  const teams = {
+    spec: (config.team?.spec ?? SPEC_TEAM).map(fillModels),
+    plan: (config.team?.plan ?? PLAN_TEAM).map(fillModels),
+    code: (config.team?.code ?? CODE_TEAM).map(fillModels)
+  };
+  const teamRegistries = {
+    spec: buildTeamRegistry("spec", teams.spec),
+    plan: buildTeamRegistry("plan", teams.plan),
+    code: buildTeamRegistry("code", teams.code)
+  };
+  const council = (config.council?.members ?? DEFAULT_COUNCIL).map(fillModels);
+  const councilRegistry = buildCouncilRegistry(council);
+  if (opts.rules) {
+    roleRegistry.setRules(opts.rules);
+    for (const s of ["spec", "plan", "code"]) teamRegistries[s].setRules(opts.rules);
+    councilRegistry.setRules(opts.rules);
+  }
+  const permission = new PermissionEngine({ mode: config.mode, allowlist: config.allowlist });
+  const queue = new ProposalQueue();
+  let kitPromise;
+  const specKit = () => kitPromise ??= loadSpecKit({ version: config.specKit.version, home: opts.home, fetch: opts.fetch });
+  const fitness = new RoleFitness(join5(opts.home ?? homedir(), ".horsecode", "model-fitness.json"));
+  roleRegistry.setFitness(fitness);
+  return {
+    provider: opts.provider,
+    roleRegistry,
+    fitness,
+    skillRegistry: opts.skillRegistry,
+    permission,
+    approve: opts.approve,
+    signal: opts.signal,
+    home: opts.home,
+    specKit,
+    // One injection log per session: shared by the coach and every role so a memory shown to one agent is
+    // not immediately re-shown to the next.
+    injectionLog: new InjectionLog(),
+    // One proposal queue per session: review agents propose into it, the curator drains it when a job ends.
+    proposals: queue,
+    proposeMemory: (text, kind, role) => queue.add(text, kind, role),
+    teams,
+    teamRegistries,
+    councilRegistry,
+    council,
+    manager: opts.manager,
+    prAdapter: opts.prAdapter,
+    // One per job: every stage records into it, and the run reports the breakdown when the waves finish.
+    timings: new Timings(),
+    rounds: 3,
+    maxParallel: opts.config.maxParallel ?? MAX_PARALLEL_TASKS,
+    askHuman: opts.askHuman
+  };
+}
+
+// src/init.ts
+var DEFAULT_BASE_URL = "http://localhost:20128";
+var DEFAULT_MODEL = "auto/best-coding";
+function parseExisting(raw) {
+  if (!raw) return {};
+  try {
+    const v = JSON.parse(raw);
+    return v && typeof v === "object" ? v : {};
+  } catch {
+    return {};
+  }
+}
+async function runInit(io) {
+  const path = `${io.home}/.horsecode/config.json`;
+  const existing = parseExisting(io.readFile(path));
+  const baseUrl = (await io.read(`omniroute baseUrl [${DEFAULT_BASE_URL}]: `)).trim() || DEFAULT_BASE_URL;
+  const apiKey = (await io.read("omniroute apiKey (empty=none): ")).trim();
+  const config = {
+    ...existing,
+    baseUrl,
+    model: existing.model ?? DEFAULT_MODEL
+  };
+  if (apiKey) config.apiKey = apiKey;
+  else delete config.apiKey;
+  io.writeFile(path, JSON.stringify(config, null, 2) + "\n");
+  io.log(`config written: ${path} (apiKey: ${apiKey ? "set" : "none"})`);
+}
+
+// src/providers/telemetry.ts
+function telemetryProvider(inner, tel) {
+  return {
+    chat(req, signal) {
+      return stream(inner, tel, req, signal);
+    }
+  };
+}
+async function* stream(inner, tel, req, signal) {
+  const started = Date.now();
+  const callId = `${started.toString(36)}-${Math.round(Math.random() * 1e6).toString(36)}`;
+  tel.event("gen_ai.chat.start", {
+    "gen_ai.request.model": req.model,
+    "hc.call_id": callId,
+    "hc.messages": req.messages.length,
+    "hc.prompt_chars": req.messages.reduce((n, m) => n + (typeof m.content === "string" ? m.content.length : 0), 0)
+  });
+  let promptTokens;
+  let completionTokens;
+  let cachedTokens;
+  let finish;
+  let failure;
+  let toolCalls = 0;
+  let textChars = 0;
+  try {
+    for await (const ev of inner.chat(req, signal)) {
+      if (ev.type === "usage") {
+        promptTokens = ev.promptTokens;
+        completionTokens = ev.completionTokens;
+        cachedTokens = ev.cachedTokens;
+      } else if (ev.type === "tool-call") toolCalls++;
+      else if (ev.type === "text-delta") textChars += ev.text.length;
+      else if (ev.type === "done") finish = ev.finishReason;
+      else if (ev.type === "error") failure = ev.message;
+      yield ev;
+    }
+  } catch (e) {
+    failure = e instanceof Error ? e.message : String(e);
+    throw e;
+  } finally {
+    tel.event("gen_ai.chat", {
+      "gen_ai.system": "omniroute",
+      "hc.call_id": callId,
+      "gen_ai.operation.name": "chat",
+      "gen_ai.request.model": req.model,
+      "gen_ai.usage.input_tokens": promptTokens,
+      "gen_ai.usage.output_tokens": completionTokens,
+      "gen_ai.usage.cached_tokens": cachedTokens,
+      "gen_ai.response.finish_reason": finish,
+      "hc.duration_ms": Date.now() - started,
+      "hc.tools_requested": toolCalls,
+      "hc.text_chars": textChars,
+      "hc.tools_offered": req.tools?.length ?? 0,
+      "hc.messages": req.messages.length,
+      ...failure ? { "hc.error": failure.slice(0, 300) } : {},
+      "hc.status": failure ? "error" : "ok"
+    });
+  }
+}
+
+// src/obs/redact.ts
+var MASK = "\xABredacted\xBB";
+var NAMED = /\b([A-Za-z0-9_]*(?:PASSWORD|PASSWD|PASS|SECRET|TOKEN|API_?KEY|ACCESS_KEY|PRIVATE_KEY|CREDENTIAL)[A-Za-z0-9_]*)\s*[=:]\s*(?:"([^"]*)"|'([^']*)'|([^\s;&|]+))/gi;
+var FLAGGED = /(--(?:password|token|secret|api-key|apikey|access-key)(?:[=\s]+))(?:"([^"]*)"|'([^']*)'|([^\s;&|]+))/gi;
+var IN_URL = /([a-z][a-z0-9+.-]*:\/\/[^\s:/@]+):([^\s@/]+)@/gi;
+var BEARER = /\b(Bearer|Basic)\s+([A-Za-z0-9._~+/=-]{8,})/g;
+var VENDOR = /\b(sk-[A-Za-z0-9_-]{8,}|gh[pousr]_[A-Za-z0-9]{16,}|xox[baprs]-[A-Za-z0-9-]{8,}|AKIA[0-9A-Z]{12,})\b/g;
+function redact(text) {
+  return text.replace(NAMED, (_m, name) => `${name}=${MASK}`).replace(FLAGGED, (_m, flag) => `${flag}${MASK}`).replace(IN_URL, (_m, head) => `${head}:${MASK}@`).replace(BEARER, (_m, scheme) => `${scheme} ${MASK}`).replace(VENDOR, MASK);
+}
+function redactRecord(record) {
+  if (typeof record === "string") return redact(record);
+  if (Array.isArray(record)) return record.map((v) => redactRecord(v));
+  if (record && typeof record === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(record)) out[k] = redactRecord(v);
+    return out;
+  }
+  return record;
+}
+
+// src/obs/sink.ts
+import { createWriteStream, mkdirSync as mkdirSync2 } from "fs";
+import { join as join6 } from "path";
+function telemetryDir(home) {
+  return join6(home, ".horsecode", "telemetry");
+}
+var MAX_QUEUE = 1e4;
+var FileSink = class {
+  stream;
+  queued = 0;
+  dropped = 0;
+  path;
+  constructor(home, runId) {
+    this.path = join6(telemetryDir(home), `${runId}.jsonl`);
+    try {
+      mkdirSync2(telemetryDir(home), { recursive: true });
+      this.stream = createWriteStream(this.path, { flags: "a" });
+      this.stream.on("error", () => {
+        this.stream = void 0;
+      });
+    } catch {
+      this.stream = void 0;
+    }
+  }
+  /** Redacted here: one sink, and dozens of places that write to it. See src/obs/redact.ts. */
+  write(record) {
+    record = redactRecord(record);
+    if (!this.stream) return;
+    if (this.queued >= MAX_QUEUE) {
+      this.dropped++;
+      return;
+    }
+    this.queued++;
+    try {
+      this.stream.write(`${JSON.stringify(record)}
+`, () => {
+        this.queued--;
+      });
+    } catch {
+      this.queued--;
+    }
+  }
+  /** How many records were dropped because the queue was full — reported rather than hidden. */
+  get lost() {
+    return this.dropped;
+  }
+  /**
+   * A stream that failed to open never calls `end`'s callback, and this awaited it forever.
+   *
+   * `createWriteStream` does not throw when the path cannot be opened — it emits `error` on a later tick. So
+   * the constructor's `catch` does not run, `stream` is set, and whether the error handler has cleared it by
+   * the time anything flushes is a race with the event loop. Lose that race and `end(cb)` is called on a
+   * broken stream, the callback is never invoked, and the promise has nothing left to resolve it.
+   *
+   * The observer then outlives what it observes: `flush()` is awaited as a run finishes, so a machine that
+   * cannot write the log cannot finish the run either. The `error` listener is the second exit, and either
+   * one is enough.
+   */
+  async flush() {
+    const s = this.stream;
+    if (!s) return;
+    this.stream = void 0;
+    await new Promise((resolve2) => {
+      s.once("error", () => resolve2());
+      s.end(() => resolve2());
+    });
+  }
+};
+
+// src/cli-info.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname3, join as join7 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function hcodeVersion() {
+  try {
+    const here = dirname3(fileURLToPath2(import.meta.url));
+    const pkg = JSON.parse(readFileSync2(join7(here, "..", "package.json"), "utf8"));
+    return pkg.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+var FLAGS = [
+  "--branch",
+  "-b",
+  "--job",
+  "-j",
+  "--rounds",
+  "--revision-rounds",
+  "--no-tui",
+  "--help",
+  "-h",
+  "--version",
+  "-v"
+];
+function usage() {
+  return [
+    `horse-code ${hcodeVersion()} \u2014 a terminal coding agent that works on its own branch.`,
+    "",
+    "USAGE",
+    "  hcode                      start the REPL",
+    '  hcode "<request>"          run one request to completion, then report where the work landed',
+    "  hcode init                 write .horsecode/ for this project and ask for the essentials",
+    "",
+    "OPTIONS",
+    "  -b, --branch <name>        branch the session's worktree from this ref (default: current branch)",
+    "  -j, --job <name>           name the session, and the branch it creates",
+    "      --rounds <n>           review rounds per document stage",
+    "      --revision-rounds <n>  revision rounds per implementation task",
+    "      --no-tui               plain output, no terminal UI \u2014 for pipes, CI and logs",
+    "  -h, --help                 this",
+    "  -v, --version              print the version and exit",
+    "",
+    "Configuration is ~/.horsecode/config.json, overlaid by .horsecode/config.json in the project.",
+    "Run `hcode init` if you have neither."
+  ].join("\n");
+}
+function nearestFlag(flag) {
+  const score = (a) => {
+    const b = flag;
+    let i = 0;
+    while (i < a.length && i < b.length && a[i] === b[i]) i++;
+    return i;
+  };
+  const best = [...FLAGS].filter((f) => f.startsWith("--") === flag.startsWith("--")).sort((a, b) => score(b) - score(a))[0];
+  return best !== void 0 && score(best) > 2 ? best : void 0;
+}
+
+// src/cli.ts
+var HEAP_MB = 12288;
+function parseArgs(argv) {
+  let fromBranch;
+  let jobName;
+  let rounds;
+  let revisionRounds;
+  let noTui;
+  let help;
+  let version;
+  let unknown;
+  const rest = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--branch" || a === "-b") fromBranch = argv[++i];
+    else if (a === "--job" || a === "-j") jobName = argv[++i];
+    else if (a === "--rounds") rounds = Number(argv[++i]);
+    else if (a === "--revision-rounds") revisionRounds = Number(argv[++i]);
+    else if (a === "--no-tui") noTui = true;
+    else if (a === "--help" || a === "-h") help = true;
+    else if (a === "--version" || a === "-v") version = true;
+    else if (unknown === void 0 && a !== void 0 && /^-/.test(a)) unknown = a;
+    else rest.push(a);
+  }
+  return {
+    prompt: rest.join(" "),
+    ...fromBranch !== void 0 && { fromBranch },
+    ...jobName !== void 0 && { jobName },
+    ...rounds !== void 0 && { rounds },
+    ...revisionRounds !== void 0 && { revisionRounds },
+    ...noTui !== void 0 && { noTui },
+    ...help !== void 0 && { help },
+    ...version !== void 0 && { version },
+    ...unknown !== void 0 && { unknown }
+  };
+}
+function whereItLanded(path) {
+  const base = sessionBase(dirname4(path));
+  if (base === void 0) {
+    return "Written directly in your working tree: no branch, no worktree, nothing to merge. Review it and commit it when you are happy with it.";
+  }
+  let branch = "";
+  try {
+    branch = execFileSync(
+      "git",
+      ["rev-parse", "--abbrev-ref", "HEAD"],
+      { cwd: base, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }
+    ).trim();
+  } catch {
+  }
+  return `Written on ${branch ? `branch \`${branch}\`` : "its own branch"}, in the worktree at \`${base}\`. Review it there, then merge it in.`;
+}
+function describeDelivery(d) {
+  if (d.mergedInto) {
+    return `Merged into \`${d.mergedInto}\` \u2014 the files are in your working copy.`;
+  }
+  return [
+    `**The work is on branch \`${d.branch}\`** \u2014 not in your working copy yet.`,
+    d.notMerged ? `Not merged: ${d.notMerged}.` : "",
+    "",
+    "To bring it in:",
+    "```",
+    `git merge --no-ff ${d.branch}`,
+    "```",
+    `Or inspect it first: \`git diff HEAD...${d.branch}\` \xB7 worktree: \`${d.worktree}\``
+  ].filter((l) => l !== void 0).join("\n");
+}
+function renderResult(res) {
+  if (res.kind === "chat") return stripThinking(res.response);
+  if (res.kind === "rejected") return `Not approved (stopped at the ${res.stage} stage).`;
+  if (res.kind === "undone") return res.report;
+  if (res.kind === "verified") return res.report;
+  if (res.kind === "tweaked") return res.report;
+  if (res.kind === "governed") {
+    return res.written ? `**Constitution written** \u2014 \`${res.path}\`
+
+_${whereItLanded(res.path)}_` : `The constitution phase finished without writing \`${res.path}\` \u2014 nothing was changed.`;
+  }
+  const outcome = res.wave.status === "completed" ? res.wave.pr ? `PR: ${res.wave.pr.url}` : "all tasks completed" : `Partial: ${res.wave.failed.length} failed, ${res.wave.skipped.length} skipped`;
+  const rev = res.revision ? `
+revision: ${res.revision.status}` : "";
+  return `${stripThinking(res.report)}
+
+Status: ${res.wave.status} \u2014 ${outcome}${rev}
+
+${describeDelivery(res.wave.delivery)}`;
+}
+function shouldUseTui(stdinTTY, stdoutTTY, noTui) {
+  return stdinTTY && stdoutTTY && !noTui;
+}
+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 currentBranch(cwd) {
+  try {
+    const sym = await defaultGitRunner(["symbolic-ref", "--short", "HEAD"], cwd);
+    if (sym.code === 0 && sym.stdout.trim()) return sym.stdout.trim();
+    const r = await defaultGitRunner(["rev-parse", "--abbrev-ref", "HEAD"], cwd);
+    const b = r.stdout.trim();
+    return b && b !== "HEAD" ? b : "main";
+  } catch {
+    return "main";
+  }
+}
+async function main(argv) {
+  const args = parseArgs(argv);
+  if (args.version) {
+    console.log(hcodeVersion());
+    return;
+  }
+  if (args.help) {
+    console.log(usage());
+    return;
+  }
+  if (args.unknown !== void 0) {
+    const near = nearestFlag(args.unknown);
+    console.error(`unknown option: ${args.unknown}${near !== void 0 ? ` \u2014 did you mean ${near}?` : ""}`);
+    console.error("`hcode --help` lists every option. To pass text starting with a dash, quote the whole request.");
+    process.exitCode = 1;
+    return;
+  }
+  if (argv[0] === "init") {
+    const { read: read2, close: close2 } = nodeLineReader();
+    try {
+      await runInit({
+        read: read2,
+        readFile: (p) => {
+          try {
+            return readFileSync3(p, "utf8");
+          } catch {
+            return void 0;
+          }
+        },
+        writeFile: (p, c) => {
+          mkdirSync3(dirname4(p), { recursive: true });
+          writeFileSync2(p, c);
+        },
+        home: process.env.HOME ?? "",
+        log: (s) => console.log(s)
+      });
+    } finally {
+      close2();
+    }
+    return;
+  }
+  const cwd = process.cwd();
+  const config = loadConfig({
+    cwd,
+    home: process.env.HOME ?? "",
+    env: process.env,
+    readFile: (p) => {
+      try {
+        return readFileSync3(p, "utf8");
+      } catch {
+        return void 0;
+      }
+    }
+  });
+  const home = process.env.HOME ?? "";
+  if (!process.env.HC_HEAP_SET && !process.env.NODE_OPTIONS) {
+    const { spawnSync } = await import("child_process");
+    if (process.stdin.isTTY) process.stdin.setRawMode(false);
+    const ignore = () => {
+    };
+    const SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+    for (const sig of SIGNALS) process.on(sig, ignore);
+    const r = spawnSync(process.execPath, [`--max-old-space-size=${HEAP_MB}`, ...process.argv.slice(1)], {
+      stdio: "inherit",
+      /**
+       * `NODE_ENV=production` is set here because it must be set BEFORE React is imported.
+       *
+       * Without it, react-reconciler loads its development build, which calls `performance.measure()` on
+       * every render. Node keeps every entry forever: a heap snapshot of a live session found 1,381,896
+       * `PerformanceMeasure` objects, with React's own labels — `Components ⚛`, `Changed Props`,
+       * `+ children` — among the largest classes on the heap. That is the ~700 MB/hour the floor was
+       * climbing by, in a TUI that re-renders several times a second for hours.
+       *
+       * A user who has chosen their own NODE_ENV keeps it.
+       */
+      env: { ...process.env, HC_HEAP_SET: "1", NODE_ENV: process.env.NODE_ENV ?? "production" }
+    });
+    restoreTerminal({ stdin: process.stdin, write: (x) => process.stdout.write(x), sane: sttySane });
+    for (const sig of SIGNALS) process.removeListener(sig, ignore);
+    if (r.signal) process.kill(process.pid, r.signal);
+    process.exit(r.status ?? 0);
+  }
+  const runId = `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${process.pid}`;
+  const sink = config.telemetry ? new FileSink(home, runId) : void 0;
+  if (sink) {
+    setTelemetry(new Telemetry(sink));
+    sampleMemory(telemetry());
+    clearPerfMarks();
+    process.on("SIGUSR2", () => {
+      void writeHeapSnapshot(telemetryDir(home), telemetry());
+    });
+    const flush = () => {
+      void sink.flush();
+    };
+    process.once("exit", flush);
+    process.once("SIGTERM", flush);
+  }
+  const telemetryNote = sink ? `\u{1F4C8} Telemetry \u2192 \`${sink.path}\` (one JSON object per line)` : void 0;
+  const raw = new OmniRouteProvider({ baseUrl: config.baseUrl, apiKey: config.apiKey });
+  const provider = config.telemetry ? telemetryProvider(raw, telemetry()) : raw;
+  const skillRegistry = new SkillRegistry();
+  await registerBuiltinSkills(skillRegistry);
+  await skillRegistry.loadFromDir(externalSkillsDir(home));
+  const skillsDir = join8(cwd, ".horsecode", "skills");
+  if (existsSync3(skillsDir)) await skillRegistry.loadFromDir(skillsDir);
+  const worktreeHome = await mainWorktreeRoot(defaultGitRunner, cwd);
+  if (worktreeHome !== cwd) {
+    console.log(`\u2139\uFE0F  Sessions will be opened in ${worktreeHome} \u2014 the repository's main checkout.`);
+  }
+  const manager = new WorktreeManager({ repoRoot: cwd, worktreeHome });
+  const remoteUrl = (await defaultGitRunner(["remote", "get-url", "origin"], cwd)).stdout.trim();
+  const prAdapter = makePRAdapter({ platform: detectPlatform(remoteUrl), run: defaultCmdRunner, cwd, log: (s) => console.log(s) });
+  const fromBranch = args.fromBranch ?? await currentBranch(cwd);
+  setTraceRoot(config.traceDir || discoverTraceRoot(cwd, await trackedFiles(cwd)));
+  const memStore = new MemoryStore({ home, cwd });
+  await memStore.load();
+  await memStore.pruneExpired();
+  const rules = () => memStore.all().filter((m) => m.kind === "rule").map((m) => m.text);
+  const buildDeps = (read2) => buildJobDeps({
+    config,
+    provider,
+    skillRegistry,
+    manager,
+    prAdapter,
+    rules,
+    // Autonomous by default: a task that exhausts the escalation ladder is auto-retried (then abandoned) so
+    // an unattended run finishes on its own instead of blocking on an interactive per-failure human prompt.
+    askHuman: autonomousAskHuman(),
+    approve: makeApprove(read2),
+    signal: new AbortController().signal,
+    home
+  });
+  const useTui = shouldUseTui(!!process.stdin.isTTY, !!process.stdout.isTTY, !!args.noTui);
+  if (!args.prompt) {
+    if (useTui) {
+      const { runTuiRepl } = await import("./app-SB2L34JW.js");
+      const { fetchCatalog, makeProbe, discoverSources } = await import("./discover-5URG7C4J.js");
+      const { loadSourceCache, saveSourceCache } = await import("./source-cache-XEK5WN7I.js");
+      const manualSources = config.modelSources.length > 0;
+      const sourcesRef = { current: manualSources ? config.modelSources : loadSourceCache(home, config.baseUrl) ?? [] };
+      const configuredModels = () => [...new Set(Object.values(config.roles).flatMap((r) => r.models ?? []))].filter((m) => m && m !== "default");
+      const listModels = async () => {
+        const catalog = await listOmniRouteModels({ baseUrl: config.baseUrl, apiKey: config.apiKey, sources: sourcesRef.current });
+        const known = new Set(catalog);
+        return [...catalog, ...configuredModels().filter((m) => !known.has(m))];
+      };
+      const refreshSources = async () => {
+        const catalog = await fetchCatalog({ baseUrl: config.baseUrl, apiKey: config.apiKey });
+        const found = await discoverSources({ catalog, probe: makeProbe({ baseUrl: config.baseUrl, apiKey: config.apiKey }) });
+        sourcesRef.current = found;
+        saveSourceCache(home, config.baseUrl, found);
+        return found;
+      };
+      const sourcesInfo = () => ({ sources: sourcesRef.current, manual: manualSources, needsDiscovery: !manualSources && sourcesRef.current.length === 0 });
+      const probeModel = async (model) => {
+        try {
+          const res = await fetch(`${config.baseUrl.replace(/\/$/, "")}/api/v1/chat/completions`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", ...config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {} },
+            body: JSON.stringify({ model, stream: false, max_tokens: 1, messages: [{ role: "user", content: "hi" }] }),
+            signal: AbortSignal.timeout(2e4)
+          });
+          return res.status === 200;
+        } catch {
+          return false;
+        }
+      };
+      const effectiveRoleSkills = (skill) => Object.keys(DEFAULT_ROLE_SKILLS).concat(Object.keys(config.roles)).filter((r, i, a) => a.indexOf(r) === i).filter((r) => (config.roles[r]?.skills ?? DEFAULT_ROLE_SKILLS[r] ?? []).includes(skill));
+      const listSkills = () => skillRegistry.list().map((s) => ({
+        ...s,
+        roles: effectiveRoleSkills(s.name)
+      }));
+      const addSkill = async (url) => {
+        const src = parseSkillUrl(url);
+        if (!src) return `Not a GitHub URL: \`${url}\`
+
+_Expected something like \`https://github.com/owner/repo\` or a link to the directory holding SKILL.md._`;
+        const r = await installSkillSource(home, src);
+        await saveSkillSource(home, src);
+        await skillRegistry.loadFromDir(externalSkillsDir(home));
+        const s = skillRegistry.get(src.name);
+        const desc = s ? `
+
+> ${s.description}` : "";
+        return `Installed **${src.name}** from \`${src.repo}\`${src.path ? `/${src.path}` : ""} at \`${r.sha.slice(0, 8)}\`.${desc}
+
+_Discoverable by every agent. \`/roles adjust\` assigns it to the roles it fits; \`/skills update\` re-installs it from upstream._`;
+      };
+      const reloadProjectSkills = async () => {
+        const dir = join8(cwd, ".horsecode", "skills");
+        if (existsSync3(dir)) await skillRegistry.loadFromDir(dir);
+      };
+      const updateSkills = async () => {
+        if (!config.skillSources.length) {
+          return "No external skill sources configured. Add them under `skillSources` in your config.";
+        }
+        const { ok, failed } = await syncSkillSources(home, config.skillSources);
+        await skillRegistry.loadFromDir(externalSkillsDir(home));
+        const changed = ok.filter((r) => r.changed);
+        const lines = [
+          ...changed.map((r) => `- \u2B06\uFE0F **${r.name}** \u2192 \`${r.sha.slice(0, 8)}\``),
+          ...ok.filter((r) => !r.changed).map((r) => `- \u2713 ${r.name} already up to date`),
+          ...failed.map((f) => `- \u274C **${f.name}** \u2014 ${f.error}`)
+        ];
+        const tail = changed.length ? "\n\n_Restart to pick up a changed skill in already-built prompts._" : "";
+        return `**Skill sources:**
+${lines.join("\n")}${tail}`;
+      };
+      const graphStatusText = async () => {
+        const st = await graphStatus(cwd);
+        if (!st.built) {
+          const py = await graphifyPython();
+          return py ? "No code graph yet. `/graph build` \u2014 AST parsing only, no tokens, a few seconds.\n\n_Without it every agent works blind: it can grep for a name but cannot tell what calls it._" : "No code graph, and graphify is not installed.\n\n`uv tool install graphifyy` (or `pipx install graphifyy`), then `/graph build`.\n\n_MIT, pure tree-sitter AST parsing \u2014 no API key, no tokens._";
+        }
+        const age = st.builtAt ? `${Math.round((Date.now() - st.builtAt) / 6e4)} min ago` : "unknown";
+        const fresh = st.stale ? `
+
+\u26A0\uFE0F **Stale** \u2014 changed since it was built: ${st.staleBecause.map((f) => `\`${f}\``).join(", ")}. Run \`/graph build\`.` : "\n\n\u2713 Up to date with the working tree.";
+        const bs = await briefStatus(cwd, await traceableDocs());
+        const briefLine = !bs.built ? "\n\n**Project brief:** not written \u2014 `/graph trace` writes it (this is the part that costs tokens)." : bs.stale ? `
+
+**Project brief:** \u26A0\uFE0F stale \u2014 ${bs.changed.slice(0, 3).map((c) => `\`${c}\``).join(", ")}. \`/graph trace\` rewrites it.` : `
+
+**Project brief:** \u2713 current, from ${bs.sources.length} document(s).`;
+        return `**Project graph** \u2014 ${st.nodes} symbols, ${st.edges} relationships, built ${age}.${fresh}${briefLine}
+
+_Every agent can query it: \`graph_impact\` (blast radius), \`graph_trace\`, \`graph_find\`, \`graph_context\`, \`graph_overview\`._`;
+      };
+      const buildGraphText = async () => (await buildProjectGraph(cwd)).message;
+      const cleanWorktreesText = async (apply, branch) => {
+        const { surveySessions, cleanSessions, describeSurvey, describeClean } = await import("./clean-YOQATBMZ.js");
+        const target = branch?.trim() || fromBranch;
+        const known = await defaultGitRunner(["rev-parse", "--verify", "--quiet", target], cwd);
+        if (known.code !== 0) return `There is no branch \`${target}\` in this repository.`;
+        if (!apply) return describeSurvey(await surveySessions(defaultGitRunner, cwd, target), target);
+        return describeClean(await cleanSessions(defaultGitRunner, cwd, target), target);
+      };
+      const gitFiles = async () => (await defaultGitRunner(["ls-files", "--cached", "--others", "--exclude-standard"], cwd)).stdout.split("\n").filter(Boolean);
+      const traceableDocs = async () => traceableFiles(cwd, { code: false });
+      const traceableFiles2 = async () => traceableFiles(cwd);
+      const tracerModel = () => {
+        for (const role of ["tracer", "architect", "senior-coder", "judge"]) {
+          const m = config.roles[role]?.models[0];
+          if (m && m !== "default") return m;
+        }
+        return config.model;
+      };
+      const planTracesFn = async () => {
+        const plan = await planFor(cwd, await traceableFiles2());
+        return { summary: describePlan(plan, tracerModel()), jobs: plan.jobs.length };
+      };
+      const runTracesFn = async (onProgress, metered) => {
+        const files = await traceableFiles2();
+        const brief = await buildBrief({ cwd, provider: metered ?? provider, model: tracerModel(), files: await traceableDocs() });
+        const plan = await planFor(cwd, files);
+        const res = await runTraces({
+          cwd,
+          provider: metered ?? provider,
+          model: tracerModel(),
+          plan,
+          liveFiles: new Set(files),
+          ...onProgress ? { onProgress } : {}
+        });
+        const bits = [`${brief.message}
+
+**Traces written: ${res.written}**`];
+        if (res.upToDate) bits.push(`${res.upToDate} already current`);
+        if (res.pruned.length) bits.push(`${res.pruned.length} removed for deleted files`);
+        if (res.wroteGitignore) bits.push("\n\n_Added .gitignore rules: traces are committed, the AST cache is not._");
+        if (res.failed.length) {
+          bits.push(`
+
+\u26A0\uFE0F ${res.failed.length} failed:
+${res.failed.slice(0, 5).map((f) => `- \`${f.file}\` \u2014 ${f.error}`).join("\n")}`);
+        }
+        return `${bits.join(" \xB7 ")}
+
+_Committed with the repo, so every clone starts with them. Agents read one with \`graph_trace\`._`;
+      };
+      await runTuiRepl({
+        buildDeps,
+        memStore,
+        listSkills,
+        updateSkills,
+        addSkill,
+        reloadProjectSkills,
+        graphStatus: graphStatusText,
+        buildGraph: buildGraphText,
+        cleanWorktrees: cleanWorktreesText,
+        planTraces: planTracesFn,
+        runTraces: runTracesFn,
+        jobBase: { fromBranch, maxRounds: args.rounds ?? 3, ...args.revisionRounds !== void 0 && { revisionRounds: args.revisionRounds } },
+        formatResult: renderResult,
+        model: config.model,
+        listModels,
+        mcp: config.mcp,
+        maxParallel: config.maxParallel,
+        ...telemetryNote ? { startupNote: telemetryNote } : {},
+        ...sink ? { telemetryPath: sink.path } : {},
+        refreshSources,
+        sourcesInfo,
+        probeModel
+      });
+      return;
+    }
+    console.error('usage: hcode "<prompt>" [--branch b] [--job j] [--rounds n] [--revision-rounds n] [--no-tui]  |  hcode (interactive TUI REPL)  |  hcode init');
+    process.exitCode = 1;
+    return;
+  }
+  const jobName = args.jobName ?? (toSlug(args.prompt) || "hcode-job");
+  const job = {
+    prompt: args.prompt,
+    fromBranch,
+    jobName,
+    maxRounds: args.rounds ?? 3,
+    ...args.revisionRounds !== void 0 && { revisionRounds: args.revisionRounds }
+  };
+  if (useTui) {
+    const { runTui } = await import("./app-SB2L34JW.js");
+    const res = await runTui({ buildDeps, job });
+    console.log(renderResult(res));
+    return;
+  }
+  const { read, close } = nodeLineReader();
+  try {
+    const deps = await buildDeps(read);
+    deps.memory = () => memStore.all();
+    deps.reinforceMemory = (id) => {
+      void memStore.reinforce(id);
+    };
+    deps.rememberFact = (fact) => {
+      void memStore.add(fact);
+    };
+    deps.recordInjection = (ids) => {
+      void memStore.recordInjection(ids);
+    };
+    deps.learnMemory = async (text, kind, o) => (await memStore.add(text, kind, o)).ok;
+    deps.onMemory = (ev) => {
+      const t = memoryNote(ev);
+      if (t) console.log(t);
+    };
+    await memStore.runHygiene().catch(() => {
+    });
+    const res = await runJob(deps, { ...job, askUser: makeAskUser(read) });
+    console.log(renderResult(res));
+  } finally {
+    close();
+  }
+}
+function isMainModule() {
+  const entry = process.argv[1];
+  if (!entry) return false;
+  try {
+    return import.meta.url === pathToFileURL(realpathSync(entry)).href;
+  } catch {
+    return false;
+  }
+}
+if (isMainModule()) {
+  main(process.argv.slice(2)).catch((e) => {
+    console.error("error:", e instanceof Error ? e.message : e);
+    process.exitCode = 1;
+  });
+}
+export {
+  describeDelivery,
+  main,
+  parseArgs,
+  renderResult,
+  shouldUseTui,
+  whereItLanded
+};