@hizliemre/horse-code 0.2.0 → 0.3.1

package/dist/cli.js

@@ -15,31 +15,25 @@ import {
   restoreTerminal,
   runJob,
   sttySane
-} from "./chunk-23CLQ2KO.js";
+} from "./chunk-2WXG35EM.js";
 import "./chunk-M2RKCIGV.js";
 import {
-  CODE_TEAM,
   CliProvider,
-  DEFAULT_COUNCIL,
-  DEFAULT_PROMPTS,
-  DEFAULT_ROLE_SKILLS,
-  PLAN_TEAM,
-  REQUIRED_ROLES,
   RoleFitness,
-  RoleRegistry,
   SHORT_CALL_MS,
-  SPEC_TEAM,
   WorktreeManager,
   buildCouncilRegistry,
   buildTeamRegistry,
-  checkProfile,
-  cliCatalog,
   mainWorktreeRoot,
-  runLogin,
   toSlug
-} from "./chunk-7JMWPTJ5.js";
+} from "./chunk-27F44PBD.js";
 import "./chunk-QF4MP6BS.js";
-import "./chunk-UGESK765.js";
+import {
+  MAX_CHUNK_CHARS,
+  discover,
+  readFinding
+} from "./chunk-QJYVZPLG.js";
+import "./chunk-UTHLEW5V.js";
 import "./chunk-ZSQ24YDJ.js";
 import {
   parseFrontmatter
@@ -48,53 +42,75 @@ import {
   UNSET_MODEL,
   loadConfig,
   saveSkillSource
-} from "./chunk-KKWZBZYK.js";
+} from "./chunk-JR2JLRE3.js";
 import "./chunk-H2FDGPVW.js";
 import {
+  CODE_TEAM,
+  DEFAULT_COUNCIL,
+  DEFAULT_PROMPTS,
+  DEFAULT_ROLE_SKILLS,
+  PLAN_TEAM,
+  REQUIRED_ROLES,
+  RoleRegistry,
+  SPEC_TEAM,
+  ZAI_MODELS,
   buildBrief,
+  cliCatalog,
   describePlan,
+  modelsFor,
   planFor,
   runTraces,
   traceableFiles
-} from "./chunk-MRZVA5JB.js";
+} from "./chunk-YULQ4URQ.js";
+import {
+  CLI_KINDS,
+  checkProfile,
+  runLogin
+} from "./chunk-G45RWL7S.js";
 import {
   defaultGitRunner
 } from "./chunk-LPQU436C.js";
 import {
   InjectionLog,
   memoryNote
-} from "./chunk-LLL7QWXB.js";
+} from "./chunk-BFIZMM4G.js";
 import "./chunk-63E73TGI.js";
+import {
+  ToolRegistry
+} from "./chunk-CYLPQWIF.js";
+import {
+  briefStatus
+} from "./chunk-6S4WWQMN.js";
 import {
   Telemetry,
-  ToolRegistry,
   clearPerfMarks,
   sampleMemory,
   setTelemetry,
   stripThinking,
   telemetry,
   writeHeapSnapshot
-} from "./chunk-AE36LLL2.js";
-import {
-  briefStatus
-} from "./chunk-6OSEQOYY.js";
+} from "./chunk-JLWQCA7B.js";
 import {
   discoverTraceRoot,
-  setTraceRoot
-} from "./chunk-KAGKX2YT.js";
+  ensureGitignore,
+  localOnly,
+  setTraceRoot,
+  sharedDerived,
+  traceRootRel
+} from "./chunk-ZPJP2VH5.js";
 import {
   buildProjectGraph,
   graphStatus,
   graphifyPython
-} from "./chunk-XEGQT5EN.js";
+} from "./chunk-4M6LXNG2.js";
 import {
   sessionBase
 } from "./chunk-6W4UH2BQ.js";
 
 // src/cli.ts
 import { execFileSync } from "child_process";
-import { readFileSync as readFileSync4, existsSync as existsSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4, realpathSync } from "fs";
-import { join as join10, dirname as dirname5 } from "path";
+import { readFileSync as readFileSync5, existsSync as existsSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, realpathSync, rmSync, statSync as statSync2 } from "fs";
+import { join as join12, dirname as dirname5 } from "path";
 import { pathToFileURL } from "url";
 
 // src/agents/cli-accounts.ts
@@ -181,6 +197,26 @@ var AccountPool = class {
     return kind ? this.accounts.filter((a) => a.kind === kind).length : this.accounts.length;
   }
 };
+function modelsPanel(usage2, models, kinds, inUse = [], now = Date.now()) {
+  const used = new Set(inUse);
+  const rows = [];
+  for (const kind of kinds) {
+    const mine = usage2.filter((u) => u.account.kind === kind);
+    const who = mine.length ? mine.map(({ account, reading }) => {
+      const name = account.email ?? account.plan ?? account.name;
+      return `${name}${reading ? ` \xB7 ${Math.round(reading.spent * 100)}% used ${ageOf(reading.at, now)} ago` : ""}`;
+    }).join(" \xB7 ") : "_not connected \u2014 these will fail every call_";
+    rows.push(`**${kind}** \u2014 ${who}`);
+    rows.push(`  ${models(kind).map((m) => `${used.has(m) ? "\u25CF" : "\xB7"} ${m}`).join("   ")}`);
+  }
+  const idle = kinds.filter((k) => usage2.some((u) => u.account.kind === k)).filter((k) => !models(k).some((m) => used.has(m)));
+  const note = idle.length ? `
+
+_\u25CF = a role is running it. ${idle.join(" and ")} ${idle.length > 1 ? "are" : "is"} connected but in no chain \u2014 \`/roles adjust\` assigns them._` : "\n\n_\u25CF = a role is running it._";
+  return `**Models** \u2014 what your connected subscriptions serve
+
+${rows.join("\n")}${note}`;
+}
 function ageOf(at, now) {
   const mins = Math.max(0, Math.round((now - at) / 6e4));
   if (mins < 60) return `${mins}m`;
@@ -207,9 +243,11 @@ function freshDir(kind, home, taken) {
   }
 }
 function nameFor(kind, status, dir) {
-  return status.email ?? `${kind}-${dir.split("/").pop() ?? "profile"}`;
+  const base = dir.split("/").pop() ?? "profile";
+  return status.email ?? (base.startsWith(`${kind}-`) ? base : `${kind}-${base}`);
 }
 function withAmbient(kind, existing, ambient) {
+  if (kind === "zai") return [...existing];
   if (existing.some((a) => a.kind === kind)) return [...existing];
   if (!ambient.loggedIn) return [...existing];
   return [
@@ -228,11 +266,11 @@ function accountsIn(config) {
   return raw.filter((a) => {
     const e = a;
     if (typeof a !== "object" || a === null) return false;
-    if (e.kind !== "claude" && e.kind !== "codex") return false;
+    if (!CLI_KINDS.includes(e.kind)) return false;
     return e.configDir === void 0 || typeof e.configDir === "string";
   });
 }
-function addProvider(kind, io) {
+async function addProvider(kind, io) {
   const config = io.readConfig();
   const existing = accountsIn(config);
   const accounts = withAmbient(kind, existing, io.check(kind));
@@ -242,12 +280,26 @@ function addProvider(kind, io) {
     io.log(`It stays first in line, so runs keep spending it before anything added now.`);
   }
   const dir = freshDir(kind, io.home, accounts);
-  io.log(`
+  if (kind === "zai") {
+    io.log(`
+z.ai has no sign-in \u2014 an account is an API key, and the profile at ${dir} will hold it.`);
+    io.log(`Take the key from your z.ai dashboard; it is written to that profile alone and nowhere else.
+`);
+  } else {
+    io.log(`
 Opening ${kind}'s own sign-in, for a NEW profile at ${dir}.`);
-  io.log(`Sign in with the account you want to add \u2014 not the one already connected.
+    io.log(`Sign in with the account you want to add \u2014 not the one already connected.
 `);
-  const r = io.login(kind, dir);
+  }
+  const r = await io.login(kind, dir);
   if (!r.ok) {
+    if (kind === "zai") {
+      io.log(`
+z.ai did not accept that key${r.error ? `: ${r.error}` : ""}. Nothing was changed.`);
+      io.log(`The key is checked by making one real call, because \`claude auth status\` reports any token as connected \u2014 valid or not.`);
+      io.log(`Nothing needs cleaning up: running this again reuses ${dir}.`);
+      return 1;
+    }
     io.log(`
 ${kind} sign-in did not complete${r.error ? `: ${r.error}` : ""}. Nothing was changed.`);
     io.log(`If a browser page opened, its address holds the reason \u2014 an \`error=\` there is the account being refused, not this command failing.`);
@@ -277,13 +329,203 @@ That is the account already connected as "${already.name}". Nothing was changed.
   const mine = [...accounts, entry].filter((a) => a.kind === kind);
   io.log(`
 Connected ${entry.email ?? entry.name}${entry.plan ? ` (${entry.plan})` : ""}.`);
-  io.log(`${mine.length} ${kind} account${mine.length === 1 ? "" : "s"} now connected. Runs use them in order, spilling to the next when one is nearly out.`);
+  io.log(`${mine.length} ${kind} account${mine.length === 1 ? "" : "s"} now connected. Runs take turns between them.`);
+  if (kind === "claude") io.log(`One nearly out of quota steps aside for the others.`);
+  else io.log(`${kind} reports no quota figures, so a spent account is discovered by being refused, not before.`);
+  if (kind === "zai" && mine.length > 1) {
+    io.log(`z.ai reports no account identity, so this cannot be checked: if that key is one already connected, remove the duplicate from ~/.horsecode/config.json.`);
+  }
   return 0;
 }
 
+// src/agents/zai-profile.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3 } from "path";
+var ZAI_BASE_URL = "https://api.z.ai/api/anthropic";
+function zaiSettings(token) {
+  return { env: { ANTHROPIC_BASE_URL: ZAI_BASE_URL, ANTHROPIC_AUTH_TOKEN: token } };
+}
+function settingsPath(dir) {
+  return join3(dir, "settings.json");
+}
+function writeZaiProfile(dir, token) {
+  mkdirSync2(dir, { recursive: true, mode: 448 });
+  writeFileSync2(settingsPath(dir), JSON.stringify(zaiSettings(token), null, 2) + "\n", { mode: 384 });
+}
+async function verifyZaiKey(token, model, timeoutMs = 3e4) {
+  const ctl = new AbortController();
+  const timer = setTimeout(() => ctl.abort(), timeoutMs);
+  try {
+    const res = await fetch(`${ZAI_BASE_URL}/v1/messages`, {
+      method: "POST",
+      signal: ctl.signal,
+      headers: {
+        "content-type": "application/json",
+        // Both spellings: z.ai accepts the bearer form, and `x-api-key` is what the Anthropic wire format
+        // names. Sending each costs nothing and removes a guess about which one this endpoint reads.
+        authorization: `Bearer ${token}`,
+        "x-api-key": token,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify({ model, max_tokens: 16, messages: [{ role: "user", content: "Reply with: ok" }] })
+    });
+    const body = await res.json().catch(() => void 0);
+    if (!res.ok) return { ok: false, error: zaiErrorText(body) ?? `the endpoint answered HTTP ${res.status}` };
+    const served = body?.model;
+    return { ok: true, ...served ? { served } : {} };
+  } catch (e) {
+    const aborted = e instanceof Error && e.name === "AbortError";
+    return {
+      ok: false,
+      error: aborted ? `${ZAI_BASE_URL} did not answer within ${Math.round(timeoutMs / 1e3)}s` : e instanceof Error ? e.message : String(e)
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function zaiErrorText(body) {
+  const msg = body?.error?.message;
+  return typeof msg === "string" && msg.trim() ? msg.trim() : void 0;
+}
+
+// src/agents/prompt.ts
+import { spawnSync } from "child_process";
+import { closeSync, openSync, readSync } from "fs";
+function promptLine() {
+  return readTty(false);
+}
+function promptSecret() {
+  return readTty(true);
+}
+function confirm(question) {
+  process.stdout.write(`${question} [y/N] `);
+  const answer = promptLine();
+  process.stdout.write("\n");
+  return /^y(es)?$/i.test((answer ?? "").trim());
+}
+function chooseFrom(question, options) {
+  process.stdout.write(`${question}
+`);
+  options.forEach((o, i) => process.stdout.write(`  ${i + 1}) ${o}
+`));
+  process.stdout.write(`Number (anything else cancels): `);
+  const line = promptLine();
+  process.stdout.write("\n");
+  const n = Number((line ?? "").trim());
+  return Number.isInteger(n) && n >= 1 && n <= options.length ? n - 1 : void 0;
+}
+function readTty(hidden) {
+  let fd;
+  try {
+    fd = openSync("/dev/tty", "r");
+  } catch {
+    return void 0;
+  }
+  const hushed = hidden && spawnSync("stty", ["-echo"], { stdio: ["inherit", "ignore", "ignore"] }).status === 0;
+  try {
+    const buf = Buffer.alloc(1);
+    let out = "";
+    for (; ; ) {
+      let n = 0;
+      try {
+        n = readSync(fd, buf, 0, 1, null);
+      } catch {
+        break;
+      }
+      if (n === 0) break;
+      const ch = buf.toString("utf8");
+      if (ch === "\n" || ch === "\r") break;
+      out += ch;
+    }
+    return out.trim() || void 0;
+  } finally {
+    if (hushed) spawnSync("stty", ["echo"], { stdio: ["inherit", "ignore", "ignore"] });
+    closeSync(fd);
+  }
+}
+
+// src/agents/remove-provider.ts
+function ownedProfile(home, dir) {
+  if (!dir) return false;
+  const root = `${home}/.horsecode/profiles/`;
+  return dir.startsWith(root) && dir.length > root.length && !dir.slice(root.length).includes("..");
+}
+function describeAccount(a) {
+  const who = a.email ?? a.name;
+  return `${a.kind} ${who}${a.plan ? ` (${a.plan})` : ""}${a.configDir ? "" : " \u2014 the signed-in default"}`;
+}
+function pickAccount(accounts, kind, name) {
+  const mine = accounts.filter((a) => a.kind === kind);
+  if (!mine.length) return { error: `no ${kind} account is connected` };
+  if (!name) return mine.length === 1 ? { account: mine[0] } : { choices: mine };
+  const found = mine.filter((a) => a.name === name || a.email === name);
+  if (!found.length) {
+    return {
+      error: `no ${kind} account called "${name}". Connected:
+` + mine.map((a) => `  ${a.name}${a.email && a.email !== a.name ? ` (${a.email})` : ""}`).join("\n")
+    };
+  }
+  if (found.length > 1) return { error: `"${name}" matches ${found.length} ${kind} accounts \u2014 remove one by its exact name` };
+  return { account: found[0] };
+}
+function removeProvider(kind, name, io) {
+  const config = io.readConfig();
+  const accounts = accountsIn(config);
+  const picked = pickAccount(accounts, kind, name);
+  if ("error" in picked) {
+    io.log(picked.error);
+    const others = accounts.filter((a) => a.kind !== kind);
+    if (!accounts.filter((a) => a.kind === kind).length && others.length) {
+      io.log(`
+Connected accounts:
+${others.map((a) => `  ${describeAccount(a)}`).join("\n")}`);
+    }
+    return { code: 1 };
+  }
+  let account;
+  if ("account" in picked) {
+    account = picked.account;
+  } else {
+    const chosen = io.choose(`Which ${kind} account should be removed?`, picked.choices.map(describeAccount));
+    if (chosen === void 0) {
+      io.log("Nothing was removed.");
+      return { code: 1 };
+    }
+    account = picked.choices[chosen];
+  }
+  const kept = accounts.filter((a) => a !== account);
+  io.writeConfig({ ...config, accounts: kept });
+  if (io.usage) {
+    const readings = io.usage.load();
+    const { [readingKey(kind, account.name)]: _dropped, ...rest } = readings;
+    io.usage.save(rest);
+  }
+  io.log(`Removed ${describeAccount(account)}.`);
+  if (!account.configDir) {
+    io.log(`That was the account you are signed into ${kind} with, not a profile horse-code created.`);
+    io.log(`It is still signed in, and a run will find it again. To stop using it, sign out of ${kind} itself.`);
+    return { code: 0, removed: account };
+  }
+  if (!ownedProfile(io.home, account.configDir)) {
+    io.log(`Its profile at ${account.configDir} was not created by horse-code, so it is left alone.`);
+    return { code: 0, removed: account };
+  }
+  const holds = kind === "zai" ? "the API key" : `the ${kind} sign-in`;
+  if (!io.confirm(`Also delete ${account.configDir}, which holds ${holds}?`)) {
+    io.log(`Left ${account.configDir} in place. Delete it by hand to remove ${holds}.`);
+    return { code: 0, removed: account };
+  }
+  io.removeDir(account.configDir);
+  io.log(`Deleted ${account.configDir}.`);
+  return { code: 0, removed: account };
+}
+function removeUsage(given) {
+  return `remove-provider needs a CLI to disconnect: ${CLI_KINDS.map((k) => `\`hcode remove-provider ${k}\``).join(", ")}${given ? ` (got "${given}")` : ""}`;
+}
+
 // src/skills/registry.ts
 import { readdir, readFile } from "fs/promises";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 var SkillRegistry = class {
   skills = /* @__PURE__ */ new Map();
   register(skill) {
@@ -306,7 +548,7 @@ var SkillRegistry = class {
       if (!e.isDirectory()) continue;
       let raw;
       try {
-        raw = await readFile(join3(dir, e.name, "SKILL.md"), "utf8");
+        raw = await readFile(join4(dir, e.name, "SKILL.md"), "utf8");
       } catch {
         continue;
       }
@@ -314,14 +556,14 @@ var SkillRegistry = class {
       if (!name || !description) {
         throw new Error(`skill ${e.name}: missing frontmatter (name/description)`);
       }
-      this.register({ name, description, content: body, dir: join3(dir, e.name) });
+      this.register({ name, description, content: body, dir: join4(dir, e.name) });
     }
   }
 };
 
 // src/skills/builtin.ts
 import { readdir as readdir2, readFile as readFile2 } from "fs/promises";
-import { dirname as dirname2, join as join4, resolve } from "path";
+import { dirname as dirname2, join as join5, resolve } from "path";
 import { fileURLToPath } from "url";
 function candidates() {
   const here = dirname2(fileURLToPath(import.meta.url));
@@ -342,14 +584,14 @@ async function registerBuiltinSkills(registry, dirs = candidates()) {
         if (!e.isDirectory()) continue;
         let raw;
         try {
-          raw = await readFile2(join4(dir, e.name, "SKILL.md"), "utf8");
+          raw = await readFile2(join5(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: join4(dir, e.name) });
+        found.push({ name, description, content: body, dir: join5(dir, e.name) });
       }
       if (!found.length) continue;
       for (const s of found) registry.register(s);
@@ -364,12 +606,12 @@ async function registerBuiltinSkills(registry, dirs = candidates()) {
 // 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 join5 } from "path";
+import { join as join6 } from "path";
 import { spawn } from "child_process";
 import { tmpdir } from "os";
 var PROVENANCE = ".horsecode-source.json";
 function externalSkillsDir(home) {
-  return join5(home, ".horsecode", "skills");
+  return join6(home, ".horsecode", "skills");
 }
 function validName(name) {
   return /^[A-Za-z0-9._-]+$/.test(name) && !name.includes("..");
@@ -413,7 +655,7 @@ async function resolveSha(src, deps) {
 }
 async function installedSource(home, name) {
   try {
-    return JSON.parse(await readFile3(join5(externalSkillsDir(home), name, PROVENANCE), "utf8"));
+    return JSON.parse(await readFile3(join6(externalSkillsDir(home), name, PROVENANCE), "utf8"));
   } catch {
     return void 0;
   }
@@ -423,27 +665,27 @@ async function installSkillSource(home, src, deps = {}) {
   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 = join5(externalSkillsDir(home), src.name);
+  const dest = join6(externalSkillsDir(home), src.name);
   const current = await installedSource(home, src.name);
-  if (current?.sha === sha && existsSync(join5(dest, "SKILL.md"))) {
+  if (current?.sha === sha && existsSync(join6(dest, "SKILL.md"))) {
     return { name: src.name, sha, changed: false };
   }
-  const staging = join5(tmpdir(), `hc-skill-${src.name}-${sha.slice(0, 8)}`);
+  const staging = join6(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 ? join5(staging, src.path) : staging;
-    if (!existsSync(join5(from, "SKILL.md"))) {
+    const from = src.path ? join6(staging, src.path) : staging;
+    if (!existsSync(join6(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(join5(dest, PROVENANCE), `${JSON.stringify(record, null, 2)}
+    await writeFile(join6(dest, PROVENANCE), `${JSON.stringify(record, null, 2)}
 `, "utf8");
     return { name: src.name, sha, changed: true };
   } finally {
@@ -463,6 +705,137 @@ async function syncSkillSources(home, sources, deps = {}) {
   return { ok, failed };
 }
 
+// src/engine/init-project.ts
+import { existsSync as existsSync2, statSync, readdirSync } from "fs";
+import { join as join7 } from "path";
+
+// src/migrate/project-docs.ts
+import { basename } from "path";
+var DERIVED = [
+  { re: /^\.horsecode\//, why: "horse-code's own state \u2014 traces describe the code, so rules mined from them would be the code talking back to itself" },
+  { re: /^graphify-out\//, why: "generated by the graph build" },
+  { re: /(^|\/)(node_modules|vendor|third_party|\.git)\//, why: "not this project's writing" },
+  { re: /(^|\/)\.claude\/worktrees\//, why: "a nested checkout of this repository" }
+];
+var HISTORY = [
+  { re: /(^|\/)archive(d)?\//i, why: "an archive of finished work" },
+  { re: /\d{4}-\d{2}-\d{2}/, why: "dated \u2014 a record of a moment, not a standing rule" },
+  { re: /(^|\/)(HANDOFF|RESUME|CHANGELOG|RELEASE[-_]NOTES)[^/]*$/i, why: "a record of what happened" },
+  { re: /(^|\/)chats?\//i, why: "a pasted conversation" },
+  { re: /(^|\/)chat\d*\.md$/i, why: "a pasted conversation" }
+];
+function sortProjectDocs(files, known = []) {
+  const seen = new Set(known.map((k) => k.replace(/\\/g, "/")));
+  const candidates2 = [];
+  const skipped = [];
+  for (const f of files) {
+    const path = f.path.replace(/\\/g, "/");
+    if (!/\.mdx?$/i.test(path)) continue;
+    if (seen.has(path) || seen.has(basename(path))) continue;
+    const why = DERIVED.find((d) => d.re.test(path))?.why ?? HISTORY.find((h) => h.re.test(path))?.why;
+    if (why) skipped.push({ path, bytes: f.bytes, skipped: why });
+    else candidates2.push({ path, bytes: f.bytes });
+  }
+  const bySize = (a, b) => b.bytes - a.bytes;
+  return { candidates: candidates2.sort(bySize), skipped: skipped.sort(bySize) };
+}
+function totalBytes(docs) {
+  return docs.reduce((n, d) => n + d.bytes, 0);
+}
+function classifyCalls(bytes, chunk) {
+  return Math.max(1, Math.ceil(bytes / chunk));
+}
+
+// src/engine/init-project.ts
+var UNCLAIMED_FILE_FLOOR = 50;
+function countFiles(dir, cap = UNCLAIMED_FILE_FLOOR * 4) {
+  let n = 0;
+  const walk = (d) => {
+    if (n >= cap) return;
+    let entries;
+    try {
+      entries = readdirSync(d, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (n >= cap) return;
+      if (e.isDirectory()) walk(join7(d, e.name));
+      else n++;
+    }
+  };
+  walk(dir);
+  return n;
+}
+async function initProject(cwd, isIgnored, untracked, knowledge) {
+  const changed = await ensureGitignore(cwd);
+  const unclaimed = [];
+  for (const rel of untracked()) {
+    const path = join7(cwd, rel);
+    let dir = false;
+    try {
+      dir = statSync(path).isDirectory();
+    } catch {
+      continue;
+    }
+    if (!dir || isIgnored(rel)) continue;
+    const files = countFiles(path);
+    if (files >= UNCLAIMED_FILE_FLOOR) unclaimed.push({ path: rel, files });
+  }
+  return {
+    changed,
+    kept: [`${traceRootRel().replace(/\\/g, "/")}/`, ...sharedDerived()].filter((p) => existsSync2(join7(cwd, p)) || p.endsWith("/")),
+    excluded: localOnly(),
+    unclaimed: unclaimed.sort((a, b) => b.files - a.files),
+    ...knowledge ? { knowledge } : {}
+  };
+}
+function hasKnowledge(k) {
+  return !!k && (k.named.length > 0 || k.docs.length > 0);
+}
+function size(bytes) {
+  return bytes >= 1024 * 1024 ? `${(bytes / 1024 / 1024).toFixed(1)} MB` : `${Math.max(1, Math.round(bytes / 1024))} KB`;
+}
+function describeKnowledge(k, chunk = MAX_CHUNK_CHARS) {
+  const lines = ["", "**This project already says things about itself.**", ""];
+  if (k.named.length) {
+    lines.push(`Files a tool is known to write \u2014 ${size(totalBytes(k.named.map((n) => ({ path: n.label, bytes: n.bytes }))))}:`);
+    lines.push(...k.named.map((n) => `  \xB7 \`${n.label}\` (${size(n.bytes)})`));
+  }
+  if (k.docs.length) {
+    const bytes = totalBytes(k.docs);
+    lines.push("", `The project's other markdown \u2014 ${k.docs.length} file(s), ${size(bytes)}, about ${classifyCalls(bytes, chunk)} classification call(s):`);
+    lines.push(...k.docs.slice(0, 8).map((d) => `  \xB7 \`${d.path}\` (${size(d.bytes)})`));
+    if (k.docs.length > 8) lines.push(`  \xB7 \u2026and ${k.docs.length - 8} more`);
+  }
+  if (k.skipped.length) {
+    const reasons = /* @__PURE__ */ new Map();
+    for (const sk of k.skipped) reasons.set(sk.skipped ?? "", (reasons.get(sk.skipped ?? "") ?? 0) + 1);
+    lines.push("", `Set aside \u2014 ${k.skipped.length} file(s), ${size(totalBytes(k.skipped))}:`);
+    for (const [why, n] of [...reasons].sort((a, b) => b[1] - a[1])) lines.push(`  \xB7 ${n} \xD7 ${why}`);
+  }
+  return lines.join("\n");
+}
+function describeInit(report) {
+  const lines = [
+    report.changed ? "**Project set up for horse-code** \u2014 `.gitignore` updated." : "**Project is already set up** \u2014 `.gitignore` already says everything needed.",
+    "",
+    "Committed on purpose, because a clone would otherwise pay to produce it again:",
+    ...report.kept.map((p) => `  \xB7 \`${p}\``),
+    "",
+    "Kept out on purpose \u2014 derived from the source, keyed to this checkout, or unmergeable:",
+    ...report.excluded.map((p) => `  \xB7 \`${p}\``)
+  ];
+  if (report.unclaimed.length) {
+    lines.push(
+      "",
+      "Untracked and covered by no rule \u2014 `git add -A` would commit these. Yours to decide:",
+      ...report.unclaimed.map((u) => `  \xB7 \`${u.path}\` (${u.files >= UNCLAIMED_FILE_FLOOR * 4 ? `${u.files}+` : u.files} files)`)
+    );
+  }
+  return lines.join("\n");
+}
+
 // src/permission/rules.ts
 import picomatch from "picomatch";
 var DANGEROUS_PATTERNS = [
@@ -733,8 +1106,8 @@ var ProposalQueue = class {
 };
 
 // src/speckit/templates.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join6, dirname as dirname3 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join8, dirname as dirname3 } from "path";
 var TEMPLATE_FILES = {
   spec: "spec-template.md",
   plan: "plan-template.md",
@@ -757,10 +1130,10 @@ async function loadSpecKit(opts) {
     );
   }
   const fetchFn = opts.fetch ?? globalThis.fetch;
-  const cacheDir = join6(opts.home, ".horsecode", "spec-kit", opts.version, "templates");
+  const cacheDir = join8(opts.home, ".horsecode", "spec-kit", opts.version, "templates");
   const get = async (relPath) => {
-    const cachePath = join6(cacheDir, relPath);
-    if (existsSync2(cachePath)) return readFileSync2(cachePath, "utf8");
+    const cachePath = join8(cacheDir, relPath);
+    if (existsSync3(cachePath)) return readFileSync3(cachePath, "utf8");
     const url = `${RAW_BASE}/${opts.version}/templates/${relPath}`;
     const res = await fetchFn(url);
     if (!res.ok) {
@@ -770,8 +1143,8 @@ Check your network or set specKit.version to a valid tag.`
       );
     }
     const text = await res.text();
-    mkdirSync2(dirname3(cachePath), { recursive: true });
-    writeFileSync2(cachePath, text, "utf8");
+    mkdirSync3(dirname3(cachePath), { recursive: true });
+    writeFileSync3(cachePath, text, "utf8");
     return text;
   };
   const templates = {};
@@ -787,7 +1160,7 @@ Check your network or set specKit.version to a valid tag.`
 
 // src/wiring.ts
 import { homedir } from "os";
-import { join as join7 } from "path";
+import { join as join9 } from "path";
 async function buildJobDeps(opts) {
   const { config } = opts;
   const roles = {};
@@ -801,7 +1174,12 @@ async function buildJobDeps(opts) {
   const roleRegistry = new RoleRegistry(roles, DEFAULT_PROMPTS, opts.skillRegistry);
   if (opts.accounts) {
     const pool = opts.accounts;
-    roleRegistry.setSourceWeights(() => ({ claude: pool.count("claude"), codex: pool.count("codex") }));
+    roleRegistry.setSourceWeights(() => ({
+      claude: pool.count("claude"),
+      codex: pool.count("codex"),
+      grok: pool.count("grok"),
+      zai: pool.count("zai")
+    }));
   }
   const fillModels = (r) => ({
     ...r,
@@ -828,7 +1206,7 @@ async function buildJobDeps(opts) {
   const queue = new ProposalQueue();
   let kitPromise;
   const specKit = () => kitPromise ??= loadSpecKit({ version: config.specKit.version, home: opts.home, fetch: opts.fetch });
-  const fitness = new RoleFitness(join7(opts.home ?? homedir(), ".horsecode", "model-fitness.json"));
+  const fitness = new RoleFitness(join9(opts.home ?? homedir(), ".horsecode", "model-fitness.json"));
   roleRegistry.setFitness(fitness);
   return {
     provider: opts.provider,
@@ -1020,10 +1398,10 @@ function redactRecord(record) {
 }
 
 // src/obs/sink.ts
-import { createWriteStream, mkdirSync as mkdirSync3 } from "fs";
-import { join as join8 } from "path";
+import { createWriteStream, mkdirSync as mkdirSync4 } from "fs";
+import { join as join10 } from "path";
 function telemetryDir(home) {
-  return join8(home, ".horsecode", "telemetry");
+  return join10(home, ".horsecode", "telemetry");
 }
 var MAX_QUEUE = 1e4;
 var FileSink = class {
@@ -1032,9 +1410,9 @@ var FileSink = class {
   dropped = 0;
   path;
   constructor(home, runId) {
-    this.path = join8(telemetryDir(home), `${runId}.jsonl`);
+    this.path = join10(telemetryDir(home), `${runId}.jsonl`);
     try {
-      mkdirSync3(telemetryDir(home), { recursive: true });
+      mkdirSync4(telemetryDir(home), { recursive: true });
       this.stream = createWriteStream(this.path, { flags: "a" });
       this.stream.on("error", () => {
         this.stream = void 0;
@@ -1091,13 +1469,13 @@ var FileSink = class {
 };
 
 // src/cli-info.ts
-import { readFileSync as readFileSync3 } from "fs";
-import { dirname as dirname4, join as join9 } from "path";
+import { readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname4, join as join11 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function hcodeVersion() {
   try {
     const here = dirname4(fileURLToPath2(import.meta.url));
-    const pkg = JSON.parse(readFileSync3(join9(here, "..", "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync4(join11(here, "..", "package.json"), "utf8"));
     return pkg.version ?? "unknown";
   } catch {
     return "unknown";
@@ -1124,7 +1502,9 @@ function 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",
-    "  hcode add-provider <cli>   connect one more claude or codex subscription, through that CLI's own sign-in",
+    "  hcode add-provider <cli>   connect one more claude, codex, grok or zai subscription",
+    "  hcode remove-provider <cli> [name]",
+    "                             disconnect one, and optionally delete the sign-in it holds",
     "",
     "OPTIONS",
     "  -b, --branch <name>        branch the session's worktree from this ref (default: current branch)",
@@ -1152,6 +1532,18 @@ function nearestFlag(flag) {
 
 // src/cli.ts
 var HEAP_MB = 12288;
+async function connectZai(dir) {
+  process.stdout.write("z.ai API key (not shown as you type): ");
+  const token = promptSecret();
+  process.stdout.write("\n");
+  if (!token) return { ok: false, error: "no key was entered" };
+  console.log(`Asking ${ZAI_MODELS[0]} one question, to see whether the key works\u2026`);
+  const v = await verifyZaiKey(token, ZAI_MODELS[0]);
+  if (!v.ok) return { ok: false, error: v.error };
+  writeZaiProfile(dir, token);
+  console.log(`  answered by ${v.served ?? "the endpoint (which named no model)"}.`);
+  return { ok: true };
+}
 function parseArgs(argv) {
   let fromBranch;
   let jobName;
@@ -1310,14 +1702,14 @@ async function main(argv) {
         read: read2,
         readFile: (p) => {
           try {
-            return readFileSync4(p, "utf8");
+            return readFileSync5(p, "utf8");
           } catch {
             return void 0;
           }
         },
         writeFile: (p, c) => {
-          mkdirSync4(dirname5(p), { recursive: true });
-          writeFileSync3(p, c);
+          mkdirSync5(dirname5(p), { recursive: true });
+          writeFileSync4(p, c);
         },
         home: process.env.HOME ?? "",
         log: (s) => console.log(s)
@@ -1329,32 +1721,74 @@ async function main(argv) {
   }
   if (argv[0] === "add-provider") {
     const kind = argv[1];
-    if (kind !== "claude" && kind !== "codex") {
-      console.error(`add-provider needs a CLI to connect: \`hcode add-provider claude\` or \`hcode add-provider codex\`${kind ? ` (got "${kind}")` : ""}`);
+    if (!kind || !CLI_KINDS.includes(kind)) {
+      console.error(`add-provider needs a CLI to connect: ${CLI_KINDS.map((k) => `\`hcode add-provider ${k}\``).join(", ")}${argv[1] ? ` (got "${argv[1]}")` : ""}`);
       process.exitCode = 1;
       return;
     }
     const path = `${process.env.HOME ?? ""}/.horsecode/config.json`;
-    process.exitCode = addProvider(kind, {
+    process.exitCode = await addProvider(kind, {
       home: process.env.HOME ?? "",
       readConfig: () => {
         try {
-          const parsed = JSON.parse(readFileSync4(path, "utf8"));
+          const parsed = JSON.parse(readFileSync5(path, "utf8"));
           return typeof parsed === "object" && parsed !== null ? parsed : {};
         } catch {
           return {};
         }
       },
       writeConfig: (c) => {
-        mkdirSync4(dirname5(path), { recursive: true });
-        writeFileSync3(path, JSON.stringify(c, null, 2) + "\n");
+        mkdirSync5(dirname5(path), { recursive: true });
+        writeFileSync4(path, JSON.stringify(c, null, 2) + "\n");
       },
-      login: runLogin,
+      /**
+       * "Make this profile real" means two different things, and z.ai is the one that is not a sign-in.
+       *
+       * The other three hand the terminal to their own OAuth. z.ai has none — a profile is a settings file
+       * holding an endpoint and a key — so here the step is: ask for the key, write it, and then SPEND one
+       * call proving it works. That last part is not ceremony: `claude auth status` reports any token as
+       * connected, valid or not, so without a real call a mistyped key would be filed as a working account
+       * and fail every call of the next run.
+       */
+      login: (k, dir) => k === "zai" ? connectZai(dir ?? "") : runLogin(k, dir),
       check: checkProfile,
       log: (line) => console.log(line)
     });
     return;
   }
+  if (argv[0] === "remove-provider") {
+    const kind = argv[1];
+    if (!kind || !CLI_KINDS.includes(kind)) {
+      console.error(removeUsage(argv[1]));
+      process.exitCode = 1;
+      return;
+    }
+    const path = `${process.env.HOME ?? ""}/.horsecode/config.json`;
+    const home2 = process.env.HOME ?? "";
+    process.exitCode = removeProvider(kind, argv[2], {
+      home: home2,
+      readConfig: () => {
+        try {
+          const parsed = JSON.parse(readFileSync5(path, "utf8"));
+          return typeof parsed === "object" && parsed !== null ? parsed : {};
+        } catch {
+          return {};
+        }
+      },
+      writeConfig: (c) => {
+        mkdirSync5(dirname5(path), { recursive: true });
+        writeFileSync4(path, JSON.stringify(c, null, 2) + "\n");
+      },
+      removeDir: (dir) => {
+        rmSync(dir, { recursive: true, force: true });
+      },
+      confirm,
+      choose: chooseFrom,
+      usage: fileUsageStore(home2),
+      log: (line) => console.log(line)
+    }).code;
+    return;
+  }
   const cwd = process.cwd();
   const config = loadConfig({
     cwd,
@@ -1362,7 +1796,7 @@ async function main(argv) {
     env: process.env,
     readFile: (p) => {
       try {
-        return readFileSync4(p, "utf8");
+        return readFileSync5(p, "utf8");
       } catch {
         return void 0;
       }
@@ -1370,13 +1804,13 @@ async function main(argv) {
   });
   const home = process.env.HOME ?? "";
   if (!process.env.HC_HEAP_SET && !process.env.NODE_OPTIONS) {
-    const { spawnSync } = await import("child_process");
+    const { spawnSync: spawnSync2 } = 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)], {
+    const r = spawnSync2(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.
@@ -1412,7 +1846,7 @@ async function main(argv) {
     process.once("SIGTERM", flush);
   }
   const telemetryNote = sink ? `\u{1F4C8} Telemetry \u2192 \`${sink.path}\` (one JSON object per line)` : void 0;
-  const ambientLogins = ["claude", "codex"].filter((k) => !config.accounts.some((a) => a.kind === k)).map((kind) => ({ kind, status: checkProfile(kind) }));
+  const ambientLogins = CLI_KINDS.filter((k) => k !== "zai" && !config.accounts.some((a) => a.kind === k)).map((kind) => ({ kind, status: checkProfile(kind) }));
   const accounts = new AccountPool(
     [
       ...config.accounts,
@@ -1427,13 +1861,43 @@ async function main(argv) {
   );
   const notSignedIn = ambientLogins.filter((a) => !a.status.loggedIn).map((a) => a.kind);
   const accountsNote = () => accountsLine(accounts.usage(), notSignedIn);
+  const initProjectFn = async () => {
+    const r = await defaultGitRunner(["ls-files", "--others", "--exclude-standard", "--directory"], cwd);
+    const list = r.stdout.split("\n").map((l) => l.trim()).filter(Boolean);
+    const ignored = /* @__PURE__ */ new Set();
+    for (const path of list) {
+      if ((await defaultGitRunner(["check-ignore", "-q", path], cwd)).code === 0) ignored.add(path);
+    }
+    const all = await defaultGitRunner(["ls-files", "--cached", "--others", "--exclude-standard"], cwd);
+    const md = all.stdout.split("\n").map((l) => l.trim()).filter((l) => /\.mdx?$/i.test(l));
+    const withSize = md.map((path) => {
+      try {
+        return { path, bytes: statSync2(join12(cwd, path)).size };
+      } catch {
+        return { path, bytes: 0 };
+      }
+    });
+    const found = await discover({ cwd, home });
+    const named = found.filter((f) => f.kind === "rules" || f.kind === "mcp").map((f) => ({ label: f.label, bytes: f.bytes }));
+    const { candidates: candidates2, skipped } = sortProjectDocs(withSize, found.map((f) => f.label));
+    const knowledge = { named, docs: candidates2, skipped };
+    const report = await initProject(cwd, (path) => ignored.has(path), () => list, knowledge);
+    const canImport = hasKnowledge(knowledge);
+    const extra = [];
+    for (const d of candidates2) {
+      const r2 = await readFinding(join12(cwd, d.path));
+      if (r2?.text) extra.push({ kind: "rules", tool: "project document", path: join12(cwd, d.path), label: d.path, bytes: r2.bytes, own: true, text: r2.text });
+    }
+    return { text: describeInit(report) + (canImport ? describeKnowledge(knowledge) : ""), canImport, extra };
+  };
+  const modelsPanelNote = (inUse) => modelsPanel(accounts.usage(), modelsFor, CLI_KINDS, inUse);
   const raw = new CliProvider({ readOnly: false, accounts });
   const provider = config.telemetry ? telemetryProvider(raw, telemetry()) : raw;
   const skillRegistry = new SkillRegistry();
   await registerBuiltinSkills(skillRegistry);
   await skillRegistry.loadFromDir(externalSkillsDir(home));
-  const skillsDir = join10(cwd, ".horsecode", "skills");
-  if (existsSync3(skillsDir)) await skillRegistry.loadFromDir(skillsDir);
+  const skillsDir = join12(cwd, ".horsecode", "skills");
+  if (existsSync4(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.`);
@@ -1465,7 +1929,7 @@ async function main(argv) {
   const useTui = shouldUseTui(!!process.stdin.isTTY, !!process.stdout.isTTY, !!args.noTui);
   if (!args.prompt) {
     if (useTui) {
-      const { runTuiRepl } = await import("./app-2GPGCDX6.js");
+      const { runTuiRepl } = await import("./app-4WN37LZ3.js");
       const { fetchCatalog, makeProbe, discoverSources } = await import("./discover-G2Z6XC3O.js");
       const { loadSourceCache, saveSourceCache } = await import("./source-cache-XEK5WN7I.js");
       const manualSources = config.modelSources.length > 0;
@@ -1516,8 +1980,8 @@ _Expected something like \`https://github.com/owner/repo\` or a link to the dire
 _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 = join10(cwd, ".horsecode", "skills");
-        if (existsSync3(dir)) await skillRegistry.loadFromDir(dir);
+        const dir = join12(cwd, ".horsecode", "skills");
+        if (existsSync4(dir)) await skillRegistry.loadFromDir(dir);
       };
       const updateSkills = async () => {
         if (!config.skillSources.length) {
@@ -1536,7 +2000,7 @@ _Discoverable by every agent. \`/roles adjust\` assigns it to the roles it fits;
 ${lines.join("\n")}${tail}`;
       };
       const graphStatusText = async () => {
-        const st = await graphStatus(cwd);
+        const st = await graphStatus((await derivedWorkdir(false)).dir);
         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._";
@@ -1555,7 +2019,7 @@ ${lines.join("\n")}${tail}`;
 
 _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 buildGraphText = async () => (await buildProjectGraph((await derivedWorkdir(true)).dir)).message;
       const cleanWorktreesText = async (apply, branch) => {
         const { surveySessions, cleanSessions, describeSurvey, describeClean } = await import("./clean-YOQATBMZ.js");
         const target = branch?.trim() || fromBranch;
@@ -1565,31 +2029,42 @@ _Every agent can query it: \`graph_impact\` (blast radius), \`graph_trace\`, \`g
         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 = () => {
+      const traceableDocs = async (dir = cwd) => traceableFiles(dir, { code: false });
+      const traceableFiles2 = async (dir = cwd) => traceableFiles(dir);
+      const tracerChain = () => {
         for (const role of ["tracer", "architect", "senior-coder", "judge"]) {
-          const m = config.roles[role]?.models[0];
-          if (m && m !== "default") return m;
+          const chain = (config.roles[role]?.models ?? []).filter((m) => m && m !== "default");
+          if (chain.length) return chain;
         }
-        return config.model;
+        return [config.model];
+      };
+      const derivedWorkdir = async (create) => {
+        const inSession = sessionBase(cwd);
+        if (inSession) return { dir: inSession };
+        const standing = join12(cwd, ".horsecode", "worktrees", "traces", "base");
+        if (!create) return { dir: existsSync4(standing) ? standing : cwd };
+        const session = await manager.openFixed(fromBranch, "traces");
+        return { dir: session.baseWorktree, session };
       };
       const planTracesFn = async () => {
-        const plan = await planFor(cwd, await traceableFiles2());
-        return { summary: describePlan(plan, tracerModel()), jobs: plan.jobs.length };
+        const { dir } = await derivedWorkdir(false);
+        const plan = await planFor(dir, await traceableFiles2(dir));
+        return { summary: describePlan(plan, tracerChain()), 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 { dir, session } = await derivedWorkdir(true);
+        const files = await traceableFiles2(dir);
+        const brief = await buildBrief({ cwd: dir, provider: metered ?? provider, models: tracerChain(), files: await traceableDocs(dir) });
+        const plan = await planFor(dir, files);
         const res = await runTraces({
-          cwd,
+          cwd: dir,
           provider: metered ?? provider,
-          model: tracerModel(),
+          models: tracerChain(),
           plan,
           liveFiles: new Set(files),
           ...onProgress ? { onProgress } : {}
         });
+        if (session) await manager.preserveSession(session, `docs(traces): ${res.written} file(s) described`);
         const bits = [`${brief.message}
 
 **Traces written: ${res.written}**`];
@@ -1597,9 +2072,13 @@ _Every agent can query it: \`graph_impact\` (blast radius), \`graph_trace\`, \`g
         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._");
         const failures = describeTraceFailures(res.failed);
+        const landed = session ? `
+
+_Written and committed on \`${session.baseBranch}\`, so your working tree is untouched._
+_Bring them in with \`git merge ${session.baseBranch}\`, or browse them at \`${session.baseWorktree}\`._` : "\n\n_Written in this session's worktree, on its own branch._";
         return `${bits.join(" \xB7 ")}${failures ? `
 
-${failures}` : ""}
+${failures}` : ""}${landed}
 
 _Committed with the repo, so every clone starts with them. Agents read one with \`graph_trace\`._`;
       };
@@ -1607,11 +2086,14 @@ _Committed with the repo, so every clone starts with them. Agents read one with
         buildDeps,
         memStore,
         accountsNote,
+        modelsPanel: modelsPanelNote,
+        initProject: initProjectFn,
         listSkills,
         updateSkills,
         addSkill,
         reloadProjectSkills,
         graphStatus: graphStatusText,
+        derivedDir: async () => (await derivedWorkdir(true)).dir,
         buildGraph: buildGraphText,
         cleanWorktrees: cleanWorktreesText,
         planTraces: planTracesFn,
@@ -1644,7 +2126,7 @@ _Committed with the repo, so every clone starts with them. Agents read one with
     ...args.revisionRounds !== void 0 && { revisionRounds: args.revisionRounds }
   };
   if (useTui) {
-    const { runTui } = await import("./app-2GPGCDX6.js");
+    const { runTui } = await import("./app-4WN37LZ3.js");
     const res = await runTui({ buildDeps, job });
     console.log(renderResult(res));
     return;