@chit-run/cli 0.9.0 → 0.10.0

package/dist/chit.js

@@ -9984,12 +9984,12 @@ var init_dist = __esm(() => {
 });
 
 // ../studio/src/server/audit.ts
-import { existsSync as existsSync9, readFileSync as readFileSync12 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join10 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync13 } from "fs";
+import { homedir as homedir9 } from "os";
+import { join as join12 } from "path";
 function defaultAuditDir2() {
-  const xdg = process.env.XDG_STATE_HOME || join10(homedir7(), ".local", "state");
-  return join10(xdg, "chit", "audit");
+  const xdg = process.env.XDG_STATE_HOME || join12(homedir9(), ".local", "state");
+  return join12(xdg, "chit", "audit");
 }
 function blobRefs(e) {
   switch (e.type) {
@@ -10008,13 +10008,13 @@ function blobRefs(e) {
 function readAuditRun(auditDir, runId, includeBlobs) {
   if (!SAFE_RUN_ID2.test(runId))
     return { kind: "invalid-id" };
-  const runDir = join10(auditDir, "runs", runId);
-  const eventsPath = join10(runDir, "events.jsonl");
-  if (!existsSync9(eventsPath))
+  const runDir = join12(auditDir, "runs", runId);
+  const eventsPath = join12(runDir, "events.jsonl");
+  if (!existsSync11(eventsPath))
     return { kind: "not-found" };
   let events2;
   try {
-    events2 = parseAuditLog(readFileSync12(eventsPath, "utf-8"));
+    events2 = parseAuditLog(readFileSync13(eventsPath, "utf-8"));
   } catch (e) {
     if (e instanceof AuditEventError)
       return { kind: "invalid-log", message: e.message };
@@ -10022,15 +10022,15 @@ function readAuditRun(auditDir, runId, includeBlobs) {
   }
   if (!includeBlobs)
     return { kind: "ok", events: events2 };
-  const blobsDir = join10(runDir, "blobs");
+  const blobsDir = join12(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 = join10(blobsDir, ref);
-      if (existsSync9(blobPath))
-        blobs[ref] = readFileSync12(blobPath, "utf-8");
+      const blobPath = join12(blobsDir, ref);
+      if (existsSync11(blobPath))
+        blobs[ref] = readFileSync13(blobPath, "utf-8");
     }
   }
   return { kind: "ok", events: events2, blobs };
@@ -10088,12 +10088,12 @@ var init_auth = __esm(() => {
 });
 
 // ../studio/src/server/paths.ts
-import { existsSync as existsSync10, statSync as statSync3 } from "fs";
+import { existsSync as existsSync12, statSync as statSync3 } from "fs";
 import { isAbsolute as isAbsolute4, resolve as resolve6 } from "path";
 function resolveExplicitPath(userPath, cwd) {
   const candidate = isAbsolute4(userPath) ? userPath : resolve6(cwd, userPath);
   const canonical = resolve6(candidate);
-  if (!existsSync10(canonical)) {
+  if (!existsSync12(canonical)) {
     throw new PathError("not-found", `path "${userPath}" does not exist`);
   }
   if (!statSync3(canonical).isFile()) {
@@ -10114,11 +10114,11 @@ var init_paths = __esm(() => {
 });
 
 // ../studio/src/server/discovery.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync13 } from "fs";
-import { basename, join as join11, relative } from "path";
+import { readdirSync as readdirSync5, readFileSync as readFileSync14 } from "fs";
+import { basename, join as join13, relative } from "path";
 function safeParseChit(absolutePath) {
   try {
-    const raw2 = JSON.parse(readFileSync13(absolutePath, "utf-8"));
+    const raw2 = JSON.parse(readFileSync14(absolutePath, "utf-8"));
     parseManifest(raw2);
     return true;
   } catch {
@@ -10138,14 +10138,14 @@ function discover(opts) {
       relPath: relPathFromCwd(absolutePath, opts.cwd)
     };
   }
-  const entries = readdirSync4(opts.cwd, { withFileTypes: true });
+  const entries = readdirSync5(opts.cwd, { withFileTypes: true });
   const candidates = [];
   for (const entry of entries) {
     if (!entry.isFile())
       continue;
     if (!entry.name.endsWith(".json"))
       continue;
-    const absolutePath = join11(opts.cwd, entry.name);
+    const absolutePath = join13(opts.cwd, entry.name);
     if (!safeParseChit(absolutePath))
       continue;
     candidates.push({
@@ -10171,7 +10171,7 @@ var init_discovery = __esm(() => {
 
 // ../studio/src/server/docs.ts
 import { createHash as createHash6 } from "crypto";
-import { readFileSync as readFileSync14, writeFileSync as writeFileSync7 } from "fs";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync8 } from "fs";
 import { basename as basename2, relative as relative2 } from "path";
 function canonicalize(draft) {
   return JSON.stringify(draft, null, "\t");
@@ -10204,7 +10204,7 @@ class DocStore {
     if (!entry)
       return null;
     try {
-      return hashRaw(readFileSync14(entry.absolutePath, "utf-8"));
+      return hashRaw(readFileSync15(entry.absolutePath, "utf-8"));
     } catch {
       return null;
     }
@@ -10246,7 +10246,7 @@ class DocStore {
       return null;
     let raw2;
     try {
-      raw2 = readFileSync14(entry.absolutePath, "utf-8");
+      raw2 = readFileSync15(entry.absolutePath, "utf-8");
     } catch (e) {
       const errorDoc = {
         id: docId,
@@ -10302,7 +10302,7 @@ class DocStore {
       return { kind: "not-found" };
     let currentRaw;
     try {
-      currentRaw = readFileSync14(entry.absolutePath, "utf-8");
+      currentRaw = readFileSync15(entry.absolutePath, "utf-8");
     } catch {
       return { kind: "not-found" };
     }
@@ -10314,7 +10314,7 @@ class DocStore {
       const manifest = parseManifest(draft);
       const graphModel = buildGraphModel(manifest, this.registry, surface);
       const canonicalRaw = canonicalize(draft);
-      writeFileSync7(entry.absolutePath, canonicalRaw, "utf-8");
+      writeFileSync8(entry.absolutePath, canonicalRaw, "utf-8");
       const newHash = hashRaw(canonicalRaw);
       return {
         kind: "saved",
@@ -10383,8 +10383,8 @@ var init_docs = __esm(() => {
 });
 
 // ../studio/src/server/loops.ts
-import { existsSync as existsSync11, readdirSync as readdirSync5, readFileSync as readFileSync15 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync13, readdirSync as readdirSync6, readFileSync as readFileSync16 } from "fs";
+import { join as join14 } from "path";
 function summarize(loopId, records) {
   const header = records[0];
   if (header?.type !== "loop")
@@ -10402,11 +10402,11 @@ function summarize(loopId, records) {
   };
 }
 function readLoopFrom(dir, loopId) {
-  const path = join12(dir, `${loopId}.jsonl`);
-  if (!existsSync11(path))
+  const path = join14(dir, `${loopId}.jsonl`);
+  if (!existsSync13(path))
     return { kind: "not-found" };
   try {
-    const records = validateLoopLog(parseLoopLog(readFileSync15(path, "utf-8")));
+    const records = validateLoopLog(parseLoopLog(readFileSync16(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" };
@@ -10419,10 +10419,10 @@ function readLoopFrom(dir, loopId) {
   }
 }
 function listLoops(loopsDir) {
-  if (!loopsDir || !existsSync11(loopsDir))
+  if (!loopsDir || !existsSync13(loopsDir))
     return [];
   const summaries = [];
-  for (const name of readdirSync5(loopsDir)) {
+  for (const name of readdirSync6(loopsDir)) {
     if (!name.endsWith(".jsonl"))
       continue;
     const loopId = name.slice(0, -".jsonl".length);
@@ -10479,8 +10479,8 @@ __export(exports_server, {
   buildApp: () => buildApp,
   PathError: () => PathError
 });
-import { existsSync as existsSync12 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync14 } from "fs";
+import { join as join15 } from "path";
 async function startStudio(opts) {
   const hostname3 = opts.hostname ?? "127.0.0.1";
   const requestedPort = opts.port ?? 0;
@@ -10533,8 +10533,8 @@ function buildApp(opts) {
     const asset = c.req.param("asset");
     if (!CLIENT_ASSETS.has(asset))
       return c.text("not found", 404);
-    const path = join13(opts.clientDistDir, asset);
-    if (!existsSync12(path)) {
+    const path = join15(opts.clientDistDir, asset);
+    if (!existsSync14(path)) {
       return c.text(`client bundle missing at ${path}. Run: bun run studio:build`, 503);
     }
     return new Response(Bun.file(path));
@@ -10709,15 +10709,15 @@ var init_server = __esm(() => {
   init_loops();
   init_token();
   init_paths();
-  CLIENT_DIST = join13(import.meta.dir, "..", "..", "dist", "client");
+  CLIENT_DIST = join15(import.meta.dir, "..", "..", "dist", "client");
   CLIENT_ASSETS = new Set(["index.js", "index.css"]);
 });
 
 // src/cli/run.ts
 init_src();
-import { readFileSync as readFileSync16 } from "fs";
-import { homedir as homedir8 } from "os";
-import { basename as basename3, dirname as dirname2, join as join14 } from "path";
+import { readFileSync as readFileSync17 } from "fs";
+import { homedir as homedir10 } from "os";
+import { basename as basename3, dirname as dirname3, join as join16 } from "path";
 
 // src/adapters/sanitize.ts
 var SENSITIVE_KEY = /key|token|secret|password|auth/i;
@@ -13389,7 +13389,7 @@ function uninstall(parentDir, name) {
 
 // src/surfaces/mcp/server.ts
 import { spawn } from "child_process";
-import { readFileSync as readFileSync11 } from "fs";
+import { readFileSync as readFileSync12 } 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
@@ -36205,6 +36205,579 @@ function showAudit(store, runId, opts) {
   return out;
 }
 
+// src/campaigns/plan.ts
+class PlanError extends Error {
+}
+var SAFE_TASK_ID = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+function normalizeClaim(claim, taskId) {
+  const raw = claim.trim();
+  if (raw === "")
+    throw new PlanError(`task ${JSON.stringify(taskId)}: a claimedPath is empty`);
+  if (raw.startsWith("/")) {
+    throw new PlanError(`task ${JSON.stringify(taskId)}: claimedPath must be repo-relative, got ${JSON.stringify(claim)}`);
+  }
+  const dirGlob = raw.endsWith("/**");
+  const dirSlash = !dirGlob && raw.endsWith("/");
+  const body = dirGlob ? raw.slice(0, -3) : dirSlash ? raw.slice(0, -1) : raw;
+  const segments = [];
+  for (const seg of body.split("/")) {
+    if (seg === "" || seg === ".")
+      continue;
+    if (seg === "..") {
+      throw new PlanError(`task ${JSON.stringify(taskId)}: claimedPath may not contain "..": ${JSON.stringify(claim)}`);
+    }
+    segments.push(seg);
+  }
+  if (segments.length === 0) {
+    throw new PlanError(`task ${JSON.stringify(taskId)}: claimedPath is empty after normalization: ${JSON.stringify(claim)}`);
+  }
+  const base = segments.join("/");
+  return dirGlob ? `${base}/**` : dirSlash ? `${base}/` : base;
+}
+function planTasks(inputs) {
+  if (inputs.length === 0)
+    throw new PlanError("a campaign needs at least one task");
+  const ids = new Set;
+  for (const t of inputs) {
+    if (!SAFE_TASK_ID.test(t.id)) {
+      throw new PlanError(`invalid task id ${JSON.stringify(t.id)} (use [A-Za-z0-9][A-Za-z0-9_-]*)`);
+    }
+    if (ids.has(t.id))
+      throw new PlanError(`duplicate task id ${JSON.stringify(t.id)}`);
+    ids.add(t.id);
+    if (!t.title?.trim())
+      throw new PlanError(`task ${JSON.stringify(t.id)}: title is required`);
+    if (!t.body?.trim())
+      throw new PlanError(`task ${JSON.stringify(t.id)}: body is required`);
+  }
+  for (const t of inputs) {
+    for (const dep of t.dependencies ?? []) {
+      if (!ids.has(dep)) {
+        throw new PlanError(`task ${JSON.stringify(t.id)} depends on unknown task ${JSON.stringify(dep)}`);
+      }
+      if (dep === t.id)
+        throw new PlanError(`task ${JSON.stringify(t.id)} depends on itself`);
+    }
+    const claims = t.claimedPaths ?? [];
+    if (claims.length === 0 && !t.allowPathOverlap) {
+      throw new PlanError(`task ${JSON.stringify(t.id)}: claimedPaths is required (declare the paths it will touch), ` + "or set allowPathOverlap to run it without a declared footprint (it will run alone)");
+    }
+  }
+  assertAcyclic(inputs);
+  return inputs.map((t) => {
+    const task = {
+      id: t.id,
+      title: t.title,
+      body: t.body,
+      status: "pending",
+      dependencies: [...t.dependencies ?? []],
+      claimedPaths: (t.claimedPaths ?? []).map((c) => normalizeClaim(c, t.id))
+    };
+    if (t.allowPathOverlap)
+      task.allowPathOverlap = true;
+    if (t.manifestPath !== undefined)
+      task.manifestPath = t.manifestPath;
+    return task;
+  });
+}
+function assertAcyclic(inputs) {
+  const deps = new Map(inputs.map((t) => [t.id, t.dependencies ?? []]));
+  const state = new Map;
+  const visit = (id, stack) => {
+    const s = state.get(id);
+    if (s === "done")
+      return;
+    if (s === "visiting") {
+      const cycle = [...stack.slice(stack.indexOf(id)), id].join(" -> ");
+      throw new PlanError(`dependency cycle: ${cycle}`);
+    }
+    state.set(id, "visiting");
+    for (const dep of deps.get(id) ?? [])
+      visit(dep, [...stack, id]);
+    state.set(id, "done");
+  };
+  for (const t of inputs)
+    visit(t.id, []);
+}
+function resolveManifestPath(task, campaignDefault) {
+  return task.manifestPath ?? campaignDefault;
+}
+
+// src/campaigns/overlap.ts
+function shape(claim) {
+  if (claim.endsWith("/**"))
+    return { base: claim.slice(0, -3), isDir: true };
+  if (claim.endsWith("/"))
+    return { base: claim.slice(0, -1), isDir: true };
+  return { base: claim, isDir: false };
+}
+function pathsOverlap(a, b) {
+  const sa = shape(a);
+  const sb = shape(b);
+  if (sa.base === sb.base)
+    return true;
+  if (sa.isDir && (sb.base === sa.base || sb.base.startsWith(`${sa.base}/`)))
+    return true;
+  if (sb.isDir && (sa.base === sb.base || sa.base.startsWith(`${sb.base}/`)))
+    return true;
+  return false;
+}
+function tasksClaimsOverlap(a, b) {
+  if (a.allowPathOverlap || b.allowPathOverlap)
+    return true;
+  return a.claimedPaths.some((pa) => b.claimedPaths.some((pb) => pathsOverlap(pa, pb)));
+}
+
+// src/campaigns/types.ts
+var ACTIVE_TASK_STATUSES = new Set(["running"]);
+var DEPENDENCY_SATISFIED_STATUSES = new Set([
+  "review_ready"
+]);
+var MAX_PARALLEL_CAP = 4;
+
+// src/campaigns/schedule.ts
+function byId(tasks) {
+  return new Map(tasks.map((t) => [t.id, t]));
+}
+function depsSatisfied(task, index) {
+  return task.dependencies.every((dep) => {
+    const d = index.get(dep);
+    return d !== undefined && DEPENDENCY_SATISFIED_STATUSES.has(d.status);
+  });
+}
+function isBlocked(task, campaign) {
+  if (task.status !== "pending")
+    return false;
+  const index = byId(campaign.tasks);
+  return task.dependencies.some((dep) => {
+    const d = index.get(dep);
+    return d !== undefined && (d.status === "failed" || d.status === "cancelled");
+  });
+}
+function isStartable(task, campaign) {
+  return task.status === "pending" && depsSatisfied(task, byId(campaign.tasks));
+}
+function selectRunnable(campaign) {
+  const index = byId(campaign.tasks);
+  const active = campaign.tasks.filter((t) => ACTIVE_TASK_STATUSES.has(t.status));
+  let freeSlots = Math.max(0, campaign.maxParallel - active.length);
+  if (freeSlots === 0)
+    return [];
+  const selected = [];
+  const blockers = [...active];
+  for (const task of campaign.tasks) {
+    if (freeSlots === 0)
+      break;
+    if (task.status !== "pending")
+      continue;
+    if (!depsSatisfied(task, index))
+      continue;
+    if (blockers.some((b) => tasksClaimsOverlap(task, b)))
+      continue;
+    selected.push(task);
+    blockers.push(task);
+    freeSlots--;
+  }
+  return selected;
+}
+function deriveCampaignStatus(campaign) {
+  const tasks = campaign.tasks;
+  if (tasks.length === 0)
+    return "ready_for_review";
+  const anyActive = tasks.some((t) => ACTIVE_TASK_STATUSES.has(t.status));
+  const anyStartable = tasks.some((t) => isStartable(t, campaign));
+  if (anyActive || anyStartable)
+    return "running";
+  const stuckPending = tasks.some((t) => t.status === "pending");
+  const anyReviewReady = tasks.some((t) => t.status === "review_ready");
+  const anyFailed = tasks.some((t) => t.status === "failed");
+  if (stuckPending)
+    return "needs_human";
+  if (anyReviewReady)
+    return "ready_for_review";
+  if (anyFailed)
+    return "failed";
+  return "ready_for_review";
+}
+
+// src/campaigns/worktree.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { existsSync as existsSync9, mkdirSync as mkdirSync6 } from "fs";
+import { homedir as homedir7 } from "os";
+import { dirname as dirname2, join as join9 } from "path";
+
+class WorktreeError extends Error {
+}
+var realGit = (args, cwd) => {
+  try {
+    const stdout = execFileSync2("git", args, {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return { code: 0, stdout, stderr: "" };
+  } catch (e) {
+    const err = e;
+    return {
+      code: typeof err.status === "number" ? err.status : 1,
+      stdout: String(err.stdout ?? ""),
+      stderr: String(err.stderr ?? "")
+    };
+  }
+};
+function gitErr(r) {
+  return (r.stderr || r.stdout || `exit ${r.code}`).trim();
+}
+function taskWorktree(campaignId, taskId) {
+  return {
+    worktreePath: join9(homedir7(), "worktrees", "chit", campaignId, taskId),
+    branch: `chit-campaign/${campaignId}/${taskId}`
+  };
+}
+function resolveBaseSha(git, repo, ref) {
+  const r = git(["rev-parse", ref], repo);
+  if (r.code !== 0) {
+    throw new WorktreeError(`cannot resolve base ref ${JSON.stringify(ref)}: ${gitErr(r)}`);
+  }
+  return r.stdout.trim();
+}
+function repoToplevel(git, cwd) {
+  const r = git(["rev-parse", "--show-toplevel"], cwd);
+  if (r.code !== 0) {
+    throw new WorktreeError(`not a git repository at ${JSON.stringify(cwd)}: ${gitErr(r)}`);
+  }
+  return r.stdout.trim();
+}
+function createTaskWorktree(git, repo, campaignId, taskId, baseSha) {
+  const { worktreePath, branch } = taskWorktree(campaignId, taskId);
+  if (git(["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`], repo).code === 0) {
+    throw new WorktreeError(`branch ${JSON.stringify(branch)} already exists`);
+  }
+  if (existsSync9(worktreePath)) {
+    throw new WorktreeError(`worktree path already exists: ${worktreePath}`);
+  }
+  mkdirSync6(dirname2(worktreePath), { recursive: true });
+  const r = git(["worktree", "add", "-b", branch, worktreePath, baseSha], repo);
+  if (r.code !== 0) {
+    throw new WorktreeError(`git worktree add failed: ${gitErr(r)}`);
+  }
+  return { worktreePath, branch };
+}
+
+// src/campaigns/engine.ts
+class CampaignEngineError extends Error {
+}
+var DEFAULT_MAX_ITERATIONS = 3;
+function iso3(ms) {
+  return new Date(ms).toISOString();
+}
+function startCampaign(store, deps, opts) {
+  const tasks = planTasks(opts.tasks);
+  const repo = repoToplevel(deps.git, opts.cwd);
+  const baseBranch = opts.baseBranch ?? "HEAD";
+  const baseSha = resolveBaseSha(deps.git, repo, baseBranch);
+  const maxParallel = Math.max(1, Math.min(opts.maxParallel, MAX_PARALLEL_CAP));
+  const maxIterations = opts.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+  const now = iso3(deps.now());
+  const campaign = {
+    schema: 1,
+    id: opts.id,
+    repo,
+    repoKey: repoKey(opts.cwd),
+    baseBranch,
+    baseSha,
+    maxParallel,
+    ...opts.manifestPath !== undefined && { manifestPath: opts.manifestPath },
+    status: "planning",
+    tasks,
+    createdAt: now,
+    updatedAt: now
+  };
+  store.create(campaign);
+  return store.update(opts.id, (c) => launchWave(c, deps, maxIterations));
+}
+function advanceCampaign(store, deps, id, maxIterations = DEFAULT_MAX_ITERATIONS) {
+  const existing = store.get(id);
+  if (!existing)
+    throw new CampaignEngineError(`no campaign ${JSON.stringify(id)}`);
+  if (existing.status === "cancelled")
+    return existing;
+  return store.update(id, (c) => launchWave(reconcile(c, deps), deps, maxIterations));
+}
+function cancelCampaign(store, deps, id) {
+  const existing = store.get(id);
+  if (!existing)
+    throw new CampaignEngineError(`no campaign ${JSON.stringify(id)}`);
+  return store.update(id, (c) => {
+    for (const t of c.tasks) {
+      if (t.status === "running" && t.jobId) {
+        try {
+          deps.cancelJob(t.jobId);
+        } catch {}
+        t.status = "cancelled";
+      } else if (t.status === "pending") {
+        t.status = "cancelled";
+      }
+    }
+    c.status = "cancelled";
+    c.updatedAt = iso3(deps.now());
+    return c;
+  });
+}
+function reconcile(c, deps) {
+  for (const t of c.tasks) {
+    if (t.status !== "running" || !t.jobId)
+      continue;
+    const job = deps.getJob(t.jobId);
+    if (!job) {
+      settleTask(t, "failed", deps, { failure: "job record not found" });
+      continue;
+    }
+    const inFlight = job.state === "queued" || job.state === "running";
+    if (inFlight) {
+      if (deps.isStale(job)) {
+        settleTask(t, "failed", deps, { job, failure: "worker appears dead (stale job)" });
+      }
+      continue;
+    }
+    if (job.state === "completed" && job.stopStatus === "converged") {
+      settleTask(t, "review_ready", deps, { job });
+    } else if (job.state === "cancelled") {
+      settleTask(t, "cancelled", deps, { job });
+    } else {
+      settleTask(t, "failed", deps, {
+        job,
+        failure: job.failure ?? `did not converge (${job.stopStatus ?? "failed"})`
+      });
+    }
+  }
+  return c;
+}
+function jobIsSettleable(job, deps) {
+  if (job.state === "queued" || job.state === "running")
+    return deps.isStale(job);
+  return true;
+}
+function settleTask(t, status, deps, extra) {
+  t.status = status;
+  const detail = t.worktreePath && t.jobId ? deps.loopDetail(t.worktreePath, jobLoopId(t, extra.job)) : undefined;
+  const result = {
+    iterations: extra.job?.iterationsCompleted ?? 0,
+    changedFiles: detail?.changedFiles ?? [],
+    workspaceWarnings: detail?.workspaceWarnings ?? [],
+    auditRefs: extra.job?.auditRefs ?? []
+  };
+  if (extra.job?.stopStatus !== undefined)
+    result.stopStatus = extra.job.stopStatus;
+  if (extra.job?.lastVerdict !== undefined)
+    result.lastVerdict = extra.job.lastVerdict;
+  t.result = result;
+  if (status === "failed" && extra.failure !== undefined)
+    t.error = extra.failure;
+}
+function jobLoopId(t, job) {
+  return job?.loopId ?? t.id;
+}
+function launchWave(c, deps, maxIterations) {
+  if (c.status === "cancelled")
+    return c;
+  const runnable = selectRunnable(c);
+  for (const task of runnable) {
+    const t = c.tasks.find((x) => x.id === task.id);
+    if (!t)
+      continue;
+    try {
+      const { worktreePath, branch } = deps.createWorktree(c.repo, c.id, t.id, c.baseSha);
+      const loopId = `${c.id}-${t.id}`;
+      const { jobId } = deps.launchJob({
+        cwd: worktreePath,
+        scope: `campaign-${c.id}-${t.id}`,
+        task: t.body,
+        loopId,
+        ...resolveManifestPath(t, c.manifestPath) !== undefined && {
+          manifestPath: resolveManifestPath(t, c.manifestPath)
+        },
+        maxIterations
+      });
+      t.worktreePath = worktreePath;
+      t.branch = branch;
+      t.jobId = jobId;
+      t.status = "running";
+    } catch (e) {
+      t.status = "failed";
+      t.error = e instanceof WorktreeError ? e.message : e.message;
+    }
+  }
+  c.status = deriveCampaignStatus(c);
+  c.updatedAt = iso3(deps.now());
+  return c;
+}
+function describeCampaign(c, deps) {
+  const tasks = c.tasks.map((t) => {
+    const view = {
+      id: t.id,
+      title: t.title,
+      status: t.status,
+      dependencies: t.dependencies,
+      ...t.branch !== undefined && { branch: t.branch },
+      ...t.worktreePath !== undefined && { worktreePath: t.worktreePath },
+      ...t.jobId !== undefined && { jobId: t.jobId }
+    };
+    if (t.status === "running" && t.jobId) {
+      const job = deps.getJob(t.jobId);
+      if (job) {
+        view.jobState = job.state === "running" && deps.isStale(job) ? "stale" : job.state;
+        if (job.phase !== undefined)
+          view.phase = job.phase;
+      }
+    }
+    if (t.result) {
+      if (t.result.stopStatus !== undefined)
+        view.stopStatus = t.result.stopStatus;
+      if (t.result.lastVerdict !== undefined)
+        view.lastVerdict = t.result.lastVerdict;
+      view.changedFiles = t.result.changedFiles;
+      view.workspaceWarnings = t.result.workspaceWarnings;
+      view.auditRefs = t.result.auditRefs;
+    }
+    if (t.error !== undefined)
+      view.error = t.error;
+    return view;
+  });
+  const runnable = selectRunnable(c);
+  const anyReconcilable = c.tasks.some((t) => {
+    if (t.status !== "running" || !t.jobId)
+      return false;
+    const job = deps.getJob(t.jobId);
+    return job !== undefined && jobIsSettleable(job, deps);
+  });
+  const startableBlocked = c.tasks.filter((t) => isStartable(t, c)).length;
+  const blocked = c.tasks.filter((t) => isBlocked(t, c)).length;
+  let nextAction;
+  if (c.status === "cancelled") {
+    nextAction = "campaign cancelled";
+  } else if (c.status === "ready_for_review") {
+    nextAction = "all tasks terminal; review the task worktrees (chit_campaign_status lists them)";
+  } else if (c.status === "needs_human") {
+    nextAction = `${blocked} task(s) blocked by a failed/cancelled dependency; inspect and start a fresh campaign for them`;
+  } else if (runnable.length > 0 || anyReconcilable) {
+    const n = runnable.length;
+    nextAction = anyReconcilable && n === 0 ? "a job finished; call chit_campaign_advance to reconcile and launch newly runnable task(s)" : `call chit_campaign_advance to launch ${n} runnable task(s)`;
+  } else {
+    nextAction = "tasks in flight; poll chit_campaign_status, or chit_campaign_cancel to stop";
+  }
+  return {
+    id: c.id,
+    repo: c.repo,
+    baseBranch: c.baseBranch,
+    baseSha: c.baseSha,
+    maxParallel: c.maxParallel,
+    status: c.status,
+    tasks,
+    runnableCount: runnable.length,
+    nextAction,
+    createdAt: c.createdAt,
+    updatedAt: c.updatedAt
+  };
+}
+
+// src/campaigns/store.ts
+import { randomUUID as randomUUID5 } from "crypto";
+import {
+  existsSync as existsSync10,
+  mkdirSync as mkdirSync7,
+  readdirSync as readdirSync4,
+  readFileSync as readFileSync11,
+  renameSync as renameSync4,
+  rmSync as rmSync7,
+  writeFileSync as writeFileSync6
+} from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join10 } from "path";
+class CampaignStoreError extends Error {
+}
+var SAFE_CAMPAIGN_ID = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+function campaignsDir(cwd) {
+  const xdg = process.env.XDG_STATE_HOME || join10(homedir8(), ".local", "state");
+  return join10(xdg, "chit", "campaigns", repoKey(cwd));
+}
+
+class CampaignStore {
+  cwd;
+  constructor(cwd) {
+    this.cwd = cwd;
+  }
+  dir() {
+    return campaignsDir(this.cwd);
+  }
+  path(id) {
+    if (!SAFE_CAMPAIGN_ID.test(id)) {
+      throw new CampaignStoreError(`invalid campaign id ${JSON.stringify(id)}`);
+    }
+    return join10(this.dir(), `${id}.json`);
+  }
+  lockPath(id) {
+    return `${this.path(id)}.lock`;
+  }
+  create(campaign) {
+    mkdirSync7(this.dir(), { recursive: true });
+    const path = this.path(campaign.id);
+    withFileLock(this.lockPath(campaign.id), () => {
+      if (existsSync10(path)) {
+        throw new CampaignStoreError(`campaign ${JSON.stringify(campaign.id)} already exists`);
+      }
+      writeAtomic2(path, campaign);
+    });
+  }
+  get(id) {
+    const path = this.path(id);
+    if (!existsSync10(path))
+      return;
+    try {
+      return JSON.parse(readFileSync11(path, "utf-8"));
+    } catch {
+      return;
+    }
+  }
+  update(id, mutate) {
+    const path = this.path(id);
+    mkdirSync7(this.dir(), { recursive: true });
+    return withFileLock(this.lockPath(id), () => {
+      if (!existsSync10(path))
+        throw new CampaignStoreError(`no campaign ${JSON.stringify(id)}`);
+      const current = JSON.parse(readFileSync11(path, "utf-8"));
+      const next = mutate(current);
+      writeAtomic2(path, next);
+      return next;
+    });
+  }
+  list() {
+    const dir = this.dir();
+    if (!existsSync10(dir))
+      return [];
+    const out = [];
+    for (const name of readdirSync4(dir)) {
+      if (!name.endsWith(".json"))
+        continue;
+      try {
+        out.push(JSON.parse(readFileSync11(join10(dir, name), "utf-8")));
+      } catch {}
+    }
+    out.sort((a, b) => (b.createdAt ?? "").localeCompare(a.createdAt ?? ""));
+    return out;
+  }
+}
+function writeAtomic2(path, campaign) {
+  const tmp = `${path}.${randomUUID5()}.tmp`;
+  writeFileSync6(tmp, JSON.stringify(campaign, null, 2));
+  try {
+    renameSync4(tmp, path);
+  } catch (err) {
+    rmSync7(tmp, { force: true });
+    throw err;
+  }
+}
+
 // src/jobs/health.ts
 var STALE_AFTER_MS = 60000;
 function pidAlive(pid) {
@@ -36842,7 +37415,7 @@ server.registerTool("chit_run_start", {
   const path = isAbsolute3(manifest_path) ? manifest_path : resolve4(process.cwd(), manifest_path);
   let raw;
   try {
-    raw = JSON.parse(readFileSync11(path, "utf-8"));
+    raw = JSON.parse(readFileSync12(path, "utf-8"));
   } catch (e) {
     return errorResult(`could not read manifest at ${path}: ${e.message}`);
   }
@@ -36994,7 +37567,7 @@ server.registerTool("chit_converge_start", {
   if (manifest_path) {
     const path = isAbsolute3(manifest_path) ? manifest_path : resolve4(runCwd, manifest_path);
     try {
-      raw = JSON.parse(readFileSync11(path, "utf-8"));
+      raw = JSON.parse(readFileSync12(path, "utf-8"));
     } catch (e) {
       return errorResult(`could not read manifest at ${path}: ${e.message}`);
     }
@@ -37164,64 +37737,54 @@ function spawnJobWorker(jobId, cwd) {
   });
   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());
+function launchConvergeJob(p) {
   let raw;
   let manifestAbs;
-  if (manifest_path) {
-    manifestAbs = isAbsolute3(manifest_path) ? manifest_path : resolve4(runCwd, manifest_path);
+  if (p.manifestPath) {
+    manifestAbs = isAbsolute3(p.manifestPath) ? p.manifestPath : resolve4(p.cwd, p.manifestPath);
     try {
-      raw = JSON.parse(readFileSync11(manifestAbs, "utf-8"));
+      raw = JSON.parse(readFileSync12(manifestAbs, "utf-8"));
     } catch (e) {
-      return errorResult(`could not read manifest at ${manifestAbs}: ${e.message}`);
+      return {
+        ok: false,
+        error: `could not read manifest at ${manifestAbs}: ${e.message}`
+      };
     }
   } else {
     raw = DEFAULT_CONVERGE_MANIFEST;
   }
-  const prep = prepareConvergeExecute(raw, getRegistry(), scope, runCwd, allow_unenforced_permissions);
+  const prep = prepareConvergeExecute(raw, getRegistry(), p.scope, p.cwd, p.allowUnenforced);
   if (!prep.ok)
-    return errorResult(prep.error);
-  const loopId = loop_id ?? crypto.randomUUID();
+    return { ok: false, error: prep.error };
+  const loopId = p.loopId ?? crypto.randomUUID();
   try {
-    startLoop(runCwd, { scope, task, maxIterations: max_iterations, loopId, force });
+    startLoop(p.cwd, {
+      scope: p.scope,
+      task: p.task,
+      maxIterations: p.maxIterations,
+      loopId,
+      force: p.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 {
+        ok: false,
+        error: `${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);
+    return { ok: false, error: e.message };
   }
   const jobId = crypto.randomUUID();
   const job = {
     jobId,
     loopId,
-    repoKey: repoKey(runCwd),
-    cwd: runCwd,
-    scope,
-    task,
+    repoKey: repoKey(p.cwd),
+    cwd: p.cwd,
+    scope: p.scope,
+    task: p.task,
     ...manifestAbs !== undefined && { manifestPath: manifestAbs },
-    maxIterations: max_iterations,
-    allowUnenforced: allow_unenforced_permissions,
+    maxIterations: p.maxIterations,
+    allowUnenforced: p.allowUnenforced,
     state: "queued",
     createdAt: new Date().toISOString(),
     iterationsCompleted: 0,
@@ -37230,11 +37793,11 @@ server.registerTool("chit_converge_run", {
   try {
     jobStore.create(job);
   } catch (e) {
-    stopLoop(runCwd, loopId, { status: "blocked", reason: "could not create job record" });
-    return errorResult(e.message);
+    stopLoop(p.cwd, loopId, { status: "blocked", reason: "could not create job record" });
+    return { ok: false, error: e.message };
   }
   try {
-    spawnJobWorker(jobId, runCwd);
+    spawnJobWorker(jobId, p.cwd);
   } catch (e) {
     jobStore.update(jobId, (c) => ({
       ...c,
@@ -37242,16 +37805,53 @@ server.registerTool("chit_converge_run", {
       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}`);
+    stopLoop(p.cwd, loopId, { status: "blocked", reason: "worker spawn failed" });
+    return { ok: false, error: `could not spawn background worker: ${e.message}` };
+  }
+  return { ok: true, jobId, loopId, warnings: prep.warnings };
+}
+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());
+  const r = launchConvergeJob({
+    task,
+    scope,
+    cwd: runCwd,
+    ...manifest_path !== undefined && { manifestPath: manifest_path },
+    maxIterations: max_iterations,
+    ...loop_id !== undefined && { loopId: loop_id },
+    force,
+    allowUnenforced: allow_unenforced_permissions
+  });
+  if (!r.ok)
+    return errorResult(r.error);
   return jsonResult({
-    jobId,
-    loopId,
+    jobId: r.jobId,
+    loopId: r.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 }
+    nextAction: `running in the background; poll chit_job_status "${r.jobId}" (or chit_status), cancel with chit_job_cancel "${r.jobId}"`,
+    ...r.warnings.length > 0 && { warnings: r.warnings }
   });
 });
 function describeJob(job) {
@@ -37309,6 +37909,27 @@ function describeJob(job) {
     nextAction
   };
 }
+function requestJobCancel(jobId) {
+  const job = jobStore.get(jobId);
+  if (!job)
+    return { status: "missing" };
+  if (job.state !== "queued" && job.state !== "running") {
+    return { status: "terminal", state: job.state };
+  }
+  const updated = jobStore.update(jobId, (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 { status: "requested", state: updated.state, signaled };
+}
 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() }
@@ -37322,37 +37943,152 @@ 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)
+  const r = requestJobCancel(job_id);
+  if (r.status === "missing")
     return errorResult(`unknown job_id ${job_id}`);
-  if (job.state !== "queued" && job.state !== "running") {
+  if (r.status === "terminal") {
     return jsonResult({
       jobId: job_id,
-      state: job.state,
+      state: r.state,
       cancelled: false,
-      note: `job already ${job.state}`
+      note: `job already ${r.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,
+    state: r.state,
     cancelRequested: true,
-    signaled,
+    signaled: r.signaled,
     note: "cancellation requested; the worker stops at the next safe point and records a clean cancelled stop"
   });
 });
+var campaignDeps = {
+  git: realGit,
+  createWorktree: (repo, cid, tid, sha) => createTaskWorktree(realGit, repo, cid, tid, sha),
+  launchJob: (p) => {
+    const r = launchConvergeJob({
+      task: p.task,
+      scope: p.scope,
+      cwd: p.cwd,
+      ...p.manifestPath !== undefined && { manifestPath: p.manifestPath },
+      maxIterations: p.maxIterations,
+      loopId: p.loopId,
+      allowUnenforced: false
+    });
+    if (!r.ok)
+      throw new Error(r.error);
+    return { jobId: r.jobId, loopId: r.loopId };
+  },
+  getJob: (id) => jobStore.get(id),
+  cancelJob: (id) => {
+    requestJobCancel(id);
+  },
+  isStale: (job) => isStale(job, Date.now()),
+  loopDetail: (worktreePath, loopId) => {
+    try {
+      const iters = readLoop(worktreePath, loopId).filter((r) => r.type === "iteration");
+      const last = iters.at(-1);
+      if (last && last.type === "iteration") {
+        return { changedFiles: last.changedFiles, workspaceWarnings: last.workspaceWarnings ?? [] };
+      }
+    } catch {}
+    return { changedFiles: [], workspaceWarnings: [] };
+  },
+  now: () => Date.now()
+};
+var campaignTaskSchema = exports_external.object({
+  id: exports_external.string().describe("Unique task id within the campaign (a safe slug)"),
+  title: exports_external.string().describe("Short task title"),
+  body: exports_external.string().describe("The task brief handed to the converge implementer"),
+  dependencies: exports_external.array(exports_external.string()).optional().describe("Task ids that must reach review_ready before this task runs"),
+  claimedPaths: exports_external.array(exports_external.string()).optional().describe("Paths this task will touch (globs: dir/**, dir/, or a file). Required unless allowPathOverlap; tasks with overlapping claims never run concurrently."),
+  allowPathOverlap: exports_external.boolean().optional().describe("Opt-in to running with no/overlapping claims; the task then runs alone."),
+  manifestPath: exports_external.string().optional().describe("Per-task converge manifest override (absolute or relative to cwd).")
+});
+function campaignError(e) {
+  if (e instanceof PlanError || e instanceof WorktreeError || e instanceof CampaignStoreError) {
+    return errorResult(e.message);
+  }
+  return errorResult(e.message);
+}
+server.registerTool("chit_campaign_start", {
+  description: "Start a campaign: run several converge tasks in parallel, each in its own git worktree, as background jobs. Plans the task graph, launches the initial runnable wave (no-dependency tasks, up to max_parallel), and returns immediately. Then poll chit_campaign_status and call chit_campaign_advance to launch the next wave as jobs finish. No auto-merge: the output is reviewable worktree branches. Manifest resolution per task: task.manifestPath > campaign manifest_path > the bundled default converge manifest.",
+  inputSchema: {
+    tasks: exports_external.array(campaignTaskSchema).min(1).describe("The task graph (an explicit, reviewed list)"),
+    cwd: exports_external.string().optional().describe("Any path in the target repo (defaults to the server cwd)"),
+    max_parallel: exports_external.number().int().min(1).default(2).describe("Max concurrent tasks. Default 2."),
+    base_branch: exports_external.string().optional().describe("Ref task worktrees branch from. Default: HEAD."),
+    manifest_path: exports_external.string().optional().describe("Campaign-level default converge manifest (absolute or relative to cwd)."),
+    max_iterations: exports_external.number().int().min(1).default(3).describe("Per-task iteration budget. Default 3.")
+  }
+}, async ({ tasks, cwd, max_parallel, base_branch, manifest_path, max_iterations }) => {
+  const runCwd = resolve4(cwd ?? process.cwd());
+  const campaignManifest = manifest_path !== undefined ? isAbsolute3(manifest_path) ? manifest_path : resolve4(runCwd, manifest_path) : undefined;
+  const planned = tasks.map((t) => ({
+    ...t,
+    ...t.manifestPath !== undefined && {
+      manifestPath: isAbsolute3(t.manifestPath) ? t.manifestPath : resolve4(runCwd, t.manifestPath)
+    }
+  }));
+  const store = new CampaignStore(runCwd);
+  try {
+    const campaign = startCampaign(store, campaignDeps, {
+      id: crypto.randomUUID(),
+      cwd: runCwd,
+      tasks: planned,
+      maxParallel: max_parallel,
+      ...base_branch !== undefined && { baseBranch: base_branch },
+      ...campaignManifest !== undefined && { manifestPath: campaignManifest },
+      maxIterations: max_iterations
+    });
+    return jsonResult(describeCampaign(campaign, campaignDeps));
+  } catch (e) {
+    return campaignError(e);
+  }
+});
+server.registerTool("chit_campaign_status", {
+  description: "Read-only campaign overview: each task's status, live job state/phase, branch/worktree, changed files, audit refs, plus how many tasks are runnable now and the next action. Inspection is safe: this NEVER launches jobs, creates worktrees, or mutates state (use chit_campaign_advance to make progress).",
+  inputSchema: {
+    campaign_id: exports_external.string(),
+    cwd: exports_external.string().optional().describe("Any path in the target repo (defaults to the server cwd)")
+  }
+}, async ({ campaign_id, cwd }) => {
+  const store = new CampaignStore(resolve4(cwd ?? process.cwd()));
+  const campaign = store.get(campaign_id);
+  if (!campaign)
+    return errorResult(`unknown campaign_id ${campaign_id}`);
+  return jsonResult(describeCampaign(campaign, campaignDeps));
+});
+server.registerTool("chit_campaign_advance", {
+  description: "Advance a campaign: reconcile finished jobs into task state (converged -> review_ready; blocked/max-iterations/failed/stale -> failed; dependents proceed only past a review_ready task), then launch the next runnable wave. The only progression trigger besides start. Call it when chit_campaign_status reports runnable tasks or a finished job.",
+  inputSchema: {
+    campaign_id: exports_external.string(),
+    cwd: exports_external.string().optional().describe("Any path in the target repo (defaults to the server cwd)")
+  }
+}, async ({ campaign_id, cwd }) => {
+  const store = new CampaignStore(resolve4(cwd ?? process.cwd()));
+  try {
+    const campaign = advanceCampaign(store, campaignDeps, campaign_id);
+    return jsonResult(describeCampaign(campaign, campaignDeps));
+  } catch (e) {
+    return campaignError(e);
+  }
+});
+server.registerTool("chit_campaign_cancel", {
+  description: "Cancel a campaign: request cancellation of every active task job (intent-first, the same safety as chit_job_cancel) and mark pending tasks cancelled. Running jobs settle cleanly in the background. Worktrees are left in place for inspection.",
+  inputSchema: {
+    campaign_id: exports_external.string(),
+    cwd: exports_external.string().optional().describe("Any path in the target repo (defaults to the server cwd)")
+  }
+}, async ({ campaign_id, cwd }) => {
+  const store = new CampaignStore(resolve4(cwd ?? process.cwd()));
+  try {
+    const campaign = cancelCampaign(store, campaignDeps, campaign_id);
+    return jsonResult(describeCampaign(campaign, campaignDeps));
+  } catch (e) {
+    return campaignError(e);
+  }
+});
 async function startMcpServer() {
   await server.connect(new StdioServerTransport);
 }
@@ -37580,9 +38316,9 @@ ${AUDIT_HELP}`);
 }
 
 // src/cli/doctor.ts
-import { randomUUID as randomUUID5 } from "crypto";
-import { mkdirSync as mkdirSync6, rmSync as rmSync7, writeFileSync as writeFileSync6 } from "fs";
-import { join as join9 } from "path";
+import { randomUUID as randomUUID6 } from "crypto";
+import { mkdirSync as mkdirSync8, rmSync as rmSync8, writeFileSync as writeFileSync7 } from "fs";
+import { join as join11 } from "path";
 var defaultIO3 = {
   out: (s) => process.stdout.write(s),
   err: (s) => process.stderr.write(s)
@@ -37650,10 +38386,10 @@ function checkGitRepo(deps) {
 }
 function checkAuditDir(deps) {
   try {
-    mkdirSync6(deps.auditDir, { recursive: true });
-    const probeFile = join9(deps.auditDir, `.doctor-${randomUUID5()}`);
-    writeFileSync6(probeFile, "ok");
-    rmSync7(probeFile);
+    mkdirSync8(deps.auditDir, { recursive: true });
+    const probeFile = join11(deps.auditDir, `.doctor-${randomUUID6()}`);
+    writeFileSync7(probeFile, "ok");
+    rmSync8(probeFile);
     return { name: "audit dir", status: "pass", detail: `writable (${deps.auditDir})` };
   } catch (e) {
     return {
@@ -38326,7 +39062,7 @@ ${HELP}`);
   }
   let manifestRaw;
   try {
-    manifestRaw = JSON.parse(readFileSync16(args.manifestPath, "utf-8"));
+    manifestRaw = JSON.parse(readFileSync17(args.manifestPath, "utf-8"));
   } catch (e) {
     process.stderr.write(`chit: failed to read manifest ${args.manifestPath}: ${e.message}
 `);
@@ -38497,7 +39233,7 @@ Pass --allow-unenforced-permissions to run anyway (emits a warning each run).
   return 1;
 }
 function defaultRuntimePath() {
-  return dirname2(dirname2(import.meta.dir));
+  return dirname3(dirname3(import.meta.dir));
 }
 var TRACE_PREVIEW_CHARS = 280;
 function tracePreview(label, text) {
@@ -38537,7 +39273,7 @@ ${HELP}`);
 `);
     return 2;
   }
-  const outputDir = args.outputDir ?? join14(homedir8(), ".claude", "skills");
+  const outputDir = args.outputDir ?? join16(homedir10(), ".claude", "skills");
   const runtimePath = args.runtimePath ?? defaultRuntimePath();
   try {
     const result = installClaudeSkill({
@@ -38580,7 +39316,7 @@ ${HELP}`);
   }
   let raw2;
   try {
-    raw2 = JSON.parse(readFileSync16(args.manifestPath, "utf-8"));
+    raw2 = JSON.parse(readFileSync17(args.manifestPath, "utf-8"));
   } catch (e) {
     process.stderr.write(`chit: failed to read manifest ${args.manifestPath}: ${e.message}
 `);

package/package.json

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