@chit-run/cli 0.4.1 → 0.6.0

package/dist/chit.js

@@ -970,6 +970,7 @@ function validateLoopRecord(raw) {
       scope: str2(o, "scope", ctx),
       task: str2(o, "task", ctx),
       repo: str2(o, "repo", ctx),
+      repoKey: str2(o, "repoKey", ctx),
       startedAt: str2(o, "startedAt", ctx),
       maxIterations: int2(o, "maxIterations", ctx, 1)
     };
@@ -988,8 +989,11 @@ function validateLoopRecord(raw) {
       checkDurationMs: int2(o, "checkDurationMs", ctx, 0),
       at: str2(o, "at", ctx)
     };
-    if (o.detailsRef !== undefined)
-      rec.detailsRef = str2(o, "detailsRef", ctx);
+    if (o.workspaceWarnings !== undefined) {
+      rec.workspaceWarnings = stringArray2(o, "workspaceWarnings", ctx);
+    }
+    if (o.auditRef !== undefined)
+      rec.auditRef = str2(o, "auditRef", ctx);
     const usage = optUsage2(o, ctx);
     if (usage !== undefined)
       rec.usage = usage;
@@ -9964,11 +9968,11 @@ var init_dist = __esm(() => {
 
 // ../studio/src/server/audit.ts
 import { existsSync as existsSync8, readFileSync as readFileSync9 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join8 } from "path";
+import { homedir as homedir6 } from "os";
+import { join as join9 } from "path";
 function defaultAuditDir2() {
-  const xdg = process.env.XDG_STATE_HOME || join8(homedir5(), ".local", "state");
-  return join8(xdg, "chit", "audit");
+  const xdg = process.env.XDG_STATE_HOME || join9(homedir6(), ".local", "state");
+  return join9(xdg, "chit", "audit");
 }
 function blobRefs(e) {
   switch (e.type) {
@@ -9987,8 +9991,8 @@ function blobRefs(e) {
 function readAuditRun(auditDir, runId, includeBlobs) {
   if (!SAFE_RUN_ID2.test(runId))
     return { kind: "invalid-id" };
-  const runDir = join8(auditDir, "runs", runId);
-  const eventsPath = join8(runDir, "events.jsonl");
+  const runDir = join9(auditDir, "runs", runId);
+  const eventsPath = join9(runDir, "events.jsonl");
   if (!existsSync8(eventsPath))
     return { kind: "not-found" };
   let events2;
@@ -10001,13 +10005,13 @@ function readAuditRun(auditDir, runId, includeBlobs) {
   }
   if (!includeBlobs)
     return { kind: "ok", events: events2 };
-  const blobsDir = join8(runDir, "blobs");
+  const blobsDir = join9(runDir, "blobs");
   const blobs = {};
   for (const e of events2) {
     for (const ref of blobRefs(e)) {
       if (!SHA256_HEX2.test(ref) || ref in blobs)
         continue;
-      const blobPath = join8(blobsDir, ref);
+      const blobPath = join9(blobsDir, ref);
       if (existsSync8(blobPath))
         blobs[ref] = readFileSync9(blobPath, "utf-8");
     }
@@ -10094,7 +10098,7 @@ var init_paths = __esm(() => {
 
 // ../studio/src/server/discovery.ts
 import { readdirSync as readdirSync3, readFileSync as readFileSync10 } from "fs";
-import { basename, join as join9, relative } from "path";
+import { basename, join as join10, relative } from "path";
 function safeParseChit(absolutePath) {
   try {
     const raw2 = JSON.parse(readFileSync10(absolutePath, "utf-8"));
@@ -10124,7 +10128,7 @@ function discover(opts) {
       continue;
     if (!entry.name.endsWith(".json"))
       continue;
-    const absolutePath = join9(opts.cwd, entry.name);
+    const absolutePath = join10(opts.cwd, entry.name);
     if (!safeParseChit(absolutePath))
       continue;
     candidates.push({
@@ -10149,14 +10153,14 @@ var init_discovery = __esm(() => {
 });
 
 // ../studio/src/server/docs.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 import { readFileSync as readFileSync11, writeFileSync as writeFileSync6 } from "fs";
 import { basename as basename2, relative as relative2 } from "path";
 function canonicalize(draft) {
   return JSON.stringify(draft, null, "\t");
 }
 function hashRaw(raw2) {
-  return createHash5("sha256").update(raw2, "utf-8").digest("hex");
+  return createHash6("sha256").update(raw2, "utf-8").digest("hex");
 }
 
 class DocStore {
@@ -10363,10 +10367,7 @@ var init_docs = __esm(() => {
 
 // ../studio/src/server/loops.ts
 import { existsSync as existsSync10, readdirSync as readdirSync4, readFileSync as readFileSync12 } from "fs";
-import { join as join10 } from "path";
-function loopsDir2(cwd) {
-  return join10(cwd, ".chit", "loops");
-}
+import { join as join11 } from "path";
 function summarize(loopId, records) {
   const header = records[0];
   if (header?.type !== "loop")
@@ -10383,26 +10384,8 @@ function summarize(loopId, records) {
     startedAt: header.startedAt
   };
 }
-function listLoops(cwd) {
-  const dir = loopsDir2(cwd);
-  if (!existsSync10(dir))
-    return [];
-  const summaries = [];
-  for (const name of readdirSync4(dir)) {
-    if (!name.endsWith(".jsonl"))
-      continue;
-    const loopId = name.slice(0, -".jsonl".length);
-    const result = readLoop2(cwd, loopId);
-    if (result.kind === "ok")
-      summaries.push(summarize(loopId, result.records));
-  }
-  summaries.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
-  return summaries;
-}
-function readLoop2(cwd, loopId) {
-  if (!SAFE_LOOP_ID2.test(loopId))
-    return { kind: "invalid-id" };
-  const path = join10(loopsDir2(cwd), `${loopId}.jsonl`);
+function readLoopFrom(dir, loopId) {
+  const path = join11(dir, `${loopId}.jsonl`);
   if (!existsSync10(path))
     return { kind: "not-found" };
   try {
@@ -10418,6 +10401,30 @@ function readLoop2(cwd, loopId) {
     throw e;
   }
 }
+function listLoops(loopsDir) {
+  if (!loopsDir || !existsSync10(loopsDir))
+    return [];
+  const summaries = [];
+  for (const name of readdirSync4(loopsDir)) {
+    if (!name.endsWith(".jsonl"))
+      continue;
+    const loopId = name.slice(0, -".jsonl".length);
+    if (!SAFE_LOOP_ID2.test(loopId))
+      continue;
+    const result = readLoopFrom(loopsDir, loopId);
+    if (result.kind === "ok")
+      summaries.push(summarize(loopId, result.records));
+  }
+  summaries.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+  return summaries;
+}
+function readLoop2(loopsDir, loopId) {
+  if (!SAFE_LOOP_ID2.test(loopId))
+    return { kind: "invalid-id" };
+  if (!loopsDir)
+    return { kind: "not-found" };
+  return readLoopFrom(loopsDir, loopId);
+}
 var SAFE_LOOP_ID2;
 var init_loops = __esm(() => {
   init_src();
@@ -10456,7 +10463,7 @@ __export(exports_server, {
   PathError: () => PathError
 });
 import { existsSync as existsSync11 } from "fs";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 async function startStudio(opts) {
   const hostname3 = opts.hostname ?? "127.0.0.1";
   const requestedPort = opts.port ?? 0;
@@ -10474,7 +10481,8 @@ async function startStudio(opts) {
     store,
     allowedHosts,
     clientDistDir,
-    lifecycle: opts.lifecycle
+    lifecycle: opts.lifecycle,
+    loopsDir: opts.loopsDir
   });
   const server2 = Bun.serve({
     port: requestedPort,
@@ -10508,7 +10516,7 @@ function buildApp(opts) {
     const asset = c.req.param("asset");
     if (!CLIENT_ASSETS.has(asset))
       return c.text("not found", 404);
-    const path = join11(opts.clientDistDir, asset);
+    const path = join12(opts.clientDistDir, asset);
     if (!existsSync11(path)) {
       return c.text(`client bundle missing at ${path}. Run: bun run studio:build`, 503);
     }
@@ -10589,10 +10597,10 @@ function buildApp(opts) {
     return c.json(result);
   });
   app.get("/api/loops", (c) => {
-    return c.json(listLoops(opts.cwd));
+    return c.json(listLoops(opts.loopsDir));
   });
   app.get("/api/loops/:loopId", (c) => {
-    const result = readLoop2(opts.cwd, c.req.param("loopId"));
+    const result = readLoop2(opts.loopsDir, c.req.param("loopId"));
     if (result.kind === "not-found")
       return c.text("not found", 404);
     if (result.kind === "invalid-id")
@@ -10684,15 +10692,15 @@ var init_server = __esm(() => {
   init_loops();
   init_token();
   init_paths();
-  CLIENT_DIST = join11(import.meta.dir, "..", "..", "dist", "client");
+  CLIENT_DIST = join12(import.meta.dir, "..", "..", "dist", "client");
   CLIENT_ASSETS = new Set(["index.js", "index.css"]);
 });
 
 // src/cli/run.ts
 init_src();
 import { readFileSync as readFileSync13 } from "fs";
-import { homedir as homedir6 } from "os";
-import { basename as basename3, dirname as dirname2, join as join12 } from "path";
+import { homedir as homedir7 } from "os";
+import { basename as basename3, dirname as dirname2, join as join13 } from "path";
 
 // src/adapters/sanitize.ts
 var SENSITIVE_KEY = /key|token|secret|password|auth/i;
@@ -11596,6 +11604,45 @@ function wrapAdaptersWithAudit(adapters, recorder) {
   return out;
 }
 
+// src/loops/location.ts
+import { spawnSync } from "child_process";
+import { createHash as createHash2 } from "crypto";
+import { realpathSync } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+function gitTopLevel(cwd) {
+  try {
+    const out = spawnSync("git", ["-C", cwd, "rev-parse", "--show-toplevel"], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    if (out.status !== 0)
+      return;
+    const top = out.stdout.trim();
+    return top || undefined;
+  } catch {
+    return;
+  }
+}
+function repoRoot(cwd) {
+  const base = gitTopLevel(cwd) ?? cwd;
+  try {
+    return realpathSync(base);
+  } catch {
+    return base;
+  }
+}
+function repoKey(cwd) {
+  return createHash2("sha256").update(repoRoot(cwd)).digest("hex").slice(0, 16);
+}
+function loopStateDir() {
+  const xdg = process.env.XDG_STATE_HOME || join3(homedir3(), ".local", "state");
+  return join3(xdg, "chit", "loops");
+}
+function loopLogDir(cwd) {
+  return join3(loopStateDir(), repoKey(cwd));
+}
+
 // src/runtime/render.ts
 import { existsSync as existsSync3 } from "fs";
 import { isAbsolute, resolve } from "path";
@@ -11818,7 +11865,7 @@ async function executeManifest(manifest, options) {
 }
 
 // src/sessions/fingerprint.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 function computeFingerprint(input) {
   const { agent, participant } = input;
   const baseUrl = agent.env?.ANTHROPIC_BASE_URL ?? agent.env?.OPENAI_BASE_URL ?? agent.env?.OLLAMA_HOST ?? "";
@@ -11834,7 +11881,7 @@ function computeFingerprint(input) {
     session: participant.session,
     permissions: participant.permissions
   });
-  return createHash2("sha256").update(material).digest("hex").slice(0, 16);
+  return createHash3("sha256").update(material).digest("hex").slice(0, 16);
 }
 
 // src/sessions/coordinator.ts
@@ -11886,7 +11933,7 @@ function buildSessionAdapter(inner, manifestId, scope, trackedFingerprints, stor
 }
 
 // src/sessions/store.ts
-import { createHash as createHash3, randomUUID as randomUUID2 } from "crypto";
+import { createHash as createHash4, randomUUID as randomUUID2 } from "crypto";
 import {
   closeSync,
   existsSync as existsSync4,
@@ -11898,8 +11945,8 @@ import {
   writeFileSync as writeFileSync2,
   writeSync
 } from "fs";
-import { homedir as homedir3 } from "os";
-import { dirname, join as join3 } from "path";
+import { homedir as homedir4 } from "os";
+import { dirname, join as join4 } from "path";
 function isObject4(v) {
   return v !== null && typeof v === "object" && !Array.isArray(v);
 }
@@ -11916,8 +11963,8 @@ function sleepSync(ms) {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
 function defaultSessionDir() {
-  const xdg = process.env.XDG_STATE_HOME || join3(homedir3(), ".local", "state");
-  return join3(xdg, "chit", "sessions");
+  const xdg = process.env.XDG_STATE_HOME || join4(homedir4(), ".local", "state");
+  return join4(xdg, "chit", "sessions");
 }
 
 class FileSessionStore {
@@ -12012,16 +12059,16 @@ class FileSessionStore {
   }
   filePath(key) {
     const readable = `${safeSegment(key.scope)}--${safeSegment(key.manifestId)}`;
-    const hash = createHash3("sha256").update(`${key.scope}${HASH_SEP}${key.manifestId}`).digest("hex").slice(0, 12);
-    return join3(this.baseDir, `${readable}--${hash}.json`);
+    const hash = createHash4("sha256").update(`${key.scope}${HASH_SEP}${key.manifestId}`).digest("hex").slice(0, 12);
+    return join4(this.baseDir, `${readable}--${hash}.json`);
   }
 }
 
 // src/surfaces/claude-skill.ts
 init_src();
-import { createHash as createHash4, randomBytes } from "crypto";
+import { createHash as createHash5, randomBytes } from "crypto";
 import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync4, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
-import { join as join4, resolve as resolvePath } from "path";
+import { join as join5, resolve as resolvePath } from "path";
 class SurfaceInstallError extends Error {
   constructor(message) {
     super(message);
@@ -12083,7 +12130,7 @@ ${formatEnforcementGaps(gaps)}
 Pass allowUnenforcedPermissions=true to install anyway; the generated skill will warn on every run.`);
   }
   const installName = opts.overrideName ?? manifest.id;
-  const skillDir = join4(outputDir, installName);
+  const skillDir = join5(outputDir, installName);
   if (existsSync5(skillDir)) {
     if (!opts.force) {
       throw new SurfaceInstallError(`skill directory already exists: ${skillDir}
@@ -12093,9 +12140,9 @@ Pass force=true to remove and replace it, or use overrideName="<id>" to install
     rmSync3(skillDir, { recursive: true, force: true });
   }
   mkdirSync3(skillDir, { recursive: true });
-  const skillMdPath = join4(skillDir, "SKILL.md");
-  const manifestPath = join4(skillDir, "manifest.json");
-  const markerPath = join4(skillDir, INSTALL_MARKER_FILENAME);
+  const skillMdPath = join5(skillDir, "SKILL.md");
+  const manifestPath = join5(skillDir, "manifest.json");
+  const markerPath = join5(skillDir, INSTALL_MARKER_FILENAME);
   const manifestJson = `${JSON.stringify(rawJson, null, 2)}
 `;
   writeFileSync3(manifestPath, manifestJson);
@@ -12115,7 +12162,7 @@ Pass force=true to remove and replace it, or use overrideName="<id>" to install
     manifestId: manifest.id,
     runtimePath,
     installedAt: new Date().toISOString(),
-    manifestHash: createHash4("sha256").update(manifestJson).digest("hex")
+    manifestHash: createHash5("sha256").update(manifestJson).digest("hex")
   };
   writeFileSync3(markerPath, `${JSON.stringify(marker, null, 2)}
 `);
@@ -12182,10 +12229,10 @@ function escapeFrontmatter(s) {
 // src/surfaces/lifecycle.ts
 init_src();
 import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync5, rmSync as rmSync4, statSync as statSync2 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join5 } from "path";
+import { homedir as homedir5 } from "os";
+import { join as join6 } from "path";
 function defaultSkillsDir() {
-  return join5(homedir4(), ".claude", "skills");
+  return join6(homedir5(), ".claude", "skills");
 }
 
 class LifecycleError extends Error {
@@ -12200,7 +12247,7 @@ function listInstalled(parentDir) {
   const out = [];
   const entries = readdirSync2(parentDir);
   for (const name of entries) {
-    const skillDir = join5(parentDir, name);
+    const skillDir = join6(parentDir, name);
     let stat;
     try {
       stat = statSync2(skillDir);
@@ -12209,7 +12256,7 @@ function listInstalled(parentDir) {
     }
     if (!stat.isDirectory())
       continue;
-    const markerPath = join5(skillDir, INSTALL_MARKER_FILENAME);
+    const markerPath = join6(skillDir, INSTALL_MARKER_FILENAME);
     if (!existsSync6(markerPath))
       continue;
     let raw;
@@ -12229,14 +12276,14 @@ function uninstall(parentDir, name) {
   if (!VALID_INSTALL_NAME_RE.test(name)) {
     throw new LifecycleError(`install name "${name}" is invalid: must be kebab-case (lowercase letters, digits, hyphens; must start with a letter). Path-traversal sequences like ".." or "/" are rejected.`);
   }
-  const skillDir = join5(parentDir, name);
+  const skillDir = join6(parentDir, name);
   if (!existsSync6(skillDir)) {
     throw new LifecycleError(`no install at ${skillDir}`);
   }
   if (!statSync2(skillDir).isDirectory()) {
     throw new LifecycleError(`${skillDir} is not a directory`);
   }
-  const markerPath = join5(skillDir, INSTALL_MARKER_FILENAME);
+  const markerPath = join6(skillDir, INSTALL_MARKER_FILENAME);
   if (!existsSync6(markerPath)) {
     throw new LifecycleError(`refusing to uninstall ${skillDir}: no install marker (${INSTALL_MARKER_FILENAME}) present. ` + `This directory was not created by chit (or was created by a pre-marker version). ` + `If you're sure this is yours, remove it manually with rm -rf.`);
   }
@@ -35061,8 +35108,7 @@ import { resolve as resolve2 } from "path";
 // src/loops/log-store.ts
 init_src();
 import { appendFileSync as appendFileSync2, existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
-import { join as join6 } from "path";
-
+import { join as join7 } from "path";
 class LoopStoreError extends Error {
 }
 var SAFE_LOOP_ID = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
@@ -35070,14 +35116,14 @@ var realClock2 = () => Date.now();
 function iso(ms) {
   return new Date(ms).toISOString();
 }
-function loopsDir(cwd) {
-  return join6(cwd, ".chit", "loops");
-}
-function loopPath(cwd, loopId) {
+function safeId(loopId) {
   if (!SAFE_LOOP_ID.test(loopId)) {
     throw new LoopStoreError(`invalid loop id ${JSON.stringify(loopId)}`);
   }
-  return join6(loopsDir(cwd), `${loopId}.jsonl`);
+  return loopId;
+}
+function loopPath(cwd, loopId) {
+  return join7(loopLogDir(cwd), `${safeId(loopId)}.jsonl`);
 }
 function readRecords(path, loopId) {
   if (!existsSync7(path)) {
@@ -35096,14 +35142,15 @@ function startLoop(cwd, opts) {
   if (existsSync7(path) && !opts.force) {
     throw new LoopStoreError(`loop log already exists at ${path} (pass force to overwrite)`);
   }
-  mkdirSync4(loopsDir(cwd), { recursive: true });
+  mkdirSync4(loopLogDir(cwd), { recursive: true });
   const header = {
     type: "loop",
     schema: 1,
     loopId,
     scope: opts.scope,
     task: opts.task,
-    repo: cwd,
+    repo: repoRoot(cwd),
+    repoKey: repoKey(cwd),
     startedAt: iso((opts.clock ?? realClock2)()),
     maxIterations: opts.maxIterations
   };
@@ -35134,8 +35181,11 @@ function appendIteration(cwd, loopId, opts) {
     checkDurationMs: opts.checkDurationMs,
     at: iso((opts.clock ?? realClock2)())
   };
-  if (opts.detailsRef !== undefined)
-    rec.detailsRef = opts.detailsRef;
+  if (opts.workspaceWarnings !== undefined && opts.workspaceWarnings.length > 0) {
+    rec.workspaceWarnings = opts.workspaceWarnings;
+  }
+  if (opts.auditRef !== undefined)
+    rec.auditRef = opts.auditRef;
   if (opts.usage !== undefined)
     rec.usage = opts.usage;
   appendFileSync2(path, `${serializeLoopRecord(rec)}
@@ -35172,7 +35222,7 @@ function readLoop(cwd, loopId) {
 var DEFAULT_CONVERGE_MANIFEST = {
   schema: 1,
   id: "converge",
-  description: "Autonomous convergence: a write-capable Claude implements a slice, then a read-only Codex reviews the diff and returns proceed/revise/block. Drive it in a loop with the `chit converge` CLI driver, or stepwise from the MCP - one chit_start per iteration, same scope so both agents keep their thread, feeding the prior review back in via inputs.prior_review. The human sequences and checkpoints (inspect the diff each round, stop if it goes sideways); chit runs the agents. Run against an isolated worktree, not the main checkout.",
+  description: "Autonomous convergence: a write-capable Claude implements a slice, then a read-only Codex reviews the diff and returns proceed/revise/block. Drive it in a loop with the `chit converge` CLI driver, or stepwise from the MCP - one chit_run_start per iteration, same scope so both agents keep their thread, feeding the prior review back in via inputs.prior_review. The human sequences and checkpoints (inspect the diff each round, stop if it goes sideways); chit runs the agents. Run against an isolated worktree, not the main checkout.",
   inputs: {
     task: { type: "string" },
     prior_review: { type: "string", optional: true }
@@ -35189,7 +35239,7 @@ var DEFAULT_CONVERGE_MANIFEST = {
     },
     reviewer: {
       agent: "codex",
-      role: "You are a skeptical implementation reviewer for a convergence loop. Claude just edited the repository at your cwd. Inspect the current git diff and the changed files, verify the work against the task, and run non-mutating checks if useful. Do not edit. Do not agree for the sake of agreeing. Use prior context from this scope. Cite file:line and command results.",
+      role: "You are a skeptical implementation reviewer for a convergence loop. Claude just edited the repository at your cwd. Inspect the current git diff and the changed files, and verify the work against the task. Base your verdict on the TASK changes. Untracked generated build artifacts (e.g. __pycache__, *.pyc) are workspace hygiene, not task changes: note them at most as a minor aside and do NOT revise solely because of them. chit keeps its own control-plane state outside the repo, so it never appears in the diff. Run non-mutating checks if useful. Do not edit. Do not agree for the sake of agreeing. Use prior context from this scope. Cite file:line and command results.",
       session: "per_scope",
       permissions: { filesystem: "read_only" }
     }
@@ -35238,6 +35288,32 @@ findingCount is the integer number of findings; checksRun is a short human strin
   output: "out"
 };
 
+// src/cli/workspace.ts
+function isChitOwned(path) {
+  return path === ".chit" || path.startsWith(".chit/");
+}
+function isGeneratedArtifact(path) {
+  const base = path.slice(path.lastIndexOf("/") + 1);
+  return path === "__pycache__" || path.startsWith("__pycache__/") || path.includes("/__pycache__/") || path.endsWith(".pyc") || path.endsWith(".pyo") || base === ".DS_Store";
+}
+function classifyWorkspace(snap) {
+  const changed = new Set;
+  for (const f of snap.tracked) {
+    if (!isChitOwned(f))
+      changed.add(f);
+  }
+  const workspaceWarnings = [];
+  for (const f of snap.untracked) {
+    if (isChitOwned(f))
+      continue;
+    if (isGeneratedArtifact(f))
+      workspaceWarnings.push(`untracked generated artifact: ${f}`);
+    else
+      changed.add(f);
+  }
+  return { changedFiles: [...changed], workspaceWarnings };
+}
+
 // src/cli/converge.ts
 var defaultIO = {
   out: (s) => process.stdout.write(s),
@@ -35330,13 +35406,14 @@ function gitLines(cwd, args) {
     return [];
   }
 }
-function gitChangedFiles(cwd) {
-  const all = [
-    ...gitLines(cwd, ["diff", "--name-only"]),
-    ...gitLines(cwd, ["diff", "--cached", "--name-only"]),
-    ...gitLines(cwd, ["ls-files", "--others", "--exclude-standard"])
-  ];
-  return [...new Set(all)];
+function gitWorkspace(cwd) {
+  return classifyWorkspace({
+    tracked: [
+      ...gitLines(cwd, ["diff", "--name-only"]),
+      ...gitLines(cwd, ["diff", "--cached", "--name-only"])
+    ],
+    untracked: gitLines(cwd, ["ls-files", "--others", "--exclude-standard"])
+  });
 }
 
 class ConvergeExecuteError extends Error {
@@ -35366,17 +35443,18 @@ async function runConvergeIteration(ctx) {
   const reviewText = result.outputs.review ?? "";
   const review = parseReview(reviewText);
   const usage = sumTraceUsage(result.trace);
-  const changedFiles = gitChangedFiles(ctx.cwd);
+  const { changedFiles, workspaceWarnings } = gitWorkspace(ctx.cwd);
   appendIteration(ctx.cwd, ctx.loopId, {
     implementSummary: capSummary(result.outputs.implement ?? ""),
     changedFiles,
+    workspaceWarnings,
     checksRun: review.checksRun,
     verdict: review.verdict,
     findingCount: review.findingCount,
     decision: review.verdict,
     checkDurationMs: reviewDurationMs(result.trace),
     ...usage && { usage },
-    ...result.auditRunId && { detailsRef: `audit:${result.auditRunId}` }
+    ...result.auditRunId && { auditRef: result.auditRunId }
   });
   const stopStatus = review.verdict === "proceed" ? "converged" : review.verdict === "block" ? "blocked" : undefined;
   return {
@@ -35386,6 +35464,7 @@ async function runConvergeIteration(ctx) {
     checksRun: review.checksRun,
     decision: review.verdict,
     changedFiles,
+    workspaceWarnings,
     ...usage && { usage },
     ...result.auditRunId && { auditRunId: result.auditRunId },
     reviewText,
@@ -35512,8 +35591,8 @@ var CONVERGE_HELP = `chit converge --task <text> --scope <id> [options]
                            adapter cannot enforce (emits a warning each run).
                            Default off: such a manifest is refused before running.
 
-Runs the implement/check loop to convergence and records it under
-.chit/loops/<loopId>.jsonl. Stops at the reviewer's verdict: proceed ->
+Runs the implement/check loop to convergence and records it under chit's
+state dir (keyed by repo, not in the worktree). Stops at the reviewer's verdict: proceed ->
 converged, block -> blocked, else revise and retry up to the budget. An
 unparseable verdict is treated as block (never an implicit proceed).
 `;
@@ -35764,6 +35843,7 @@ async function runNextIteration(session, signal) {
       findingCount: iter.findingCount,
       checksRun: iter.checksRun,
       changedFiles: iter.changedFiles,
+      workspaceWarnings: iter.workspaceWarnings,
       ...iter.usage !== undefined && { usage: iter.usage },
       ...iter.auditRunId !== undefined && { auditRunId: iter.auditRunId },
       ...session.terminalStatus !== undefined && { stopStatus: session.terminalStatus }
@@ -35842,6 +35922,9 @@ class ConvergeStore {
     if (this.sessions.has(loopId))
       this.lastTouched.set(loopId, now);
   }
+  list() {
+    return [...this.sessions.values()];
+  }
   sweep(now) {
     const evicted = [];
     for (const [loopId, session] of this.sessions) {
@@ -35875,7 +35958,7 @@ function startRun(runId, opts) {
   }
   const needsScope = Object.values(manifest.participants).some((p) => p.session === "per_scope");
   if (needsScope && opts.scope === undefined) {
-    throw new RuntimeError(`manifest "${manifest.id}" has per_scope participant(s); a scope is required (pass scope to chit_start)`);
+    throw new RuntimeError(`manifest "${manifest.id}" has per_scope participant(s); a scope is required (pass scope to chit_run_start)`);
   }
   const baseAdapters = {};
   for (const p of Object.values(manifest.participants)) {
@@ -36078,6 +36161,9 @@ class RunStore {
     if (this.runs.has(runId))
       this.lastTouched.set(runId, now);
   }
+  list() {
+    return [...this.runs.values()];
+  }
   sweep(now) {
     const evicted = [];
     for (const [runId, run] of this.runs) {
@@ -36098,6 +36184,39 @@ class RunStore {
   }
 }
 
+// src/surfaces/mcp/status.ts
+function summarizeRunForStatus(run) {
+  const complete = isComplete(run);
+  return {
+    run_id: run.runId,
+    manifest: run.manifest.id,
+    complete,
+    ready: complete ? [] : readySteps(run),
+    audited: run.recorder !== undefined && run.recorder.lastError === undefined
+  };
+}
+function byNewest(items) {
+  return [...items].sort((a, b) => b.startedAtMs - a.startedAtMs);
+}
+function recentRuns(auditStore, recentLimit) {
+  if (recentLimit === 0)
+    return [];
+  try {
+    return listAudit(auditStore, recentLimit);
+  } catch {
+    return [];
+  }
+}
+function buildStatus(runs, convergeSessions, auditStore, recentLimit) {
+  return {
+    active: {
+      runs: byNewest(runs.list()).map(summarizeRunForStatus),
+      loops: byNewest(convergeSessions.list()).map(describeConverge)
+    },
+    recent: recentRuns(auditStore, recentLimit)
+  };
+}
+
 // src/surfaces/mcp/server.ts
 var runs = new RunStore;
 var controllers = new Map;
@@ -36140,7 +36259,7 @@ function describeRun(run) {
     audit: run.recorder && run.recorder.lastError === undefined ? { runId: run.runId } : undefined
   };
 }
-server.registerTool("chit_start", {
+server.registerTool("chit_run_start", {
   description: "Start a stepwise run of a chit manifest. Returns a run_id and the steps ready to run. chit owns the declared order; only ready steps can be run. Then call chit_run_step for each ready step.",
   inputSchema: {
     manifest_path: exports_external.string().describe("Path to the manifest .json (absolute, or relative to cwd)"),
@@ -36176,7 +36295,7 @@ server.registerTool("chit_start", {
   runs.add(run, Date.now());
   return jsonResult(describeRun(run));
 });
-server.registerTool("chit_next", {
+server.registerTool("chit_run_next", {
   description: "List the steps ready to run next for a run, or report that the run is complete.",
   inputSchema: { run_id: exports_external.string() }
 }, async ({ run_id }) => {
@@ -36235,7 +36354,7 @@ server.registerTool("chit_run_step", {
     runs.touch(run_id, Date.now());
   }
 });
-server.registerTool("chit_cancel", {
+server.registerTool("chit_run_cancel", {
   description: "Cancel a step that is currently running: aborts its controller, which kills the agent's child process and settles the step as cancelled (terminal, blocks dependents). Returns cancelled:true if it stopped a running step, or a reason (already_done | not_running) otherwise. Use after interrupting a long step.",
   inputSchema: { run_id: exports_external.string(), step_id: exports_external.string() }
 }, async ({ run_id, step_id }) => {
@@ -36252,7 +36371,7 @@ server.registerTool("chit_cancel", {
     ...describeRun(run)
   });
 });
-server.registerTool("chit_trace", {
+server.registerTool("chit_run_trace", {
   description: "Return the transcript of a run so far: each step's status, participant, agent, elapsed, and output.",
   inputSchema: { run_id: exports_external.string() }
 }, async ({ run_id }) => {
@@ -36310,7 +36429,7 @@ Pass allow_unenforced_permissions=true to run anyway.`
   return { ok: true, execute: buildExecute(manifest, registry3, scope, cwd), warnings };
 }
 server.registerTool("chit_converge_start", {
-  description: "Start an autonomous converge loop (a write-capable implementer slices the task, a read-only reviewer checks the diff) driven one iteration at a time. Returns a loop_id and the next action. Then call chit_converge_next per iteration. Records to .chit/loops/<loop_id>.jsonl, identical to `chit converge`.",
+  description: "Start an autonomous converge loop (a write-capable implementer slices the task, a read-only reviewer checks the diff) driven one iteration at a time. Returns a loop_id and the next action. Then call chit_converge_next per iteration. Records the loop under chit's state dir (keyed by repo), identical to `chit converge`.",
   inputSchema: {
     task: exports_external.string().describe("The slice to converge on"),
     scope: exports_external.string().describe("Session scope id; both agents keep their thread across iterations"),
@@ -36415,6 +36534,7 @@ server.registerTool("chit_converge_next", {
       findingCount: result.findingCount,
       checksRun: result.checksRun,
       changedFiles: result.changedFiles,
+      workspaceWarnings: result.workspaceWarnings,
       ...result.usage && { usage: result.usage },
       ...result.auditRunId && { auditRunId: result.auditRunId },
       ...result.stopStatus && { stopStatus: result.stopStatus },
@@ -36480,6 +36600,14 @@ server.registerTool("chit_audit_show", {
     return errorResult(e.message);
   }
 });
+server.registerTool("chit_status", {
+  description: "Operator overview: the stepwise runs and converge loops live in THIS server right now (each loop with its status and next action), plus a compact list of recently audited runs (newest first). Read-only; answers 'what is active and what should I do next?'. Active state is per-session (a new session starts empty, and idle runs are evicted); recent state is durable. Drill into one item with chit_converge_status/chit_run_trace, or chit_audit_show for a run's receipt.",
+  inputSchema: {
+    recent_limit: exports_external.number().int().min(0).default(5).describe("How many recently audited runs to include (newest first). Default 5; 0 for none.")
+  }
+}, async ({ recent_limit }) => {
+  return jsonResult(buildStatus(runs, convergeSessions, auditStore, recent_limit));
+});
 async function startMcpServer() {
   await server.connect(new StdioServerTransport);
 }
@@ -36710,7 +36838,7 @@ ${AUDIT_HELP}`);
 // src/cli/doctor.ts
 import { randomUUID as randomUUID3 } from "crypto";
 import { mkdirSync as mkdirSync5, rmSync as rmSync5, writeFileSync as writeFileSync5 } from "fs";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 var defaultIO3 = {
   out: (s) => process.stdout.write(s),
   err: (s) => process.stderr.write(s)
@@ -36779,7 +36907,7 @@ function checkGitRepo(deps) {
 function checkAuditDir(deps) {
   try {
     mkdirSync5(deps.auditDir, { recursive: true });
-    const probeFile = join7(deps.auditDir, `.doctor-${randomUUID3()}`);
+    const probeFile = join8(deps.auditDir, `.doctor-${randomUUID3()}`);
     writeFileSync5(probeFile, "ok");
     rmSync5(probeFile);
     return { name: "audit dir", status: "pass", detail: `writable (${deps.auditDir})` };
@@ -36912,12 +37040,13 @@ var ALLOWED = {
       "loop-id",
       "summary",
       "changed-files",
+      "workspace-warnings",
       "checks-run",
       "verdict",
       "finding-count",
       "decision",
       "duration-ms",
-      "details-ref"
+      "audit-ref"
     ],
     bools: []
   },
@@ -36929,7 +37058,8 @@ var LOOP_LOG_HELP = `chit loop-log <start|append|stop|show> [flags]
   start   --scope <s> --task <t> --max-iterations <n> [--cwd <dir>] [--loop-id <id>] [--force]
   append  --loop-id <id> --summary <t> --changed-files <json> --checks-run <t>
           --verdict <proceed|revise|block> --finding-count <n>
-          --decision <proceed|revise|block> --duration-ms <n> [--details-ref <r>] [--cwd <dir>]
+          --decision <proceed|revise|block> --duration-ms <n>
+          [--workspace-warnings <json>] [--audit-ref <r>] [--cwd <dir>]
   stop    --loop-id <id> --status <converged|blocked|max-iterations|needs-decision> --reason <t> [--cwd <dir>]
   show    --loop-id <id> [--json] [--cwd <dir>]
 
@@ -36979,15 +37109,15 @@ function intFlag(p, key, verb) {
   }
   return n;
 }
-function parseChangedFiles(raw) {
+function parseStringArray(raw, flag) {
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch {
-    throw new UsageError3("--changed-files must be a JSON array of strings");
+    throw new UsageError3(`--${flag} must be a JSON array of strings`);
   }
   if (!Array.isArray(parsed) || parsed.some((e) => typeof e !== "string")) {
-    throw new UsageError3("--changed-files must be a JSON array of strings");
+    throw new UsageError3(`--${flag} must be a JSON array of strings`);
   }
   return parsed;
 }
@@ -37006,6 +37136,11 @@ function renderLoop(records) {
       lines.push(`  ${r.n}. ${r.implementSummary}`);
       lines.push(`     ${r.changedFiles.length} files \xB7 check ${r.verdict.toUpperCase()} \xB7 ` + `${Math.round(r.checkDurationMs / 1000)}s \xB7 ${r.findingCount} findings`);
       lines.push(`     decide ${r.decision}`);
+      if (r.workspaceWarnings && r.workspaceWarnings.length > 0) {
+        lines.push(`     workspace: ${r.workspaceWarnings.length} warning(s)`);
+        for (const w of r.workspaceWarnings)
+          lines.push(`       - ${w}`);
+      }
     } else if (r.type === "stop") {
       lines.push("");
       lines.push(`  stopped: ${r.status} (${r.reason}) \xB7 ${r.iterations} iters \xB7 ` + `${Math.round(r.totalElapsedMs / 1000)}s`);
@@ -37037,15 +37172,19 @@ function runLoopLog(argv, io = defaultIO4) {
       return 0;
     }
     if (verb === "append") {
+      const warningsRaw = p.flags["workspace-warnings"];
       const res = appendIteration(cwd, req(p, "loop-id", verb), {
         implementSummary: req(p, "summary", verb),
-        changedFiles: parseChangedFiles(req(p, "changed-files", verb)),
+        changedFiles: parseStringArray(req(p, "changed-files", verb), "changed-files"),
+        ...warningsRaw !== undefined && {
+          workspaceWarnings: parseStringArray(warningsRaw, "workspace-warnings")
+        },
         checksRun: req(p, "checks-run", verb),
         verdict: req(p, "verdict", verb),
         findingCount: intFlag(p, "finding-count", verb),
         decision: req(p, "decision", verb),
         checkDurationMs: intFlag(p, "duration-ms", verb),
-        detailsRef: p.flags["details-ref"]
+        auditRef: p.flags["audit-ref"]
       });
       io.out(`${JSON.stringify(res)}
 `);
@@ -37643,7 +37782,7 @@ ${HELP}`);
 `);
     return 2;
   }
-  const outputDir = args.outputDir ?? join12(homedir6(), ".claude", "skills");
+  const outputDir = args.outputDir ?? join13(homedir7(), ".claude", "skills");
   const runtimePath = args.runtimePath ?? defaultRuntimePath();
   try {
     const result = installClaudeSkill({
@@ -37810,7 +37949,8 @@ async function runStudio(args) {
       cwd: process.cwd(),
       explicitPath: args.manifestPath,
       registry: registry3,
-      lifecycle: buildStudioLifecycle()
+      lifecycle: buildStudioLifecycle(),
+      loopsDir: loopLogDir(process.cwd())
     });
   } catch (e) {
     if (e instanceof PathError2) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@chit-run/cli",
-	"version": "0.4.1",
+	"version": "0.6.0",
 	"description": "Versioned, cross-vendor agent routines with an audit trail. Stop being the glue between your agents.",
 	"type": "module",
 	"license": "MIT",