@chit-run/cli 0.6.0 → 0.8.0

package/dist/chit.js

@@ -4679,7 +4679,7 @@ var require_compile = __commonJS((exports) => {
     const schOrFunc = root.refs[ref];
     if (schOrFunc)
       return schOrFunc;
-    let _sch = resolve2.call(this, root, ref);
+    let _sch = resolve4.call(this, root, ref);
     if (_sch === undefined) {
       const schema = (_a3 = root.localRefs) === null || _a3 === undefined ? undefined : _a3[ref];
       const { schemaId } = this.opts;
@@ -4706,7 +4706,7 @@ var require_compile = __commonJS((exports) => {
   function sameSchemaEnv(s1, s2) {
     return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
   }
-  function resolve2(root, ref) {
+  function resolve4(root, ref) {
     let sch;
     while (typeof (sch = this.refs[ref]) == "string")
       ref = sch;
@@ -5292,7 +5292,7 @@ var require_fast_uri = __commonJS((exports, module) => {
     }
     return uri;
   }
-  function resolve2(baseURI, relativeURI, options) {
+  function resolve4(baseURI, relativeURI, options) {
     const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
     const resolved = resolveComponent(parse7(baseURI, schemelessOptions), parse7(relativeURI, schemelessOptions), schemelessOptions, true);
     schemelessOptions.skipEscape = true;
@@ -5551,7 +5551,7 @@ var require_fast_uri = __commonJS((exports, module) => {
   var fastUri = {
     SCHEMES,
     normalize,
-    resolve: resolve2,
+    resolve: resolve4,
     resolveComponent,
     equal,
     serialize,
@@ -9967,12 +9967,12 @@ var init_dist = __esm(() => {
 });
 
 // ../studio/src/server/audit.ts
-import { existsSync as existsSync8, readFileSync as readFileSync9 } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join9 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync12 } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join10 } from "path";
 function defaultAuditDir2() {
-  const xdg = process.env.XDG_STATE_HOME || join9(homedir6(), ".local", "state");
-  return join9(xdg, "chit", "audit");
+  const xdg = process.env.XDG_STATE_HOME || join10(homedir7(), ".local", "state");
+  return join10(xdg, "chit", "audit");
 }
 function blobRefs(e) {
   switch (e.type) {
@@ -9991,13 +9991,13 @@ function blobRefs(e) {
 function readAuditRun(auditDir, runId, includeBlobs) {
   if (!SAFE_RUN_ID2.test(runId))
     return { kind: "invalid-id" };
-  const runDir = join9(auditDir, "runs", runId);
-  const eventsPath = join9(runDir, "events.jsonl");
-  if (!existsSync8(eventsPath))
+  const runDir = join10(auditDir, "runs", runId);
+  const eventsPath = join10(runDir, "events.jsonl");
+  if (!existsSync9(eventsPath))
     return { kind: "not-found" };
   let events2;
   try {
-    events2 = parseAuditLog(readFileSync9(eventsPath, "utf-8"));
+    events2 = parseAuditLog(readFileSync12(eventsPath, "utf-8"));
   } catch (e) {
     if (e instanceof AuditEventError)
       return { kind: "invalid-log", message: e.message };
@@ -10005,15 +10005,15 @@ function readAuditRun(auditDir, runId, includeBlobs) {
   }
   if (!includeBlobs)
     return { kind: "ok", events: events2 };
-  const blobsDir = join9(runDir, "blobs");
+  const blobsDir = join10(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 = join9(blobsDir, ref);
-      if (existsSync8(blobPath))
-        blobs[ref] = readFileSync9(blobPath, "utf-8");
+      const blobPath = join10(blobsDir, ref);
+      if (existsSync9(blobPath))
+        blobs[ref] = readFileSync12(blobPath, "utf-8");
     }
   }
   return { kind: "ok", events: events2, blobs };
@@ -10071,12 +10071,12 @@ var init_auth = __esm(() => {
 });
 
 // ../studio/src/server/paths.ts
-import { existsSync as existsSync9, statSync as statSync3 } from "fs";
-import { isAbsolute as isAbsolute3, resolve as resolve5 } from "path";
+import { existsSync as existsSync10, statSync as statSync3 } from "fs";
+import { isAbsolute as isAbsolute4, resolve as resolve6 } from "path";
 function resolveExplicitPath(userPath, cwd) {
-  const candidate = isAbsolute3(userPath) ? userPath : resolve5(cwd, userPath);
-  const canonical = resolve5(candidate);
-  if (!existsSync9(canonical)) {
+  const candidate = isAbsolute4(userPath) ? userPath : resolve6(cwd, userPath);
+  const canonical = resolve6(candidate);
+  if (!existsSync10(canonical)) {
     throw new PathError("not-found", `path "${userPath}" does not exist`);
   }
   if (!statSync3(canonical).isFile()) {
@@ -10097,11 +10097,11 @@ var init_paths = __esm(() => {
 });
 
 // ../studio/src/server/discovery.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync10 } from "fs";
-import { basename, join as join10, relative } from "path";
+import { readdirSync as readdirSync4, readFileSync as readFileSync13 } from "fs";
+import { basename, join as join11, relative } from "path";
 function safeParseChit(absolutePath) {
   try {
-    const raw2 = JSON.parse(readFileSync10(absolutePath, "utf-8"));
+    const raw2 = JSON.parse(readFileSync13(absolutePath, "utf-8"));
     parseManifest(raw2);
     return true;
   } catch {
@@ -10121,14 +10121,14 @@ function discover(opts) {
       relPath: relPathFromCwd(absolutePath, opts.cwd)
     };
   }
-  const entries = readdirSync3(opts.cwd, { withFileTypes: true });
+  const entries = readdirSync4(opts.cwd, { withFileTypes: true });
   const candidates = [];
   for (const entry of entries) {
     if (!entry.isFile())
       continue;
     if (!entry.name.endsWith(".json"))
       continue;
-    const absolutePath = join10(opts.cwd, entry.name);
+    const absolutePath = join11(opts.cwd, entry.name);
     if (!safeParseChit(absolutePath))
       continue;
     candidates.push({
@@ -10154,7 +10154,7 @@ var init_discovery = __esm(() => {
 
 // ../studio/src/server/docs.ts
 import { createHash as createHash6 } from "crypto";
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync6 } from "fs";
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync7 } from "fs";
 import { basename as basename2, relative as relative2 } from "path";
 function canonicalize(draft) {
   return JSON.stringify(draft, null, "\t");
@@ -10187,7 +10187,7 @@ class DocStore {
     if (!entry)
       return null;
     try {
-      return hashRaw(readFileSync11(entry.absolutePath, "utf-8"));
+      return hashRaw(readFileSync14(entry.absolutePath, "utf-8"));
     } catch {
       return null;
     }
@@ -10229,7 +10229,7 @@ class DocStore {
       return null;
     let raw2;
     try {
-      raw2 = readFileSync11(entry.absolutePath, "utf-8");
+      raw2 = readFileSync14(entry.absolutePath, "utf-8");
     } catch (e) {
       const errorDoc = {
         id: docId,
@@ -10285,7 +10285,7 @@ class DocStore {
       return { kind: "not-found" };
     let currentRaw;
     try {
-      currentRaw = readFileSync11(entry.absolutePath, "utf-8");
+      currentRaw = readFileSync14(entry.absolutePath, "utf-8");
     } catch {
       return { kind: "not-found" };
     }
@@ -10297,7 +10297,7 @@ class DocStore {
       const manifest = parseManifest(draft);
       const graphModel = buildGraphModel(manifest, this.registry, surface);
       const canonicalRaw = canonicalize(draft);
-      writeFileSync6(entry.absolutePath, canonicalRaw, "utf-8");
+      writeFileSync7(entry.absolutePath, canonicalRaw, "utf-8");
       const newHash = hashRaw(canonicalRaw);
       return {
         kind: "saved",
@@ -10366,8 +10366,8 @@ var init_docs = __esm(() => {
 });
 
 // ../studio/src/server/loops.ts
-import { existsSync as existsSync10, readdirSync as readdirSync4, readFileSync as readFileSync12 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync11, readdirSync as readdirSync5, readFileSync as readFileSync15 } from "fs";
+import { join as join12 } from "path";
 function summarize(loopId, records) {
   const header = records[0];
   if (header?.type !== "loop")
@@ -10385,11 +10385,11 @@ function summarize(loopId, records) {
   };
 }
 function readLoopFrom(dir, loopId) {
-  const path = join11(dir, `${loopId}.jsonl`);
-  if (!existsSync10(path))
+  const path = join12(dir, `${loopId}.jsonl`);
+  if (!existsSync11(path))
     return { kind: "not-found" };
   try {
-    const records = validateLoopLog(parseLoopLog(readFileSync12(path, "utf-8")));
+    const records = validateLoopLog(parseLoopLog(readFileSync15(path, "utf-8")));
     const header = records[0];
     if (header?.type !== "loop" || header.loopId !== loopId) {
       return { kind: "invalid-log", message: "header loopId does not match the file name" };
@@ -10402,10 +10402,10 @@ function readLoopFrom(dir, loopId) {
   }
 }
 function listLoops(loopsDir) {
-  if (!loopsDir || !existsSync10(loopsDir))
+  if (!loopsDir || !existsSync11(loopsDir))
     return [];
   const summaries = [];
-  for (const name of readdirSync4(loopsDir)) {
+  for (const name of readdirSync5(loopsDir)) {
     if (!name.endsWith(".jsonl"))
       continue;
     const loopId = name.slice(0, -".jsonl".length);
@@ -10462,8 +10462,8 @@ __export(exports_server, {
   buildApp: () => buildApp,
   PathError: () => PathError
 });
-import { existsSync as existsSync11 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync12 } from "fs";
+import { join as join13 } from "path";
 async function startStudio(opts) {
   const hostname3 = opts.hostname ?? "127.0.0.1";
   const requestedPort = opts.port ?? 0;
@@ -10516,8 +10516,8 @@ function buildApp(opts) {
     const asset = c.req.param("asset");
     if (!CLIENT_ASSETS.has(asset))
       return c.text("not found", 404);
-    const path = join12(opts.clientDistDir, asset);
-    if (!existsSync11(path)) {
+    const path = join13(opts.clientDistDir, asset);
+    if (!existsSync12(path)) {
       return c.text(`client bundle missing at ${path}. Run: bun run studio:build`, 503);
     }
     return new Response(Bun.file(path));
@@ -10692,15 +10692,15 @@ var init_server = __esm(() => {
   init_loops();
   init_token();
   init_paths();
-  CLIENT_DIST = join12(import.meta.dir, "..", "..", "dist", "client");
+  CLIENT_DIST = join13(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 homedir7 } from "os";
-import { basename as basename3, dirname as dirname2, join as join13 } from "path";
+import { readFileSync as readFileSync16 } from "fs";
+import { homedir as homedir8 } from "os";
+import { basename as basename3, dirname as dirname2, join as join14 } from "path";
 
 // src/adapters/sanitize.ts
 var SENSITIVE_KEY = /key|token|secret|password|auth/i;
@@ -10820,6 +10820,11 @@ class ClaudeCliAdapter {
         if (noProgress)
           throw new Error(`claude --print made no progress for ${noProgressMs}ms`);
         if (exitCode !== 0) {
+          const rateLimit = detectClaudeRateLimit(`${stdoutText}
+${stderrText}`);
+          if (rateLimit !== undefined) {
+            throw new Error(`claude --print rate limited${rateLimit ? `: ${rateLimit}` : ` (exit ${exitCode})`}`);
+          }
           const cleaned = sanitize(stderrText || stdoutText, sensitive);
           const tail = cleaned.trim().split(`
 `).slice(-5).join(`
@@ -10953,6 +10958,42 @@ function parseClaudeResult(stdout) {
   }
   return result;
 }
+function detectClaudeRateLimit(stdout) {
+  const pickStr = (v) => typeof v === "string" && v.trim() !== "" ? v.trim().replace(/\s+/g, " ").slice(0, 120) : undefined;
+  const pickNum = (v) => typeof v === "number" && Number.isFinite(v) ? v : undefined;
+  let found = false;
+  let detail = "";
+  for (const line of stdout.split(`
+`)) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    let evt;
+    try {
+      evt = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (evt.type !== "rate_limit_event")
+      continue;
+    found = true;
+    const rl = evt.rate_limit_info && typeof evt.rate_limit_info === "object" ? evt.rate_limit_info : evt.rate_limit && typeof evt.rate_limit === "object" ? evt.rate_limit : evt;
+    const parts = [];
+    const status = pickStr(rl.status);
+    if (status)
+      parts.push(`status=${status}`);
+    const resetsAt = pickStr(rl.resetsAt);
+    if (resetsAt)
+      parts.push(`resets ${resetsAt}`);
+    const retryAfter = pickNum(rl.retryAfter) ?? pickNum(rl.resetInSeconds);
+    if (retryAfter !== undefined)
+      parts.push(`retry after ${retryAfter}s`);
+    if (rl.isUsingOverage === false)
+      parts.push("overage disabled");
+    detail = parts.join(", ");
+  }
+  return found ? detail : undefined;
+}
 
 // src/adapters/codex-exec.ts
 var DEFAULT_CALL_TIMEOUT_MS2 = 15 * 60000;
@@ -10972,7 +11013,7 @@ class CodexExecAdapter {
     const sensitive = findSensitiveValues(this.config.env);
     try {
       const priorThreadId = getCodexThreadId(req.session);
-      const cmd = this.buildCommand(priorThreadId);
+      const cmd = this.buildCommand(priorThreadId, req.filesystem);
       const proc = Bun.spawn({
         cmd,
         cwd: req.cwd,
@@ -11049,7 +11090,7 @@ class CodexExecAdapter {
       throw new Error(message);
     }
   }
-  buildCommand(priorThreadId) {
+  buildCommand(priorThreadId, filesystem) {
     if (priorThreadId) {
       return ["codex", "exec", "resume", "--json", "--skip-git-repo-check", priorThreadId, "-"];
     }
@@ -11059,7 +11100,8 @@ class CodexExecAdapter {
     if (this.config.reasoningEffort) {
       cmd.push("-c", `model_reasoning_effort="${this.config.reasoningEffort}"`);
     }
-    cmd.push("--sandbox", "read-only", "--skip-git-repo-check", "-");
+    const sandbox = filesystem === "write" ? "workspace-write" : "read-only";
+    cmd.push("--sandbox", sandbox, "--skip-git-repo-check", "-");
     return cmd;
   }
 }
@@ -11604,12 +11646,172 @@ function wrapAdaptersWithAudit(adapters, recorder) {
   return out;
 }
 
+// src/jobs/store.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import {
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync2,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync4,
+  renameSync as renameSync2,
+  rmSync as rmSync3,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+
+// src/jobs/lock.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { closeSync, openSync, readFileSync as readFileSync3, rmSync as rmSync2, writeSync } from "fs";
+
+class LockError extends Error {
+}
+function sleepSync(ms) {
+  if (ms <= 0)
+    return;
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function acquireLock(lockPath, opts = {}) {
+  const retryMs = opts.retryMs ?? 50;
+  const maxAttempts = opts.maxAttempts ?? 200;
+  const token = randomUUID2();
+  for (let attempt = 0;attempt < maxAttempts; attempt++) {
+    try {
+      const fd = openSync(lockPath, "wx");
+      try {
+        writeSync(fd, token);
+      } finally {
+        closeSync(fd);
+      }
+      return { path: lockPath, token };
+    } catch (err) {
+      if (err.code !== "EEXIST")
+        throw err;
+      sleepSync(retryMs);
+    }
+  }
+  throw new LockError(`could not acquire lock ${lockPath} after ${maxAttempts} attempts. ` + "If no chit process holds it, a previous run may have crashed while holding it; " + `remove the lock file to continue: rm ${JSON.stringify(lockPath)}`);
+}
+function releaseLock(lock) {
+  try {
+    if (readFileSync3(lock.path, "utf-8") === lock.token)
+      rmSync2(lock.path, { force: true });
+  } catch {}
+}
+function withFileLock(lockPath, fn, opts) {
+  const lock = acquireLock(lockPath, opts);
+  try {
+    return fn();
+  } finally {
+    releaseLock(lock);
+  }
+}
+
+// src/jobs/store.ts
+class JobStoreError extends Error {
+}
+var SAFE_JOB_ID = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+function defaultJobsDir() {
+  const xdg = process.env.XDG_STATE_HOME || join3(homedir3(), ".local", "state");
+  return join3(xdg, "chit", "jobs");
+}
+
+class JobStore {
+  baseDir;
+  constructor(baseDir = defaultJobsDir()) {
+    this.baseDir = baseDir;
+  }
+  path(jobId) {
+    if (!SAFE_JOB_ID.test(jobId))
+      throw new JobStoreError(`invalid job id ${JSON.stringify(jobId)}`);
+    return join3(this.baseDir, `${jobId}.json`);
+  }
+  lockPath(jobId) {
+    return `${this.path(jobId)}.lock`;
+  }
+  loopLockPath(loopId) {
+    if (!SAFE_JOB_ID.test(loopId))
+      throw new JobStoreError(`invalid loop id ${JSON.stringify(loopId)}`);
+    mkdirSync2(join3(this.baseDir, "locks"), { recursive: true });
+    return join3(this.baseDir, "locks", `${loopId}.lock`);
+  }
+  create(record) {
+    mkdirSync2(this.baseDir, { recursive: true });
+    const path = this.path(record.jobId);
+    withFileLock(this.lockPath(record.jobId), () => {
+      if (existsSync3(path))
+        throw new JobStoreError(`job ${JSON.stringify(record.jobId)} already exists`);
+      writeAtomic(path, record);
+    });
+  }
+  get(jobId) {
+    const path = this.path(jobId);
+    if (!existsSync3(path))
+      return;
+    try {
+      return JSON.parse(readFileSync4(path, "utf-8"));
+    } catch {
+      return;
+    }
+  }
+  update(jobId, mutate) {
+    const path = this.path(jobId);
+    return withFileLock(this.lockPath(jobId), () => {
+      if (!existsSync3(path))
+        throw new JobStoreError(`no job ${JSON.stringify(jobId)}`);
+      const current = JSON.parse(readFileSync4(path, "utf-8"));
+      const next = mutate(current);
+      writeAtomic(path, next);
+      return next;
+    });
+  }
+  list() {
+    if (!existsSync3(this.baseDir))
+      return [];
+    const jobs = [];
+    for (const name of readdirSync2(this.baseDir)) {
+      if (!name.endsWith(".json"))
+        continue;
+      try {
+        jobs.push(JSON.parse(readFileSync4(join3(this.baseDir, name), "utf-8")));
+      } catch {}
+    }
+    jobs.sort((a, b) => (b.createdAt ?? "").localeCompare(a.createdAt ?? ""));
+    return jobs;
+  }
+}
+function writeAtomic(path, record) {
+  const tmp = `${path}.${randomUUID3()}.tmp`;
+  writeFileSync2(tmp, JSON.stringify(record, null, 2));
+  try {
+    renameSync2(tmp, path);
+  } catch (err) {
+    rmSync3(tmp, { force: true });
+    throw err;
+  }
+}
+
+// src/jobs/worker.ts
+import { readFileSync as readFileSync8 } from "fs";
+import { isAbsolute as isAbsolute2, resolve as resolve3 } from "path";
+
+// src/cli/converge.ts
+init_src();
+import { execFileSync } from "child_process";
+import { readFileSync as readFileSync7 } from "fs";
+import { resolve as resolve2 } from "path";
+
+// src/loops/log-store.ts
+init_src();
+import { appendFileSync as appendFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { join as join5 } from "path";
+
 // 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";
+import { homedir as homedir4 } from "os";
+import { join as join4 } from "path";
 function gitTopLevel(cwd) {
   try {
     const out = spawnSync("git", ["-C", cwd, "rev-parse", "--show-toplevel"], {
@@ -11636,15 +11838,125 @@ 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");
+  const xdg = process.env.XDG_STATE_HOME || join4(homedir4(), ".local", "state");
+  return join4(xdg, "chit", "loops");
 }
 function loopLogDir(cwd) {
-  return join3(loopStateDir(), repoKey(cwd));
+  return join4(loopStateDir(), repoKey(cwd));
+}
+
+// src/loops/log-store.ts
+class LoopStoreError extends Error {
+}
+var SAFE_LOOP_ID = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+var realClock2 = () => Date.now();
+function iso(ms) {
+  return new Date(ms).toISOString();
+}
+function safeId(loopId) {
+  if (!SAFE_LOOP_ID.test(loopId)) {
+    throw new LoopStoreError(`invalid loop id ${JSON.stringify(loopId)}`);
+  }
+  return loopId;
+}
+function loopPath(cwd, loopId) {
+  return join5(loopLogDir(cwd), `${safeId(loopId)}.jsonl`);
+}
+function readRecords(path, loopId) {
+  if (!existsSync4(path)) {
+    throw new LoopStoreError(`no loop log for ${JSON.stringify(loopId)} at ${path}`);
+  }
+  const records = validateLoopLog(parseLoopLog(readFileSync5(path, "utf-8")));
+  const header = records[0];
+  if (header.loopId !== loopId) {
+    throw new LoopStoreError(`loop log at ${path} declares loopId ${JSON.stringify(header.loopId)}, expected ${JSON.stringify(loopId)}`);
+  }
+  return records;
+}
+function startLoop(cwd, opts) {
+  const loopId = opts.loopId ?? crypto.randomUUID();
+  const path = loopPath(cwd, loopId);
+  if (existsSync4(path) && !opts.force) {
+    throw new LoopStoreError(`loop log already exists at ${path} (pass force to overwrite)`);
+  }
+  mkdirSync3(loopLogDir(cwd), { recursive: true });
+  const header = {
+    type: "loop",
+    schema: 1,
+    loopId,
+    scope: opts.scope,
+    task: opts.task,
+    repo: repoRoot(cwd),
+    repoKey: repoKey(cwd),
+    startedAt: iso((opts.clock ?? realClock2)()),
+    maxIterations: opts.maxIterations
+  };
+  writeFileSync3(path, `${serializeLoopRecord(header)}
+`);
+  return { loopId, path };
+}
+function appendIteration(cwd, loopId, opts) {
+  const path = loopPath(cwd, loopId);
+  const records = readRecords(path, loopId);
+  if (records.some((r) => r.type === "stop")) {
+    throw new LoopStoreError(`loop ${JSON.stringify(loopId)} is already stopped; cannot append`);
+  }
+  const header = records[0];
+  const n = records.filter((r) => r.type === "iteration").length + 1;
+  if (n > header.maxIterations) {
+    throw new LoopStoreError(`loop ${JSON.stringify(loopId)} is at its iteration budget (maxIterations=${header.maxIterations}); cannot append iteration ${n}`);
+  }
+  const rec = {
+    type: "iteration",
+    n,
+    implementSummary: opts.implementSummary,
+    changedFiles: opts.changedFiles,
+    checksRun: opts.checksRun,
+    verdict: opts.verdict,
+    findingCount: opts.findingCount,
+    decision: opts.decision,
+    checkDurationMs: opts.checkDurationMs,
+    at: iso((opts.clock ?? realClock2)())
+  };
+  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)}
+`);
+  return { n, path };
+}
+function stopLoop(cwd, loopId, opts) {
+  const path = loopPath(cwd, loopId);
+  const records = readRecords(path, loopId);
+  if (records.some((r) => r.type === "stop")) {
+    throw new LoopStoreError(`loop ${JSON.stringify(loopId)} is already stopped`);
+  }
+  const header = records[0];
+  const iterations = records.filter((r) => r.type === "iteration").length;
+  const nowMs = (opts.clock ?? realClock2)();
+  const totalElapsedMs = Math.max(0, nowMs - Date.parse(header.startedAt));
+  const rec = {
+    type: "stop",
+    status: opts.status,
+    reason: opts.reason,
+    iterations,
+    totalElapsedMs,
+    endedAt: iso(nowMs)
+  };
+  appendFileSync2(path, `${serializeLoopRecord(rec)}
+`);
+  return { iterations, totalElapsedMs, path };
+}
+function readLoop(cwd, loopId) {
+  return readRecords(loopPath(cwd, loopId), loopId);
 }
 
 // src/runtime/render.ts
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import { isAbsolute, resolve } from "path";
 
 class RuntimeError extends Error {
@@ -11692,7 +12004,7 @@ function renderFilePaths(paths, invocationCwd, inputName) {
   const resolved = [];
   for (const p of paths) {
     const abs = isAbsolute(p) ? p : resolve(invocationCwd, p);
-    if (!existsSync3(abs)) {
+    if (!existsSync5(abs)) {
       throw new RuntimeError(`input "${inputName}" references missing file: ${p}`);
     }
     resolved.push(abs);
@@ -11876,6 +12188,9 @@ function computeFingerprint(input) {
     reasoningEffort: agent.reasoningEffort ?? null,
     passModelOnResume: agent.adapter === "claude-cli" ? agent.passModelOnResume : null,
     strictMcp: agent.adapter === "claude-cli" ? agent.strictMcp !== false : null,
+    ...agent.adapter === "codex-exec" && {
+      codexSandbox: participant.permissions.filesystem === "write" ? "workspace-write" : "read-only"
+    },
     baseUrl,
     role: participant.role,
     session: participant.session,
@@ -11933,20 +12248,20 @@ function buildSessionAdapter(inner, manifestId, scope, trackedFingerprints, stor
 }
 
 // src/sessions/store.ts
-import { createHash as createHash4, randomUUID as randomUUID2 } from "crypto";
+import { createHash as createHash4, randomUUID as randomUUID4 } from "crypto";
 import {
-  closeSync,
-  existsSync as existsSync4,
-  mkdirSync as mkdirSync2,
-  openSync,
-  readFileSync as readFileSync3,
-  renameSync as renameSync2,
-  rmSync as rmSync2,
-  writeFileSync as writeFileSync2,
-  writeSync
+  closeSync as closeSync2,
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync4,
+  openSync as openSync2,
+  readFileSync as readFileSync6,
+  renameSync as renameSync3,
+  rmSync as rmSync4,
+  writeFileSync as writeFileSync4,
+  writeSync as writeSync2
 } from "fs";
-import { homedir as homedir4 } from "os";
-import { dirname, join as join4 } from "path";
+import { homedir as homedir5 } from "os";
+import { dirname, join as join6 } from "path";
 function isObject4(v) {
   return v !== null && typeof v === "object" && !Array.isArray(v);
 }
@@ -11957,14 +12272,14 @@ function entryKey(participantId, fingerprint) {
   return `${participantId}--${fingerprint}`;
 }
 var HASH_SEP = String.fromCharCode(0);
-function sleepSync(ms) {
+function sleepSync2(ms) {
   if (ms <= 0)
     return;
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
 function defaultSessionDir() {
-  const xdg = process.env.XDG_STATE_HOME || join4(homedir4(), ".local", "state");
-  return join4(xdg, "chit", "sessions");
+  const xdg = process.env.XDG_STATE_HOME || join6(homedir5(), ".local", "state");
+  return join6(xdg, "chit", "sessions");
 }
 
 class FileSessionStore {
@@ -11978,11 +12293,11 @@ class FileSessionStore {
   }
   load(key) {
     const path = this.filePath(key);
-    if (!existsSync4(path))
+    if (!existsSync6(path))
       return;
     let raw;
     try {
-      raw = JSON.parse(readFileSync3(path, "utf-8"));
+      raw = JSON.parse(readFileSync6(path, "utf-8"));
     } catch {
       return;
     }
@@ -11992,13 +12307,13 @@ class FileSessionStore {
   }
   save(key, payload) {
     const path = this.filePath(key);
-    mkdirSync2(dirname(path), { recursive: true });
+    mkdirSync4(dirname(path), { recursive: true });
     const lock = this.acquireLock(path);
     try {
       let data = {};
-      if (existsSync4(path)) {
+      if (existsSync6(path)) {
         try {
-          const raw = JSON.parse(readFileSync3(path, "utf-8"));
+          const raw = JSON.parse(readFileSync6(path, "utf-8"));
           if (isObject4(raw))
             data = raw;
         } catch {
@@ -12006,13 +12321,13 @@ class FileSessionStore {
         }
       }
       data[entryKey(key.participantId, key.fingerprint)] = payload;
-      const tmpPath = `${path}.${randomUUID2()}.tmp`;
-      writeFileSync2(tmpPath, JSON.stringify(data, null, 2));
+      const tmpPath = `${path}.${randomUUID4()}.tmp`;
+      writeFileSync4(tmpPath, JSON.stringify(data, null, 2));
       try {
         this.assertOwned(lock);
-        renameSync2(tmpPath, path);
+        renameSync3(tmpPath, path);
       } catch (err) {
-        rmSync2(tmpPath, { force: true });
+        rmSync4(tmpPath, { force: true });
         throw err;
       }
     } finally {
@@ -12021,20 +12336,20 @@ class FileSessionStore {
   }
   acquireLock(path) {
     const lockPath = `${path}.lock`;
-    const token = randomUUID2();
+    const token = randomUUID4();
     for (let attempt = 0;attempt < this.lockMaxAttempts; attempt++) {
       try {
-        const fd = openSync(lockPath, "wx");
+        const fd = openSync2(lockPath, "wx");
         try {
-          writeSync(fd, token);
+          writeSync2(fd, token);
         } finally {
-          closeSync(fd);
+          closeSync2(fd);
         }
         return { path: lockPath, token };
       } catch (err) {
         if (err.code !== "EEXIST")
           throw err;
-        sleepSync(this.lockRetryMs);
+        sleepSync2(this.lockRetryMs);
       }
     }
     throw new Error(`session store: could not acquire lock ${lockPath} after ${this.lockMaxAttempts} attempts. ` + "If no chit process is using this scope, a previous run may have crashed while holding it; " + `remove the lock file to continue: rm ${JSON.stringify(lockPath)}`);
@@ -12042,7 +12357,7 @@ class FileSessionStore {
   assertOwned(lock) {
     let current;
     try {
-      current = readFileSync3(lock.path, "utf-8");
+      current = readFileSync6(lock.path, "utf-8");
     } catch {
       current = undefined;
     }
@@ -12052,265 +12367,1013 @@ class FileSessionStore {
   }
   releaseLock(lock) {
     try {
-      if (readFileSync3(lock.path, "utf-8") === lock.token) {
-        rmSync2(lock.path, { force: true });
+      if (readFileSync6(lock.path, "utf-8") === lock.token) {
+        rmSync4(lock.path, { force: true });
       }
     } catch {}
   }
   filePath(key) {
     const readable = `${safeSegment(key.scope)}--${safeSegment(key.manifestId)}`;
     const hash = createHash4("sha256").update(`${key.scope}${HASH_SEP}${key.manifestId}`).digest("hex").slice(0, 12);
-    return join4(this.baseDir, `${readable}--${hash}.json`);
+    return join6(this.baseDir, `${readable}--${hash}.json`);
   }
 }
 
-// src/surfaces/claude-skill.ts
-init_src();
-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 join5, resolve as resolvePath } from "path";
-class SurfaceInstallError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "SurfaceInstallError";
-  }
-}
-var CLAUDE_SKILL_CAPABILITIES = new Set([
-  "can_show_markdown",
-  "can_provide_stable_scope"
-]);
-function installClaudeSkill(opts) {
-  if (opts.overrideName !== undefined && !VALID_INSTALL_NAME_RE.test(opts.overrideName)) {
-    throw new SurfaceInstallError(`overrideName "${opts.overrideName}" is invalid: must be kebab-case (lowercase letters, digits, hyphens; must start with a letter). Path-traversal sequences like ".." or "/" are rejected.`);
-  }
-  const outputDir = resolvePath(opts.outputDir);
-  const runtimePath = resolvePath(opts.runtimePath);
-  const allowUnenforced = opts.allowUnenforcedPermissions === true;
-  let rawJson;
-  try {
-    rawJson = JSON.parse(readFileSync4(opts.manifestPath, "utf-8"));
-  } catch (e) {
-    throw new SurfaceInstallError(`failed to read manifest ${opts.manifestPath}: ${e.message}`);
-  }
-  let manifest;
-  try {
-    manifest = parseManifest(rawJson);
-  } catch (e) {
-    throw new SurfaceInstallError(`invalid manifest at ${opts.manifestPath}: ${e.message}`);
-  }
-  const missingCaps = findMissingCapabilities(manifest, CLAUDE_SKILL_CAPABILITIES);
-  if (missingCaps.length > 0) {
-    throw new SurfaceInstallError(`claude-skill surface does not provide capabilities required by "${manifest.id}": ${missingCaps.join(", ")}`);
-  }
-  const inputNames = Object.keys(manifest.inputs);
-  const primaryInput = inputNames[0];
-  if (!primaryInput) {
-    throw new SurfaceInstallError(`manifest "${manifest.id}" has no inputs; nothing to wire from $ARGUMENTS`);
-  }
-  const primaryInputSchema = manifest.inputs[primaryInput];
-  if (primaryInputSchema?.type !== "string") {
-    throw new SurfaceInstallError(`manifest "${manifest.id}": claude-skill surface only supports a string-typed primary input ` + `(got "${primaryInput}": ${primaryInputSchema?.type ?? "missing"})`);
-  }
-  if (inputNames.length > 1) {
-    throw new SurfaceInstallError(`manifest "${manifest.id}" declares multiple inputs (${inputNames.join(", ")}); ` + `claude-skill surface in PR6 supports exactly one string input`);
-  }
-  const registry2 = opts.registry ?? loadRegistry();
-  const unknownAgents = findUnknownAgents(manifest, registry2);
-  if (unknownAgents.length > 0) {
-    const lines = unknownAgents.map((u) => `  - participant "${u.participantId}" references unknown agent "${u.agentId}"`).join(`
-`);
-    throw new SurfaceInstallError(`manifest "${manifest.id}" references agents that are not in the registry:
-${lines}`);
-  }
-  const gaps = findEnforcementGaps(manifest, registry2);
-  if (gaps.length > 0 && !allowUnenforced) {
-    throw new SurfaceInstallError(`cannot enforce required permissions for "${manifest.id}":
-${formatEnforcementGaps(gaps)}
+// src/cli/default-converge-manifest.ts
+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_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 }
+  },
+  requires: {
+    can_show_markdown: true
+  },
+  participants: {
+    implementer: {
+      agent: "claude",
+      role: "You implement one small, focused slice of a software task in the repository at your cwd. Make the ACTUAL code edits with your tools - do not just describe them. Stay scoped to the task; do not refactor unrelated code. If a prior review is provided, address its concrete findings. Run the project's checks if quick. Then summarize precisely: which files you changed, what each change does and why, what you deliberately did NOT do, and which checks you ran with their results.",
+      session: "per_scope",
+      permissions: { filesystem: "write" }
+    },
+    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, 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" }
+    }
+  },
+  steps: {
+    implement: {
+      call: "implementer",
+      prompt: `Task:
+{{ inputs.task }}
 
-Pass allowUnenforcedPermissions=true to install anyway; the generated skill will warn on every run.`);
-  }
-  const installName = opts.overrideName ?? manifest.id;
-  const skillDir = join5(outputDir, installName);
-  if (existsSync5(skillDir)) {
-    if (!opts.force) {
-      throw new SurfaceInstallError(`skill directory already exists: ${skillDir}
+Prior review to address (empty on the first iteration):
+{{ inputs.prior_review }}
 
-Pass force=true to remove and replace it, or use overrideName="<id>" to install with a different name (avoids overwriting an unrelated skill that happens to share this id).`);
-    }
-    rmSync3(skillDir, { recursive: true, force: true });
-  }
-  mkdirSync3(skillDir, { recursive: true });
-  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);
-  writeFileSync3(skillMdPath, buildSkillMd({
-    manifest,
-    runtimePath,
-    primaryInputName: primaryInput,
-    allowUnenforced: gaps.length > 0,
-    trace: opts.trace === true,
-    heredocDelimiter: generateHeredocDelimiter(),
-    installName
-  }));
-  const marker = {
-    schema: 1,
-    surface: "claude-skill",
-    installName,
-    manifestId: manifest.id,
-    runtimePath,
-    installedAt: new Date().toISOString(),
-    manifestHash: createHash5("sha256").update(manifestJson).digest("hex")
-  };
-  writeFileSync3(markerPath, `${JSON.stringify(marker, null, 2)}
-`);
-  return { skillDir, skillMdPath, manifestPath, markerPath, enforcementGaps: gaps };
-}
-function generateHeredocDelimiter() {
-  return `CHIT_INPUT_${randomBytes(8).toString("hex").toUpperCase()}_EOF`;
-}
-function buildSkillMd(opts) {
-  const {
-    manifest,
-    runtimePath,
-    primaryInputName,
-    allowUnenforced,
-    trace,
-    heredocDelimiter,
-    installName
-  } = opts;
-  const allowFlag = allowUnenforced ? `\\
-    --allow-unenforced-permissions ` : "";
-  const traceFlag = trace ? `\\
-    --trace ` : "";
-  return `---
-name: ${installName}
-description: ${escapeFrontmatter(manifest.description)}
-argument-hint: <${primaryInputName}>
-disable-model-invocation: true
----
+Implement this slice now by editing files in the repo at your cwd. Keep it small and focused. Then summarize what you changed (files + what/why), what you did not do, and any checks you ran.`
+    },
+    review: {
+      call: "reviewer",
+      prompt: `Task under review:
+{{ inputs.task }}
 
-# /${installName}
+Claude's summary of what it just implemented:
+{{ steps.implement.output }}
 
-\`\`\`!
-{
-  # Claude Code's \`! \` preprocessor substitutes \${CLAUDE_SESSION_ID} (bare
-  # brace form) BEFORE bash runs. The :- default form is NOT substituted, so
-  # we use the bare form: when running inside Claude Code, this line gets
-  # the real session id baked in (always non-empty); when running outside,
-  # bash evaluates the env var (typically empty, so we fail fast).
-  if [ -z "\${CLAUDE_SESSION_ID}" ]; then
-    echo "chit: CLAUDE_SESSION_ID is required; this skill must run inside Claude Code" >&2
-    exit 2
-  fi
-  WORKTREE="$(git rev-parse --show-toplevel 2>/dev/null || pwd)"
-  SCOPE_HASH=$(printf '%s' "$WORKTREE" | (shasum -a 256 2>/dev/null || sha256sum) | cut -c1-12)
-  SCOPE="\${CLAUDE_SESSION_ID}-\${SCOPE_HASH}"
+Inspect the current git diff and the changed files at your cwd. Verify the change against the task and run non-mutating checks if useful. Return prose with:
+1. Verdict: proceed / revise / block.
+2. Findings ordered by severity, with file:line.
+3. What Claude should fix next if the verdict is revise.
+4. Remaining risk if proceeding.
 
-  bun "${runtimePath}/src/cli/run.ts" run \\
-    "\${CLAUDE_SKILL_DIR}/manifest.json" \\
-    --scope "$SCOPE" \\
-    --invocation-cwd "$WORKTREE" ${allowFlag}${traceFlag}\\
-    --input-stdin ${primaryInputName} <<'${heredocDelimiter}'
-$ARGUMENTS
-${heredocDelimiter}
-} 2>&1
+Then, as the LAST thing in your reply, emit a single machine-readable fenced JSON block that the driver parses (the prose above is for humans). Use exactly these keys:
+\`\`\`json
+{"verdict": "proceed | revise | block", "findingCount": 0, "checksRun": "the non-mutating checks you ran, or 'none'", "risk": "remaining risk if proceeding"}
 \`\`\`
+findingCount is the integer number of findings; checksRun is a short human string.`
+    },
+    out: {
+      format: `## Converge iteration
 
-The block above ran the chit runtime and its output replaced the fenced section before you saw this skill. Present that output to the user as your entire response, verbatim. Preserve every \`##\` header as a markdown header. Do not summarize, rephrase, or add commentary, preamble, or trailing text. If the output contains a \`WARNING\` line, include it.
-`;
-}
-function escapeFrontmatter(s) {
-  return s.replace(/\r?\n/g, " ").replace(/"/g, "'");
-}
+### Implementer (Claude)
+{{ steps.implement.output }}
 
-// 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 homedir5 } from "os";
-import { join as join6 } from "path";
-function defaultSkillsDir() {
-  return join6(homedir5(), ".claude", "skills");
-}
+### Reviewer (Codex)
+{{ steps.review.output }}`
+    }
+  },
+  output: "out"
+};
 
-class LifecycleError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "LifecycleError";
-  }
+// src/cli/workspace.ts
+function isChitOwned(path) {
+  return path === ".chit" || path.startsWith(".chit/");
 }
-function listInstalled(parentDir) {
-  if (!existsSync6(parentDir))
-    return [];
-  const out = [];
-  const entries = readdirSync2(parentDir);
-  for (const name of entries) {
-    const skillDir = join6(parentDir, name);
-    let stat;
-    try {
-      stat = statSync2(skillDir);
-    } catch {
-      continue;
-    }
-    if (!stat.isDirectory())
-      continue;
-    const markerPath = join6(skillDir, INSTALL_MARKER_FILENAME);
-    if (!existsSync6(markerPath))
-      continue;
-    let raw;
-    try {
-      raw = JSON.parse(readFileSync5(markerPath, "utf-8"));
-    } catch {
-      continue;
-    }
-    try {
-      const marker = parseInstallMarker(raw, markerPath);
-      out.push({ skillDir, markerPath, marker });
-    } catch {}
-  }
-  return out.sort((a, b) => a.marker.installName.localeCompare(b.marker.installName));
+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 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 = 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`);
+function classifyWorkspace(snap) {
+  const changed = new Set;
+  for (const f of snap.tracked) {
+    if (!isChitOwned(f))
+      changed.add(f);
   }
-  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.`);
+  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);
   }
-  let raw;
-  try {
-    raw = JSON.parse(readFileSync5(markerPath, "utf-8"));
-  } catch (e) {
-    throw new LifecycleError(`refusing to uninstall ${skillDir}: ${INSTALL_MARKER_FILENAME} is not valid JSON (${e.message})`);
+  return { changedFiles: [...changed], workspaceWarnings };
+}
+
+// src/cli/converge.ts
+var defaultIO = {
+  out: (s) => process.stdout.write(s),
+  err: (s) => process.stderr.write(s)
+};
+var JSON_BLOCK_RE = /```json\s*([\s\S]*?)```/gi;
+var VERDICTS3 = new Set(["proceed", "revise", "block"]);
+var IMPLEMENT_STEP_ID = "implement";
+var REVIEW_STEP_ID = "review";
+var IMPLEMENT_SUMMARY_CAP = 2000;
+var CHECKS_RUN_FALLBACK = "unreported";
+function extractReviewJson(reviewText) {
+  let last;
+  for (const m of reviewText.matchAll(JSON_BLOCK_RE)) {
+    if (m[1] !== undefined)
+      last = m[1];
   }
-  let marker;
+  if (last === undefined)
+    return null;
   try {
-    marker = parseInstallMarker(raw, markerPath);
-  } catch (e) {
-    if (e instanceof MarkerError) {
-      throw new LifecycleError(`refusing to uninstall ${skillDir}: ${e.message}`);
+    const parsed = JSON.parse(last);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
     }
-    throw e;
-  }
-  const record = { skillDir, markerPath, marker };
-  rmSync4(skillDir, { recursive: true, force: true });
-  return record;
+  } catch {}
+  return null;
+}
+function parseReview(reviewText) {
+  const block = extractReviewJson(reviewText);
+  const rawVerdict = typeof block?.verdict === "string" ? block.verdict.toLowerCase() : undefined;
+  if (block && rawVerdict && VERDICTS3.has(rawVerdict)) {
+    const fc = block.findingCount;
+    const cr = block.checksRun;
+    return {
+      verdict: rawVerdict,
+      findingCount: typeof fc === "number" && Number.isInteger(fc) && fc >= 0 ? fc : 0,
+      checksRun: typeof cr === "string" && cr.trim() !== "" ? cr.trim() : CHECKS_RUN_FALLBACK
+    };
+  }
+  return { verdict: "block", findingCount: 0, checksRun: CHECKS_RUN_FALLBACK };
+}
+function reviewDurationMs(trace) {
+  for (const e of trace) {
+    if (e.type === "step.completed" && e.stepId === REVIEW_STEP_ID)
+      return e.durationMs;
+  }
+  return 0;
+}
+var USAGE_KEYS = [
+  "inputTokens",
+  "outputTokens",
+  "totalTokens",
+  "cachedInputTokens",
+  "reasoningTokens",
+  "estimatedCostUsd"
+];
+function sumTraceUsage(trace) {
+  const usage = {};
+  let any = false;
+  for (const e of trace) {
+    if (e.type !== "step.completed" || !e.usage)
+      continue;
+    for (const k of USAGE_KEYS) {
+      const v = e.usage[k];
+      if (typeof v === "number") {
+        usage[k] = (usage[k] ?? 0) + v;
+        any = true;
+      }
+    }
+  }
+  return any ? usage : undefined;
+}
+function capSummary(text) {
+  if (text === "")
+    return "(no summary)";
+  if (text.length <= IMPLEMENT_SUMMARY_CAP)
+    return text;
+  return `${text.slice(0, IMPLEMENT_SUMMARY_CAP)}\u2026 (truncated, ${text.length} chars)`;
+}
+function gitLines(cwd, args) {
+  try {
+    const out = execFileSync("git", args, {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return out.split(`
+`).map((s) => s.trim()).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+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"])
+  });
 }
 
-// src/surfaces/mcp/server.ts
+class ConvergeExecuteError extends Error {
+  executeError;
+  constructor(executeError) {
+    super(executeError instanceof Error ? executeError.message : String(executeError));
+    this.executeError = executeError;
+  }
+}
+async function runConvergeIteration(ctx) {
+  let result;
+  try {
+    result = await ctx.execute({ task: ctx.task, prior_review: ctx.prior_review }, {
+      loopId: ctx.loopId,
+      iteration: ctx.iteration,
+      ...ctx.signal && { signal: ctx.signal },
+      ...ctx.onTrace && { onTrace: ctx.onTrace }
+    });
+  } catch (e) {
+    throw new ConvergeExecuteError(e);
+  }
+  if (!result.ok) {
+    return {
+      ok: false,
+      failure: `manifest run failed at step "${result.failedStep}": ${result.error}`,
+      ...result.auditRunId && { auditRunId: result.auditRunId }
+    };
+  }
+  const reviewText = result.outputs.review ?? "";
+  const review = parseReview(reviewText);
+  const usage = sumTraceUsage(result.trace);
+  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 && { auditRef: result.auditRunId }
+  });
+  const stopStatus = review.verdict === "proceed" ? "converged" : review.verdict === "block" ? "blocked" : undefined;
+  return {
+    ok: true,
+    verdict: review.verdict,
+    findingCount: review.findingCount,
+    checksRun: review.checksRun,
+    decision: review.verdict,
+    changedFiles,
+    workspaceWarnings,
+    ...usage && { usage },
+    ...result.auditRunId && { auditRunId: result.auditRunId },
+    reviewText,
+    ...stopStatus && { stopStatus }
+  };
+}
+async function convergeLoop(opts) {
+  const { loopId } = startLoop(opts.cwd, {
+    scope: opts.scope,
+    task: opts.task,
+    maxIterations: opts.maxIterations,
+    loopId: opts.loopId,
+    force: opts.force
+  });
+  let priorReview = "";
+  let iterations = 0;
+  let status;
+  for (let i = 1;i <= opts.maxIterations; i++) {
+    let iter;
+    try {
+      iter = await runConvergeIteration({
+        cwd: opts.cwd,
+        loopId,
+        iteration: i,
+        task: opts.task,
+        prior_review: priorReview,
+        execute: opts.execute
+      });
+    } catch (e) {
+      if (e instanceof ConvergeExecuteError) {
+        stopLoop(opts.cwd, loopId, {
+          status: "blocked",
+          reason: `manifest run threw: ${e.message}`
+        });
+        throw e.executeError;
+      }
+      throw e;
+    }
+    if (!iter.ok) {
+      status = "blocked";
+      stopLoop(opts.cwd, loopId, { status, reason: iter.failure });
+      return { loopId, iterations, status, failure: iter.failure };
+    }
+    iterations++;
+    if (iter.stopStatus !== undefined) {
+      status = iter.stopStatus;
+      break;
+    }
+    priorReview = iter.reviewText;
+  }
+  if (status === undefined)
+    status = "max-iterations";
+  const reason = status === "converged" ? "reviewer returned proceed" : status === "blocked" ? "reviewer returned block" : `reached max iterations (${opts.maxIterations}) without converging`;
+  stopLoop(opts.cwd, loopId, { status, reason });
+  return { loopId, iterations, status };
+}
+function buildExecute(manifest, registry2, scope, cwd) {
+  const baseAdapters = {};
+  for (const p of Object.values(manifest.participants)) {
+    if (!(p.agent in baseAdapters)) {
+      const agent = registry2.agents[p.agent];
+      if (!agent)
+        continue;
+      baseAdapters[p.agent] = buildAdapter(agent);
+    }
+  }
+  return makeAuditedExecute(manifest, baseAdapters, registry2, scope, cwd, new FileSessionStore(defaultSessionDir()), new AuditStore);
+}
+function prepareConvergeExecute(raw, registry2, scope, cwd, allowUnenforced) {
+  let manifest;
+  try {
+    manifest = parseManifest(raw);
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+  const shapeError = validateConvergeManifest(manifest);
+  if (shapeError)
+    return { ok: false, error: shapeError };
+  const unknown = findUnknownAgents(manifest, registry2);
+  if (unknown.length > 0) {
+    return {
+      ok: false,
+      error: `unknown agent(s): ${unknown.map((u) => `${u.agentId} (participant "${u.participantId}")`).join(", ")}`
+    };
+  }
+  const gaps = findEnforcementGaps(manifest, registry2);
+  if (gaps.length > 0 && !allowUnenforced) {
+    return {
+      ok: false,
+      error: `cannot enforce required permissions:
+${formatEnforcementGaps(gaps)}
+Pass allow_unenforced_permissions=true to run anyway.`
+    };
+  }
+  const warnings = gaps.map((g) => `unenforced permission: participant "${g.participantId}" requires ${g.permission}`);
+  return { ok: true, execute: buildExecute(manifest, registry2, scope, cwd), warnings };
+}
+function makeAuditedExecute(manifest, baseAdapters, registry2, scope, cwd, sessionStore, auditStore) {
+  return async (inputs, ctx) => {
+    const runId = crypto.randomUUID();
+    const recorder = new AuditRecorder(auditStore, runId, {
+      manifestId: manifest.id,
+      cwd,
+      surface: "converge",
+      scope,
+      ...ctx?.loopId !== undefined && { loopId: ctx.loopId },
+      ...ctx?.iteration !== undefined && { iteration: ctx.iteration },
+      participants: resolveParticipantSnapshots(manifest, registry2)
+    });
+    recorder.runStarted();
+    const adapters = wrapAdaptersWithSessions(wrapAdaptersWithAudit(baseAdapters, recorder), manifest, registry2, scope, sessionStore);
+    const startedAt = Date.now();
+    try {
+      const result = await executeManifest(manifest, {
+        inputs,
+        adapters,
+        invocationCwd: cwd,
+        onTrace: (e) => {
+          recorder.fromTrace(e);
+          ctx?.onTrace?.(e);
+        },
+        ...ctx?.signal && { signal: ctx.signal }
+      });
+      recorder.runCompleted(result.ok ? "ok" : "failed", Date.now() - startedAt);
+      recorder.prune();
+      return recorder.lastError === undefined ? { ...result, auditRunId: runId } : result;
+    } catch (e) {
+      recorder.runCompleted("failed", Date.now() - startedAt);
+      recorder.prune();
+      throw e;
+    }
+  };
+}
+function validateConvergeManifest(manifest) {
+  for (const id of [IMPLEMENT_STEP_ID, REVIEW_STEP_ID]) {
+    const step = manifest.steps[id];
+    if (!step) {
+      return `manifest "${manifest.id}" is not converge-shaped: missing call step "${id}" (converge needs call steps named "implement" and "review")`;
+    }
+    if (step.kind !== "call") {
+      return `manifest "${manifest.id}" is not converge-shaped: step "${id}" must be a call step, not ${step.kind}`;
+    }
+  }
+  return null;
+}
+var CONVERGE_HELP = `chit converge --task <text> --scope <id> [options]
+
+  --task <text>            Required. The slice to converge on.
+  --scope <id>             Required. Session scope; both agents keep their thread.
+  --cwd <dir>              Repo to run in. Default: current directory.
+  --manifest <path>        Convergence manifest. Default: the built-in converge manifest.
+  --max-iterations <n>     Iteration budget. Default: 3.
+  --loop-id <id>           Reuse/seed a loop id. Default: generated.
+  --allow-unenforced-permissions
+                           Run even when the manifest declares permissions its
+                           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'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).
+`;
+
+class UsageError extends Error {
+}
+function parseConvergeArgs(argv) {
+  let task;
+  let scope;
+  let cwd;
+  let manifestPath;
+  let maxIterations = 3;
+  let loopId;
+  let allowUnenforcedPermissions = false;
+  for (let i = 0;i < argv.length; i++) {
+    const a = argv[i];
+    const need = (key) => {
+      const v = argv[++i];
+      if (v === undefined)
+        throw new UsageError(`${key} requires a value`);
+      return v;
+    };
+    if (a === "--task")
+      task = need("--task");
+    else if (a === "--scope")
+      scope = need("--scope");
+    else if (a === "--cwd")
+      cwd = need("--cwd");
+    else if (a === "--manifest")
+      manifestPath = need("--manifest");
+    else if (a === "--loop-id")
+      loopId = need("--loop-id");
+    else if (a === "--allow-unenforced-permissions")
+      allowUnenforcedPermissions = true;
+    else if (a === "--max-iterations") {
+      const raw = need("--max-iterations");
+      const n = Number(raw);
+      if (!Number.isInteger(n) || n < 1) {
+        throw new UsageError(`--max-iterations must be a positive integer (got ${JSON.stringify(raw)})`);
+      }
+      maxIterations = n;
+    } else {
+      throw new UsageError(`unknown flag ${JSON.stringify(a)}`);
+    }
+  }
+  if (task === undefined)
+    throw new UsageError("--task is required");
+  if (scope === undefined)
+    throw new UsageError("--scope is required");
+  return {
+    task,
+    scope,
+    cwd: resolve2(cwd ?? process.cwd()),
+    manifestPath,
+    maxIterations,
+    loopId,
+    allowUnenforcedPermissions
+  };
+}
+async function runConverge(argv, io = defaultIO) {
+  if (argv[0] === "-h" || argv[0] === "--help") {
+    io.out(CONVERGE_HELP);
+    return 0;
+  }
+  let parsed;
+  try {
+    parsed = parseConvergeArgs(argv);
+  } catch (e) {
+    if (e instanceof UsageError) {
+      io.err(`chit converge: ${e.message}
+
+${CONVERGE_HELP}`);
+      return 2;
+    }
+    throw e;
+  }
+  let manifest;
+  try {
+    const raw = parsed.manifestPath !== undefined ? JSON.parse(readFileSync7(parsed.manifestPath, "utf-8")) : DEFAULT_CONVERGE_MANIFEST;
+    manifest = parseManifest(raw);
+  } catch (e) {
+    io.err(`chit converge: failed to load manifest ${parsed.manifestPath ?? "(built-in default)"}: ${e.message}
+`);
+    return 2;
+  }
+  const shapeError = validateConvergeManifest(manifest);
+  if (shapeError) {
+    io.err(`chit converge: ${shapeError}
+`);
+    return 1;
+  }
+  let registry2;
+  try {
+    registry2 = loadRegistry();
+  } catch (e) {
+    io.err(`chit converge: ${e.message}
+`);
+    return 1;
+  }
+  const unknown = findUnknownAgents(manifest, registry2);
+  if (unknown.length > 0) {
+    for (const u of unknown) {
+      io.err(`chit converge: unknown agent "${u.agentId}" in registry (participant "${u.participantId}")
+`);
+    }
+    return 2;
+  }
+  const gaps = findEnforcementGaps(manifest, registry2);
+  if (gaps.length > 0 && !parsed.allowUnenforcedPermissions) {
+    io.err(`chit converge: cannot enforce required permissions for "${manifest.id}":
+`);
+    io.err(`${formatEnforcementGaps(gaps)}
+`);
+    io.err(`
+Pass --allow-unenforced-permissions to run anyway (emits a warning each run).
+`);
+    return 1;
+  }
+  for (const g of gaps) {
+    io.err(`chit converge: WARNING -- unenforced permission: participant "${g.participantId}" requires ${g.permission}
+`);
+  }
+  let result;
+  try {
+    result = await convergeLoop({
+      cwd: parsed.cwd,
+      scope: parsed.scope,
+      task: parsed.task,
+      maxIterations: parsed.maxIterations,
+      loopId: parsed.loopId,
+      execute: buildExecute(manifest, registry2, parsed.scope, parsed.cwd)
+    });
+  } catch (e) {
+    io.err(`chit converge: ${e.message}
+`);
+    return 1;
+  }
+  if (result.failure !== undefined) {
+    io.err(`chit converge: ${result.failure}
+`);
+    return 1;
+  }
+  io.out(`chit converge: ${result.loopId}
+`);
+  io.out(`  iterations: ${result.iterations}
+`);
+  io.out(`  status:     ${result.status}
+`);
+  return 0;
+}
+
+// src/jobs/worker.ts
+function iso2(ms) {
+  return new Date(ms).toISOString();
+}
+function defaultResolveExecute(job) {
+  let raw;
+  if (job.manifestPath) {
+    const path = isAbsolute2(job.manifestPath) ? job.manifestPath : resolve3(job.cwd, job.manifestPath);
+    try {
+      raw = JSON.parse(readFileSync8(path, "utf-8"));
+    } catch (e) {
+      return { ok: false, error: `could not read manifest at ${path}: ${e.message}` };
+    }
+  } else {
+    raw = DEFAULT_CONVERGE_MANIFEST;
+  }
+  const prep = prepareConvergeExecute(raw, loadRegistry(), job.scope, job.cwd, job.allowUnenforced);
+  return prep.ok ? { ok: true, execute: prep.execute } : { ok: false, error: prep.error };
+}
+async function runJobWorker(jobId, deps) {
+  const store = deps.jobStore;
+  const now = deps.now ?? Date.now;
+  const heartbeatMs = deps.heartbeatMs ?? 1e4;
+  const resolveExecute = deps.resolveExecute ?? defaultResolveExecute;
+  const job = store.get(jobId);
+  if (job?.state !== "queued")
+    return;
+  const workerToken = crypto.randomUUID();
+  const setPhase = (phase) => {
+    try {
+      store.update(jobId, (c) => ({
+        ...c,
+        phase,
+        ...c.phase !== phase && { phaseStartedAt: iso2(now()) },
+        lastHeartbeatAt: iso2(now())
+      }));
+    } catch {}
+  };
+  const controller = new AbortController;
+  const onSignal = () => {
+    setPhase("cancelling");
+    controller.abort();
+  };
+  if (deps.installSignalHandlers !== false) {
+    process.once("SIGTERM", onSignal);
+    process.once("SIGINT", onSignal);
+  }
+  let loopLock;
+  let heartbeat;
+  try {
+    store.update(jobId, (c) => ({
+      ...c,
+      state: "running",
+      startedAt: iso2(now()),
+      pid: process.pid,
+      pgid: process.pid,
+      workerToken,
+      lastHeartbeatAt: iso2(now()),
+      phase: "starting",
+      phaseStartedAt: iso2(now())
+    }));
+    const resolved = resolveExecute(job);
+    if (!resolved.ok) {
+      stopLoopSafely(job, "blocked", `could not prepare converge execute: ${resolved.error}`);
+      finish(store, jobId, now, "failed", { failure: resolved.error });
+      return;
+    }
+    try {
+      loopLock = acquireLock(store.loopLockPath(job.loopId), deps.loopLockOpts);
+    } catch (e) {
+      if (e instanceof LockError) {
+        finish(store, jobId, now, "failed", {
+          failure: `loop "${job.loopId}" is locked by another advancer; not started`
+        });
+        return;
+      }
+      throw e;
+    }
+    heartbeat = setInterval(() => {
+      try {
+        store.update(jobId, (c) => ({ ...c, lastHeartbeatAt: iso2(now()) }));
+      } catch {}
+    }, heartbeatMs);
+    let priorReview = "";
+    for (let i = 1;i <= job.maxIterations; i++) {
+      if (store.get(jobId)?.cancelRequestedAt || controller.signal.aborted) {
+        stopLoopSafely(job, "cancelled", "cancelled via chit_job_cancel");
+        finish(store, jobId, now, "cancelled", { stopStatus: "cancelled" });
+        return;
+      }
+      store.update(jobId, (c) => ({
+        ...c,
+        iteration: i,
+        phase: "implementing",
+        ...c.phase !== "implementing" && { phaseStartedAt: iso2(now()) },
+        lastHeartbeatAt: iso2(now())
+      }));
+      let iter;
+      try {
+        iter = await runConvergeIteration({
+          cwd: job.cwd,
+          loopId: job.loopId,
+          iteration: i,
+          task: job.task,
+          prior_review: priorReview,
+          execute: resolved.execute,
+          signal: controller.signal,
+          onTrace: (e) => {
+            if (e.type === "step.started" && e.stepId === "implement")
+              setPhase("implementing");
+            else if (e.type === "step.started" && e.stepId === "review")
+              setPhase("reviewing");
+          }
+        });
+      } catch (e) {
+        if (e instanceof ConvergeExecuteError) {
+          stopLoopSafely(job, "blocked", `manifest run threw: ${e.message}`);
+          finish(store, jobId, now, "failed", { failure: e.message });
+        } else {
+          finish(store, jobId, now, "failed", { failure: e.message });
+        }
+        return;
+      }
+      if (!iter.ok) {
+        if (iter.auditRunId) {
+          const ref = iter.auditRunId;
+          store.update(jobId, (c) => ({ ...c, auditRefs: [...c.auditRefs, ref] }));
+        }
+        if (controller.signal.aborted) {
+          stopLoopSafely(job, "cancelled", "cancelled mid-iteration (signal)");
+          finish(store, jobId, now, "cancelled", { stopStatus: "cancelled" });
+        } else {
+          stopLoopSafely(job, "blocked", iter.failure);
+          finish(store, jobId, now, "failed", { failure: iter.failure });
+        }
+        return;
+      }
+      store.update(jobId, (c) => ({
+        ...c,
+        phase: "recording",
+        ...c.phase !== "recording" && { phaseStartedAt: iso2(now()) },
+        iterationsCompleted: i,
+        lastVerdict: iter.verdict,
+        auditRefs: iter.auditRunId ? [...c.auditRefs, iter.auditRunId] : c.auditRefs,
+        lastHeartbeatAt: iso2(now())
+      }));
+      if (iter.stopStatus) {
+        const reason = iter.stopStatus === "converged" ? "reviewer returned proceed" : "reviewer returned block";
+        stopLoopSafely(job, iter.stopStatus, reason);
+        finish(store, jobId, now, "completed", { stopStatus: iter.stopStatus });
+        return;
+      }
+      priorReview = iter.reviewText;
+      if (i >= job.maxIterations) {
+        stopLoopSafely(job, "max-iterations", `reached max iterations (${job.maxIterations}) without converging`);
+        finish(store, jobId, now, "completed", { stopStatus: "max-iterations" });
+        return;
+      }
+    }
+  } finally {
+    if (heartbeat)
+      clearInterval(heartbeat);
+    if (deps.installSignalHandlers !== false) {
+      process.removeListener("SIGTERM", onSignal);
+      process.removeListener("SIGINT", onSignal);
+    }
+    if (loopLock)
+      releaseLock(loopLock);
+  }
+}
+function stopLoopSafely(job, status, reason) {
+  try {
+    stopLoop(job.cwd, job.loopId, { status, reason });
+  } catch {}
+}
+function finish(store, jobId, now, state, extra) {
+  store.update(jobId, (c) => ({
+    ...c,
+    state,
+    endedAt: iso2(now()),
+    phase: undefined,
+    phaseStartedAt: undefined,
+    lastHeartbeatAt: iso2(now()),
+    ...extra.stopStatus !== undefined && { stopStatus: extra.stopStatus },
+    ...extra.failure !== undefined && { failure: extra.failure }
+  }));
+}
+
+// src/surfaces/claude-skill.ts
 init_src();
-import { readFileSync as readFileSync8 } from "fs";
-import { isAbsolute as isAbsolute2, resolve as resolve3 } from "path";
+import { createHash as createHash5, randomBytes } from "crypto";
+import { existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync9, rmSync as rmSync5, writeFileSync as writeFileSync5 } from "fs";
+import { join as join7, resolve as resolvePath } from "path";
+class SurfaceInstallError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SurfaceInstallError";
+  }
+}
+var CLAUDE_SKILL_CAPABILITIES = new Set([
+  "can_show_markdown",
+  "can_provide_stable_scope"
+]);
+function installClaudeSkill(opts) {
+  if (opts.overrideName !== undefined && !VALID_INSTALL_NAME_RE.test(opts.overrideName)) {
+    throw new SurfaceInstallError(`overrideName "${opts.overrideName}" is invalid: must be kebab-case (lowercase letters, digits, hyphens; must start with a letter). Path-traversal sequences like ".." or "/" are rejected.`);
+  }
+  const outputDir = resolvePath(opts.outputDir);
+  const runtimePath = resolvePath(opts.runtimePath);
+  const allowUnenforced = opts.allowUnenforcedPermissions === true;
+  let rawJson;
+  try {
+    rawJson = JSON.parse(readFileSync9(opts.manifestPath, "utf-8"));
+  } catch (e) {
+    throw new SurfaceInstallError(`failed to read manifest ${opts.manifestPath}: ${e.message}`);
+  }
+  let manifest;
+  try {
+    manifest = parseManifest(rawJson);
+  } catch (e) {
+    throw new SurfaceInstallError(`invalid manifest at ${opts.manifestPath}: ${e.message}`);
+  }
+  const missingCaps = findMissingCapabilities(manifest, CLAUDE_SKILL_CAPABILITIES);
+  if (missingCaps.length > 0) {
+    throw new SurfaceInstallError(`claude-skill surface does not provide capabilities required by "${manifest.id}": ${missingCaps.join(", ")}`);
+  }
+  const inputNames = Object.keys(manifest.inputs);
+  const primaryInput = inputNames[0];
+  if (!primaryInput) {
+    throw new SurfaceInstallError(`manifest "${manifest.id}" has no inputs; nothing to wire from $ARGUMENTS`);
+  }
+  const primaryInputSchema = manifest.inputs[primaryInput];
+  if (primaryInputSchema?.type !== "string") {
+    throw new SurfaceInstallError(`manifest "${manifest.id}": claude-skill surface only supports a string-typed primary input ` + `(got "${primaryInput}": ${primaryInputSchema?.type ?? "missing"})`);
+  }
+  if (inputNames.length > 1) {
+    throw new SurfaceInstallError(`manifest "${manifest.id}" declares multiple inputs (${inputNames.join(", ")}); ` + `claude-skill surface in PR6 supports exactly one string input`);
+  }
+  const registry2 = opts.registry ?? loadRegistry();
+  const unknownAgents = findUnknownAgents(manifest, registry2);
+  if (unknownAgents.length > 0) {
+    const lines = unknownAgents.map((u) => `  - participant "${u.participantId}" references unknown agent "${u.agentId}"`).join(`
+`);
+    throw new SurfaceInstallError(`manifest "${manifest.id}" references agents that are not in the registry:
+${lines}`);
+  }
+  const gaps = findEnforcementGaps(manifest, registry2);
+  if (gaps.length > 0 && !allowUnenforced) {
+    throw new SurfaceInstallError(`cannot enforce required permissions for "${manifest.id}":
+${formatEnforcementGaps(gaps)}
+
+Pass allowUnenforcedPermissions=true to install anyway; the generated skill will warn on every run.`);
+  }
+  const installName = opts.overrideName ?? manifest.id;
+  const skillDir = join7(outputDir, installName);
+  if (existsSync7(skillDir)) {
+    if (!opts.force) {
+      throw new SurfaceInstallError(`skill directory already exists: ${skillDir}
+
+Pass force=true to remove and replace it, or use overrideName="<id>" to install with a different name (avoids overwriting an unrelated skill that happens to share this id).`);
+    }
+    rmSync5(skillDir, { recursive: true, force: true });
+  }
+  mkdirSync5(skillDir, { recursive: true });
+  const skillMdPath = join7(skillDir, "SKILL.md");
+  const manifestPath = join7(skillDir, "manifest.json");
+  const markerPath = join7(skillDir, INSTALL_MARKER_FILENAME);
+  const manifestJson = `${JSON.stringify(rawJson, null, 2)}
+`;
+  writeFileSync5(manifestPath, manifestJson);
+  writeFileSync5(skillMdPath, buildSkillMd({
+    manifest,
+    runtimePath,
+    primaryInputName: primaryInput,
+    allowUnenforced: gaps.length > 0,
+    trace: opts.trace === true,
+    heredocDelimiter: generateHeredocDelimiter(),
+    installName
+  }));
+  const marker = {
+    schema: 1,
+    surface: "claude-skill",
+    installName,
+    manifestId: manifest.id,
+    runtimePath,
+    installedAt: new Date().toISOString(),
+    manifestHash: createHash5("sha256").update(manifestJson).digest("hex")
+  };
+  writeFileSync5(markerPath, `${JSON.stringify(marker, null, 2)}
+`);
+  return { skillDir, skillMdPath, manifestPath, markerPath, enforcementGaps: gaps };
+}
+function generateHeredocDelimiter() {
+  return `CHIT_INPUT_${randomBytes(8).toString("hex").toUpperCase()}_EOF`;
+}
+function buildSkillMd(opts) {
+  const {
+    manifest,
+    runtimePath,
+    primaryInputName,
+    allowUnenforced,
+    trace,
+    heredocDelimiter,
+    installName
+  } = opts;
+  const allowFlag = allowUnenforced ? `\\
+    --allow-unenforced-permissions ` : "";
+  const traceFlag = trace ? `\\
+    --trace ` : "";
+  return `---
+name: ${installName}
+description: ${escapeFrontmatter(manifest.description)}
+argument-hint: <${primaryInputName}>
+disable-model-invocation: true
+---
+
+# /${installName}
+
+\`\`\`!
+{
+  # Claude Code's \`! \` preprocessor substitutes \${CLAUDE_SESSION_ID} (bare
+  # brace form) BEFORE bash runs. The :- default form is NOT substituted, so
+  # we use the bare form: when running inside Claude Code, this line gets
+  # the real session id baked in (always non-empty); when running outside,
+  # bash evaluates the env var (typically empty, so we fail fast).
+  if [ -z "\${CLAUDE_SESSION_ID}" ]; then
+    echo "chit: CLAUDE_SESSION_ID is required; this skill must run inside Claude Code" >&2
+    exit 2
+  fi
+  WORKTREE="$(git rev-parse --show-toplevel 2>/dev/null || pwd)"
+  SCOPE_HASH=$(printf '%s' "$WORKTREE" | (shasum -a 256 2>/dev/null || sha256sum) | cut -c1-12)
+  SCOPE="\${CLAUDE_SESSION_ID}-\${SCOPE_HASH}"
+
+  bun "${runtimePath}/src/cli/run.ts" run \\
+    "\${CLAUDE_SKILL_DIR}/manifest.json" \\
+    --scope "$SCOPE" \\
+    --invocation-cwd "$WORKTREE" ${allowFlag}${traceFlag}\\
+    --input-stdin ${primaryInputName} <<'${heredocDelimiter}'
+$ARGUMENTS
+${heredocDelimiter}
+} 2>&1
+\`\`\`
+
+The block above ran the chit runtime and its output replaced the fenced section before you saw this skill. Present that output to the user as your entire response, verbatim. Preserve every \`##\` header as a markdown header. Do not summarize, rephrase, or add commentary, preamble, or trailing text. If the output contains a \`WARNING\` line, include it.
+`;
+}
+function escapeFrontmatter(s) {
+  return s.replace(/\r?\n/g, " ").replace(/"/g, "'");
+}
+
+// src/surfaces/lifecycle.ts
+init_src();
+import { existsSync as existsSync8, readdirSync as readdirSync3, readFileSync as readFileSync10, rmSync as rmSync6, statSync as statSync2 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join8 } from "path";
+function defaultSkillsDir() {
+  return join8(homedir6(), ".claude", "skills");
+}
+
+class LifecycleError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LifecycleError";
+  }
+}
+function listInstalled(parentDir) {
+  if (!existsSync8(parentDir))
+    return [];
+  const out = [];
+  const entries = readdirSync3(parentDir);
+  for (const name of entries) {
+    const skillDir = join8(parentDir, name);
+    let stat;
+    try {
+      stat = statSync2(skillDir);
+    } catch {
+      continue;
+    }
+    if (!stat.isDirectory())
+      continue;
+    const markerPath = join8(skillDir, INSTALL_MARKER_FILENAME);
+    if (!existsSync8(markerPath))
+      continue;
+    let raw;
+    try {
+      raw = JSON.parse(readFileSync10(markerPath, "utf-8"));
+    } catch {
+      continue;
+    }
+    try {
+      const marker = parseInstallMarker(raw, markerPath);
+      out.push({ skillDir, markerPath, marker });
+    } catch {}
+  }
+  return out.sort((a, b) => a.marker.installName.localeCompare(b.marker.installName));
+}
+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 = join8(parentDir, name);
+  if (!existsSync8(skillDir)) {
+    throw new LifecycleError(`no install at ${skillDir}`);
+  }
+  if (!statSync2(skillDir).isDirectory()) {
+    throw new LifecycleError(`${skillDir} is not a directory`);
+  }
+  const markerPath = join8(skillDir, INSTALL_MARKER_FILENAME);
+  if (!existsSync8(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.`);
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync10(markerPath, "utf-8"));
+  } catch (e) {
+    throw new LifecycleError(`refusing to uninstall ${skillDir}: ${INSTALL_MARKER_FILENAME} is not valid JSON (${e.message})`);
+  }
+  let marker;
+  try {
+    marker = parseInstallMarker(raw, markerPath);
+  } catch (e) {
+    if (e instanceof MarkerError) {
+      throw new LifecycleError(`refusing to uninstall ${skillDir}: ${e.message}`);
+    }
+    throw e;
+  }
+  const record = { skillDir, markerPath, marker };
+  rmSync6(skillDir, { recursive: true, force: true });
+  return record;
+}
+
+// src/surfaces/mcp/server.ts
+import { spawn } from "child_process";
+import { readFileSync as readFileSync11 } from "fs";
+import { isAbsolute as isAbsolute3, resolve as resolve4 } from "path";
 
 // ../../node_modules/.bun/zod@4.4.3/node_modules/zod/v3/helpers/util.js
 var util;
@@ -33178,7 +34241,7 @@ class Protocol {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1000;
-        await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+        await new Promise((resolve4) => setTimeout(resolve4, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error51) {
@@ -33190,7 +34253,7 @@ class Protocol {
   }
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve4, reject) => {
       const earlyReject = (error51) => {
         reject(error51);
       };
@@ -33268,7 +34331,7 @@ class Protocol {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve2(parseResult.data);
+            resolve4(parseResult.data);
           }
         } catch (error51) {
           reject(error51);
@@ -33459,12 +34522,12 @@ class Protocol {
         interval = task.pollInterval;
       }
     } catch {}
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve4, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve2, interval);
+      const timeoutId = setTimeout(resolve4, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -34317,7 +35380,7 @@ class McpServer {
     let task = createTaskResult.task;
     const pollInterval = task.pollInterval ?? 5000;
     while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
-      await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+      await new Promise((resolve4) => setTimeout(resolve4, pollInterval));
       const updatedTask = await extra.taskStore.getTask(taskId);
       if (!updatedTask) {
         throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
@@ -34935,19 +35998,19 @@ class StdioServerTransport {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve2) => {
+    return new Promise((resolve4) => {
       const json2 = serializeMessage(message);
       if (this._stdout.write(json2)) {
-        resolve2();
+        resolve4();
       } else {
-        this._stdout.once("drain", resolve2);
+        this._stdout.once("drain", resolve4);
       }
     });
   }
 }
 
 // src/audit/reader.ts
-var USAGE_KEYS = [
+var USAGE_KEYS2 = [
   "inputTokens",
   "outputTokens",
   "totalTokens",
@@ -34961,7 +36024,7 @@ function sumUsage(events2) {
   for (const e of events2) {
     if (e.type !== "adapter.call.completed" || !e.usage)
       continue;
-    for (const k of USAGE_KEYS) {
+    for (const k of USAGE_KEYS2) {
       const v = e.usage[k];
       if (typeof v === "number") {
         usage[k] = (usage[k] ?? 0) + v;
@@ -35007,741 +36070,154 @@ function describeIncomplete(s, events2) {
 }
 function summarizeRun(runId, events2) {
   const started = events2.find((e) => e.type === "run.started");
-  const completed = events2.find((e) => e.type === "run.completed");
-  const summary = {
-    runId,
-    manifestId: started?.type === "run.started" ? started.manifestId : "?",
-    surface: started?.type === "run.started" ? started.surface : "?",
-    status: completed?.type === "run.completed" ? completed.status : "incomplete",
-    stepCount: events2.filter((e) => e.type === "step.completed").length
-  };
-  if (started?.type === "run.started") {
-    summary.startedAt = started.ts;
-    if (started.scope !== undefined)
-      summary.scope = started.scope;
-    if (started.loopId !== undefined)
-      summary.loopId = started.loopId;
-    if (started.iteration !== undefined)
-      summary.iteration = started.iteration;
-  }
-  const usage = sumUsage(events2);
-  if (usage !== undefined)
-    summary.usage = usage;
-  const openCall = findOpenCall(events2);
-  if (openCall !== undefined)
-    summary.openCall = openCall;
-  return summary;
-}
-function safeReadEvents(store, runId) {
-  try {
-    return store.readEvents(runId);
-  } catch {
-    return [];
-  }
-}
-function listAudit(store, limit) {
-  const summaries = store.listRuns().map((id) => summarizeRun(id, safeReadEvents(store, id)));
-  summaries.sort((a, b) => (b.startedAt ?? "").localeCompare(a.startedAt ?? ""));
-  return limit !== undefined ? summaries.slice(0, limit) : summaries;
-}
-function readBody(store, runId, ref) {
-  try {
-    return store.readBlob(runId, ref);
-  } catch (err) {
-    return `<blob unavailable: ${err.message}>`;
-  }
-}
-function isReceiptEvent(e) {
-  return e.type !== "adapter.event";
-}
-function hiddenAdapterEventCount(events2) {
-  return events2.reduce((n, e) => e.type === "adapter.event" ? n + 1 : n, 0);
-}
-function auditTimeline(store, runId, events2, opts) {
-  const rows = opts.verbose ? events2 : events2.filter(isReceiptEvent);
-  return rows.map((e) => {
-    if (!opts.includeBodies)
-      return e;
-    if (e.type === "adapter.call.started") {
-      return { ...e, input: readBody(store, runId, e.inputBlob) };
-    }
-    if (e.type === "adapter.event" && e.rawBlob !== undefined) {
-      return { ...e, raw: readBody(store, runId, e.rawBlob) };
-    }
-    if (e.type === "adapter.call.completed") {
-      return { ...e, output: readBody(store, runId, e.outputBlob) };
-    }
-    if (e.type === "step.completed" && e.outputBlob !== undefined) {
-      return { ...e, output: readBody(store, runId, e.outputBlob) };
-    }
-    return e;
-  });
-}
-function showAudit(store, runId, opts) {
-  const events2 = store.readEvents(runId);
-  const summary = summarizeRun(runId, events2);
-  const out = {
-    summary,
-    timeline: auditTimeline(store, runId, events2, opts)
-  };
-  if (summary.status === "incomplete")
-    out.incompleteReason = describeIncomplete(summary, events2);
-  const started = events2.find((e) => e.type === "run.started");
-  if (started?.type === "run.started" && started.participants !== undefined) {
-    out.participants = started.participants;
-  }
-  if (!opts.verbose) {
-    const hidden = hiddenAdapterEventCount(events2);
-    if (hidden > 0) {
-      out.note = `${hidden} raw adapter events hidden; pass verbose to include them, include_bodies to show blob bodies.`;
-    }
-  }
-  return out;
-}
-
-// src/cli/converge.ts
-init_src();
-import { execFileSync } from "child_process";
-import { readFileSync as readFileSync7 } from "fs";
-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 join7 } from "path";
-class LoopStoreError extends Error {
-}
-var SAFE_LOOP_ID = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
-var realClock2 = () => Date.now();
-function iso(ms) {
-  return new Date(ms).toISOString();
-}
-function safeId(loopId) {
-  if (!SAFE_LOOP_ID.test(loopId)) {
-    throw new LoopStoreError(`invalid loop id ${JSON.stringify(loopId)}`);
-  }
-  return loopId;
-}
-function loopPath(cwd, loopId) {
-  return join7(loopLogDir(cwd), `${safeId(loopId)}.jsonl`);
-}
-function readRecords(path, loopId) {
-  if (!existsSync7(path)) {
-    throw new LoopStoreError(`no loop log for ${JSON.stringify(loopId)} at ${path}`);
-  }
-  const records = validateLoopLog(parseLoopLog(readFileSync6(path, "utf-8")));
-  const header = records[0];
-  if (header.loopId !== loopId) {
-    throw new LoopStoreError(`loop log at ${path} declares loopId ${JSON.stringify(header.loopId)}, expected ${JSON.stringify(loopId)}`);
-  }
-  return records;
-}
-function startLoop(cwd, opts) {
-  const loopId = opts.loopId ?? crypto.randomUUID();
-  const path = loopPath(cwd, loopId);
-  if (existsSync7(path) && !opts.force) {
-    throw new LoopStoreError(`loop log already exists at ${path} (pass force to overwrite)`);
-  }
-  mkdirSync4(loopLogDir(cwd), { recursive: true });
-  const header = {
-    type: "loop",
-    schema: 1,
-    loopId,
-    scope: opts.scope,
-    task: opts.task,
-    repo: repoRoot(cwd),
-    repoKey: repoKey(cwd),
-    startedAt: iso((opts.clock ?? realClock2)()),
-    maxIterations: opts.maxIterations
-  };
-  writeFileSync4(path, `${serializeLoopRecord(header)}
-`);
-  return { loopId, path };
-}
-function appendIteration(cwd, loopId, opts) {
-  const path = loopPath(cwd, loopId);
-  const records = readRecords(path, loopId);
-  if (records.some((r) => r.type === "stop")) {
-    throw new LoopStoreError(`loop ${JSON.stringify(loopId)} is already stopped; cannot append`);
-  }
-  const header = records[0];
-  const n = records.filter((r) => r.type === "iteration").length + 1;
-  if (n > header.maxIterations) {
-    throw new LoopStoreError(`loop ${JSON.stringify(loopId)} is at its iteration budget (maxIterations=${header.maxIterations}); cannot append iteration ${n}`);
-  }
-  const rec = {
-    type: "iteration",
-    n,
-    implementSummary: opts.implementSummary,
-    changedFiles: opts.changedFiles,
-    checksRun: opts.checksRun,
-    verdict: opts.verdict,
-    findingCount: opts.findingCount,
-    decision: opts.decision,
-    checkDurationMs: opts.checkDurationMs,
-    at: iso((opts.clock ?? realClock2)())
-  };
-  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)}
-`);
-  return { n, path };
-}
-function stopLoop(cwd, loopId, opts) {
-  const path = loopPath(cwd, loopId);
-  const records = readRecords(path, loopId);
-  if (records.some((r) => r.type === "stop")) {
-    throw new LoopStoreError(`loop ${JSON.stringify(loopId)} is already stopped`);
-  }
-  const header = records[0];
-  const iterations = records.filter((r) => r.type === "iteration").length;
-  const nowMs = (opts.clock ?? realClock2)();
-  const totalElapsedMs = Math.max(0, nowMs - Date.parse(header.startedAt));
-  const rec = {
-    type: "stop",
-    status: opts.status,
-    reason: opts.reason,
-    iterations,
-    totalElapsedMs,
-    endedAt: iso(nowMs)
-  };
-  appendFileSync2(path, `${serializeLoopRecord(rec)}
-`);
-  return { iterations, totalElapsedMs, path };
-}
-function readLoop(cwd, loopId) {
-  return readRecords(loopPath(cwd, loopId), loopId);
-}
-
-// src/cli/default-converge-manifest.ts
-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_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 }
-  },
-  requires: {
-    can_show_markdown: true
-  },
-  participants: {
-    implementer: {
-      agent: "claude",
-      role: "You implement one small, focused slice of a software task in the repository at your cwd. Make the ACTUAL code edits with your tools - do not just describe them. Stay scoped to the task; do not refactor unrelated code. If a prior review is provided, address its concrete findings. Run the project's checks if quick. Then summarize precisely: which files you changed, what each change does and why, what you deliberately did NOT do, and which checks you ran with their results.",
-      session: "per_scope",
-      permissions: { filesystem: "write" }
-    },
-    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, 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" }
-    }
-  },
-  steps: {
-    implement: {
-      call: "implementer",
-      prompt: `Task:
-{{ inputs.task }}
-
-Prior review to address (empty on the first iteration):
-{{ inputs.prior_review }}
-
-Implement this slice now by editing files in the repo at your cwd. Keep it small and focused. Then summarize what you changed (files + what/why), what you did not do, and any checks you ran.`
-    },
-    review: {
-      call: "reviewer",
-      prompt: `Task under review:
-{{ inputs.task }}
-
-Claude's summary of what it just implemented:
-{{ steps.implement.output }}
-
-Inspect the current git diff and the changed files at your cwd. Verify the change against the task and run non-mutating checks if useful. Return prose with:
-1. Verdict: proceed / revise / block.
-2. Findings ordered by severity, with file:line.
-3. What Claude should fix next if the verdict is revise.
-4. Remaining risk if proceeding.
-
-Then, as the LAST thing in your reply, emit a single machine-readable fenced JSON block that the driver parses (the prose above is for humans). Use exactly these keys:
-\`\`\`json
-{"verdict": "proceed | revise | block", "findingCount": 0, "checksRun": "the non-mutating checks you ran, or 'none'", "risk": "remaining risk if proceeding"}
-\`\`\`
-findingCount is the integer number of findings; checksRun is a short human string.`
-    },
-    out: {
-      format: `## Converge iteration
-
-### Implementer (Claude)
-{{ steps.implement.output }}
-
-### Reviewer (Codex)
-{{ steps.review.output }}`
-    }
-  },
-  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),
-  err: (s) => process.stderr.write(s)
-};
-var JSON_BLOCK_RE = /```json\s*([\s\S]*?)```/gi;
-var VERDICTS3 = new Set(["proceed", "revise", "block"]);
-var IMPLEMENT_STEP_ID = "implement";
-var REVIEW_STEP_ID = "review";
-var IMPLEMENT_SUMMARY_CAP = 2000;
-var CHECKS_RUN_FALLBACK = "unreported";
-function extractReviewJson(reviewText) {
-  let last;
-  for (const m of reviewText.matchAll(JSON_BLOCK_RE)) {
-    if (m[1] !== undefined)
-      last = m[1];
-  }
-  if (last === undefined)
-    return null;
-  try {
-    const parsed = JSON.parse(last);
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-      return parsed;
-    }
-  } catch {}
-  return null;
-}
-function parseReview(reviewText) {
-  const block = extractReviewJson(reviewText);
-  const rawVerdict = typeof block?.verdict === "string" ? block.verdict.toLowerCase() : undefined;
-  if (block && rawVerdict && VERDICTS3.has(rawVerdict)) {
-    const fc = block.findingCount;
-    const cr = block.checksRun;
-    return {
-      verdict: rawVerdict,
-      findingCount: typeof fc === "number" && Number.isInteger(fc) && fc >= 0 ? fc : 0,
-      checksRun: typeof cr === "string" && cr.trim() !== "" ? cr.trim() : CHECKS_RUN_FALLBACK
-    };
-  }
-  return { verdict: "block", findingCount: 0, checksRun: CHECKS_RUN_FALLBACK };
-}
-function reviewDurationMs(trace) {
-  for (const e of trace) {
-    if (e.type === "step.completed" && e.stepId === REVIEW_STEP_ID)
-      return e.durationMs;
-  }
-  return 0;
-}
-var USAGE_KEYS2 = [
-  "inputTokens",
-  "outputTokens",
-  "totalTokens",
-  "cachedInputTokens",
-  "reasoningTokens",
-  "estimatedCostUsd"
-];
-function sumTraceUsage(trace) {
-  const usage = {};
-  let any3 = false;
-  for (const e of trace) {
-    if (e.type !== "step.completed" || !e.usage)
-      continue;
-    for (const k of USAGE_KEYS2) {
-      const v = e.usage[k];
-      if (typeof v === "number") {
-        usage[k] = (usage[k] ?? 0) + v;
-        any3 = true;
-      }
-    }
+  const completed = events2.find((e) => e.type === "run.completed");
+  const summary = {
+    runId,
+    manifestId: started?.type === "run.started" ? started.manifestId : "?",
+    surface: started?.type === "run.started" ? started.surface : "?",
+    status: completed?.type === "run.completed" ? completed.status : "incomplete",
+    stepCount: events2.filter((e) => e.type === "step.completed").length
+  };
+  if (started?.type === "run.started") {
+    summary.startedAt = started.ts;
+    if (started.scope !== undefined)
+      summary.scope = started.scope;
+    if (started.loopId !== undefined)
+      summary.loopId = started.loopId;
+    if (started.iteration !== undefined)
+      summary.iteration = started.iteration;
   }
-  return any3 ? usage : undefined;
-}
-function capSummary(text) {
-  if (text === "")
-    return "(no summary)";
-  if (text.length <= IMPLEMENT_SUMMARY_CAP)
-    return text;
-  return `${text.slice(0, IMPLEMENT_SUMMARY_CAP)}\u2026 (truncated, ${text.length} chars)`;
+  const usage = sumUsage(events2);
+  if (usage !== undefined)
+    summary.usage = usage;
+  const openCall = findOpenCall(events2);
+  if (openCall !== undefined)
+    summary.openCall = openCall;
+  return summary;
 }
-function gitLines(cwd, args) {
+function safeReadEvents(store, runId) {
   try {
-    const out = execFileSync("git", args, {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-    return out.split(`
-`).map((s) => s.trim()).filter(Boolean);
+    return store.readEvents(runId);
   } catch {
     return [];
   }
 }
-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 {
-  executeError;
-  constructor(executeError) {
-    super(executeError instanceof Error ? executeError.message : String(executeError));
-    this.executeError = executeError;
-  }
+function listAudit(store, limit) {
+  const summaries = store.listRuns().map((id) => summarizeRun(id, safeReadEvents(store, id)));
+  summaries.sort((a, b) => (b.startedAt ?? "").localeCompare(a.startedAt ?? ""));
+  return limit !== undefined ? summaries.slice(0, limit) : summaries;
 }
-async function runConvergeIteration(ctx) {
-  let result;
+function readBody(store, runId, ref) {
   try {
-    result = await ctx.execute({ task: ctx.task, prior_review: ctx.prior_review }, {
-      loopId: ctx.loopId,
-      iteration: ctx.iteration,
-      ...ctx.signal && { signal: ctx.signal }
-    });
-  } catch (e) {
-    throw new ConvergeExecuteError(e);
-  }
-  if (!result.ok) {
-    return {
-      ok: false,
-      failure: `manifest run failed at step "${result.failedStep}": ${result.error}`
-    };
+    return store.readBlob(runId, ref);
+  } catch (err) {
+    return `<blob unavailable: ${err.message}>`;
   }
-  const reviewText = result.outputs.review ?? "";
-  const review = parseReview(reviewText);
-  const usage = sumTraceUsage(result.trace);
-  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 && { auditRef: result.auditRunId }
-  });
-  const stopStatus = review.verdict === "proceed" ? "converged" : review.verdict === "block" ? "blocked" : undefined;
-  return {
-    ok: true,
-    verdict: review.verdict,
-    findingCount: review.findingCount,
-    checksRun: review.checksRun,
-    decision: review.verdict,
-    changedFiles,
-    workspaceWarnings,
-    ...usage && { usage },
-    ...result.auditRunId && { auditRunId: result.auditRunId },
-    reviewText,
-    ...stopStatus && { stopStatus }
-  };
 }
-async function convergeLoop(opts) {
-  const { loopId } = startLoop(opts.cwd, {
-    scope: opts.scope,
-    task: opts.task,
-    maxIterations: opts.maxIterations,
-    loopId: opts.loopId,
-    force: opts.force
-  });
-  let priorReview = "";
-  let iterations = 0;
-  let status;
-  for (let i = 1;i <= opts.maxIterations; i++) {
-    let iter;
-    try {
-      iter = await runConvergeIteration({
-        cwd: opts.cwd,
-        loopId,
-        iteration: i,
-        task: opts.task,
-        prior_review: priorReview,
-        execute: opts.execute
-      });
-    } catch (e) {
-      if (e instanceof ConvergeExecuteError) {
-        stopLoop(opts.cwd, loopId, {
-          status: "blocked",
-          reason: `manifest run threw: ${e.message}`
-        });
-        throw e.executeError;
-      }
-      throw e;
+function isReceiptEvent(e) {
+  return e.type !== "adapter.event";
+}
+function hiddenAdapterEventCount(events2) {
+  return events2.reduce((n, e) => e.type === "adapter.event" ? n + 1 : n, 0);
+}
+function auditTimeline(store, runId, events2, opts) {
+  const rows = opts.verbose ? events2 : events2.filter(isReceiptEvent);
+  return rows.map((e) => {
+    if (!opts.includeBodies)
+      return e;
+    if (e.type === "adapter.call.started") {
+      return { ...e, input: readBody(store, runId, e.inputBlob) };
     }
-    if (!iter.ok) {
-      status = "blocked";
-      stopLoop(opts.cwd, loopId, { status, reason: iter.failure });
-      return { loopId, iterations, status, failure: iter.failure };
+    if (e.type === "adapter.event" && e.rawBlob !== undefined) {
+      return { ...e, raw: readBody(store, runId, e.rawBlob) };
     }
-    iterations++;
-    if (iter.stopStatus !== undefined) {
-      status = iter.stopStatus;
-      break;
+    if (e.type === "adapter.call.completed") {
+      return { ...e, output: readBody(store, runId, e.outputBlob) };
     }
-    priorReview = iter.reviewText;
-  }
-  if (status === undefined)
-    status = "max-iterations";
-  const reason = status === "converged" ? "reviewer returned proceed" : status === "blocked" ? "reviewer returned block" : `reached max iterations (${opts.maxIterations}) without converging`;
-  stopLoop(opts.cwd, loopId, { status, reason });
-  return { loopId, iterations, status };
-}
-function buildExecute(manifest, registry3, scope, cwd) {
-  const baseAdapters = {};
-  for (const p of Object.values(manifest.participants)) {
-    if (!(p.agent in baseAdapters)) {
-      const agent = registry3.agents[p.agent];
-      if (!agent)
-        continue;
-      baseAdapters[p.agent] = buildAdapter(agent);
+    if (e.type === "step.completed" && e.outputBlob !== undefined) {
+      return { ...e, output: readBody(store, runId, e.outputBlob) };
     }
-  }
-  return makeAuditedExecute(manifest, baseAdapters, registry3, scope, cwd, new FileSessionStore(defaultSessionDir()), new AuditStore);
+    return e;
+  });
 }
-function makeAuditedExecute(manifest, baseAdapters, registry3, scope, cwd, sessionStore, auditStore) {
-  return async (inputs, ctx) => {
-    const runId = crypto.randomUUID();
-    const recorder = new AuditRecorder(auditStore, runId, {
-      manifestId: manifest.id,
-      cwd,
-      surface: "converge",
-      scope,
-      ...ctx?.loopId !== undefined && { loopId: ctx.loopId },
-      ...ctx?.iteration !== undefined && { iteration: ctx.iteration },
-      participants: resolveParticipantSnapshots(manifest, registry3)
-    });
-    recorder.runStarted();
-    const adapters = wrapAdaptersWithSessions(wrapAdaptersWithAudit(baseAdapters, recorder), manifest, registry3, scope, sessionStore);
-    const startedAt = Date.now();
-    try {
-      const result = await executeManifest(manifest, {
-        inputs,
-        adapters,
-        invocationCwd: cwd,
-        onTrace: (e) => recorder.fromTrace(e),
-        ...ctx?.signal && { signal: ctx.signal }
-      });
-      recorder.runCompleted(result.ok ? "ok" : "failed", Date.now() - startedAt);
-      recorder.prune();
-      return recorder.lastError === undefined ? { ...result, auditRunId: runId } : result;
-    } catch (e) {
-      recorder.runCompleted("failed", Date.now() - startedAt);
-      recorder.prune();
-      throw e;
-    }
+function showAudit(store, runId, opts) {
+  const events2 = store.readEvents(runId);
+  const summary = summarizeRun(runId, events2);
+  const out = {
+    summary,
+    timeline: auditTimeline(store, runId, events2, opts)
   };
-}
-function validateConvergeManifest(manifest) {
-  for (const id of [IMPLEMENT_STEP_ID, REVIEW_STEP_ID]) {
-    const step = manifest.steps[id];
-    if (!step) {
-      return `manifest "${manifest.id}" is not converge-shaped: missing call step "${id}" (converge needs call steps named "implement" and "review")`;
-    }
-    if (step.kind !== "call") {
-      return `manifest "${manifest.id}" is not converge-shaped: step "${id}" must be a call step, not ${step.kind}`;
-    }
+  if (summary.status === "incomplete")
+    out.incompleteReason = describeIncomplete(summary, events2);
+  const started = events2.find((e) => e.type === "run.started");
+  if (started?.type === "run.started" && started.participants !== undefined) {
+    out.participants = started.participants;
   }
-  return null;
-}
-var CONVERGE_HELP = `chit converge --task <text> --scope <id> [options]
-
-  --task <text>            Required. The slice to converge on.
-  --scope <id>             Required. Session scope; both agents keep their thread.
-  --cwd <dir>              Repo to run in. Default: current directory.
-  --manifest <path>        Convergence manifest. Default: the built-in converge manifest.
-  --max-iterations <n>     Iteration budget. Default: 3.
-  --loop-id <id>           Reuse/seed a loop id. Default: generated.
-  --allow-unenforced-permissions
-                           Run even when the manifest declares permissions its
-                           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'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).
-`;
-
-class UsageError extends Error {
-}
-function parseConvergeArgs(argv) {
-  let task;
-  let scope;
-  let cwd;
-  let manifestPath;
-  let maxIterations = 3;
-  let loopId;
-  let allowUnenforcedPermissions = false;
-  for (let i = 0;i < argv.length; i++) {
-    const a = argv[i];
-    const need = (key) => {
-      const v = argv[++i];
-      if (v === undefined)
-        throw new UsageError(`${key} requires a value`);
-      return v;
-    };
-    if (a === "--task")
-      task = need("--task");
-    else if (a === "--scope")
-      scope = need("--scope");
-    else if (a === "--cwd")
-      cwd = need("--cwd");
-    else if (a === "--manifest")
-      manifestPath = need("--manifest");
-    else if (a === "--loop-id")
-      loopId = need("--loop-id");
-    else if (a === "--allow-unenforced-permissions")
-      allowUnenforcedPermissions = true;
-    else if (a === "--max-iterations") {
-      const raw = need("--max-iterations");
-      const n = Number(raw);
-      if (!Number.isInteger(n) || n < 1) {
-        throw new UsageError(`--max-iterations must be a positive integer (got ${JSON.stringify(raw)})`);
-      }
-      maxIterations = n;
-    } else {
-      throw new UsageError(`unknown flag ${JSON.stringify(a)}`);
+  if (!opts.verbose) {
+    const hidden = hiddenAdapterEventCount(events2);
+    if (hidden > 0) {
+      out.note = `${hidden} raw adapter events hidden; pass verbose to include them, include_bodies to show blob bodies.`;
     }
   }
-  if (task === undefined)
-    throw new UsageError("--task is required");
-  if (scope === undefined)
-    throw new UsageError("--scope is required");
-  return {
-    task,
-    scope,
-    cwd: resolve2(cwd ?? process.cwd()),
-    manifestPath,
-    maxIterations,
-    loopId,
-    allowUnenforcedPermissions
-  };
+  return out;
 }
-async function runConverge(argv, io = defaultIO) {
-  if (argv[0] === "-h" || argv[0] === "--help") {
-    io.out(CONVERGE_HELP);
-    return 0;
-  }
-  let parsed;
-  try {
-    parsed = parseConvergeArgs(argv);
-  } catch (e) {
-    if (e instanceof UsageError) {
-      io.err(`chit converge: ${e.message}
 
-${CONVERGE_HELP}`);
-      return 2;
-    }
-    throw e;
-  }
-  let manifest;
-  try {
-    const raw = parsed.manifestPath !== undefined ? JSON.parse(readFileSync7(parsed.manifestPath, "utf-8")) : DEFAULT_CONVERGE_MANIFEST;
-    manifest = parseManifest(raw);
-  } catch (e) {
-    io.err(`chit converge: failed to load manifest ${parsed.manifestPath ?? "(built-in default)"}: ${e.message}
-`);
-    return 2;
-  }
-  const shapeError = validateConvergeManifest(manifest);
-  if (shapeError) {
-    io.err(`chit converge: ${shapeError}
-`);
-    return 1;
-  }
-  let registry3;
+// src/jobs/health.ts
+var STALE_AFTER_MS = 60000;
+function pidAlive(pid) {
+  if (pid === undefined)
+    return false;
   try {
-    registry3 = loadRegistry();
+    process.kill(pid, 0);
+    return true;
   } catch (e) {
-    io.err(`chit converge: ${e.message}
-`);
-    return 1;
+    return e.code === "EPERM";
   }
-  const unknown3 = findUnknownAgents(manifest, registry3);
-  if (unknown3.length > 0) {
-    for (const u of unknown3) {
-      io.err(`chit converge: unknown agent "${u.agentId}" in registry (participant "${u.participantId}")
-`);
-    }
-    return 2;
+}
+function isStale(job, nowMs, staleAfterMs = STALE_AFTER_MS) {
+  if (job.state === "queued") {
+    const created = Date.parse(job.createdAt);
+    return Number.isFinite(created) && nowMs - created > staleAfterMs;
   }
-  const gaps = findEnforcementGaps(manifest, registry3);
-  if (gaps.length > 0 && !parsed.allowUnenforcedPermissions) {
-    io.err(`chit converge: cannot enforce required permissions for "${manifest.id}":
-`);
-    io.err(`${formatEnforcementGaps(gaps)}
-`);
-    io.err(`
-Pass --allow-unenforced-permissions to run anyway (emits a warning each run).
-`);
-    return 1;
+  if (job.state !== "running")
+    return false;
+  const beat = job.lastHeartbeatAt ? Date.parse(job.lastHeartbeatAt) : 0;
+  const heartbeatOld = !Number.isFinite(beat) || nowMs - beat > staleAfterMs;
+  return heartbeatOld || !pidAlive(job.pid);
+}
+function jobTiming(job, nowMs) {
+  const inFlight = job.state === "queued" || job.state === "running";
+  const timing = {};
+  const startMs = Date.parse(job.startedAt ?? job.createdAt);
+  const endMs = job.endedAt ? Date.parse(job.endedAt) : nowMs;
+  if (Number.isFinite(startMs) && Number.isFinite(endMs) && endMs >= startMs) {
+    timing.elapsedMs = endMs - startMs;
   }
-  for (const g of gaps) {
-    io.err(`chit converge: WARNING -- unenforced permission: participant "${g.participantId}" requires ${g.permission}
-`);
+  if (inFlight && job.lastHeartbeatAt) {
+    const beat = Date.parse(job.lastHeartbeatAt);
+    if (Number.isFinite(beat) && nowMs >= beat)
+      timing.lastHeartbeatAgeMs = nowMs - beat;
   }
-  let result;
-  try {
-    result = await convergeLoop({
-      cwd: parsed.cwd,
-      scope: parsed.scope,
-      task: parsed.task,
-      maxIterations: parsed.maxIterations,
-      loopId: parsed.loopId,
-      execute: buildExecute(manifest, registry3, parsed.scope, parsed.cwd)
-    });
-  } catch (e) {
-    io.err(`chit converge: ${e.message}
-`);
-    return 1;
+  if (job.phase !== undefined && job.phaseStartedAt) {
+    const phaseStart = Date.parse(job.phaseStartedAt);
+    if (Number.isFinite(phaseStart) && nowMs >= phaseStart) {
+      timing.phaseElapsedMs = nowMs - phaseStart;
+    }
   }
-  if (result.failure !== undefined) {
-    io.err(`chit converge: ${result.failure}
-`);
-    return 1;
+  return timing;
+}
+function formatDuration(ms) {
+  const totalSec = Math.floor(ms / 1000);
+  if (totalSec < 60)
+    return `${totalSec}s`;
+  const totalMin = Math.floor(totalSec / 60);
+  if (totalMin < 60) {
+    const sec = totalSec % 60;
+    return sec ? `${totalMin}m${sec}s` : `${totalMin}m`;
   }
-  io.out(`chit converge: ${result.loopId}
-`);
-  io.out(`  iterations: ${result.iterations}
-`);
-  io.out(`  status:     ${result.status}
-`);
-  return 0;
+  const hours = Math.floor(totalMin / 60);
+  const min = totalMin % 60;
+  return min ? `${hours}h${min}m` : `${hours}h`;
 }
 
 // src/surfaces/mcp/converge-engine.ts
@@ -36195,6 +36671,42 @@ function summarizeRunForStatus(run) {
     audited: run.recorder !== undefined && run.recorder.lastError === undefined
   };
 }
+function runningNextAction(job, timing) {
+  const parts = [];
+  if (timing.elapsedMs !== undefined)
+    parts.push(`running for ${formatDuration(timing.elapsedMs)}`);
+  if (job.phase) {
+    parts.push(timing.phaseElapsedMs !== undefined ? `${job.phase} for ${formatDuration(timing.phaseElapsedMs)}` : job.phase);
+  }
+  const lead = parts.length > 0 ? parts.join(", ") : "in progress";
+  return `${lead}; chit_job_status / chit_job_cancel "${job.jobId}"`;
+}
+function summarizeJobForStatus(job, nowMs) {
+  const stale = isStale(job, nowMs);
+  const display = stale ? "stale" : job.state;
+  const timing = jobTiming(job, nowMs);
+  const latestRef = job.auditRefs.at(-1);
+  const nextAction = display === "running" ? runningNextAction(job, timing) : display === "queued" ? "queued; the worker is starting" : display === "stale" ? `worker appears dead; chit_job_status "${job.jobId}" to inspect, then start a fresh job` : `${display}${job.stopStatus ? ` (${job.stopStatus})` : ""}; chit_job_status "${job.jobId}"${latestRef ? ` or chit_audit_show ${latestRef}` : ""}`;
+  return {
+    jobId: job.jobId,
+    loopId: job.loopId,
+    scope: job.scope,
+    task: job.task,
+    display,
+    ...job.phase !== undefined && { phase: job.phase },
+    iterationsCompleted: job.iterationsCompleted,
+    ...job.lastVerdict !== undefined && { lastVerdict: job.lastVerdict },
+    ...job.stopStatus !== undefined && { stopStatus: job.stopStatus },
+    auditRefs: job.auditRefs,
+    createdAt: job.createdAt,
+    ...timing.elapsedMs !== undefined && { elapsedMs: timing.elapsedMs },
+    ...timing.lastHeartbeatAgeMs !== undefined && {
+      lastHeartbeatAgeMs: timing.lastHeartbeatAgeMs
+    },
+    ...timing.phaseElapsedMs !== undefined && { phaseElapsedMs: timing.phaseElapsedMs },
+    nextAction
+  };
+}
 function byNewest(items) {
   return [...items].sort((a, b) => b.startedAtMs - a.startedAtMs);
 }
@@ -36207,21 +36719,34 @@ function recentRuns(auditStore, recentLimit) {
     return [];
   }
 }
-function buildStatus(runs, convergeSessions, auditStore, recentLimit) {
+function buildStatus(runs, convergeSessions, auditStore, jobStore, recentLimit, nowMs) {
   return {
     active: {
       runs: byNewest(runs.list()).map(summarizeRunForStatus),
       loops: byNewest(convergeSessions.list()).map(describeConverge)
     },
+    jobs: jobsForStatus(jobStore, recentLimit, nowMs),
     recent: recentRuns(auditStore, recentLimit)
   };
 }
+function jobsForStatus(jobStore, recentLimit, nowMs) {
+  let all;
+  try {
+    all = jobStore.list();
+  } catch {
+    return [];
+  }
+  const inFlight = all.filter((j) => j.state === "queued" || j.state === "running");
+  const terminal = all.filter((j) => j.state !== "queued" && j.state !== "running").slice(0, recentLimit);
+  return [...inFlight, ...terminal].map((j) => summarizeJobForStatus(j, nowMs));
+}
 
 // src/surfaces/mcp/server.ts
 var runs = new RunStore;
 var controllers = new Map;
 var convergeSessions = new ConvergeStore;
 var auditStore = new AuditStore;
+var jobStore = new JobStore;
 var registryCache;
 function getRegistry() {
   registryCache ??= loadRegistry();
@@ -36271,10 +36796,10 @@ server.registerTool("chit_run_start", {
   }
 }, async ({ manifest_path, inputs, scope, cwd, allow_unenforced_permissions, audit }) => {
   runs.sweep(Date.now());
-  const path = isAbsolute2(manifest_path) ? manifest_path : resolve3(process.cwd(), manifest_path);
+  const path = isAbsolute3(manifest_path) ? manifest_path : resolve4(process.cwd(), manifest_path);
   let raw;
   try {
-    raw = JSON.parse(readFileSync8(path, "utf-8"));
+    raw = JSON.parse(readFileSync11(path, "utf-8"));
   } catch (e) {
     return errorResult(`could not read manifest at ${path}: ${e.message}`);
   }
@@ -36398,36 +36923,6 @@ server.registerTool("chit_run_trace", {
     trace
   });
 });
-function prepareConvergeExecute(raw, scope, cwd, allowUnenforced) {
-  let manifest;
-  try {
-    manifest = parseManifest(raw);
-  } catch (e) {
-    return { ok: false, error: e.message };
-  }
-  const shapeError = validateConvergeManifest(manifest);
-  if (shapeError)
-    return { ok: false, error: shapeError };
-  const registry3 = getRegistry();
-  const unknown3 = findUnknownAgents(manifest, registry3);
-  if (unknown3.length > 0) {
-    return {
-      ok: false,
-      error: `unknown agent(s): ${unknown3.map((u) => `${u.agentId} (participant "${u.participantId}")`).join(", ")}`
-    };
-  }
-  const gaps = findEnforcementGaps(manifest, registry3);
-  if (gaps.length > 0 && !allowUnenforced) {
-    return {
-      ok: false,
-      error: `cannot enforce required permissions:
-${formatEnforcementGaps(gaps)}
-Pass allow_unenforced_permissions=true to run anyway.`
-    };
-  }
-  const warnings = gaps.map((g) => `unenforced permission: participant "${g.participantId}" requires ${g.permission}`);
-  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 the loop under chit's state dir (keyed by repo), identical to `chit converge`.",
   inputSchema: {
@@ -36451,19 +36946,19 @@ server.registerTool("chit_converge_start", {
   allow_unenforced_permissions
 }) => {
   convergeSessions.sweep(Date.now());
-  const runCwd = resolve3(cwd ?? process.cwd());
+  const runCwd = resolve4(cwd ?? process.cwd());
   let raw;
   if (manifest_path) {
-    const path = isAbsolute2(manifest_path) ? manifest_path : resolve3(runCwd, manifest_path);
+    const path = isAbsolute3(manifest_path) ? manifest_path : resolve4(runCwd, manifest_path);
     try {
-      raw = JSON.parse(readFileSync8(path, "utf-8"));
+      raw = JSON.parse(readFileSync11(path, "utf-8"));
     } catch (e) {
       return errorResult(`could not read manifest at ${path}: ${e.message}`);
     }
   } else {
     raw = DEFAULT_CONVERGE_MANIFEST;
   }
-  const prep = prepareConvergeExecute(raw, scope, runCwd, allow_unenforced_permissions);
+  const prep = prepareConvergeExecute(raw, getRegistry(), scope, runCwd, allow_unenforced_permissions);
   if (!prep.ok)
     return errorResult(prep.error);
   let session;
@@ -36505,6 +37000,15 @@ server.registerTool("chit_converge_next", {
     }
     server.sendLoggingMessage({ level: "info", data: message, logger: "chit" }).catch(() => {});
   };
+  let loopLock;
+  try {
+    loopLock = acquireLock(jobStore.loopLockPath(loop_id), { retryMs: 50, maxAttempts: 4 });
+  } catch (e) {
+    if (e instanceof LockError) {
+      return errorResult(`loop "${loop_id}" is being advanced by a background job; cancel it with chit_job_cancel or wait, then retry`);
+    }
+    throw e;
+  }
   const iterationNo = session.iteration + 1;
   heartbeat(`${loop_id} \xB7 iteration ${iterationNo} \xB7 starting`);
   try {
@@ -36543,6 +37047,7 @@ server.registerTool("chit_converge_next", {
   } catch (e) {
     return errorResult(e.message);
   } finally {
+    releaseLock(loopLock);
     convergeSessions.touch(loop_id, Date.now());
   }
 });
@@ -36606,7 +37111,204 @@ server.registerTool("chit_status", {
     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));
+  return jsonResult(buildStatus(runs, convergeSessions, auditStore, jobStore, recent_limit, Date.now()));
+});
+function spawnJobWorker(jobId, cwd) {
+  const child = spawn(String(process.argv[0]), [String(process.argv[1]), "job-run", jobId], {
+    cwd,
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+}
+server.registerTool("chit_converge_run", {
+  description: "Start an autonomous converge loop as a BACKGROUND job (a detached worker advances it; you keep chatting). Returns immediately with a job_id and loop_id. Inspect with chit_job_status / chit_status, stop with chit_job_cancel. Use the foreground chit_converge_start/next instead when you want to checkpoint each iteration. v1 starts a NEW loop only: an existing loop_id is refused (use chit_converge_next to continue a foreground loop, or force=true / a new loop_id).",
+  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"),
+    cwd: exports_external.string().optional().describe("Repo to run in (defaults to the server cwd)"),
+    manifest_path: exports_external.string().optional().describe("Converge manifest path (absolute or relative to cwd). Default: the built-in."),
+    max_iterations: exports_external.number().int().min(1).default(3).describe("Iteration budget. Default 3."),
+    loop_id: exports_external.string().optional().describe("Seed a loop id. Default: generated."),
+    force: exports_external.boolean().default(false).describe("Overwrite an existing loop log at this loop_id rather than refusing."),
+    allow_unenforced_permissions: exports_external.boolean().default(false).describe("Run even when a declared permission cannot be enforced (emits warnings).")
+  }
+}, async ({
+  task,
+  scope,
+  cwd,
+  manifest_path,
+  max_iterations,
+  loop_id,
+  force,
+  allow_unenforced_permissions
+}) => {
+  const runCwd = resolve4(cwd ?? process.cwd());
+  let raw;
+  let manifestAbs;
+  if (manifest_path) {
+    manifestAbs = isAbsolute3(manifest_path) ? manifest_path : resolve4(runCwd, manifest_path);
+    try {
+      raw = JSON.parse(readFileSync11(manifestAbs, "utf-8"));
+    } catch (e) {
+      return errorResult(`could not read manifest at ${manifestAbs}: ${e.message}`);
+    }
+  } else {
+    raw = DEFAULT_CONVERGE_MANIFEST;
+  }
+  const prep = prepareConvergeExecute(raw, getRegistry(), scope, runCwd, allow_unenforced_permissions);
+  if (!prep.ok)
+    return errorResult(prep.error);
+  const loopId = loop_id ?? crypto.randomUUID();
+  try {
+    startLoop(runCwd, { scope, task, maxIterations: max_iterations, loopId, force });
+  } catch (e) {
+    if (e instanceof LoopStoreError) {
+      return errorResult(`${e.message}. Use chit_converge_next to continue a foreground loop, or start a background job with force=true or a new loop_id.`);
+    }
+    return errorResult(e.message);
+  }
+  const jobId = crypto.randomUUID();
+  const job = {
+    jobId,
+    loopId,
+    repoKey: repoKey(runCwd),
+    cwd: runCwd,
+    scope,
+    task,
+    ...manifestAbs !== undefined && { manifestPath: manifestAbs },
+    maxIterations: max_iterations,
+    allowUnenforced: allow_unenforced_permissions,
+    state: "queued",
+    createdAt: new Date().toISOString(),
+    iterationsCompleted: 0,
+    auditRefs: []
+  };
+  try {
+    jobStore.create(job);
+  } catch (e) {
+    stopLoop(runCwd, loopId, { status: "blocked", reason: "could not create job record" });
+    return errorResult(e.message);
+  }
+  try {
+    spawnJobWorker(jobId, runCwd);
+  } catch (e) {
+    jobStore.update(jobId, (c) => ({
+      ...c,
+      state: "failed",
+      failure: `could not spawn worker: ${e.message}`,
+      endedAt: new Date().toISOString()
+    }));
+    stopLoop(runCwd, loopId, { status: "blocked", reason: "worker spawn failed" });
+    return errorResult(`could not spawn background worker: ${e.message}`);
+  }
+  return jsonResult({
+    jobId,
+    loopId,
+    repo: repoRoot(runCwd),
+    state: "queued",
+    nextAction: `running in the background; poll chit_job_status "${jobId}" (or chit_status), cancel with chit_job_cancel "${jobId}"`,
+    ...prep.warnings.length > 0 && { warnings: prep.warnings }
+  });
+});
+function describeJob(job) {
+  const now = Date.now();
+  const stale = isStale(job, now);
+  const display = stale ? "stale" : job.state;
+  let latest;
+  try {
+    const iters = readLoop(job.cwd, job.loopId).filter((r) => r.type === "iteration");
+    const last = iters.at(-1);
+    if (last && last.type === "iteration") {
+      latest = {
+        iteration: last.n,
+        changedFiles: last.changedFiles,
+        workspaceWarnings: last.workspaceWarnings ?? [],
+        ...last.usage !== undefined && { usage: last.usage }
+      };
+    }
+  } catch {}
+  const timing = jobTiming(job, now);
+  const latestRef = job.auditRefs.at(-1);
+  const runningDetail = [
+    timing.elapsedMs !== undefined ? `running for ${formatDuration(timing.elapsedMs)}` : undefined,
+    job.phase ? timing.phaseElapsedMs !== undefined ? `${job.phase} for ${formatDuration(timing.phaseElapsedMs)}` : job.phase : undefined
+  ].filter(Boolean);
+  const nextAction = display === "running" ? `${runningDetail.length > 0 ? `${runningDetail.join(", ")}; ` : ""}chit_job_cancel to stop, or wait and poll again` : display === "queued" ? "queued; the worker is starting" : display === "stale" ? `worker appears dead; inspect with chit_job_status${latestRef ? ` (chit_audit_show ${latestRef} for the transcript)` : ""}, then start a fresh job` : `${display}${job.stopStatus ? ` (${job.stopStatus})` : ""}; ${latestRef ? `open a transcript with chit_audit_show ${latestRef}` : "no audit transcript was recorded"}`;
+  return {
+    jobId: job.jobId,
+    loopId: job.loopId,
+    scope: job.scope,
+    task: job.task,
+    state: job.state,
+    display,
+    stale,
+    alive: pidAlive(job.pid),
+    ...job.phase !== undefined && { phase: job.phase },
+    ...job.iteration !== undefined && { iteration: job.iteration },
+    iterationsCompleted: job.iterationsCompleted,
+    ...job.lastVerdict !== undefined && { lastVerdict: job.lastVerdict },
+    ...job.stopStatus !== undefined && { stopStatus: job.stopStatus },
+    ...job.failure !== undefined && { failure: job.failure },
+    ...job.cancelRequestedAt !== undefined && { cancelRequestedAt: job.cancelRequestedAt },
+    auditRefs: job.auditRefs,
+    createdAt: job.createdAt,
+    ...job.startedAt !== undefined && { startedAt: job.startedAt },
+    ...job.endedAt !== undefined && { endedAt: job.endedAt },
+    ...job.lastHeartbeatAt !== undefined && { lastHeartbeatAt: job.lastHeartbeatAt },
+    ...job.phaseStartedAt !== undefined && { phaseStartedAt: job.phaseStartedAt },
+    ...timing.elapsedMs !== undefined && { elapsedMs: timing.elapsedMs },
+    ...timing.lastHeartbeatAgeMs !== undefined && {
+      lastHeartbeatAgeMs: timing.lastHeartbeatAgeMs
+    },
+    ...timing.phaseElapsedMs !== undefined && { phaseElapsedMs: timing.phaseElapsedMs },
+    ...latest !== undefined && { latest },
+    nextAction
+  };
+}
+server.registerTool("chit_job_status", {
+  description: "Show one background job: state (queued/running/completed/cancelled/failed, or derived `stale` when the worker is gone), current phase, timing fields (elapsedMs, lastHeartbeatAgeMs, phaseElapsedMs), loop id, iterations, last verdict, audit refs, and the latest iteration's changed files / workspace warnings / usage. Read-only.",
+  inputSchema: { job_id: exports_external.string() }
+}, async ({ job_id }) => {
+  const job = jobStore.get(job_id);
+  if (!job)
+    return errorResult(`unknown job_id ${job_id}`);
+  return jsonResult(describeJob(job));
+});
+server.registerTool("chit_job_cancel", {
+  description: "Cancel a background job from any turn. Persists the cancel intent FIRST (so it survives a worker restart), then signals the worker's process group. A queued job is cancelled before it starts; a running job stops at the next safe point and records a clean `cancelled` stop. A job that already finished is reported back unchanged.",
+  inputSchema: { job_id: exports_external.string() }
+}, async ({ job_id }) => {
+  const job = jobStore.get(job_id);
+  if (!job)
+    return errorResult(`unknown job_id ${job_id}`);
+  if (job.state !== "queued" && job.state !== "running") {
+    return jsonResult({
+      jobId: job_id,
+      state: job.state,
+      cancelled: false,
+      note: `job already ${job.state}`
+    });
+  }
+  const updated = jobStore.update(job_id, (c) => ({
+    ...c,
+    cancelRequestedAt: new Date().toISOString(),
+    ...c.state === "running" && { phase: "cancelling" }
+  }));
+  let signaled = false;
+  if (!isStale(updated, Date.now()) && updated.pgid !== undefined && pidAlive(updated.pid)) {
+    try {
+      process.kill(-updated.pgid, "SIGTERM");
+      signaled = true;
+    } catch {}
+  }
+  return jsonResult({
+    jobId: job_id,
+    state: updated.state,
+    cancelRequested: true,
+    signaled,
+    note: "cancellation requested; the worker stops at the next safe point and records a clean cancelled stop"
+  });
 });
 async function startMcpServer() {
   await server.connect(new StdioServerTransport);
@@ -36836,9 +37538,9 @@ ${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 join8 } from "path";
+import { randomUUID as randomUUID5 } from "crypto";
+import { mkdirSync as mkdirSync6, rmSync as rmSync7, writeFileSync as writeFileSync6 } from "fs";
+import { join as join9 } from "path";
 var defaultIO3 = {
   out: (s) => process.stdout.write(s),
   err: (s) => process.stderr.write(s)
@@ -36906,10 +37608,10 @@ function checkGitRepo(deps) {
 }
 function checkAuditDir(deps) {
   try {
-    mkdirSync5(deps.auditDir, { recursive: true });
-    const probeFile = join8(deps.auditDir, `.doctor-${randomUUID3()}`);
-    writeFileSync5(probeFile, "ok");
-    rmSync5(probeFile);
+    mkdirSync6(deps.auditDir, { recursive: true });
+    const probeFile = join9(deps.auditDir, `.doctor-${randomUUID5()}`);
+    writeFileSync6(probeFile, "ok");
+    rmSync7(probeFile);
     return { name: "audit dir", status: "pass", detail: `writable (${deps.auditDir})` };
   } catch (e) {
     return {
@@ -37027,7 +37729,7 @@ ${DOCTOR_HELP}`);
 
 // src/cli/loop-log.ts
 init_src();
-import { resolve as resolve4 } from "path";
+import { resolve as resolve5 } from "path";
 var defaultIO4 = {
   out: (s) => process.stdout.write(s),
   err: (s) => process.stderr.write(s)
@@ -37158,7 +37860,7 @@ function runLoopLog(argv, io = defaultIO4) {
   }
   try {
     const p = parseFlags(verb, argv.slice(1));
-    const cwd = resolve4(p.flags.cwd ?? ".");
+    const cwd = resolve5(p.flags.cwd ?? ".");
     if (verb === "start") {
       const res = startLoop(cwd, {
         scope: req(p, "scope", verb),
@@ -37512,9 +38214,10 @@ Permission enforcement: each participant's declared permissions are checked
 against the chosen adapter's capabilities at install time. If the adapter
 cannot enforce a permission, the run is rejected unless
 --allow-unenforced-permissions is set. Both built-in adapters enforce
-filesystem read_only today: codex-exec via --sandbox read-only (a hard OS
-sandbox), claude-cli via --permission-mode plan (Claude plan-mode permissions,
-not an OS/filesystem sandbox).
+filesystem read_only today: codex-exec via an OS sandbox (--sandbox read-only
+for a reviewer, --sandbox workspace-write for a write-capable implementer),
+claude-cli via --permission-mode plan (a Claude plan-mode permission, not an
+OS/filesystem sandbox).
 
 Limitations in this build:
 - file[] inputs are not yet supported via the CLI.
@@ -37531,6 +38234,16 @@ async function runMain(argv) {
     return runAudit(argv.slice(1));
   if (argv[0] === "doctor")
     return runDoctor(argv.slice(1));
+  if (argv[0] === "job-run") {
+    const jobId = argv[1];
+    if (!jobId) {
+      process.stderr.write(`chit job-run: requires a <jobId>
+`);
+      return 2;
+    }
+    await runJobWorker(jobId, { jobStore: new JobStore });
+    return 0;
+  }
   let args;
   try {
     args = parseArgs(argv);
@@ -37571,7 +38284,7 @@ ${HELP}`);
   }
   let manifestRaw;
   try {
-    manifestRaw = JSON.parse(readFileSync13(args.manifestPath, "utf-8"));
+    manifestRaw = JSON.parse(readFileSync16(args.manifestPath, "utf-8"));
   } catch (e) {
     process.stderr.write(`chit: failed to read manifest ${args.manifestPath}: ${e.message}
 `);
@@ -37782,7 +38495,7 @@ ${HELP}`);
 `);
     return 2;
   }
-  const outputDir = args.outputDir ?? join13(homedir7(), ".claude", "skills");
+  const outputDir = args.outputDir ?? join14(homedir8(), ".claude", "skills");
   const runtimePath = args.runtimePath ?? defaultRuntimePath();
   try {
     const result = installClaudeSkill({
@@ -37825,7 +38538,7 @@ ${HELP}`);
   }
   let raw2;
   try {
-    raw2 = JSON.parse(readFileSync13(args.manifestPath, "utf-8"));
+    raw2 = JSON.parse(readFileSync16(args.manifestPath, "utf-8"));
   } catch (e) {
     process.stderr.write(`chit: failed to read manifest ${args.manifestPath}: ${e.message}
 `);
@@ -37964,13 +38677,13 @@ async function runStudio(args) {
 `);
   process.stdout.write(`Press Ctrl-C to stop.
 `);
-  await new Promise((resolve6) => {
+  await new Promise((resolve7) => {
     process.on("SIGINT", () => {
       process.stdout.write(`
 chit studio: stopped
 `);
       handle.stop();
-      resolve6();
+      resolve7();
     });
   });
   return 0;