@brainervirus/workit-claude-code 8.17.1 → 8.18.0

package/dist/workit.js

@@ -65,7 +65,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@brainervirus/workit-cli",
-    version: "8.17.1",
+    version: "8.18.0",
     private: false,
     description: "Workit CLI — setup wizard, doctor, and task control for agentic coding workflows",
     keywords: [
@@ -103,13 +103,13 @@ var init_package = __esm(() => {
     },
     dependencies: {
       "@babel/parser": "7.29.9",
-      "@brainervirus/workit-cursor": "^8.17.1",
+      "@brainervirus/workit-cursor": "^8.18.0",
       "@inkjs/ui": "2.0.0",
       ink: "7.1.1",
       react: "19.2.8"
     },
     devDependencies: {
-      "@brainervirus/workit-core": "^8.17.1"
+      "@brainervirus/workit-core": "^8.18.0"
     },
     engines: {
       node: ">=24"
@@ -170,6 +170,20 @@ var init_output = __esm(() => {
 import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
+function checksConfigFile(root) {
+  const current = path.join(root, CHECKS_FILE);
+  const legacy = path.join(root, LEGACY_CHECKS_FILE);
+  return !fs.existsSync(current) && fs.existsSync(legacy) ? legacy : current;
+}
+function ensureWorkitDir(root) {
+  const dir = path.join(root, ".workit");
+  fs.mkdirSync(dir, { recursive: true });
+  const ignore = path.join(dir, ".gitignore");
+  if (!fs.existsSync(ignore))
+    fs.writeFileSync(ignore, `*
+`);
+  return dir;
+}
 function repoHeavyCommands(root) {
   try {
     const value = JSON.parse(fs.readFileSync(checksConfigFile(root), "utf8"));
@@ -261,19 +275,25 @@ function detectedChecks(root) {
 function loadCheckConfig(cwd) {
   const root = checkRoot(cwd);
   const file = checksConfigFile(root);
+  const legacy = path.basename(file) === LEGACY_CHECKS_FILE;
+  const label = legacy ? LEGACY_CHECKS_FILE : CHECKS_FILE;
+  const note = legacy ? {
+    note: `${LEGACY_CHECKS_FILE} is deprecated; move it to ${CHECKS_FILE} (workit doctor --fix)`
+  } : {};
   const none = (error = null) => ({
-    source: error ? CHECKS_FILE : "none",
+    source: error ? label : "none",
     root,
     checks: [],
     gates: {},
-    error
+    error,
+    ...note
   });
   let text = null;
   try {
     text = fs.readFileSync(file, "utf8");
   } catch (error) {
     if (error.code !== "ENOENT")
-      return none(`cannot read ${CHECKS_FILE}: ${error.message}`);
+      return none(`cannot read ${label}: ${error.message}`);
   }
   if (text === null) {
     const checks = detectedChecks(root);
@@ -283,33 +303,33 @@ function loadCheckConfig(cwd) {
   try {
     parsed = JSON.parse(text);
   } catch {
-    return none(`${CHECKS_FILE} is not valid JSON`);
+    return none(`${label} is not valid JSON`);
   }
   if (!isRecord(parsed) || !isRecord(parsed.checks))
-    return none(`${CHECKS_FILE} must be {"checks":{"<name>":"<command>"|["argv",…]}}`);
+    return none(`${label} must be {"checks":{"<name>":"<command>"|["argv",…]}}`);
   const checks = [];
   for (const [name, value] of Object.entries(parsed.checks)) {
     if (!CHECK_NAME.test(name))
-      return none(`${CHECKS_FILE}: check name "${name}" must match ${CHECK_NAME.source}`);
+      return none(`${label}: check name "${name}" must match ${CHECK_NAME.source}`);
     const argv = typeof value === "string" ? splitCommand(value) : Array.isArray(value) && value.length > 0 && value.every((item) => typeof item === "string" && item.length > 0) ? value : new Error("expected a command string or a non-empty argv array");
     if (argv instanceof Error)
-      return none(`${CHECKS_FILE}: check "${name}": ${argv.message}`);
+      return none(`${label}: check "${name}": ${argv.message}`);
     checks.push({ name, argv, accepts: [argv] });
   }
   const gates = {};
   if (parsed.gates !== undefined) {
     if (!isRecord(parsed.gates))
-      return none(`${CHECKS_FILE}: gates must be {"testing":"<name>"|["<name>",…]}`);
+      return none(`${label}: gates must be {"testing":"<name>"|["<name>",…]}`);
     for (const [gate, value] of Object.entries(parsed.gates)) {
       if (!GATES.includes(gate))
-        return none(`${CHECKS_FILE}: unknown gate "${gate}" (use ${GATES.join(" or ")})`);
+        return none(`${label}: unknown gate "${gate}" (use ${GATES.join(" or ")})`);
       const names = typeof value === "string" ? [value] : value;
       if (!Array.isArray(names) || names.length === 0 || !names.every((name) => typeof name === "string" && checks.some((c) => c.name === name)))
-        return none(`${CHECKS_FILE}: gates.${gate} must name configured checks`);
+        return none(`${label}: gates.${gate} must name configured checks`);
       gates[gate] = names;
     }
   }
-  return { source: CHECKS_FILE, root, checks, gates, error: null, resources: parsed.resources };
+  return { source: label, root, checks, gates, error: null, ...note, resources: parsed.resources };
 }
 function matchesNamedCheck(config, name, argv, cwd) {
   if (config.error || name === null || cwd !== ".")
@@ -344,7 +364,7 @@ function workitAvailable(env = process.env) {
 function checkCommand(args, version, onPath = workitAvailable()) {
   return onPath ? `workit check ${args}` : `npx -y @brainervirus/workit-cli@${version} check ${args}`;
 }
-var SCRIPT_CHECKS, CHECKS_FILE = "workit.checks.json", checksConfigFile = (root) => path.join(root, CHECKS_FILE), isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value), SHELL_META, git = (cwd, args) => {
+var SCRIPT_CHECKS, CHECKS_FILE = ".workit/checks.json", LEGACY_CHECKS_FILE = "workit.checks.json", isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value), SHELL_META, git = (cwd, args) => {
   const run = spawnSync("git", args, {
     cwd,
     encoding: "utf8",
@@ -15647,6 +15667,10 @@ function checkSupersede(context, type, row = {}) {
   return problem ? err("invalid_input", `--supersedes: ${problem}`) : { ok: true, value: undefined };
 }
 function recordDecision(context, input) {
+  if (input.by !== undefined && input.by !== "decider")
+    return err("invalid_input", `--by takes "decider", got "${input.by}"`);
+  if (input.by === undefined && input.views?.length)
+    return err("invalid_input", "--view needs --by decider");
   const what = required2(input.what, "<what>");
   if (!what.ok)
     return what;
@@ -15661,7 +15685,9 @@ function recordDecision(context, input) {
     type: "decision",
     what: what.value,
     why: why.value,
-    refs: input.refs ?? []
+    refs: input.refs ?? [],
+    ...input.by === "decider" ? { by: "decider" } : {},
+    ...input.views?.length ? { views: input.views } : {}
   }, { now: context.now });
 }
 function recordRuling(context, input) {
@@ -15828,15 +15854,19 @@ function rowLabels(row) {
     labels.push("ignored");
   if (row.type === "verdict" && row.self === true)
     labels.push("self");
+  if (row.type === "decision" && row.by === "decider")
+    labels.push("decider");
   return labels;
 }
 function summarizeRow(row) {
   const text = (key) => str2(row[key]) ?? "";
   let summary;
   switch (row.type) {
-    case "decision":
-      summary = `${text("what")} (why: ${text("why")})`;
+    case "decision": {
+      const views = Array.isArray(row.views) ? row.views.map(String) : [];
+      summary = `${row.by === "decider" ? "[decider] " : ""}${text("what")} (why: ${text("why")}${views.length ? `; views: ${views.join(" | ")}` : ""})`;
       break;
+    }
     case "ruling":
       summary = `${text("what")} (why: ${text("why")}; cost if wrong: ${text("costIfWrong")})`;
       break;
@@ -16445,7 +16475,7 @@ var RULES, derived2 = (spec) => ({
     };
   const since = Date.parse(task.createdAt);
   const branch = ledger.branch();
-  const row = ledger.rows().findLast((item) => item.type === "decision" && !item.superseded && (item.branch ?? null) === branch && Date.parse(item.at) >= since);
+  const row = ledger.rows().findLast((item) => item.type === "decision" && item.by !== "decider" && !item.superseded && (item.branch ?? null) === branch && Date.parse(item.at) >= since);
   return row ? { met: true, reason: `ledger decision ${row.id} records the choice`, decisionIds: [] } : {
     met: false,
     reason: 'open product choice: ask the user, then `workit ledger decision "<choice>" --why "<reason>"` (or, if it is not open, `workit policy assess --judge product-choice=no --why "<reason>"`)',
@@ -16680,7 +16710,7 @@ function evaluateObservedGate(task, requirement, statuses, config) {
     return {
       satisfied: [],
       considered,
-      reason: requirement.dimension === "testing" && config.checks.length ? `no \`test\` check is configured; add one (or gates.testing) to ${CHECKS_FILE}, then run ${checkCommand("test", runtimeVersion())}` : `no checks are configured or detected; add ${CHECKS_FILE} (committed, so it shows in the diff), e.g. {"checks":{"test":"<your test command>"}}, then run ${checkCommand("test", runtimeVersion())}`
+      reason: requirement.dimension === "testing" && config.checks.length ? `no \`test\` check is configured; add one (or gates.testing) to ${CHECKS_FILE}, then run ${checkCommand("test", runtimeVersion())}` : `no checks are configured or detected; add ${CHECKS_FILE}, e.g. {"checks":{"test":"<your test command>"}}, then run ${checkCommand("test", runtimeVersion())}`
     };
   const satisfied = fresh.filter(named);
   if (satisfied.length)
@@ -66219,6 +66249,7 @@ import {
   readdirSync as readdirSync8,
   readFileSync as readFileSync14,
   readlinkSync as readlinkSync2,
+  renameSync as renameSync4,
   rmSync as rmSync3,
   statSync as statSync5,
   unlinkSync as unlinkSync3,
@@ -67995,6 +68026,36 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
     status: "pass",
     detail: "no hook passed its deadline in the last day"
   };
+}, checkChecksConfig = (res) => {
+  const root = checkRoot(res.cwd);
+  const current = existsSync14(path34.join(root, CHECKS_FILE));
+  const legacy = existsSync14(path34.join(root, LEGACY_CHECKS_FILE));
+  if (!legacy)
+    return {
+      id: "checks_config",
+      status: "pass",
+      detail: current ? `${CHECKS_FILE} is the checks config` : "no per-repo checks config at the root"
+    };
+  return {
+    id: "checks_config",
+    status: "warn",
+    detail: current ? `${LEGACY_CHECKS_FILE} at the repo root is ignored: ${CHECKS_FILE} wins` : `${LEGACY_CHECKS_FILE} at the repo root is a legacy location, still read`,
+    fix: current ? `delete ${LEGACY_CHECKS_FILE} once ${CHECKS_FILE} has what you need` : "workit doctor --fix (moves it to .workit/checks.json)"
+  };
+}, fixChecksConfig = (options = {}) => {
+  const root = checkRoot(resolve(options).cwd);
+  const from = path34.join(root, LEGACY_CHECKS_FILE);
+  const to = path34.join(root, CHECKS_FILE);
+  if (!existsSync14(from))
+    return { action: "none", detail: `no ${LEGACY_CHECKS_FILE} at ${root}` };
+  if (existsSync14(to))
+    return {
+      action: "skipped",
+      detail: `${CHECKS_FILE} already exists; ${LEGACY_CHECKS_FILE} left in place`
+    };
+  ensureWorkitDir(root);
+  renameSync4(from, to);
+  return { action: "moved", detail: `${LEGACY_CHECKS_FILE} -> ${CHECKS_FILE}` };
 }, CLAUDE_PLUGIN_PACKAGE = "@brainervirus/workit-claude-code", versionBehind = (version, latest) => version !== latest && semverAtLeast(latest, version), checkClaudePlugin = (res) => {
   const installs = claudeWorkitInstalls(res.home, res.env, res.cwd);
   if (installs.length === 0)
@@ -68181,6 +68242,7 @@ var init_doctor = __esm(() => {
   init_branch_policy();
   init_config();
   init_logger();
+  init_check_config();
   init_heavy_scope();
   init_package_root();
   init_registration();
@@ -68222,7 +68284,8 @@ var init_doctor = __esm(() => {
     checkGitLabIdentity,
     checkLogWritable,
     checkHeavyScope,
-    checkHookDeadline
+    checkHookDeadline,
+    checkChecksConfig
   ];
   INSTALLER_REQUIRED = new Set([
     "runtime",
@@ -68247,7 +68310,7 @@ import {
   readFileSync as readFileSync15,
   readdirSync as readdirSync9,
   realpathSync as realpathSync7,
-  renameSync as renameSync4,
+  renameSync as renameSync5,
   rmSync as rmSync4,
   statSync as statSync6,
   writeFileSync as writeFileSync8
@@ -68536,7 +68599,7 @@ function applyMutation(m) {
             detail: "workspace config changed while applying the preview; rebuild and review it"
           };
         }
-        renameSync4(tmp, m.path);
+        renameSync5(tmp, m.path);
       } catch (error) {
         rmSync4(tmp, { force: true });
         return {
@@ -68729,12 +68792,12 @@ function copyPluginDir(src, dest) {
       throw new Error("staged adapter resolved to a symlink — refusing fragile cache install");
     }
     if (hadDir)
-      renameSync4(dest, backup);
+      renameSync5(dest, backup);
     try {
-      renameSync4(stage, dest);
+      renameSync5(stage, dest);
     } catch (error) {
       if (hadDir && !existsSync15(dest))
-        renameSync4(backup, dest);
+        renameSync5(backup, dest);
       throw error;
     }
     rmSync4(backup, { recursive: true, force: true });
@@ -69257,7 +69320,7 @@ var init_setup = __esm(() => {
 });
 
 // packages/workit-core/src/core/workspace-branch-policy.ts
-import { mkdirSync as mkdirSync8, readFileSync as readFileSync16, renameSync as renameSync5, rmSync as rmSync5, writeFileSync as writeFileSync9 } from "node:fs";
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync16, renameSync as renameSync6, rmSync as rmSync5, writeFileSync as writeFileSync9 } from "node:fs";
 import path36 from "node:path";
 import { isDeepStrictEqual as isDeepStrictEqual3 } from "node:util";
 function applyWorkspaceBranchPolicy(opts) {
@@ -69335,7 +69398,7 @@ function applyWorkspaceBranchPolicy(opts) {
         error: `workspaces.json changed while applying the branch policy: ${wsPath}`
       };
     }
-    renameSync5(tmp, wsPath);
+    renameSync6(tmp, wsPath);
   } catch (error) {
     try {
       rmSync5(tmp, { force: true });
@@ -73936,6 +73999,17 @@ async function run6(argv, io) {
       };
     }
   }
+  let checksConfig = null;
+  if (argv.includes("--fix")) {
+    try {
+      checksConfig = fixChecksConfig({ host: "cli", cwd: io.cwd });
+    } catch (error) {
+      checksConfig = {
+        action: "failed",
+        detail: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
   const report = runDoctor({
     host: "cli",
     cwd: io.cwd,
@@ -73958,7 +74032,7 @@ async function run6(argv, io) {
       budget: knowledge.budget,
       findings: knowledge.findings.length
     } : { unavailable: true };
-    io.stdout(`${JSON.stringify({ ...report, ...fixLock ? { fixLock } : {}, ...sessionHook ? { sessionHook } : {}, knowledge: summary }, null, 2)}
+    io.stdout(`${JSON.stringify({ ...report, ...fixLock ? { fixLock } : {}, ...sessionHook ? { sessionHook } : {}, ...checksConfig ? { checksConfig } : {}, knowledge: summary }, null, 2)}
 `);
     return report.exitCode;
   }
@@ -73969,6 +74043,9 @@ async function run6(argv, io) {
   }
   if (sessionHook)
     io.stdout(`fix: session hook ${sessionHook.action}: ${sessionHook.detail}
+`);
+  if (checksConfig && checksConfig.action !== "none")
+    io.stdout(`fix: checks config ${checksConfig.action}: ${checksConfig.detail}
 `);
   io.stdout(`workit doctor — ${report.ok ? "healthy" : "problems found"} (${report.offline ? "offline" : "online"})
 `);
@@ -75824,6 +75901,9 @@ async function run10(argv, io) {
   if (options instanceof Error)
     return emit(io, fail("invalid_input", options.message, { unblock: USAGE3 }));
   const config = loadCheckConfig(io.cwd);
+  if (config.note)
+    io.stderr(`note: ${config.note}
+`);
   const top = checkRoot(io.cwd);
   let command;
   let runCwd = io.cwd;
@@ -75838,7 +75918,7 @@ async function run10(argv, io) {
     if (!check)
       return emit(io, fail("not_found", `no configured check named "${name}"`, {
         data: { configured: config.checks.map((item) => item.name), source: config.source },
-        unblock: config.checks.length ? `workit check ${config.checks.map((item) => item.name).join("|")}` : `add {"checks":{"${name}":"<command>"}} to workit.checks.json, or run workit check --name ${name} -- <cmd…>`
+        unblock: config.checks.length ? `workit check ${config.checks.map((item) => item.name).join("|")}` : `add {"checks":{"${name}":"<command>"}} to .workit/checks.json, or run workit check --name ${name} -- <cmd…>`
       }));
     command = check.argv;
     runCwd = config.root;
@@ -84795,7 +84875,8 @@ var DEFAULT_TIMEBOX = "30 minutes", REPORT, identityOf = (host) => {
     '  2. Decide ambiguities yourself: `workit ledger ruling "<what>" --why "<why>" --cost-if-wrong "<cost>"`; stop only for an irreversible, security-sensitive or out-of-worktree action.',
     plain ? '  3. Commit with plain `git commit -m <msg> --trailer "Workit-Session: <the WORKIT_SESSION_ID in your env>" --trailer "<your host attribution trailer>" -- <paths in SCOPE>`; push only if this brief says so.' : "  3. Commit with `workit git commit -m <msg> -- <paths in SCOPE>`; push only if this brief says so.",
     "  4. Never record a verdict on your own work.",
-    "  5. Run tests, lint, typecheck and builds only through `workit check` (a named check, or `workit check --heavy -- <cmd>`): one machine-wide lease queues every agent, so never a hand-made flock; `workit lock status` shows who holds it."
+    "  5. Run tests, lint, typecheck and builds only through `workit check` (a named check, or `workit check --heavy -- <cmd>`): one machine-wide lease queues every agent, so never a hand-made flock; `workit lock status` shows who holds it.",
+    "  6. A failed review gets one fix round and one recheck. Still failing: stop and report the open finding, never a third round (the lead spawns a decider). A product choice is the user's: report it, do not decide it."
   ];
 }, sessionSafe = (text) => text.replace(/[^A-Za-z0-9_.:@/+-]/gu, "-"), SESSION_MAX = 128;
 var init_fanout_brief = __esm(() => {
@@ -85889,7 +85970,13 @@ async function run19(argv, io) {
     return result;
   };
   if (sub === "decision")
-    return fromResult(io, await recorded(recordDecision(context, { what: text, why: values.why, refs: values.ref })), (row) => `recorded decision ${row.id}`);
+    return fromResult(io, await recorded(recordDecision(context, {
+      what: text,
+      why: values.why,
+      refs: values.ref,
+      by: values.by,
+      views: values.view
+    })), (row) => `recorded decision ${row.id}`);
   if (sub === "ruling")
     return fromResult(io, await recorded(recordRuling(context, {
       what: text,
@@ -86062,6 +86149,8 @@ var init_ledger2 = __esm(() => {
     why: { type: "string" },
     "cost-if-wrong": { type: "string" },
     ref: { type: "string", multiple: true },
+    by: { type: "string" },
+    view: { type: "string", multiple: true },
     how: { type: "string" },
     kind: { type: "string" },
     surface: { type: "string" },
@@ -102082,7 +102171,7 @@ import {
   readFileSync as readFileSync24,
   readlinkSync as readlinkSync3,
   realpathSync as realpathSync9,
-  renameSync as renameSync6,
+  renameSync as renameSync7,
   rmSync as rmSync8,
   statSync as statSync9,
   symlinkSync,
@@ -102259,7 +102348,7 @@ function writeInside(copy, file, content) {
   }
   const temp = `${target}.workit-mutant-${process.pid}`;
   writeFileSync11(temp, content);
-  renameSync6(temp, target);
+  renameSync7(temp, target);
   return true;
 }
 function copyWorkingTree(repo) {
@@ -102688,7 +102777,7 @@ usage: ${USAGE12}`));
     const runner = testCommand(repo, io.cwd, options.testCmd);
     if (!runner)
       return emit(io, fail("unavailable", "no test command for --mutate", {
-        unblock: 'workit test-audit --mutate --test-cmd "<runner> {files}" (or configure a `test` check in workit.checks.json)'
+        unblock: 'workit test-audit --mutate --test-cmd "<runner> {files}" (or configure a `test` check in .workit/checks.json)'
       }));
     try {
       mutation = await runMutation({
@@ -103586,8 +103675,8 @@ var VERBS = [
     subcommands: [
       {
         name: "decision",
-        usage: `workit ledger decision "<what>" --why "<why>" [--ref <path|url>]… ${LEDGER_ACTOR}`,
-        summary: "Record a decision and why"
+        usage: `workit ledger decision "<what>" --why "<why>" [--by decider [--view "<view>"]…] [--ref <path|url>]… ${LEDGER_ACTOR}`,
+        summary: "Record a decision and why; --by decider marks a tie-breaker agent's call (not the user's answer, not a verdict)"
       },
       {
         name: "ruling",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-claude-code",
-  "version": "8.17.1",
+  "version": "8.18.0",
   "private": false,
   "description": "Workit Claude Code plugin — session and per-turn task context, branch policy on git shell commands, workit method skills, and verifier/reviewer/implementer agents",
   "keywords": [
@@ -39,8 +39,8 @@
     "build": "bun scripts/build.ts"
   },
   "devDependencies": {
-    "@brainervirus/workit-cli": "^8.17.1",
-    "@brainervirus/workit-core": "^8.17.1"
+    "@brainervirus/workit-cli": "^8.18.0",
+    "@brainervirus/workit-core": "^8.18.0"
   },
   "engines": {
     "node": ">=24"

package/skills/bdd/SKILL.md

@@ -22,7 +22,7 @@ description: Turn requirements into Given/When/Then scenarios, agree the test se
    then take the next scenario. Any edit makes the observation stale; re-run
    before you claim it. A recorded "tests pass" is a note, and an ad-hoc
    `workit check -- <cmd>` never satisfies the gate: only the configured
-   `test` check does. No `test` detected? Create `workit.checks.json`, copying
+   `test` check does. No `test` detected? Create `.workit/checks.json`, copying
    in every check the repo already runs: once it exists it replaces the
    detected defaults.
 5. **Mock only at system boundaries:** network, clock, randomness, other

package/skills/fanout/SKILL.md

@@ -37,8 +37,8 @@ units of ~100+ lines each. Coupled work stays with one owner. Workit never spawn
 6. **Retry once, then escalate.** A stuck or failed slice gets one retry with
    a fresh brief (`workit fanout brief <slice> --mode resume`, same branch);
    if that fails too, re-slice it, take it over, or report the gap. Never
-   chain resumes. A hard slice may race instead: N attempts, keep the best
-   verdict (`references/orchestration.md`).
+   chain resumes. A fix round and recheck that both fail: a decider, not a
+   third round; product choices go to the user (`references/orchestration.md`).
 7. **Verify by the workspace `verification` setting** (`workit grant show`).
    A report is a pointer, never evidence. `self`: a verifier that wrote none
    of the slices, or you if you wrote none. `independent` or high risk: a

package/skills/fanout/references/orchestration.md

@@ -43,6 +43,27 @@ rulings). If the retry fails too, escalate instead of a third worker:
 re-slice it smaller (`workit fanout plan` again), take it over yourself, or
 report the gap to the user.
 
+## Stuck calls: the decider
+
+A failed review gets one fix round and one recheck (the changed hunks only).
+If the recheck fails, or a worker and a reviewer disagree, spawn a decider
+instead of a third round. A decider is a fresh read-only agent, not the author
+or the reviewer. It returns three things: the options, a pick by
+reversibility (the option cheapest to undo wins a tie), and the exact change
+list. The fixer applies that list once, then one focused recheck follows.
+
+- Hard call (shared contract, security, migration): two deciders on different
+  models (Claude Code: a different `model` on the Agent call; OpenCode: a
+  child session on another configured agent; Codex, Cursor and Pi: one
+  decider, since the host picks no model). If they disagree, you take the
+  more reversible option.
+- Record it: `workit ledger decision "<pick>" --by decider --why "<why it is
+  the more reversible>" --view "<decider A: view>" --view "<decider B: view>"`.
+  The row is listed as a decider call; it is never the user's answer to a
+  product choice and never a verdict.
+- A product choice, or authority nobody here has, is not a decider's call:
+  ask the user with your recommendation.
+
 ## Race a hard slice
 
 When a hard slice has an uncertain approach and a cheap VERIFY, run 2-3

package/skills/retro/SKILL.md

@@ -32,7 +32,7 @@ proposes and stops. Nothing changes until the user approves.
    more cited occurrences**; a one-off is not a learning.
 4. **Name the strongest enforcer that works**, strongest first: architecture
    or types (the mistake cannot be written) > lint rule > configured check
-   (`workit.checks.json`, `workit check <name>`) or CI job > test >
+   (`.workit/checks.json`, `workit check <name>`) or CI job > test >
    `CODING_STANDARDS.md` (judgment the reviewer reads) > AGENTS.md pointer
    (navigation only). A mechanical rule gets a check, not prose: a check can
    fail, a sentence cannot. From types to test, the proof is that the new
@@ -60,7 +60,7 @@ Bad: "Agents seem lost in the build. Added 'read the build docs carefully' to
 AGENTS.md." One vague occurrence, no citation, a no-op line, auto-applied.
 
 Good: "Navigation, 3 occurrences (rulings 12, 19; PR #88 thread): agents sought
-check names in package.json, missing `workit.checks.json`. Enforcer: AGENTS.md
+check names in package.json, missing `.workit/checks.json`. Enforcer: AGENTS.md
 pointer, +74 bytes, minus the stale Commands paragraph (-210). Unstable check,
 2 occurrences (ledger rows 31, 44: `e2e` red then green on one SHA): a debug
 slice to fix the check. Approve?"

package/skills/review/SKILL.md

@@ -36,7 +36,10 @@ independent; `type-check-only` never proves a behavior change.
 7. Record the verdict:
    `workit ledger verdict verified|failed|blocked --kind review --branch <b> --how "<what you ran and read>"`
    under your own session (the one the lead or the hook gave you).
-8. **Harness note** (optional): friction caused by the repo or harness, not
+8. **Bound the loop.** A failed verdict gets one fix round and one recheck of
+   the changed hunks. Still failing, or stuck: no third round; the lead spawns
+   a decider (call the Skill tool with `workit:fanout`). A product choice goes to the user.
+9. **Harness note** (optional): friction caused by the repo or harness, not
    the change (a flaky fixture, a missing check, a misleading doc or skill
    line), goes on its own `Harness note:` line in the report and any PR
    comment, never as a finding or in the verdict, so a later retro finds it.

package/skills/ship/SKILL.md

@@ -30,7 +30,7 @@ once the verdict is accepted. `merged`: step 7. `null` (closed, not merged):
 stop and report. Stop early only for a new consequential choice, a host
 denial, a review comment that needs a product decision, a required update
 that repeats because the base keeps moving, or after 3 failed fix attempts on
-the same check.
+the same check. Fix round and recheck both failed: a decider (call the Skill tool with `workit:fanout`).
 
 1. **Open.** `workit git push`, then `workit pr create --title "<title>"
    --body-file <f|->` plus `--issue <#n|ID>` per issue (`--refs`: no close; idempotent;

package/skills/verify-app/SKILL.md

@@ -35,7 +35,7 @@ way a user would.
    never run is a guess; do not hand it off.
 4. **Make the driver a named check** when it is cheap and deterministic. A
    named check is one command without shell syntax (put pipes and setup in a
-   script). Add `"verify": "<driver>"` to `checks` in `workit.checks.json`; if
+   script). Add `"verify": "<driver>"` to `checks` in `.workit/checks.json`; if
    the file does not exist yet, first copy in every check the repo already runs
    (test, lint, typecheck), because the file replaces the detected defaults.
    `workit check verify` then records it, and it joins the verification gate