@brainervirus/workit-claude-code 7.2.0 → 7.3.0

package/dist/workit.js

@@ -65,7 +65,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@brainervirus/workit-cli",
-    version: "7.2.0",
+    version: "7.3.0",
     private: false,
     description: "Workit CLI — setup wizard, doctor, and task control for agentic coding workflows",
     keywords: [
@@ -103,9 +103,9 @@ var init_package = __esm(() => {
     },
     dependencies: {
       "@babel/parser": "7.29.9",
-      "@brainervirus/workit-core": "^7.2.0",
-      "@brainervirus/workit-cursor": "^7.2.0",
-      "@brainervirus/workit-opencode": "^7.2.0",
+      "@brainervirus/workit-core": "^7.3.0",
+      "@brainervirus/workit-cursor": "^7.3.0",
+      "@brainervirus/workit-opencode": "^7.3.0",
       "@inkjs/ui": "2.0.0",
       ink: "7.1.1",
       react: "19.2.8"
@@ -73017,6 +73017,20 @@ function parseDuration2(value) {
   const factor = unit === "ms" ? 1 : unit === "s" ? 1000 : unit === "m" ? 60000 : 3600000;
   return Math.round(Number(match[1]) * factor);
 }
+function releaseTrunk(io, track, branch) {
+  const resolved = vcsConfig("resolve", io.cwd, {
+    track,
+    ...branch ? { branch } : {}
+  });
+  if (resolved.ok === false)
+    return track !== null || String(resolved.configPath ?? "").endsWith("workspaces.json") ? { error: String(resolved.error) } : { trunk: null, tracked: false };
+  if (resolved.releaseTrack?.blocking)
+    return { error: String(resolved.releaseTrack.blocking) };
+  return {
+    trunk: String(resolved.defaultTargetBranch ?? "") || null,
+    tracked: Boolean(resolved.releaseTrack)
+  };
+}
 function connect(io, branch) {
   const resolved = resolveForge(io.cwd, {
     branch,
@@ -73084,6 +73098,7 @@ function renderStatus(doc) {
 var forgeDeps, usage3 = (io, message, line) => emit(io, fail("invalid_input", message, { unblock: line })), forgeFail = (io, result, data) => emit(io, fail(result.code, result.error, { data, unblock: result.unblock })), short = (sha) => sha ? sha.slice(0, 7) : "?";
 var init_forge_common = __esm(() => {
   init_resolve();
+  init_vcs_config();
   init_output();
   forgeDeps = {
     runner: undefined,
@@ -75207,7 +75222,7 @@ async function plan(argv, io) {
     return usage3(io, "pass --trunk or --track, not both (--track picks the trunk)", PLAN_USAGE);
   let trunk = flags.values.trunk ?? existing?.trunk ?? null;
   if (trunk === null || track !== null) {
-    const derived = defaultTrunk(io, track, flags.positionals[0] ?? null);
+    const derived = releaseTrunk(io, track, flags.positionals[0] ?? null);
     if ("error" in derived)
       return emit(io, fail("blocked", derived.error, {
         unblock: "workit stack plan --track <name> …  # or --trunk <branch>"
@@ -75375,17 +75390,7 @@ async function run14(argv, io) {
     return land(rest, io);
   return usage3(io, sub && !sub.startsWith("-") ? `unknown stack subcommand "${sub}"` : "missing stack subcommand", USAGE7);
 }
-var PLAN_USAGE = "workit stack plan [--name <n>] [--trunk <b> | --track <t>] [<bottom> … <top>] [--json]", STATUS_USAGE2 = "workit stack status [--name <n>] [--json]", SYNC_USAGE = "workit stack sync [--name <n>] [--local] [--dry-run] [--force <branch>]… [--json]", LAND_USAGE = "workit stack land [--name <n>] [--dry-run] [--max <n>] [--method squash|merge|rebase] [--timeout 20m] [--interval 30s] [--json]", USAGE7 = "workit stack plan|status|sync|land ... (workit help stack)", short4 = (sha) => sha ? sha.slice(0, 12) : "?", stackFailed = (io, result) => emit(io, fail(result.code, result.error, { unblock: result.unblock, data: result.data ?? {} })), defaultTrunk = (io, track, branch) => {
-  const resolved = vcsConfig("resolve", io.cwd, {
-    track,
-    ...branch ? { branch } : {}
-  });
-  if (resolved.ok === false)
-    return track !== null || String(resolved.configPath ?? "").endsWith("workspaces.json") ? { error: String(resolved.error) } : { trunk: null };
-  if (resolved.releaseTrack?.blocking)
-    return { error: String(resolved.releaseTrack.blocking) };
-  return { trunk: String(resolved.defaultTargetBranch ?? "") || null };
-}, label = (forge, pr) => pr === null ? "no PR" : `${forge === "gitlab" ? "MR !" : "PR #"}${pr}`, renderSync = (data) => [
+var PLAN_USAGE = "workit stack plan [--name <n>] [--trunk <b> | --track <t>] [<bottom> … <top>] [--json]", STATUS_USAGE2 = "workit stack status [--name <n>] [--json]", SYNC_USAGE = "workit stack sync [--name <n>] [--local] [--dry-run] [--force <branch>]… [--json]", LAND_USAGE = "workit stack land [--name <n>] [--dry-run] [--max <n>] [--method squash|merge|rebase] [--timeout 20m] [--interval 30s] [--json]", USAGE7 = "workit stack plan|status|sync|land ... (workit help stack)", short4 = (sha) => sha ? sha.slice(0, 12) : "?", stackFailed = (io, result) => emit(io, fail(result.code, result.error, { unblock: result.unblock, data: result.data ?? {} })), label = (forge, pr) => pr === null ? "no PR" : `${forge === "gitlab" ? "MR !" : "PR #"}${pr}`, renderSync = (data) => [
   `${data.dryRun ? "would sync" : "synced"} stack ${data.name}${data.merged.length ? `; merged: ${data.merged.map((item) => item.branch).join(", ")}` : ""}`,
   ...data.steps.map((step) => [
     `  ${step.branch} on ${step.parent}:`,
@@ -75397,16 +75402,993 @@ var PLAN_USAGE = "workit stack plan [--name <n>] [--trunk <b> | --track <t>] [<b
 var init_stack2 = __esm(() => {
   init_ledger();
   init_stack();
-  init_vcs_config();
   init_output();
   init_forge_common();
   METHODS3 = new Set(["squash", "merge", "rebase"]);
 });
 
+// packages/workit-core/src/fanout.ts
+import { spawnSync as spawnSync20 } from "node:child_process";
+import fs22 from "node:fs";
+import path42 from "node:path";
+function scopeSamples(pattern) {
+  if (!hasWildcard(pattern))
+    return [unescape2(pattern)];
+  let out = "";
+  for (let index = 0;index < pattern.length; index += 1) {
+    const char = pattern[index];
+    if (char === "\\" && index + 1 < pattern.length) {
+      out += pattern[index + 1];
+      index += 1;
+    } else if (char === "*" && pattern[index + 1] === "*") {
+      const atSegmentStart = index === 0 || pattern[index - 1] === "/";
+      if (atSegmentStart && pattern[index + 2] === "/")
+        index += 2;
+      else {
+        out += "<any>";
+        index += 1;
+      }
+    } else if (char === "*")
+      out += "<any>";
+    else if (char === "?")
+      out += "x";
+    else if (char === "{" && pattern.indexOf("}", index) > index) {
+      const close = pattern.indexOf("}", index);
+      out += pattern.slice(index + 1, close).split(",")[0];
+      index = close;
+    } else
+      out += char;
+  }
+  return [out];
+}
+function globSource(pattern) {
+  let out = "";
+  for (let index = 0;index < pattern.length; index += 1) {
+    const char = pattern[index];
+    if (char === "\\" && index + 1 < pattern.length) {
+      out += escapeRegExp4(pattern[index + 1]);
+      index += 1;
+    } else if (char === "*" && pattern[index + 1] === "*") {
+      const atSegmentStart = index === 0 || pattern[index - 1] === "/";
+      if (atSegmentStart && pattern[index + 2] === "/") {
+        out += "(?:[^/]*/)*";
+        index += 2;
+      } else {
+        out += ".*";
+        index += 1;
+      }
+    } else if (char === "*")
+      out += "[^/]*";
+    else if (char === "?")
+      out += "[^/]";
+    else if (char === "{" && pattern.indexOf("}", index) > index) {
+      const close = pattern.indexOf("}", index);
+      const alternatives = pattern.slice(index + 1, close).split(",").map(globSource);
+      out += `(?:${alternatives.join("|")})`;
+      index = close;
+    } else
+      out += escapeRegExp4(char);
+  }
+  return out;
+}
+function matchesScope(pattern, file) {
+  let regex = compiled.get(pattern);
+  if (!regex) {
+    regex = new RegExp(`^${globSource(pattern)}$`, "u");
+    compiled.set(pattern, regex);
+  }
+  return regex.test(file) || !hasWildcard(pattern) && file.startsWith(`${unescape2(pattern)}/`);
+}
+function normalizePattern(raw) {
+  let pattern = raw.trim().replace(/\\(?![[\]{}*?])/gu, "/");
+  while (pattern.startsWith("./"))
+    pattern = pattern.slice(2);
+  if (pattern === "." || pattern === "")
+    pattern = raw.trim() ? "**" : "";
+  if (pattern.endsWith("/"))
+    pattern = `${pattern}**`;
+  if (!pattern)
+    return { error: "is empty" };
+  if (pattern.startsWith("/") || /^[A-Za-z]:/u.test(pattern))
+    return { error: "must be relative to the repository root" };
+  if (pattern.split("/").includes(".."))
+    return { error: "must not contain .." };
+  const bare = pattern.replace(/\\./gu, "");
+  if (/[[\]]/u.test(bare))
+    return {
+      error: 'has an unescaped [ or ]: write \\[ and \\] for literal brackets (app/\\[id\\]/page.tsx; in JSON "app/\\\\[id\\\\]/page.tsx")'
+    };
+  if (bare.startsWith("!"))
+    return { error: "uses ! (negation is not supported)" };
+  let depth = 0;
+  for (const char of bare) {
+    if (char === "{")
+      depth += 1;
+    if (char === "}")
+      depth -= 1;
+    if (depth < 0 || depth > 1)
+      return { error: "has unbalanced or nested braces" };
+  }
+  if (depth !== 0)
+    return { error: "has unbalanced or nested braces" };
+  return { pattern };
+}
+function inScope(plan, slice, file) {
+  if (matchesAny(slice.owns, file))
+    return true;
+  if (!matchesAny(slice.scope, file))
+    return false;
+  return !plan.slices.some((other) => other.id !== slice.id && matchesAny(other.owns, file));
+}
+function parsePlan(raw, defaults, name) {
+  const problems = [];
+  if (!isRecord8(raw))
+    return { ok: false, problems: ["the plan must be a JSON object"] };
+  const planName = name ?? (typeof raw.name === "string" ? raw.name.trim() : "");
+  if (!planName || planName.length > 200 || /\p{Cc}/u.test(planName))
+    problems.push('name: pass --name or set a 1-200 character "name"');
+  const trunk = typeof raw.trunk === "string" && raw.trunk.trim() ? raw.trunk.trim() : defaults.trunk;
+  const shared = [];
+  for (const entry of textList(raw.shared ?? []) ?? ["<not a list>"]) {
+    const normalized = normalizePattern(entry);
+    if ("error" in normalized)
+      problems.push(`shared "${entry}" ${normalized.error}`);
+    else
+      shared.push(normalized.pattern);
+  }
+  if (!Array.isArray(raw.slices) || raw.slices.length === 0)
+    return { ok: false, problems: [...problems, "slices: list at least one slice"] };
+  const slices = [];
+  const seenIds = new Set;
+  const seenBranches = new Map;
+  raw.slices.forEach((item, index) => {
+    const where = isRecord8(item) && typeof item.id === "string" ? `slice ${item.id}` : `slice #${index + 1}`;
+    if (!isRecord8(item)) {
+      problems.push(`${where}: must be an object`);
+      return;
+    }
+    const id = typeof item.id === "string" ? item.id : "";
+    if (!ID.test(id))
+      problems.push(`${where}: id must match ${ID.source}`);
+    else if (seenIds.has(id))
+      problems.push(`${where}: duplicate id`);
+    seenIds.add(id);
+    const branch = typeof item.branch === "string" ? item.branch.trim() : "";
+    if (!branch)
+      problems.push(`${where}: branch is empty`);
+    else if (seenBranches.has(branch))
+      problems.push(`${where}: branch ${branch} is also slice ${seenBranches.get(branch)}'s`);
+    else
+      seenBranches.set(branch, id);
+    if (branch === trunk)
+      problems.push(`${where}: branch must not be the trunk ${trunk}`);
+    const goal = typeof item.goal === "string" ? item.goal.trim() : "";
+    if (!filled(goal))
+      problems.push(`${where}: goal is empty`);
+    const brief = (field) => {
+      const list = textList(item[field]);
+      const kept = (list ?? []).map((entry) => entry.trim()).filter(filled);
+      if (kept.length === 0)
+        problems.push(`${where}: ${field} is empty`);
+      return kept;
+    };
+    const acceptance = brief("acceptance");
+    const verify = brief("verify");
+    const forbidden = brief("forbidden");
+    const scope = [];
+    const owns = [];
+    for (const [field, out] of [
+      ["scope", scope],
+      ["owns", owns]
+    ]) {
+      const list = textList(item[field] ?? []);
+      if (list === null) {
+        problems.push(`${where}: ${field} must be a list of globs`);
+        continue;
+      }
+      for (const entry of list.filter(filled)) {
+        const normalized = normalizePattern(entry);
+        if ("error" in normalized)
+          problems.push(`${where}: ${field} "${entry}" ${normalized.error}`);
+        else
+          out.push(normalized.pattern);
+      }
+    }
+    if (scope.length === 0 && textList(item.scope ?? []) !== null)
+      problems.push(`${where}: scope is empty`);
+    const tier = item.tier;
+    if (typeof tier !== "string" || !TIERS.includes(tier))
+      problems.push(`${where}: tier must be one of ${TIERS.join(", ")}`);
+    const dependsOn = textList(item.dependsOn ?? []);
+    if (dependsOn === null)
+      problems.push(`${where}: dependsOn must be a list of slice ids`);
+    const optional = (field) => typeof item[field] === "string" && filled(item[field]) ? item[field].trim() : null;
+    slices.push({
+      id,
+      branch,
+      base: optional("base") ?? "",
+      worktree: optional("worktree") ?? path42.join(defaults.worktreeRoot, id),
+      tier,
+      dependsOn: [...new Set(dependsOn ?? [])],
+      scope,
+      owns,
+      goal,
+      acceptance,
+      verify,
+      forbidden,
+      context: optional("context"),
+      timebox: optional("timebox")
+    });
+  });
+  const byId = new Map(slices.map((slice) => [slice.id, slice]));
+  const byBranch = new Map(slices.map((slice) => [slice.branch, slice]));
+  for (const slice of slices) {
+    for (const dep of slice.dependsOn) {
+      if (dep === slice.id)
+        problems.push(`slice ${slice.id}: depends on itself`);
+      else if (!byId.has(dep))
+        problems.push(`slice ${slice.id}: depends on unknown slice ${dep}`);
+    }
+    const explicitBase = slice.base;
+    if (explicitBase) {
+      const parent = byBranch.get(explicitBase);
+      if (parent && !slice.dependsOn.includes(parent.id))
+        problems.push(`slice ${slice.id}: base ${explicitBase} is slice ${parent.id}'s branch; add "${parent.id}" to its dependsOn`);
+    } else {
+      const single = slice.dependsOn.length === 1 ? byId.get(slice.dependsOn[0]) : undefined;
+      slice.base = single ? single.branch : trunk;
+    }
+  }
+  const cycle = findCycle(slices);
+  if (cycle)
+    problems.push(`dependency cycle: ${cycle.join(" -> ")}`);
+  if (problems.length)
+    return { ok: false, problems };
+  return {
+    ok: true,
+    plan: {
+      v: FANOUT_VERSION,
+      name: planName,
+      trunk,
+      shared,
+      slices,
+      createdAt: "",
+      updatedAt: ""
+    }
+  };
+}
+function findCycle(slices) {
+  const byId = new Map(slices.map((slice) => [slice.id, slice]));
+  const state = new Map;
+  const trail = [];
+  const visit = (id) => {
+    if (state.get(id) === "done")
+      return null;
+    if (state.get(id) === "open")
+      return [...trail.slice(trail.indexOf(id)), id];
+    state.set(id, "open");
+    trail.push(id);
+    for (const dep of byId.get(id)?.dependsOn ?? []) {
+      if (!byId.has(dep) || dep === id)
+        continue;
+      const found = visit(dep);
+      if (found)
+        return found;
+    }
+    trail.pop();
+    state.set(id, "done");
+    return null;
+  };
+  for (const slice of slices) {
+    const found = visit(slice.id);
+    if (found)
+      return found;
+  }
+  return null;
+}
+function landingOrder(slices) {
+  const order = [];
+  const placed = new Set;
+  const known = new Set(slices.map((slice) => slice.id));
+  while (order.length < slices.length) {
+    const next = slices.find((slice) => !placed.has(slice.id) && slice.dependsOn.every((dep) => placed.has(dep) || !known.has(dep)));
+    if (!next)
+      break;
+    order.push(next.id);
+    placed.add(next.id);
+  }
+  return order;
+}
+function waves(slices) {
+  const level = new Map;
+  const byId = new Map(slices.map((slice) => [slice.id, slice]));
+  for (const id of landingOrder(slices)) {
+    const deps = byId.get(id)?.dependsOn ?? [];
+    level.set(id, deps.length ? Math.max(...deps.map((dep) => level.get(dep) ?? 0)) + 1 : 0);
+  }
+  const out = [];
+  for (const slice of slices)
+    (out[level.get(slice.id) ?? 0] ??= []).push(slice.id);
+  return out.filter(Boolean);
+}
+function ancestors(slices) {
+  const byId = new Map(slices.map((slice) => [slice.id, slice]));
+  const out = new Map;
+  for (const id of landingOrder(slices)) {
+    const set = new Set;
+    for (const dep of byId.get(id)?.dependsOn ?? []) {
+      set.add(dep);
+      for (const deeper of out.get(dep) ?? [])
+        set.add(deeper);
+    }
+    out.set(id, set);
+  }
+  return out;
+}
+function analyzeOverlap(plan, candidates) {
+  const shared = [...DEFAULT_SHARED, ...plan.shared];
+  const before = ancestors(plan.slices);
+  const related = (a, b) => Boolean(before.get(a)?.has(b) || before.get(b)?.has(a));
+  const overlaps = [];
+  const groups = new Map;
+  const byCase = new Map;
+  for (const file of [...new Set(candidates)].toSorted())
+    (byCase.get(file.toLowerCase()) ?? byCase.set(file.toLowerCase(), []).get(file.toLowerCase()))?.push(file);
+  for (const spellings of byCase.values()) {
+    const file = spellings.join(" ~ ");
+    const any = (patterns) => spellings.some((spelling) => matchesAny(patterns, spelling));
+    const matching = plan.slices.filter((slice) => any(slice.scope) || any(slice.owns));
+    if (matching.length < 2)
+      continue;
+    const ids = matching.map((slice) => slice.id);
+    const owners = matching.filter((slice) => any(slice.owns));
+    if (owners.length === 1) {
+      overlaps.push({ path: file, slices: ids, resolution: "owner", owner: owners[0].id });
+      continue;
+    }
+    if (owners.length === 0 && matching.every((a, i) => matching.slice(i + 1).every((b) => related(a.id, b.id)))) {
+      overlaps.push({ path: file, slices: ids, resolution: "serialized" });
+      continue;
+    }
+    const members = owners.length > 1 ? owners : matching;
+    const reason = owners.length > 1 ? "several_owners" : "overlap";
+    const isShared = any(shared);
+    const key = `${reason}|${isShared}|${members.map((slice) => slice.id).join(",")}`;
+    const group = groups.get(key);
+    if (group)
+      group.paths.push(file);
+    else
+      groups.set(key, {
+        slices: members.map((slice) => slice.id),
+        paths: [file],
+        shared: isShared,
+        reason,
+        members,
+        suggestion: ownerSuggestion(members[0].id, [])
+      });
+  }
+  const conflicts = [...groups.values()].map(({ members, ...group }) => {
+    const literal = members.find((slice) => slice.scope.some((pattern) => group.paths.includes(pattern)));
+    const owner = ownerSuggestion((literal ?? members[0]).id, group.paths);
+    if (group.reason === "several_owners")
+      return {
+        ...group,
+        suggestion: {
+          ...owner,
+          text: `keep ${quoteList(group.paths)} in "owns" of slice ${owner.slice} only`
+        }
+      };
+    const serialize = serializeSuggestion(group.slices);
+    return group.shared ? { ...group, suggestion: owner, alternative: serialize } : { ...group, suggestion: serialize, alternative: owner };
+  });
+  return { overlaps, conflicts };
+}
+function branchRef(cwd, branch) {
+  if (!branch || branch.startsWith("-"))
+    return null;
+  const local = resolveRef(cwd, `refs/heads/${branch}`);
+  if (local)
+    return local;
+  const remote = pushRemoteName(cwd) ?? "origin";
+  return resolveRef(cwd, `refs/remotes/${remote}/${branch}`);
+}
+function trunkRef(cwd, trunk) {
+  if (!trunk || trunk.startsWith("-"))
+    return null;
+  const remote = pushRemoteName(cwd) ?? "origin";
+  for (const ref of [`refs/remotes/${remote}/${trunk}`, `refs/heads/${trunk}`, trunk])
+    if (resolveRef(cwd, ref))
+      return ref;
+  return null;
+}
+function defaultTrunk(cwd) {
+  const base = defaultBase(cwd);
+  return base ? base.replace(/^origin\//u, "") : "main";
+}
+function worktreeRoot(cwd) {
+  const common = gitCommonDir(cwd);
+  const main = common && path42.basename(common) === ".git" ? path42.dirname(common) : cwd;
+  return path42.join(path42.dirname(main), `${path42.basename(main)}-wt`);
+}
+function fanoutsDir(cwd) {
+  const root = storeRoot(cwd);
+  if (!root.ok)
+    return fanoutFail(root.code, root.error, root.unblock);
+  return { ok: true, data: path42.join(root.value.root, "fanouts") };
+}
+function parseStored(raw) {
+  if (!isRecord8(raw) || typeof raw.name !== "string" || typeof raw.trunk !== "string")
+    return null;
+  if (!Array.isArray(raw.slices))
+    return null;
+  const list = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+  const text = (value) => typeof value === "string" ? value : "";
+  let globsValid = true;
+  const globs = (value) => list(value).map((entry) => {
+    const normalized = normalizePattern(entry);
+    if ("error" in normalized) {
+      globsValid = false;
+      return entry;
+    }
+    return normalized.pattern;
+  });
+  const slices = [];
+  for (const item of raw.slices) {
+    if (!isRecord8(item) || typeof item.id !== "string" || typeof item.branch !== "string")
+      return null;
+    slices.push({
+      id: item.id,
+      branch: item.branch,
+      base: text(item.base) || raw.trunk,
+      worktree: text(item.worktree),
+      tier: TIERS.includes(item.tier) ? item.tier : "standard",
+      dependsOn: list(item.dependsOn),
+      scope: globs(item.scope),
+      owns: globs(item.owns),
+      goal: text(item.goal),
+      acceptance: list(item.acceptance),
+      verify: list(item.verify),
+      forbidden: list(item.forbidden),
+      context: typeof item.context === "string" ? item.context : null,
+      timebox: typeof item.timebox === "string" ? item.timebox : null
+    });
+  }
+  const shared = globs(raw.shared);
+  const ids = new Set(slices.map((slice) => slice.id));
+  if (!globsValid || ids.size !== slices.length || slices.some((slice) => slice.dependsOn.some((dep) => dep === slice.id || !ids.has(dep))) || findCycle(slices))
+    return null;
+  return {
+    v: typeof raw.v === "number" ? raw.v : FANOUT_VERSION,
+    name: raw.name,
+    trunk: raw.trunk,
+    shared,
+    slices,
+    createdAt: text(raw.createdAt),
+    updatedAt: text(raw.updatedAt)
+  };
+}
+function readFanout(cwd, name) {
+  const dir = fanoutsDir(cwd);
+  if (!dir.ok)
+    return dir;
+  const file = path42.join(dir.data, stackFileName(name));
+  let parsed = null;
+  try {
+    parsed = parseStored(JSON.parse(fs22.readFileSync(file, "utf8")));
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return { ok: true, data: null };
+    parsed = null;
+  }
+  return parsed ? { ok: true, data: parsed } : fanoutFail("failed", `fanout file ${file} is not a valid plan`, `workit fanout plan <plan.json> --name ${name}  # rewrite it`);
+}
+function listFanouts(cwd) {
+  const dir = fanoutsDir(cwd);
+  if (!dir.ok)
+    return dir;
+  let names = [];
+  try {
+    names = fs22.readdirSync(dir.data).filter((entry) => entry.endsWith(".json"));
+  } catch {
+    return { ok: true, data: [] };
+  }
+  const out = [];
+  for (const entry of names) {
+    let parsed = null;
+    try {
+      parsed = parseStored(JSON.parse(fs22.readFileSync(path42.join(dir.data, entry), "utf8")));
+    } catch {
+      parsed = null;
+    }
+    if (parsed && stackFileName(parsed.name) === entry)
+      out.push(parsed);
+  }
+  return { ok: true, data: out.toSorted((a, b) => a.name.localeCompare(b.name)) };
+}
+function selectFanout(cwd, name, current) {
+  if (name) {
+    const read = readFanout(cwd, name);
+    if (!read.ok)
+      return read;
+    return read.data ? { ok: true, data: read.data } : fanoutFail("not_found", `no fanout plan named ${name}`, "workit fanout plan <plan.json>");
+  }
+  const all = listFanouts(cwd);
+  if (!all.ok)
+    return all;
+  const holding = all.data.filter((plan) => plan.slices.some((slice) => slice.branch === current));
+  if (holding.length === 1)
+    return { ok: true, data: holding[0] };
+  if (all.data.length === 1)
+    return { ok: true, data: all.data[0] };
+  return all.data.length === 0 ? fanoutFail("not_found", "no fanout plan is recorded here", "workit fanout plan <plan.json>") : fanoutFail("invalid_input", `several fanout plans match; pick one (${all.data.map((plan) => plan.name).join(", ")})`, "pass --name <plan>");
+}
+function writeFanout(cwd, plan) {
+  const dir = fanoutsDir(cwd);
+  if (!dir.ok)
+    return dir;
+  const file = path42.join(dir.data, stackFileName(plan.name));
+  const temp = `${file}.${process.pid}.tmp`;
+  try {
+    fs22.mkdirSync(dir.data, { recursive: true });
+    fs22.writeFileSync(temp, `${JSON.stringify(plan, null, 2)}
+`);
+    fs22.renameSync(temp, file);
+    return { ok: true, data: file };
+  } catch (error) {
+    fs22.rmSync(temp, { force: true });
+    return fanoutFail("unavailable", `cannot write ${file}: ${error.message}`);
+  }
+}
+function planFanout(cwd, input, now = new Date) {
+  const dir = fanoutsDir(cwd);
+  if (!dir.ok)
+    return dir;
+  const parsed = parsePlan(input.trunk && isRecord8(input.raw) ? { ...input.raw, trunk: input.trunk } : input.raw, { trunk: input.trunk ?? defaultTrunk(cwd), worktreeRoot: worktreeRoot(cwd) }, input.name);
+  if (!parsed.ok)
+    return fanoutFail("invalid_input", `the plan is incomplete: ${parsed.problems[0]}${parsed.problems.length > 1 ? ` (+${parsed.problems.length - 1} more)` : ""}`, "fill every listed field, then run workit fanout plan again", { problems: parsed.problems });
+  const plan = parsed.plan;
+  const badBranches = plan.slices.filter((slice) => !gitRun4(cwd, ["check-ref-format", "--branch", slice.branch]).ok).map((slice) => `slice ${slice.id}: ${slice.branch} is not a valid branch name`);
+  if (badBranches.length)
+    return fanoutFail("invalid_input", badBranches[0], "rename the branch in the plan", {
+      problems: badBranches
+    });
+  const ref = trunkRef(cwd, plan.trunk);
+  const tracked = ref ? nulList2(gitRun4(cwd, ["ls-tree", "-r", "-z", "--name-only", ref]).stdout) : [];
+  const samples = plan.slices.flatMap((slice) => [...slice.scope, ...slice.owns].flatMap(scopeSamples));
+  const { overlaps, conflicts } = analyzeOverlap(plan, [...tracked, ...samples]);
+  if (conflicts.length)
+    return fanoutFail("blocked", `${conflicts.length} file-scope overlap${conflicts.length === 1 ? "" : "s"} between slices: ${conflicts[0].slices.join(" and ")} on ${conflicts[0].paths[0]}${conflicts[0].paths.length > 1 ? ` (+${conflicts[0].paths.length - 1})` : ""}`, conflicts[0].suggestion.text, { name: plan.name, conflicts, overlaps });
+  const existing = readFanout(cwd, plan.name);
+  const previous = existing.ok ? existing.data : null;
+  plan.createdAt = previous?.createdAt || now.toISOString();
+  plan.updatedAt = now.toISOString();
+  const written = writeFanout(cwd, plan);
+  if (!written.ok)
+    return written;
+  appendObserved(cwd, {
+    type: "fanout.planned",
+    actor: input.actor,
+    fanout: plan.name,
+    trunk: plan.trunk,
+    slices: plan.slices.length,
+    ids: plan.slices.slice(0, 20).map((slice) => slice.id)
+  });
+  const grouped = waves(plan.slices);
+  const notes = [];
+  if (!ref)
+    notes.push(`trunk ${plan.trunk} does not resolve here; only sample paths of each glob were compared`);
+  grouped.forEach((wave, index) => {
+    if (wave.length > IN_FLIGHT_CAP)
+      notes.push(`wave ${index + 1} has ${wave.length} slices; keep 4-${IN_FLIGHT_CAP} in flight and queue the rest`);
+  });
+  for (const slice of plan.slices)
+    if (slice.dependsOn.length > 1 && slice.base === plan.trunk)
+      notes.push(`slice ${slice.id} depends on ${slice.dependsOn.join(", ")}: start it from ${plan.trunk} after they land`);
+  return {
+    ok: true,
+    data: {
+      name: plan.name,
+      trunk: plan.trunk,
+      file: written.data,
+      created: previous === null,
+      slices: plan.slices.map(({ id, branch, base, worktree, tier, dependsOn, scope, owns }) => ({
+        id,
+        branch,
+        base,
+        worktree,
+        tier,
+        dependsOn,
+        scope,
+        owns
+      })),
+      overlaps,
+      waves: grouped,
+      landingOrder: landingOrder(plan.slices),
+      notes
+    }
+  };
+}
+var FANOUT_VERSION = 1, TIERS, fanoutFail = (code, error, unblock, data) => ({
+  ok: false,
+  code,
+  error,
+  ...unblock ? { unblock } : {},
+  ...data ? { data } : {}
+}), DEFAULT_SHARED, escapeRegExp4 = (text) => text.replace(/[.+^$()|[\]\\{}*?]/gu, "\\$&"), unescape2 = (pattern) => pattern.replace(/\\(.)/gu, "$1"), hasWildcard = (pattern) => /[*?{]/u.test(pattern.replace(/\\./gu, "")), compiled, matchesAny = (patterns, file) => patterns.some((pattern) => matchesScope(pattern, file)), isRecord8 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), PLACEHOLDER2, filled = (text) => text.trim() !== "" && !PLACEHOLDER2.test(text.trim()), textList = (value) => {
+  if (typeof value === "string")
+    return [value];
+  if (Array.isArray(value) && value.every((item) => typeof item === "string"))
+    return value;
+  return null;
+}, ID, quoteList = (items) => items.map((item) => `"${item}"`).join(", "), ownerSuggestion = (slice, paths) => ({
+  kind: "owner",
+  slice,
+  paths,
+  text: `add ${quoteList(paths)} to "owns" of slice ${slice}`
+}), serializeSuggestion = (ids) => {
+  const edges = ids.slice(1).map((slice, index) => ({ slice, dependsOn: ids[index] }));
+  return {
+    kind: "serialize",
+    edges,
+    text: edges.map((edge) => `add "${edge.dependsOn}" to "dependsOn" of slice ${edge.slice}`).join("; ")
+  };
+}, gitRun4 = (cwd, args) => {
+  const run = spawnSync20("git", args, {
+    cwd,
+    encoding: "utf8",
+    timeout: GIT_TIMEOUTS.local,
+    killSignal: "SIGKILL",
+    windowsHide: true,
+    maxBuffer: 64 * 1024 * 1024,
+    env: { ...process.env, GIT_TERMINAL_PROMPT: "0", LC_ALL: "C", LANGUAGE: "C" }
+  });
+  return {
+    ok: run.status === 0,
+    status: run.status,
+    stdout: run.stdout ?? "",
+    stderr: run.error ? String(run.error.message) : run.stderr ?? ""
+  };
+}, nulList2 = (text) => text.split("\x00").filter(Boolean), IN_FLIGHT_CAP = 6;
+var init_fanout = __esm(() => {
+  init_rev();
+  init_ledger();
+  init_stack();
+  TIERS = ["mundane", "standard", "hard"];
+  DEFAULT_SHARED = [
+    "**/package.json",
+    "**/{package-lock.json,npm-shrinkwrap.json,bun.lock,bun.lockb,pnpm-lock.yaml,pnpm-workspace.yaml,yarn.lock}",
+    "**/{Cargo.lock,go.mod,go.sum,poetry.lock,uv.lock,Gemfile.lock,composer.lock}",
+    "**/index.{ts,tsx,js,jsx,mjs,cjs}",
+    "**/tsconfig.json",
+    ".github/**",
+    ".gitlab-ci.yml",
+    "CHANGELOG.md"
+  ];
+  compiled = new Map;
+  PLACEHOLDER2 = /^(?:<[^>]*>|tbd|todo|fixme|\?+|\.\.\.|…)$/iu;
+  ID = /^[a-z0-9][a-z0-9._-]{0,63}$/u;
+});
+
+// packages/workit-core/src/fanout-check.ts
+function mergeConflicts(cwd, a, b) {
+  const run = gitRun4(cwd, [
+    "merge-tree",
+    "--write-tree",
+    "--name-only",
+    "--no-messages",
+    "-z",
+    a,
+    b
+  ]);
+  if (run.status === 0)
+    return [];
+  if (run.status === 1)
+    return [...new Set(nulList2(run.stdout).slice(1))];
+  const first = run.stderr.trim().split(`
+`)[0] || `git merge-tree exited ${run.status}`;
+  return {
+    error: /write-tree|usage: git merge-tree/u.test(run.stderr) ? `${first} (needs git >= 2.38 for merge-tree --write-tree)` : first
+  };
+}
+function checkFanout(cwd, plan, options = {}) {
+  const unknown = (options.only ?? []).filter((id) => !plan.slices.some((s) => s.id === id));
+  if (unknown.length)
+    return fanoutFail("invalid_input", `${unknown.join(", ")}: not a slice of fanout ${plan.name}`, `slices: ${plan.slices.map((slice) => slice.id).join(", ")}`);
+  const trunk = options.trunkRef ?? trunkRef(cwd, plan.trunk);
+  if (!SAFE(trunk) || !resolves(cwd, trunk))
+    return fanoutFail("unavailable", `trunk ${options.trunkRef ?? plan.trunk} does not resolve here`, `git fetch, or pass --base <ref>`);
+  const order = landingOrder(plan.slices);
+  const byId = new Map(plan.slices.map((slice) => [slice.id, slice]));
+  const tips = new Map(plan.slices.map((slice) => [slice.id, branchRef(cwd, slice.branch)]));
+  const ledger = readLedger(cwd);
+  const rows = ledger.ok ? ledger.value.rows : [];
+  const checks = new Map;
+  const changedBy = new Map;
+  for (const slice of plan.slices)
+    checks.set(slice.id, inspect(cwd, plan, slice, trunk, tips, rows, changedBy));
+  const conflicts = [];
+  for (let i = 0;i < order.length; i += 1)
+    for (let j = i + 1;j < order.length; j += 1) {
+      const first = order[i];
+      const second = order[j];
+      const a = tips.get(first);
+      const b = tips.get(second);
+      if (!a || !b || isAncestor2(cwd, a, b) || isAncestor2(cwd, b, a))
+        continue;
+      const check = checks.get(second);
+      const theirs = new Map((changedBy.get(first) ?? []).map((file) => [file.toLowerCase(), file]));
+      const cased = (changedBy.get(second) ?? []).flatMap((file) => {
+        const other = theirs.get(file.toLowerCase());
+        return other !== undefined && other !== file ? [`${other} ~ ${file}`] : [];
+      });
+      if (cased.length) {
+        conflicts.push({
+          first,
+          second,
+          paths: cased,
+          caseOnly: true,
+          resolution: `use ${first}'s spelling on ${second} (git mv), then workit fanout check`
+        });
+        check.siblingConflicts.push({ with: first, paths: cased });
+        check.reasons.push(`differs only in case from ${first}: ${cased.join(", ")}`);
+      }
+      const result = mergeConflicts(cwd, a, b);
+      if (!Array.isArray(result)) {
+        check.reasons.push(`cannot merge with ${first}: ${result.error}`);
+        continue;
+      }
+      if (result.length === 0)
+        continue;
+      const related = byId.get(second)?.dependsOn.includes(first);
+      conflicts.push({
+        first,
+        second,
+        paths: result,
+        resolution: related ? `rebase ${second} onto ${byId.get(first)?.branch} (its dependency), then workit fanout check` : `land ${first} first, then rebase ${second} onto ${plan.trunk} and run workit fanout check; or make ${second} depend on ${first}`
+      });
+      check.siblingConflicts.push({ with: first, paths: result });
+      check.reasons.push(`conflicts with ${first} on ${result.join(", ")}`);
+    }
+  for (const id of order) {
+    const check = checks.get(id);
+    check.waitsFor = (byId.get(id)?.dependsOn ?? []).filter((dep) => checks.get(dep)?.status !== "ready");
+    if (check.waitsFor.length)
+      check.reasons.push(`waits for ${check.waitsFor.join(", ")}`);
+    check.status = check.reasons.length ? "blocked" : "ready";
+  }
+  const selected = options.only?.length ? new Set(options.only) : null;
+  const slices = order.filter((id) => !selected || selected.has(id)).map((id) => checks.get(id));
+  const ready = slices.every((check) => check.status === "ready");
+  const blocked = slices.find((check) => check.status === "blocked");
+  const notes = plan.v === FANOUT_VERSION ? [] : [
+    `plan file version ${plan.v} is not ${FANOUT_VERSION}; read leniently (re-plan to rewrite it)`
+  ];
+  const next = blocked ? unblockFor(blocked, plan) : `land in this order: ${slices.map((check) => check.id).join(", ")} (workit pr merge each once verified; stacked slices with workit stack land)`;
+  return {
+    ok: true,
+    data: {
+      name: plan.name,
+      trunk: plan.trunk,
+      trunkRef: trunk,
+      ready,
+      slices,
+      conflicts: conflicts.filter((conflict) => !selected || selected.has(conflict.first) || selected.has(conflict.second)),
+      landingOrder: order,
+      notes,
+      next
+    }
+  };
+}
+function inspect(cwd, plan, slice, trunk, tips, rows, changedBy) {
+  const head = tips.get(slice.id) ?? null;
+  const check = {
+    id: slice.id,
+    branch: slice.branch,
+    head,
+    base: slice.base,
+    status: "blocked",
+    changed: 0,
+    outOfScope: [],
+    trunkConflicts: [],
+    siblingConflicts: [],
+    waitsFor: [],
+    verdict: { accepted: false, basis: "missing" },
+    reasons: []
+  };
+  if (!head) {
+    check.reasons.push(`branch ${slice.branch} not found (not started, landed, or not fetched)`);
+    return check;
+  }
+  const parent = plan.slices.find((other) => other.branch === slice.base);
+  const baseRef = slice.base === plan.trunk ? trunk : parent ? tips.get(parent.id) ?? null : branchRef(cwd, slice.base);
+  if (!SAFE(baseRef)) {
+    check.reasons.push(`base ${slice.base} not found`);
+    return check;
+  }
+  const diff = gitRun4(cwd, ["diff", "--name-only", "--no-renames", "-z", `${baseRef}...${head}`]);
+  if (!diff.ok) {
+    check.reasons.push(`cannot diff ${slice.base}...${slice.branch}: ${diff.stderr.trim()}`);
+    return check;
+  }
+  const changed = nulList2(diff.stdout);
+  changedBy.set(slice.id, changed);
+  check.changed = changed.length;
+  if (changed.length === 0)
+    check.reasons.push(`no changes beyond ${slice.base}`);
+  check.outOfScope = changed.filter((file) => !inScope(plan, slice, file)).toSorted();
+  if (check.outOfScope.length)
+    check.reasons.push(`edits outside its scope: ${check.outOfScope.join(", ")}`);
+  const trunkResult = mergeConflicts(cwd, trunk, head);
+  if (Array.isArray(trunkResult)) {
+    check.trunkConflicts = trunkResult;
+    if (trunkResult.length)
+      check.reasons.push(`conflicts with ${plan.trunk} on ${trunkResult.join(", ")}`);
+  } else
+    check.reasons.push(`cannot merge with ${plan.trunk}: ${trunkResult.error}`);
+  const verdict = checkVerdicts(cwd, slice.branch, rows);
+  check.verdict = { accepted: verdict.accepted.accepted, basis: verdict.current.basis };
+  return check;
+}
+function unblockFor(check, plan) {
+  if (!check.head)
+    return `start or fetch ${check.branch}, then workit fanout check; if it landed, re-plan without slice ${check.id}`;
+  if (check.outOfScope.length)
+    return `move ${check.outOfScope.join(", ")} off ${check.branch} (a follow-up slice), or widen slice ${check.id}'s scope with workit fanout plan, then workit fanout check`;
+  if (check.trunkConflicts.length)
+    return `rebase ${check.branch} onto ${plan.trunk} and resolve ${check.trunkConflicts.join(", ")}, then workit fanout check`;
+  if (check.siblingConflicts.length) {
+    const first = check.siblingConflicts[0].with;
+    return `land ${first} first, then rebase ${check.branch} onto ${plan.trunk} and run workit fanout check`;
+  }
+  if (check.waitsFor.length)
+    return `unblock ${check.waitsFor.join(", ")} first`;
+  return check.reasons[0] ?? "workit fanout check";
+}
+var SAFE = (value) => Boolean(value) && !value?.startsWith("-"), isAncestor2 = (cwd, a, b) => gitRun4(cwd, ["merge-base", "--is-ancestor", a, b]).ok, resolves = (cwd, ref) => gitRun4(cwd, ["rev-parse", "--verify", "-q", `${ref}^{commit}`]).ok;
+var init_fanout_check = __esm(() => {
+  init_ledger();
+  init_fanout();
+});
+
+// packages/workit-cli/src/verbs/fanout.ts
+var exports_fanout = {};
+__export(exports_fanout, {
+  run: () => run15
+});
+import fs23 from "node:fs";
+import path43 from "node:path";
+function renderBlockedPlan(io, result) {
+  if (io.json || result.code !== "blocked" && result.code !== "invalid_input")
+    return;
+  const problems = result.data?.problems;
+  if (Array.isArray(problems))
+    for (const problem of problems)
+      io.stderr(`  - ${problem}
+`);
+  const conflicts = result.data?.conflicts;
+  if (Array.isArray(conflicts))
+    for (const conflict of conflicts)
+      io.stderr(`  - ${conflict.slices.join(" + ")}: ${conflict.paths.join(", ")}
+      fix: ${conflict.suggestion.text}${conflict.alternative ? `
+      or:  ${conflict.alternative.text}` : ""}
+`);
+}
+function resolveTrunk(io, raw, flag, track) {
+  if (flag !== null)
+    return { trunk: flag };
+  const named = typeof raw === "object" && raw !== null && typeof raw.trunk === "string" ? raw.trunk.trim() || null : null;
+  if (named !== null && track === null)
+    return { trunk: null };
+  const derived = releaseTrunk(io, track, null);
+  if ("error" in derived)
+    return {
+      code: emit(io, fail("blocked", derived.error, {
+        unblock: "workit fanout plan <plan.json> --track <name>  # or --trunk <branch>"
+      }))
+    };
+  if (named !== null && derived.trunk !== named)
+    return {
+      code: usage3(io, `the plan names trunk ${named}; --track ${track} targets ${derived.trunk ?? "(none)"}`, PLAN_USAGE2)
+    };
+  return { trunk: derived.tracked || track !== null ? derived.trunk : null };
+}
+function plan2(argv, io) {
+  const flags = parseFlags(argv, { name: "value", trunk: "value", track: "value" });
+  if (typeof flags === "string")
+    return usage3(io, flags, PLAN_USAGE2);
+  const track = flags.values.track ?? null;
+  if (track !== null && flags.values.trunk !== undefined)
+    return usage3(io, "pass --trunk or --track, not both (--track picks the trunk)", PLAN_USAGE2);
+  if (flags.positionals.length !== 1)
+    return usage3(io, flags.positionals.length ? `unexpected argument ${flags.positionals[1]}` : "missing <plan.json>", PLAN_USAGE2);
+  const file = path43.resolve(io.cwd, flags.positionals[0]);
+  let raw;
+  try {
+    raw = JSON.parse(fs23.readFileSync(file, "utf8"));
+  } catch (error) {
+    return usage3(io, `cannot read ${file} as JSON: ${error.message}`, PLAN_USAGE2);
+  }
+  const trunk = resolveTrunk(io, raw, flags.values.trunk ?? null, track);
+  if ("code" in trunk)
+    return trunk.code;
+  const result = planFanout(io.cwd, {
+    raw,
+    name: flags.values.name ?? null,
+    trunk: trunk.trunk,
+    actor: actorFromEnv(io.env)
+  });
+  if (!result.ok) {
+    const code = failed(io, result);
+    renderBlockedPlan(io, result);
+    return code;
+  }
+  return emit(io, ok(result.data), (data) => [
+    `${data.created ? "planned" : "re-planned"} fanout ${data.name} on ${data.trunk}: ${data.slices.length} slice${data.slices.length === 1 ? "" : "s"}`,
+    ...data.slices.map((slice) => `  ${slice.id} [${slice.tier}] ${slice.branch} <- ${slice.base}${slice.dependsOn.length ? `  after ${slice.dependsOn.join(", ")}` : ""}
+      worktree ${slice.worktree}`),
+    ...data.overlaps.map((overlap) => `  shared ${overlap.path}: ${overlap.resolution === "owner" ? `owned by ${overlap.owner}` : `serialized (${overlap.slices.join(" -> ")})`}`),
+    `waves: ${data.waves.map((wave) => wave.join(", ")).join("  |  ")}`,
+    `landing order: ${data.landingOrder.join(", ")}`,
+    ...data.notes.map((note) => `note: ${note}`)
+  ]);
+}
+function check2(argv, io) {
+  const flags = parseFlags(argv, { name: "value", base: "value" });
+  if (typeof flags === "string")
+    return usage3(io, flags, CHECK_USAGE);
+  const selected = selectFanout(io.cwd, flags.values.name ?? null, currentBranch(io.cwd));
+  if (!selected.ok)
+    return failed(io, selected);
+  const result = checkFanout(io.cwd, selected.data, {
+    only: flags.positionals,
+    trunkRef: flags.values.base ?? null
+  });
+  if (!result.ok)
+    return failed(io, result);
+  if (result.data.ready)
+    return emit(io, ok(result.data), renderCheck);
+  if (!io.json)
+    for (const line of renderCheck(result.data))
+      io.stdout(`${line}
+`);
+  const first = result.data.slices.find((slice) => slice.status === "blocked");
+  return emit(io, fail("blocked", `slice ${first?.id ?? "?"} is not ready: ${first?.reasons[0] ?? "blocked"}`, {
+    data: result.data,
+    unblock: result.data.next
+  }));
+}
+async function run15(argv, io) {
+  const [sub, ...rest] = argv.filter((arg) => arg !== "--json");
+  if (sub === "plan")
+    return plan2(rest, io);
+  if (sub === "check")
+    return check2(rest, io);
+  return usage3(io, sub && !sub.startsWith("-") ? `unknown fanout subcommand "${sub}"` : "missing fanout subcommand", USAGE8);
+}
+var PLAN_USAGE2 = "workit fanout plan <plan.json> [--name <n>] [--trunk <b> | --track <t>] [--json]", CHECK_USAGE = "workit fanout check [<slice>…] [--name <n>] [--base <ref>] [--json]", USAGE8 = "workit fanout plan|check ... (workit help fanout)", failed = (io, result) => emit(io, fail(result.code, result.error, { unblock: result.unblock, data: result.data ?? {} })), renderCheck = (data) => [
+  `fanout ${data.name} against ${data.trunkRef}: ${data.ready ? "ready to land" : "blocked"}`,
+  ...data.slices.map((slice) => `  ${slice.status === "ready" ? "ok " : "x  "}${slice.id} (${slice.branch}) ${slice.changed} file${slice.changed === 1 ? "" : "s"} · verdict ${slice.verdict.accepted ? "accepted" : slice.verdict.basis}${slice.reasons.length ? `
+      ${slice.reasons.join(`
+      `)}` : ""}`),
+  ...data.conflicts.map((conflict) => `  conflict ${conflict.first} x ${conflict.second}: ${conflict.paths.join(", ")}
+      fix: ${conflict.resolution}`),
+  `landing order: ${data.landingOrder.join(", ")}`,
+  `next: ${data.next}`,
+  ...data.notes.map((note) => `note: ${note}`)
+];
+var init_fanout2 = __esm(() => {
+  init_fanout_check();
+  init_fanout();
+  init_rev();
+  init_ledger();
+  init_output();
+  init_forge_common();
+});
+
 // packages/workit-cli/src/verbs/ledger.ts
 var exports_ledger = {};
 __export(exports_ledger, {
-  run: () => run15
+  run: () => run16
 });
 import { randomBytes as randomBytes4 } from "node:crypto";
 import { parseArgs } from "node:util";
@@ -75430,7 +76412,7 @@ function targetBranch(io, rows, branch, pr) {
   }
   return { ok: true, value: branch ?? null };
 }
-async function run15(argv, io) {
+async function run16(argv, io) {
   let parsed;
   try {
     parsed = parseArgs({ args: argv, options: OPTIONS, allowPositionals: true, strict: true });
@@ -75458,7 +76440,7 @@ async function run15(argv, io) {
     return usage4(io, `unknown ledger subcommand "${sub}"`);
   const ledger = readLedger(io.cwd);
   if (!ledger.ok)
-    return failed(io, ledger);
+    return failed2(io, ledger);
   const { rows } = ledger.value;
   if (sub === "list" || sub === "show") {
     if (rest.length)
@@ -75480,7 +76462,7 @@ async function run15(argv, io) {
       return usage4(io, `unexpected argument: ${rest.at(-1)}`);
     const target = targetBranch(io, rows, rest[0] ?? values.branch, pr);
     if (!target.ok)
-      return failed(io, target);
+      return failed2(io, target);
     const branch = target.value ?? currentBranch(io.cwd);
     if (!branch)
       return emit(io, fail("invalid_input", "HEAD is detached; name the branch", {
@@ -75490,7 +76472,7 @@ async function run15(argv, io) {
   }
   const target = targetBranch(io, rows, values.branch, pr);
   if (!target.ok)
-    return failed(io, target);
+    return failed2(io, target);
   const acting = actorFor(io, values);
   if (acting instanceof Error)
     return usage4(io, acting.message);
@@ -75529,7 +76511,7 @@ async function run15(argv, io) {
     ..."derivedFrom" in acting ? { derivedFrom: acting.derivedFrom } : {}
   })), (row) => `recorded verdict ${row.id}: ${row.result} [${row.kind}] for ${row.branch} @ ${(row.head ?? "").slice(0, 12)} as ${actor.session ?? "no session"}${row.self ? ` (self${row.selfReason === "no_session" ? ": WORKIT_SESSION_ID unset" : ""}; never accepted)` : ""}`);
 }
-var USAGE8 = "workit ledger decision|ruling|verdict|list|check ... (workit help ledger for the grammar)", OPTIONS, SESSION_SAFE2, ROLE_SAFE, actorFor = (io, values) => {
+var USAGE9 = "workit ledger decision|ruling|verdict|list|check ... (workit help ledger for the grammar)", OPTIONS, SESSION_SAFE2, ROLE_SAFE, actorFor = (io, values) => {
   const actor = actorFromEnv(io.env);
   if (values.session !== undefined && values.as !== undefined)
     return new Error("pass --session or --as, not both");
@@ -75553,7 +76535,7 @@ var USAGE8 = "workit ledger decision|ruling|verdict|list|check ... (workit help
     return;
   const parsed = Number(value);
   return Number.isInteger(parsed) && parsed > 0 ? parsed : new Error(`${flag} must be a positive integer`);
-}, failed = (io, result) => emit(io, fail(result.code, result.error, result.unblock ? { unblock: result.unblock } : {})), fromResult = (io, result, human) => result.ok ? emit(io, ok(result.value), human) : failed(io, result), usage4 = (io, error) => emit(io, fail("invalid_input", error, { unblock: USAGE8 })), verdictLines = (check) => {
+}, failed2 = (io, result) => emit(io, fail(result.code, result.error, result.unblock ? { unblock: result.unblock } : {})), fromResult = (io, result, human) => result.ok ? emit(io, ok(result.value), human) : failed2(io, result), usage4 = (io, error) => emit(io, fail("invalid_input", error, { unblock: USAGE9 })), verdictLines = (check) => {
   const lines = [
     `${check.branch} @ ${(check.head ?? "no commit").slice(0, 12)}: current: ${check.current.basis}${typeof check.current.verdict?.result === "string" ? ` (${check.current.verdict.result})` : ""}; ${check.accepted.accepted ? "accepted" : `not accepted (${check.accepted.reasons.join(", ")})`}; review: ${check.review}`
   ];
@@ -90550,7 +91532,7 @@ var init_ast = __esm(() => {
 
 // packages/workit-cli/src/test-audit/rules.ts
 import { builtinModules } from "node:module";
-import path42 from "node:path";
+import path44 from "node:path";
 function testCallee(call) {
   let callee = call.callee;
   if (callee.type === "CallExpression")
@@ -91043,12 +92025,12 @@ function checkConstantsOnly(ctx, emit) {
 }
 function checkOverMocking(ctx, emit) {
   const { program } = ctx.parsed;
-  const unit = path42.basename(ctx.file).replace(/\.(?:[cm]?[jt]sx?)$/, "").replace(/\.(?:test|spec)$/, "");
+  const unit = path44.basename(ctx.file).replace(/\.(?:[cm]?[jt]sx?)$/, "").replace(/\.(?:test|spec)$/, "");
   const mocked = find2(program, (node) => node.type === "CallExpression" && MODULE_MOCK.test(calleeName(node.callee) ?? "") && node.arguments[0]?.type === "StringLiteral");
   const internal = mocked.filter((call) => /^(?:\.|@\/|~\/)/.test(call.arguments[0].value));
   for (const call of mocked) {
     const spec = call.arguments[0].value;
-    const base = path42.basename(spec.replace(/\/index(?:\.[cm]?[jt]sx?)?$/, "")).replace(/\.(?:[cm]?[jt]sx?)$/, "");
+    const base = path44.basename(spec.replace(/\/index(?:\.[cm]?[jt]sx?)?$/, "")).replace(/\.(?:[cm]?[jt]sx?)$/, "");
     if (base === unit)
       emit({
         rule: "over-mocking",
@@ -91436,11 +92418,11 @@ var init_rules = __esm(() => {
 });
 
 // packages/workit-cli/src/test-audit/audit.ts
-import { spawnSync as spawnSync20 } from "node:child_process";
+import { spawnSync as spawnSync21 } from "node:child_process";
 import { existsSync as existsSync18, readdirSync as readdirSync8, readFileSync as readFileSync19, statSync as statSync7 } from "node:fs";
-import path43 from "node:path";
+import path45 from "node:path";
 function git6(cwd, args) {
-  const run = spawnSync20("git", ["-c", "core.quotepath=off", ...args], {
+  const run = spawnSync21("git", ["-c", "core.quotepath=off", ...args], {
     cwd,
     encoding: "utf8",
     maxBuffer: 64 * 1024 * 1024
@@ -91451,7 +92433,7 @@ function walkTests(dir, out) {
   for (const entry of readdirSync8(dir, { withFileTypes: true })) {
     if (entry.name.startsWith(".") && entry.name !== "." && entry.isDirectory())
       continue;
-    const full = path43.join(dir, entry.name);
+    const full = path45.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (!SKIP_DIRS.has(entry.name))
         walkTests(full, out);
@@ -91463,7 +92445,7 @@ function expandPaths(cwd, inputs) {
   const files = [];
   const missing = [];
   for (const input of inputs.length > 0 ? inputs : ["."]) {
-    const full = path43.resolve(cwd, input);
+    const full = path45.resolve(cwd, input);
     if (!existsSync18(full))
       missing.push(input);
     else if (statSync7(full).isDirectory())
@@ -91500,11 +92482,11 @@ function changedLines(cwd, base) {
       for (let offset = 0;offset < count; offset += 1)
         lines.add(start + offset);
     }
-    changed.set(path43.join(root, file), lines);
+    changed.set(path45.join(root, file), lines);
   }
   const untracked = git6(root, ["ls-files", "--others", "--exclude-standard", "-z"]);
   for (const file of untracked.stdout.split("\x00").filter(Boolean))
-    changed.set(path43.join(root, file), "all");
+    changed.set(path45.join(root, file), "all");
   return changed;
 }
 function auditFiles(files, display) {
@@ -91566,7 +92548,7 @@ function auditFiles(files, display) {
     durationMs: Math.round(performance.now() - started)
   };
 }
-var TEST_FILE, CODE_FILE, SKIP_DIRS, toPosix = (file) => file.split(path43.sep).join("/"), SEVERITY_ORDER, ruleIds;
+var TEST_FILE, CODE_FILE, SKIP_DIRS, toPosix = (file) => file.split(path45.sep).join("/"), SEVERITY_ORDER, ruleIds;
 var init_audit = __esm(() => {
   init_ast();
   init_rules();
@@ -91596,7 +92578,7 @@ import {
   copyFileSync as copyFileSync6
 } from "node:fs";
 import os14 from "node:os";
-import path44 from "node:path";
+import path46 from "node:path";
 function mutantsFor(source, file, lines) {
   const parsed = parseSource(source, file);
   const out = [];
@@ -91669,7 +92651,7 @@ function relatedTests(source, testFiles) {
     for (const match of text.matchAll(SPECIFIER)) {
       const spec = match[1];
       if (spec.startsWith(".")) {
-        if (stripExt(path44.posix.join(path44.posix.dirname(file), spec)) === target)
+        if (stripExt(path46.posix.join(path46.posix.dirname(file), spec)) === target)
           return true;
       } else if (spec.includes("/") && stripExt(spec).split("/").slice(-2).join("/") === tail)
         return true;
@@ -91689,12 +92671,12 @@ function removeStaleCopies(tmp = os14.tmpdir()) {
   for (const name of names) {
     if (!name.startsWith(TEMP_PREFIX))
       continue;
-    const dir = path44.join(tmp, name);
+    const dir = path46.join(tmp, name);
     try {
       const stat = lstatSync7(dir);
       if (!stat.isDirectory() || uid !== undefined && stat.uid !== uid)
         continue;
-      const pid = Number(readFileSync20(path44.join(dir, PID_FILE), "utf8"));
+      const pid = Number(readFileSync20(path46.join(dir, PID_FILE), "utf8"));
       if (Number.isInteger(pid) && pid > 0 && alive(pid))
         continue;
     } catch (error) {
@@ -91711,8 +92693,8 @@ function removeStaleCopies(tmp = os14.tmpdir()) {
 function linkNodeModules(origin, target, repo, copy) {
   mkdirSync9(target, { recursive: true });
   for (const entry of readdirSync9(origin, { withFileTypes: true })) {
-    const from = path44.join(origin, entry.name);
-    const to = path44.join(target, entry.name);
+    const from = path46.join(origin, entry.name);
+    const to = path46.join(target, entry.name);
     if (entry.name.startsWith("@") && entry.isDirectory()) {
       linkNodeModules(from, to, repo, copy);
       continue;
@@ -91728,9 +92710,9 @@ function linkNodeModules(origin, target, repo, copy) {
       } catch {
         continue;
       }
-      const relative = path44.relative(repo, real);
-      if (!relative.startsWith("..") && !path44.isAbsolute(relative) && !relative.split(path44.sep).includes("node_modules")) {
-        symlinkSync(path44.join(copy, relative), to, "junction");
+      const relative = path46.relative(repo, real);
+      if (!relative.startsWith("..") && !path46.isAbsolute(relative) && !relative.split(path46.sep).includes("node_modules")) {
+        symlinkSync(path46.join(copy, relative), to, "junction");
         continue;
       }
     }
@@ -91746,7 +92728,7 @@ function copySymlink(repo, tree, from, to) {
   }
   const realRepo = realpathSync9(repo);
   if (real && inside2(realRepo, real)) {
-    symlinkSync(path44.relative(path44.dirname(to), path44.join(tree, path44.relative(realRepo, real))), to);
+    symlinkSync(path46.relative(path46.dirname(to), path46.join(tree, path46.relative(realRepo, real))), to);
     return;
   }
   if (real && statSync8(real).isFile())
@@ -91755,10 +92737,10 @@ function copySymlink(repo, tree, from, to) {
     symlinkSync(readlinkSync3(from), to);
 }
 function writeInside(copy, file, content) {
-  const target = path44.join(copy, file);
+  const target = path46.join(copy, file);
   try {
     const stat = lstatSync7(target);
-    if (!stat.isFile() || !inside2(realpathSync9(copy), realpathSync9(path44.dirname(target))))
+    if (!stat.isFile() || !inside2(realpathSync9(copy), realpathSync9(path46.dirname(target))))
       return false;
   } catch {
     return false;
@@ -91769,9 +92751,9 @@ function writeInside(copy, file, content) {
   return true;
 }
 function copyWorkingTree(repo) {
-  const dir = mkdtempSync4(path44.join(os14.tmpdir(), TEMP_PREFIX));
-  writeFileSync9(path44.join(dir, PID_FILE), String(process.pid));
-  const tree = path44.join(dir, "tree");
+  const dir = mkdtempSync4(path46.join(os14.tmpdir(), TEMP_PREFIX));
+  writeFileSync9(path46.join(dir, PID_FILE), String(process.pid));
+  const tree = path46.join(dir, "tree");
   const head = git6(repo, ["rev-parse", "--verify", "--quiet", "HEAD"]).stdout.trim();
   if (head && git6(dir, ["clone", "-q", "--shared", "--no-checkout", repo, tree]).ok) {
     const branch = git6(repo, ["symbolic-ref", "--quiet", "--short", "HEAD"]).stdout.trim();
@@ -91788,29 +92770,29 @@ function copyWorkingTree(repo) {
   for (const relative of listed) {
     if (!relative)
       continue;
-    const from = path44.join(repo, relative);
+    const from = path46.join(repo, relative);
     let stat;
     try {
       stat = lstatSync7(from);
     } catch {
       continue;
     }
-    const to = path44.join(tree, relative);
-    mkdirSync9(path44.dirname(to), { recursive: true });
+    const to = path46.join(tree, relative);
+    mkdirSync9(path46.dirname(to), { recursive: true });
     if (stat.isSymbolicLink())
       copySymlink(repo, tree, from, to);
     else if (stat.isFile())
       copyFileSync6(from, to);
-    let parent = path44.dirname(relative);
+    let parent = path46.dirname(relative);
     while (parent !== "." && !dirs.has(parent)) {
       dirs.add(parent);
-      parent = path44.dirname(parent);
+      parent = path46.dirname(parent);
     }
   }
   for (const parent of dirs) {
-    const modules = path44.join(repo, parent, "node_modules");
-    if (existsSync19(modules) && !existsSync19(path44.join(tree, parent, "node_modules")))
-      linkNodeModules(modules, path44.join(tree, parent, "node_modules"), repo, tree);
+    const modules = path46.join(repo, parent, "node_modules");
+    if (existsSync19(modules) && !existsSync19(path46.join(tree, parent, "node_modules")))
+      linkNodeModules(modules, path46.join(tree, parent, "node_modules"), repo, tree);
   }
   return { dir, tree };
 }
@@ -91849,14 +92831,14 @@ async function runMutation(options) {
   const tracked = git6(repo, ["ls-files", "-co", "--exclude-standard", "-z"]).stdout.split("\x00").filter(Boolean);
   const testFiles = tracked.filter((file) => TEST_FILE.test(file)).map((file) => {
     try {
-      return { file, text: readFileSync20(path44.join(repo, file), "utf8") };
+      return { file, text: readFileSync20(path46.join(repo, file), "utf8") };
     } catch {
       return { file, text: "" };
     }
   });
   const candidates = [];
   for (const [absolute, lines] of [...options.changed].toSorted(([a], [b]) => a.localeCompare(b))) {
-    const relative = toPosix(path44.relative(repo, absolute));
+    const relative = toPosix(path46.relative(repo, absolute));
     if (!CODE_FILE.test(relative) || TEST_FILE.test(relative) || relative.endsWith(".d.ts"))
       continue;
     if (NOT_SOURCE.test(relative) || !existsSync19(absolute))
@@ -91870,9 +92852,9 @@ async function runMutation(options) {
   for (const mutant of mutants)
     if (!related.has(mutant.file))
       related.set(mutant.file, relatedTests(mutant.file, testFiles));
-  const cwdRelative = path44.relative(repo, options.cwd);
+  const cwdRelative = path46.relative(repo, options.cwd);
   const asArg = (file) => {
-    const relative = toPosix(path44.relative(cwdRelative, file));
+    const relative = toPosix(path46.relative(cwdRelative, file));
     return shellQuote(relative.startsWith(".") ? relative : `./${relative}`);
   };
   const commandFor = (tests) => options.command.replaceAll("{files}", () => tests.map(asArg).join(" "));
@@ -91907,7 +92889,7 @@ async function runMutation(options) {
     return finish2(options, 0, results, counts, started);
   removeStaleCopies();
   const { dir: copyDir, tree: copy } = copyWorkingTree(repo);
-  const copyCwd = path44.join(copy, cwdRelative);
+  const copyCwd = path46.join(copy, cwdRelative);
   let current = null;
   const restore = () => {
     if (current)
@@ -91942,7 +92924,7 @@ async function runMutation(options) {
         record({ ...mutant, status: "skipped", durationMs: 0, tests, reason: "budget" });
         continue;
       }
-      const original = readFileSync20(path44.join(copy, mutant.file), "utf8");
+      const original = readFileSync20(path46.join(copy, mutant.file), "utf8");
       const mutated = original.slice(0, mutant.start) + mutant.replacement + original.slice(mutant.end);
       current = { file: mutant.file, original };
       if (!writeInside(copy, mutant.file, mutated)) {
@@ -91999,8 +92981,8 @@ var NOT_SOURCE, FLIPS, isStringy = (node) => node.type === "StringLiteral" || no
     return error.code === "EPERM";
   }
 }, inside2 = (root, file) => {
-  const relative = path44.relative(root, file);
-  return relative === "" || !relative.startsWith("..") && !path44.isAbsolute(relative);
+  const relative = path46.relative(root, file);
+  return relative === "" || !relative.startsWith("..") && !path46.isAbsolute(relative);
 }, active, killTree = (child) => {
   try {
     if (child.pid && process.platform !== "win32")
@@ -92046,10 +93028,10 @@ var init_mutate = __esm(() => {
 // packages/workit-cli/src/verbs/test-audit.ts
 var exports_test_audit = {};
 __export(exports_test_audit, {
-  run: () => run16
+  run: () => run17
 });
 import { existsSync as existsSync20 } from "node:fs";
-import path45 from "node:path";
+import path47 from "node:path";
 function parse7(argv) {
   const options = {
     paths: [],
@@ -92143,14 +93125,14 @@ function human(data) {
   }
   return lines;
 }
-async function run16(argv, io) {
+async function run17(argv, io) {
   const options = parse7(argv);
   if (typeof options === "string")
     return emit(io, fail("invalid_input", `${options}
-usage: ${USAGE9}`));
+usage: ${USAGE10}`));
   const top = git6(io.cwd, ["rev-parse", "--show-toplevel"]);
-  const repo = top.ok ? path45.resolve(top.stdout.trim()) : null;
-  const display = (file) => toPosix(path45.relative(io.cwd, file) || file);
+  const repo = top.ok ? path47.resolve(top.stdout.trim()) : null;
+  const display = (file) => toPosix(path47.relative(io.cwd, file) || file);
   let base = null;
   let changed = null;
   if (options.diff || options.mutate) {
@@ -92233,7 +93215,7 @@ usage: ${USAGE9}`));
   }
   return emit(io, ok(data), human);
 }
-var USAGE9 = "workit test-audit [paths…] [--diff [base]] [--rule <ids>] [--min-severity <level>] [--fail-on <level>] [--mutate [--test-cmd <cmd>] [--max-mutants <n>] [--budget <s>] [--timeout <s>]] [--json]", LEVELS, VALUE_FLAGS2, quote = (arg) => /^[\w./@:=+-]+$/.test(arg) ? arg : `'${arg.replace(/'/g, "'\\''")}'`;
+var USAGE10 = "workit test-audit [paths…] [--diff [base]] [--rule <ids>] [--min-severity <level>] [--fail-on <level>] [--mutate [--test-cmd <cmd>] [--max-mutants <n>] [--budget <s>] [--timeout <s>]] [--json]", LEVELS, VALUE_FLAGS2, quote = (arg) => /^[\w./@:=+-]+$/.test(arg) ? arg : `'${arg.replace(/'/g, "'\\''")}'`;
 var init_test_audit = __esm(() => {
   init_audit();
   init_mutate();
@@ -92358,14 +93340,14 @@ var init_youtrack_writes = __esm(() => {
 // packages/workit-cli/src/verbs/youtrack.ts
 var exports_youtrack = {};
 __export(exports_youtrack, {
-  run: () => run17
+  run: () => run18
 });
 import { readFileSync as readFileSync21 } from "node:fs";
-import path46 from "node:path";
-async function run17(argv, io) {
+import path48 from "node:path";
+async function run18(argv, io) {
   const [sub, ...rest] = argv;
   if (sub !== "note" && sub !== "time" && sub !== "meeting")
-    return usage3(io, `unknown subcommand "${sub ?? ""}"`, USAGE10);
+    return usage3(io, `unknown subcommand "${sub ?? ""}"`, USAGE11);
   const flags = parseFlags(rest, {
     markdown: "value",
     file: "value",
@@ -92374,18 +93356,18 @@ async function run17(argv, io) {
     date: "value"
   });
   if (typeof flags === "string")
-    return usage3(io, flags, USAGE10);
+    return usage3(io, flags, USAGE11);
   const [issueId, extra] = flags.positionals;
   if (!issueId || !ISSUE_RE2.test(issueId))
-    return usage3(io, "an issue id like ABC-123 is required", USAGE10);
+    return usage3(io, "an issue id like ABC-123 is required", USAGE11);
   if (extra !== undefined)
-    return usage3(io, `unexpected argument ${extra}`, USAGE10);
+    return usage3(io, `unexpected argument ${extra}`, USAGE11);
   const minutes = positiveInt(flags.values.minutes, "--minutes");
   if (typeof minutes === "string")
-    return usage3(io, minutes, USAGE10);
+    return usage3(io, minutes, USAGE11);
   const date = youTrackWorkDateMs(flags.values.date ?? "auto");
   if ("error" in date)
-    return usage3(io, date.error, USAGE10);
+    return usage3(io, date.error, USAGE11);
   const dateMs = date.data.dateMs;
   const markedDay = flags.values.date !== undefined && flags.values.date !== "auto" ? { dateMs } : {};
   const root = io.cwd;
@@ -92403,24 +93385,24 @@ async function run17(argv, io) {
   };
   if (sub === "note") {
     if (Boolean(flags.values.markdown) === Boolean(flags.values.file))
-      return usage3(io, "pass exactly one of --markdown or --file", USAGE10);
+      return usage3(io, "pass exactly one of --markdown or --file", USAGE11);
     let markdown = flags.values.markdown ?? "";
     if (flags.values.file)
       try {
-        markdown = readFileSync21(path46.resolve(io.cwd, flags.values.file), "utf8");
+        markdown = readFileSync21(path48.resolve(io.cwd, flags.values.file), "utf8");
       } catch (error) {
-        return usage3(io, `cannot read ${flags.values.file}: ${String(error)}`, USAGE10);
+        return usage3(io, `cannot read ${flags.values.file}: ${String(error)}`, USAGE11);
       }
     if (!markdown.trim())
-      return usage3(io, "the note is empty", USAGE10);
+      return usage3(io, "the note is empty", USAGE11);
     const missing = step("comment", "comments", { operation: "note", issueId, markdown }, markdown, async (text) => commentResult(await postComment(issueId, text, root))) ?? (minutes ? step("time", "workItems", { operation: "note.time", issueId, markdown, minutes, ...markedDay }, "workit update", (text) => logTimeUpdate({ issueId, minutes, text, dateMs, workspace_root: root })) : null);
     if (missing)
       return emit(io, fail("unavailable", missing));
   } else {
     if (!minutes)
-      return usage3(io, `${sub} needs --minutes <n>`, USAGE10);
+      return usage3(io, `${sub} needs --minutes <n>`, USAGE11);
     if (sub === "meeting" && !flags.values.text)
-      return usage3(io, "meeting needs --text <what the meeting was>", USAGE10);
+      return usage3(io, "meeting needs --text <what the meeting was>", USAGE11);
     const text = flags.values.text ?? "";
     const missing = step(sub, "workItems", { operation: sub, issueId, minutes, text, ...markedDay }, text, (marked) => logTimeUpdate({ issueId, minutes, text: marked, dateMs, workspace_root: root }));
     if (missing)
@@ -92449,7 +93431,7 @@ async function run17(argv, io) {
     ...data.steps.flatMap((entry) => entry.note ? [`  note (${entry.step}): ${entry.note}`] : [])
   ]);
 }
-var USAGE10 = "workit youtrack note <ISSUE> (--markdown <t> | --file <p>) [--minutes <n>] [--date auto|YYYY-MM-DD] | youtrack time <ISSUE> --minutes <n> [--text <t>] [--date …] | youtrack meeting <ISSUE> --minutes <n> --text <t> [--date …]", commentResult = (value) => {
+var USAGE11 = "workit youtrack note <ISSUE> (--markdown <t> | --file <p>) [--minutes <n>] [--date auto|YYYY-MM-DD] | youtrack time <ISSUE> --minutes <n> [--text <t>] [--date …] | youtrack meeting <ISSUE> --minutes <n> --text <t> [--date …]", commentResult = (value) => {
   try {
     return { ok: true, data: unwrap2(value) };
   } catch (error) {
@@ -92473,14 +93455,14 @@ var init_youtrack2 = __esm(() => {
 // packages/workit-cli/src/verbs/changelog.ts
 var exports_changelog = {};
 __export(exports_changelog, {
-  run: () => run18
+  run: () => run19
 });
 import { readFileSync as readFileSync22 } from "node:fs";
-import path47 from "node:path";
-async function run18(argv, io) {
+import path49 from "node:path";
+async function run19(argv, io) {
   const [sub, ...rest] = argv;
   if (sub !== "apply")
-    return usage3(io, `unknown subcommand "${sub ?? ""}"`, USAGE11);
+    return usage3(io, `unknown subcommand "${sub ?? ""}"`, USAGE12);
   const flags = parseFlags(rest, {
     entries: "value",
     path: "value",
@@ -92488,18 +93470,18 @@ async function run18(argv, io) {
     preview: "boolean"
   });
   if (typeof flags === "string")
-    return usage3(io, flags, USAGE11);
+    return usage3(io, flags, USAGE12);
   if (flags.positionals.length)
-    return usage3(io, `unexpected argument ${flags.positionals[0]}`, USAGE11);
+    return usage3(io, `unexpected argument ${flags.positionals[0]}`, USAGE12);
   const normalizeOnly = flags.booleans.has("normalize-only");
   if (!normalizeOnly && !flags.values.entries)
-    return usage3(io, "pass --entries <JSON> or --normalize-only", USAGE11);
+    return usage3(io, "pass --entries <JSON> or --normalize-only", USAGE12);
   let entries;
   if (flags.values.entries)
     try {
       entries = readEntries(flags.values.entries, io.cwd);
     } catch (error) {
-      return usage3(io, `--entries is not valid JSON: ${String(error)}`, USAGE11);
+      return usage3(io, `--entries is not valid JSON: ${String(error)}`, USAGE12);
     }
   const input = {
     entries,
@@ -92521,8 +93503,8 @@ async function run18(argv, io) {
     `changelog updated: ${String(applied.path ?? "CHANGELOG.md")}`
   ]);
 }
-var USAGE11 = "workit changelog apply (--entries <JSON|@file|-> | --normalize-only) [--path CHANGELOG.md] [--preview]", readEntries = (raw, cwd) => {
-  const text = raw === "-" ? readFileSync22(0, "utf8") : raw.startsWith("@") ? readFileSync22(path47.resolve(cwd, raw.slice(1)), "utf8") : raw;
+var USAGE12 = "workit changelog apply (--entries <JSON|@file|-> | --normalize-only) [--path CHANGELOG.md] [--preview]", readEntries = (raw, cwd) => {
+  const text = raw === "-" ? readFileSync22(0, "utf8") : raw.startsWith("@") ? readFileSync22(path49.resolve(cwd, raw.slice(1)), "utf8") : raw;
   return JSON.parse(text);
 };
 var init_changelog2 = __esm(() => {
@@ -92534,7 +93516,7 @@ var init_changelog2 = __esm(() => {
 // packages/workit-cli/src/verbs/handoff.ts
 var exports_handoff = {};
 __export(exports_handoff, {
-  run: () => run19
+  run: () => run20
 });
 import { parseArgs as parseArgs2 } from "node:util";
 function human2(brief) {
@@ -92582,11 +93564,11 @@ async function resumeBrief(argv, io) {
       strict: true
     }));
   } catch (error) {
-    return emit(io, fail("invalid_input", error.message, { unblock: USAGE12 }));
+    return emit(io, fail("invalid_input", error.message, { unblock: USAGE13 }));
   }
   const last = values.last === undefined ? 10 : Number(values.last);
   if (!Number.isInteger(last) || last < 1)
-    return emit(io, fail("invalid_input", "--last must be a positive integer", { unblock: USAGE12 }));
+    return emit(io, fail("invalid_input", "--last must be a positive integer", { unblock: USAGE13 }));
   const built = buildHandoff(io.cwd, {
     last,
     note: values.note ?? null,
@@ -92604,13 +93586,13 @@ async function resumeBrief(argv, io) {
   }
   return emit(io, ok({ ...data, recorded }), human2);
 }
-async function run19(argv, io) {
+async function run20(argv, io) {
   if (!argv.includes("--task"))
     return resumeBrief(argv, io);
   await Promise.resolve().then(() => init_task());
   return runTaskCommand(["handoff", ...argv]);
 }
-var USAGE12 = "workit handoff [--note <text>] [--next <text>] [--record] [--last <n>] [--json]", short5 = (sha) => sha ? sha.slice(0, 12) : "no commit";
+var USAGE13 = "workit handoff [--note <text>] [--next <text>] [--record] [--last <n>] [--json]", short5 = (sha) => sha ? sha.slice(0, 12) : "no commit";
 var init_handoff = __esm(() => {
   init_ledger();
   init_output();
@@ -92619,7 +93601,7 @@ var init_handoff = __esm(() => {
 // packages/workit-cli/src/main.ts
 init_package();
 init_output();
-import path48 from "node:path";
+import path50 from "node:path";
 
 // packages/workit-cli/src/verbs/registry.ts
 var TASK_FAMILY_NAMES = [
@@ -92731,6 +93713,13 @@ var VERBS = [
     summary: "Plan, restack (lease push + retarget) and land a base-branch stack of PRs, root first",
     load: () => Promise.resolve().then(() => (init_stack2(), exports_stack))
   },
+  {
+    name: "fanout",
+    group: "delivery",
+    usage: "workit fanout plan <plan.json> [--name <n>] [--trunk <b> | --track <t>] | fanout check [<slice>…] [--name <n>] [--base <ref>] [--json]",
+    summary: "Register parallel slices (complete briefs, disjoint scopes, shared-file owners), then gate fan-in: out-of-scope edits, trunk and sibling merge conflicts, landing order",
+    load: () => Promise.resolve().then(() => (init_fanout2(), exports_fanout))
+  },
   {
     name: "ledger",
     group: "delivery",
@@ -92849,7 +93838,7 @@ var defaultIo = (json) => ({
 });
 async function main(argv, overrides = {}, options = {}) {
   const parsed = parseGlobals(argv);
-  const cwd = path48.resolve(overrides.cwd ?? process.cwd(), parsed.cwd ?? ".");
+  const cwd = path50.resolve(overrides.cwd ?? process.cwd(), parsed.cwd ?? ".");
   const io = { ...defaultIo(parsed.json), ...overrides, json: parsed.json, cwd };
   if (parsed.error)
     return emit(io, fail("invalid_input", parsed.error));