@dougharness/cli 1.5.0 → 1.6.0

package/node_modules/@dougharness/flow/scripts/memory.mjs

@@ -162,7 +162,7 @@
 //                                                 ids that the card's fetched.jsonl lists; verified true; passes = --rounds, default 1; one fixed
 //                                                 blocker ledger entry per --review id), then reflects on it
 //                                                 exactly as above. --commit is required (exit 2). No schema change.
-//   memory.mjs reflect --failures <card-id> [dir] [--session <id>] [--claude-bin <path>] [--model <name>] [--max-usd <n>] [--dry-run] [--json]
+//   memory.mjs reflect --failures <card-id> [dir] [--session <id>] [--claude-bin <path>] [--model <name>] [--max-usd <n>] [--detach] [--dry-run] [--json]
 //                                                 (card memory-failure-lessons) the failure pass: reads the card's
 //                                                 run history for stopped reports, blocks classed real and
 //                                                 denials, prints the item count with the blocks it hid by class
@@ -172,7 +172,10 @@
 //                                                 .doug/.state/memory/pitfalls.jsonl (no new lesson, no helpful).
 //                                                 Exclusive with --hand and a report path (exit 2); idempotent on
 //                                                 the slice; --dry-run makes no model call and prints the prompt it would send;
-//                                                 not wired into any loop (its spend cap is open)
+//                                                 --detach runs it as job failures-<card>; autopilot and doug-hand start it
+//                                                 so when a card stops, --max-usd 0.5 on the cheap row (user, 2026-10-28).
+//                                                 A real block with the same class on a file a live pitfall's recorded
+//                                                 occurrence names is a code-side repeat (via 'file'); empty files never match
 //   memory.mjs ideas [dir] [--claude-bin <path>] [--model <name>] [--max-usd <n>] [--cap <n>] [--dry-run] [--json]
 //                                                 (card memory-idea-proposals, ADR 0019 L3) one cheap-row `claude
 //                                                 -p --json-schema` call (--max-usd default 0.5) over the live
@@ -275,15 +278,15 @@
 //                                                 remove: [{line,enforcedBy,source}], note }); writes only a diff
 //                                                 under .doug/.state/learn/, never CLAUDE.md itself; refuses when
 //                                                 an edit would touch the Models section or the fenced Commands
-//                                                 block, or would push CLAUDE.md over 60 lines. Approve and write
+//                                                 block, or would push CLAUDE.md over 200 lines. Approve and write
 //                                                 it with `learn.mjs apply <diff>`
 // lesson add and import embed only the row(s) they just wrote, best-effort, when a provider is configured: a
 // provider failure prints one stderr line and never turns into a nonzero exit for that add/import. A pending
 // row from an earlier add is left alone until `reembed` (or a later add/import) picks it up.
-import { readFileSync, existsSync, mkdirSync, writeFileSync, readdirSync, appendFileSync, statSync } from "node:fs";
+import { readFileSync, existsSync, mkdirSync, writeFileSync, readdirSync, appendFileSync, statSync, openSync, closeSync, renameSync, linkSync, unlinkSync } from "node:fs";
 import { resolve, join, dirname } from "node:path";
 import { createHash } from "node:crypto";
-import { spawnSync } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { parseAdversaryClasses, loadBoard, saveBoard, findCard } from "../lib/board.mjs";
 import { planFor, unwrapReport } from "../lib/plan.mjs";
 import { costRun } from "../lib/cost.mjs";
@@ -301,7 +304,7 @@ import {
 } from "../lib/embeddings.mjs";
 
 const argv = process.argv.slice(2);
-const FLAGS = new Set(["json", "all", "hand", "dry-run", "check", "no-check", "unconfirmed"]);
+const FLAGS = new Set(["json", "all", "hand", "dry-run", "check", "no-check", "unconfirmed", "detach", "earlier"]);
 const REPEATABLE = new Set(["adversary", "review", "harmful"]);
 const opts = {};
 const positional = [];
@@ -326,8 +329,145 @@ function fail(msg, code = 1) {
   process.exit(code);
 }
 
+// Card detach-background-chores: start `reflect` (or any command) as a detached job and read it later with
+// `memory.mjs job <name>`. State lives in <dir>/.doug/.state/jobs/<name>.json (pid, argv, startedAt, and on exit
+// exitCode/signal/endedAt, written by the runner); stdout and stderr go to <name>.log, never to the caller's
+// pipes, so the caller returns at once.
+function jobPaths(dir, name) {
+  const jobs = join(dir, ".doug", ".state", "jobs");
+  return { jobs, file: join(jobs, `${name}.json`), log: join(jobs, `${name}.log`) };
+}
+
+function readJobFile(file) {
+  try {
+    return JSON.parse(readFileSync(file, "utf8")) || {};
+  } catch {
+    return null;
+  }
+}
+
+// A job file is replaced whole (write a temp file, rename it over), so a concurrent reader never sees a truncated
+// file. `ifAbsent` links the temp file in instead, so the start command never overwrites a result the runner wrote
+// (startDetachedJob removes an ended job's old file first, so the new start record is linked in fresh).
+function writeJobFile(file, state, ifAbsent = false) {
+  const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  writeFileSync(tmp, JSON.stringify(state, null, 2) + "\n", "utf8");
+  try {
+    if (ifAbsent) linkSync(tmp, file);
+    else renameSync(tmp, file);
+  } catch (err) {
+    if (!ifAbsent || !err || err.code !== "EEXIST") throw err;
+  } finally {
+    if (ifAbsent) {
+      try {
+        unlinkSync(tmp);
+      } catch {}
+    }
+  }
+}
+
+function startDetachedJob(dir, name, command) {
+  const { jobs, file, log } = jobPaths(dir, name);
+  mkdirSync(jobs, { recursive: true });
+  // A name is reusable once its job ended or its process is gone; a live job holding it is never touched.
+  const held = readJobFile(file);
+  if (held && held.endedAt === undefined && held.exitCode === undefined && !held.signal && pidAlive(held.pid)) {
+    fail(`job ${name} is already running (pid ${held.pid}); read it with: memory.mjs job ${name}`, 1);
+  }
+  try {
+    unlinkSync(file);
+  } catch {}
+  const fd = openSync(log, "w");
+  const startedAt = new Date().toISOString();
+  let child;
+  try {
+    child = spawn(process.execPath, [process.argv[1], "__jobrun", dir, name, "--", ...command], {
+      detached: true,
+      stdio: ["ignore", fd, fd],
+      cwd: process.cwd(),
+      env: process.env,
+    });
+    child.unref();
+  } finally {
+    closeSync(fd);
+  }
+  writeJobFile(file, { name, argv: command, pid: child.pid, startedAt }, true);
+  return { name, pid: child.pid };
+}
+
+// The detached runner: runs `command` with the log as its stdout/stderr, then records how it ended.
+async function runJob(dir, name, command) {
+  const { file } = jobPaths(dir, name);
+  // Only this runner's own start record (same pid) lends startedAt and argv; nothing else carries over.
+  const prior = readJobFile(file) || {};
+  const own = prior.pid === process.pid;
+  const state = { name, argv: own && prior.argv ? prior.argv : command, startedAt: own && prior.startedAt ? prior.startedAt : new Date().toISOString(), pid: process.pid };
+  writeJobFile(file, state);
+  const end = await new Promise((resolveEnd) => {
+    const c = spawn(command[0], command.slice(1), { stdio: "inherit", cwd: process.cwd(), env: process.env });
+    c.on("error", (err) => {
+      process.stderr.write(`job: cannot start ${command[0]}: ${err.message}\n`);
+      resolveEnd({ exitCode: 127, signal: null });
+    });
+    c.on("close", (code, signal) => resolveEnd({ exitCode: code, signal }));
+  });
+  const done = { ...state, exitCode: end.exitCode, signal: end.signal, endedAt: new Date().toISOString() };
+  writeJobFile(file, done);
+}
+
+// One job's state as { state: "pending"|"done"|"failed", line, st }; null when there is no job file.
+function jobStatus(dir, name) {
+  const { file, log } = jobPaths(dir, name);
+  const st = readJobFile(file);
+  if (!st) return null;
+  let lines = [];
+  try {
+    lines = readFileSync(log, "utf8").split("\n");
+  } catch {
+    lines = [];
+  }
+  const ended = st.endedAt !== undefined || st.exitCode !== undefined || st.signal;
+  const lastLine = () => lines.map((l) => l.trim()).filter(Boolean).slice(-1)[0] || "";
+  if (!ended) {
+    if (pidAlive(st.pid)) return { state: "pending", line: `${name}: pending (started ${st.startedAt}, pid ${st.pid})`, st };
+    return { state: "failed", line: `${name}: failed (the job process ${st.pid} is gone and wrote no result)${lastLine() ? `; last output: ${lastLine()}` : ""}`, st };
+  }
+  if (st.exitCode === 0 && !st.signal) {
+    const secs = st.endedAt && st.startedAt ? Math.max(0, Math.round((Date.parse(st.endedAt) - Date.parse(st.startedAt)) / 1000)) : null;
+    return { state: "done", line: `${jobSummaryLine(lines)}${secs === null ? "" : ` (job ${name}, ${secs} s)`}`, st };
+  }
+  return { state: "failed", line: `${name}: failed (${st.signal ? `signal ${st.signal}` : `exit ${st.exitCode}`})${lastLine() ? `: ${lastLine()}` : ""}`, st };
+}
+
+// Mark a finished job as read, so a later landing's `job --earlier` does not report it again.
+function markJobReported(dir, name, st) {
+  try {
+    writeJobFile(jobPaths(dir, name).file, { ...st, reportedAt: new Date().toISOString() });
+  } catch {}
+}
+
+function pidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return !!err && err.code === "EPERM";
+  }
+}
+
+function jobSummaryLine(lines) {
+  const nonEmpty = lines.filter((l) => l.trim());
+  const reflected = nonEmpty.filter((l) => /(?:^|\) )(?:Reflected on |Already reflected on )/.test(l));
+  if (reflected.length) return reflected[reflected.length - 1];
+  const flush = nonEmpty.filter((l) => !/^\s/.test(l));
+  return (flush.length ? flush : nonEmpty).slice(-1)[0] || "";
+}
+
 function dirFrom(args, n) {
-  return resolve(process.env.CLAUDE_PROJECT_DIR || args[n] || process.cwd());
+  const d = resolve(process.env.CLAUDE_PROJECT_DIR || args[n] || process.cwd());
+  if (!existsSync(join(d, ".doug"))) fail(`not a Doug project: ${d} has no .doug/`, 1);
+  return d;
 }
 
 function verifiedWord(v) {
@@ -771,7 +911,7 @@ try {
         'usage: memory.mjs reflect <report.json> [dir] [--run <wf-id>] [--card <id>] [--commit <sha>] [--adversary "<id>=<class>[: <reason>]"]... [--harmful <id>]... [--claude-bin <path>] [--claude-dir <path>] [--model <name>] [--max-usd <n>] [--dry-run] [--json]';
       if (opts.failures !== undefined) {
         const failuresUsage =
-          "usage: memory.mjs reflect --failures <card-id> [dir] [--session <id>] [--claude-bin <path>] [--model <name>] [--max-usd <n>] [--dry-run] [--json]";
+          "usage: memory.mjs reflect --failures <card-id> [dir] [--session <id>] [--claude-bin <path>] [--model <name>] [--max-usd <n>] [--detach] [--dry-run] [--json]";
         const card = textOrNull(opts.failures);
         if (!card || opts.hand) fail(`${failuresUsage}\n--failures takes a card id and is exclusive with --hand and a report path.`, 2);
         if (rest.length > 1) fail(failuresUsage, 2);
@@ -786,6 +926,11 @@ try {
           if (isFile) fail(`${failuresUsage}\n--failures takes a card id and is exclusive with --hand and a report path.`, 2);
         }
         const fdir = dirFrom(rest, 0);
+        if (opts.detach) {
+          const started = startDetachedJob(fdir, `failures-${card}`, [process.execPath, process.argv[1], ...argv.filter((a) => a !== "--detach")]);
+          process.stdout.write(`${started.name}: started detached (pid ${started.pid}); read it with: memory.mjs job ${started.name}\n`);
+          break;
+        }
         const fmodels = loadModels(fdir);
         const fmodel = textOrNull(opts.model) || (fmodels.tiers.cheap && fmodels.tiers.cheap.model) || "haiku";
         let fmaxUsd = 0.5;
@@ -874,6 +1019,11 @@ try {
         } catch (err) {
           fail(`${handUsage}\n${err.message}`, 2);
         }
+        if (opts.detach) {
+          const started = startDetachedJob(dir, `reflect-${id}`, [process.execPath, process.argv[1], ...argv.filter((a) => a !== "--detach")]);
+          process.stdout.write(`${started.name}: started detached (pid ${started.pid}); read it with: memory.mjs job ${started.name}\n`);
+          break;
+        }
         const base = join(dir, ".doug", ".state", "reports", id);
         const readDirFiles = (sub) => {
           const d = join(base, sub);
@@ -958,6 +1108,12 @@ try {
           fail(`cannot parse report file ${reportPath} as JSON: ${err.message}`);
         }
         classes = parseAdversaryClasses(opts.adversary || []);
+        if (opts.detach) {
+          const tag = textOrNull(opts.card) || textOrNull(opts.run) || createHash("sha256").update(reportText).digest("hex").slice(0, 12);
+          const started = startDetachedJob(dir, `reflect-${tag}`, [process.execPath, process.argv[1], ...argv.filter((a) => a !== "--detach")]);
+          process.stdout.write(`${started.name}: started detached (pid ${started.pid}); read it with: memory.mjs job ${started.name}\n`);
+          break;
+        }
       }
       const reportHash = createHash("sha256").update(reportText).digest("hex");
       const plan = planFor(dir, opts.card);
@@ -1051,6 +1207,59 @@ try {
       }
       break;
     }
+    case "__jobrun": {
+      const raw = process.argv.slice(2);
+      const sep = raw.indexOf("--");
+      if (sep < 3 || sep === raw.length - 1) fail("usage: memory.mjs __jobrun <dir> <name> -- <command> [args...]", 2);
+      await runJob(raw[1], raw[2], raw.slice(sep + 1));
+      break;
+    }
+    case "job": {
+      const usage = "usage: memory.mjs job <name> [dir] [--wait <seconds>] | memory.mjs job --earlier [dir]";
+      if (opts.earlier) {
+        // Earlier landings' jobs nobody has read yet: pending, failed, or finished with the summary never printed.
+        const edir = dirFrom(rest, 0);
+        const { jobs } = jobPaths(edir, "x");
+        let names = [];
+        try {
+          names = readdirSync(jobs).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -5));
+        } catch {
+          names = [];
+        }
+        let failed = false;
+        let any = false;
+        for (const n of names.sort()) {
+          const js = jobStatus(edir, n);
+          if (!js || js.st.reportedAt) continue;
+          any = true;
+          process.stdout.write(`earlier job ${js.line}\n`);
+          if (js.state === "failed") failed = true;
+          if (js.state !== "pending") markJobReported(edir, n, js.st);
+        }
+        if (!any) process.stdout.write("no earlier jobs unread\n");
+        if (failed) process.exit(1);
+        break;
+      }
+      const [name] = rest;
+      if (!name || !/^[A-Za-z0-9._-]+$/.test(name)) fail(usage, 2);
+      let waitSec = 0;
+      if (opts.wait !== undefined) {
+        waitSec = /^\d+$/.test(String(opts.wait)) ? Number(opts.wait) : NaN;
+        if (!Number.isInteger(waitSec)) fail(`${usage}\n--wait must be a whole number of seconds, got ${JSON.stringify(opts.wait)}.`, 2);
+      }
+      const jdir = dirFrom(rest, 1);
+      const deadline = Date.now() + waitSec * 1000;
+      let js = jobStatus(jdir, name);
+      if (!js) fail(`${name}: no such job in ${jdir}`, 1);
+      while (js.state === "pending" && Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, Math.min(500, Math.max(1, deadline - Date.now()))));
+        js = jobStatus(jdir, name) || js;
+      }
+      process.stdout.write(`${js.line}\n`);
+      if (js.state !== "pending") markJobReported(jdir, name, js.st);
+      if (js.state === "failed") process.exit(1);
+      break;
+    }
     case "outcomes": {
       const dir = dirFrom(rest, 0);
       const { openMemory, listOutcomes } = await import("../lib/memory.mjs");
@@ -2080,7 +2289,7 @@ try {
       break;
     }
     default:
-      fail("usage: memory.mjs <record|reflect|outcomes|arms|lessons|lesson|history|model|import|recall|brief-lessons|doctor|reembed|embed-check|index|condition|decision|rule|claude-md> ...", 2);
+      fail("usage: memory.mjs <record|reflect|job|outcomes|arms|lessons|lesson|history|model|import|recall|brief-lessons|doctor|reembed|embed-check|index|condition|decision|rule|claude-md> ...", 2);
   }
 } catch (err) {
   fail(err.message);

package/node_modules/@dougharness/flow/skills/doug-hand/SKILL.md

@@ -86,7 +86,7 @@ Before the commit the lead itself runs `node .doug/hooks/scripts/verify.mjs` (th
 
 Stay within the card's goal. A defect found on the way that the goal does not cover becomes a new hand-track card, not part of this commit.
 
-When a by-hand run stops a card after Start (a hook block it reports, a design question answered stop, a gate it cannot get green, an unresolved reviewer blocker, or the user saying stop), the lead runs the recording step once: `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" record <id> --hand --stop <reason> --detail "<one line>"`. `<reason>` is one of the card loop's stop reasons (`lib/card-loop.mjs` `STOP_REASONS`) or `user-stopped` when the user stopped it.
+When a by-hand run stops a card after Start (a hook block it reports, a design question answered stop, a gate it cannot get green, an unresolved reviewer blocker, or the user saying stop), the lead runs the recording step once: `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" record <id> --hand --stop <reason> --detail "<one line>"`. `<reason>` is one of the card loop's stop reasons (`lib/card-loop.mjs` `STOP_REASONS`) or `user-stopped` when the user stopped it. Then it starts the failure pass once, detached: `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" reflect --failures <id> --max-usd 0.5 --detach` (cheap row, capped at $0.5; the doug-hand start is the approval; user, 2026-10-28). A start that fails does not stop the card's hand-back.
 
 ## 4. Record and land
 
@@ -106,6 +106,8 @@ Follow-ups are filed without a question. A landing with no candidates files noth
 
 The lead says in the chat what it filed and where: each new card's id, title, and its Backlog position with the reason. Then one commit `"Board: <id> follow-ups added: <new-id>, <new-id>"`, whatever the count; the served page (`doug board serve`) shows the new cards without a republish. Batch: each card's deps name the card of the batch it came from; still one commit for the whole batch.
 
+Last read: after the landing commit and the follow-up step, and before the final message, the lead reads the reflect that `run-report` started detached: `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" job reflect-<id> --wait 120`. It polls until the job is done or failed, or 120 s have passed. Its line (reflect's one-line summary with the measured cost) goes in the chat. `pending` after the cap is said as pending in the chat and the landing goes on; the next landing's `run-report` reads it with `memory.mjs job --earlier`. A `failed` line (exit 1) is said in the chat with its reason and the landing goes on regardless: reflect is a log, not a gate. Batch: one read for the batch's job.
+
 ## Cards the user asks for
 
 A card the user asks for is a mini ADR, not a one-line goal. Before filing it, the lead asks the scoping questions in one `AskUserQuestion` of up to 4 questions, and writes the answers into the goal. The goal carries the fixed headings Context / Decision / Options / Questions; `docs/decisions` stays for real ADRs. Only a user-requested card takes this form: a follow-up the lead files keeps step 5's lighter form, so autopilot follow-ups stay question-free. The goal opens with the user's request quoted verbatim under Context, and each Decision line is marked (user answer) or (lead, not asked). One question names the broadest word in the user's request and offers its readings. An option is marked Recommended only when its description cites the fact it rests on, checked before asking; an option resting on an unchecked fact says (unverified) and is not Recommended, and a question with no checked option has no Recommended. When the user asked for research, "Let the research decide" is the Recommended option. A card the user asks for while autopilot runs is scoped at once with the same questions, filed to Backlog, and the queue resumes at the card it was on: the request is input, not a gate, and the running queue is unchanged.

package/node_modules/@dougharness/flow/skills/doug-next/SKILL.md

@@ -88,6 +88,8 @@ Follow-ups are filed without a question. A landing with no candidates files noth
 
 The lead says in the chat what it filed and where: each new card's id, title, and its Backlog position with the reason. Then one commit `"Board: <id> follow-ups added: <new-id>, <new-id>"`, whatever the count; the served page (`doug board serve`) shows the new cards without a republish. Batch: each card's deps name the card of the batch it came from; still one commit for the whole batch.
 
+Last read: after the landing commit and the follow-up step, and before the final message, the lead reads the reflect that `run-report` started detached: `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" job reflect-<card id, else the run id> (a batch: reflect-<run id>) --wait 120`. It polls until the job is done or failed, or 120 s have passed. Its line (reflect's one-line summary with the measured cost) goes in the chat. `pending` after the cap is said as pending in the chat and the landing goes on; the next landing's `run-report` reads it with `memory.mjs job --earlier`. A `failed` line (exit 1) is said in the chat with its reason and the landing goes on regardless: reflect is a log, not a gate. Batch: one read for the batch's job.
+
 ## Cards the user asks for
 
 A card the user asks for is a mini ADR, not a one-line goal. Before filing it, the lead asks the scoping questions in one `AskUserQuestion` of up to 4 questions, and writes the answers into the goal. The goal carries the fixed headings Context / Decision / Options / Questions; `docs/decisions` stays for real ADRs. Only a user-requested card takes this form: a follow-up the lead files keeps section 6's lighter form, so autopilot follow-ups stay question-free. The goal opens with the user's request quoted verbatim under Context, and each Decision line is marked (user answer) or (lead, not asked). One question names the broadest word in the user's request and offers its readings. An option is marked Recommended only when its description cites the fact it rests on, checked before asking; an option resting on an unchecked fact says (unverified) and is not Recommended, and a question with no checked option has no Recommended. When the user asked for research, "Let the research decide" is the Recommended option. A card the user asks for while autopilot runs is scoped at once with the same questions, filed to Backlog, and the queue resumes at the card it was on: the request is input, not a gate, and the running queue is unchanged.

package/node_modules/@dougharness/flow/skills/run-report/SKILL.md

@@ -19,8 +19,9 @@ With the card id, the report (`.doug/.state/last-report.json` unless another pat
 3. `node "${CLAUDE_PLUGIN_ROOT}/scripts/board.mjs" record <id> <report.json> --run <run-id> --wall "<m> min" --commit <sha> --cost <usd> --summary "<one sentence>" [--codex-cost <usd>] --adversary "F1=<class>: <reason>"` with `--adversary` repeated once per block, leaving `--cost` out when step 1 gave no number and `--codex-cost` out when step 1 showed no Codex line. This appends the entry to `docs/live-runs.md`: the measures table with the precision line (n real / n marginal / n false), the per-level, per-task table, and one line per classified block. It also promotes `.doug/.state/research/<id>.md` to `docs/research/<id>.md` when that note exists, printing one line saying so; add that path to the landing commit alongside `docs/live-runs.md`.
 4. `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" import`: rolls any auto-memory file written since the last import into the lessons store — it is idempotent, a rewritten file supersedes its old row, and it never writes under the auto-memory directory. Its one-line output goes in the chat; an exit 1 naming Node is said in the chat and the landing goes on, the same as record below.
 5. `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" record <report.json> --run <run-id> --card <id> --commit <sha> --adversary "F1=<class>: <reason>"` with `--adversary` repeated once per block, the same values step 3 used, and `--commit` left out for a run that stopped. It appends one row per task of the report to the local outcome log `.doug/.state/memory/memory.db` (uncommitted; run id, card, spec hash, owned files from the plan, size, shape, models, verify and review results, the classified adversary blocks, fix passes, budget, tokens and USD measured from the same transcripts `cost.mjs` read, or null where nothing was measured). It needs Node >=22.16 (node:sqlite). When it exits 1 naming Node, say so in the chat and go on, since the record is a log, not a gate.
-6. `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" reflect <report.json> --run <run-id> --card <id> --commit <sha> --adversary "F1=<class>: <reason>"` with `--adversary` repeated once per block, the same values step 5 used. It applies deterministic helpful counters to any lesson a task's `memoryUsed` names. A real block no longer bumps harmful; pass `--harmful <id>` once per recalled lesson the lead judges actually misled the work (it must be in a task's `memoryUsed`, else exit 1). Give `--harmful` on the report's first reflect: a rerun is "Already reflected" and ignores it. Then it runs a cheap-row `claude -p --json-schema` pass that proposes and appends at most three lessons from the report, filtered in code. Its one-line summary (with the measured cost) goes in the chat. An exit 1 naming the LLM pass is said in the chat and the landing goes on regardless — reflect is a log, not a gate, the same as record.
+6. `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" reflect <report.json> --run <run-id> --card <id> --commit <sha> --adversary "F1=<class>: <reason>" --detach` with `--adversary` repeated once per block, the same values step 5 used. It applies deterministic helpful counters to any lesson a task's `memoryUsed` names. A real block no longer bumps harmful; pass `--harmful <id>` once per recalled lesson the lead judges actually misled the work (it must be in a task's `memoryUsed`, else exit 1). Give `--harmful` on the report's first reflect: a rerun is "Already reflected" and ignores it. Then it runs a cheap-row `claude -p --json-schema` pass that proposes and appends at most three lessons from the report, filtered in code. Before it starts, `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" job --earlier` reads any job an earlier landing left pending, failed, or finished unread: each line goes in the chat, a failed one with its reason, and the landing goes on. It starts detached and returns at once (the model call runs in the background, about 80 s); the caller reads its result at the end of the landing. If the `--detach` start is refused (`job reflect-<id> is already running (pid <pid>) ...`), put that line in the chat verbatim, say this landing's reflect did not start because an earlier reflect holds the name, and the landing goes on (reflect is a log, not a gate); the end-of-landing `job reflect-<id> --wait 120` read then reports that running job.
 7. `node "${CLAUDE_PLUGIN_ROOT}/scripts/board.mjs" summary <report.json> --run <run-id> --wall "<m> min" --commit <sha> --summary "<one sentence>" [--codex-cost <usd>]` (same `--cost` rule) and put its sentence first in the chat, outside the fence (it is the same sentence step 3's record printed, so it goes in the chat once), then its three lines verbatim in a fenced code block: the outcome, the tasks, and what stopped or was not met. The workflow form's landing block is printed by `board.mjs record` (both forms) and by `board.mjs summary --card` as their last three lines (Changed, Outcome, Learned; at most 100 words, `--note` feeds Learned); plain `summary` (no `--card`) prints no block. Your final message carries it verbatim, and the Stop gate blocks until it does.
+8. Reading the detached reflect is not this skill's step: the caller reads it as the last thing of the landing, after the landing commit and the follow-up step, with `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" job reflect-<card id, else the run id> --wait 120` (doug-hand section 5, doug-next section 6). That read polls until the job is done or failed, or 120 s have passed. Its line (reflect's one-line summary with the measured cost) goes in the chat. `pending` after the cap is said as pending: pending is said as pending in the chat, reflect is still running and the landing goes on; the next landing's `memory.mjs job --earlier` reads it. A `failed` line (exit 1) is said in the chat with its reason and the landing goes on regardless — reflect is a log, not a gate, the same as record.
 
 A run that stopped is recorded the same way, without `--commit`; the summary's third line quotes each task's stop reason.
 
@@ -33,8 +34,9 @@ When `.doug/plan.json` carries `cards` (made by `plan.mjs merge`), the run is re
 3. For each card, in the plan's `cards` order: `node "${CLAUDE_PLUGIN_ROOT}/scripts/board.mjs" record <id> <report.json> --run <run-id> --wall "<m> min" --commit <sha> --summary "<one sentence>" --cost <that card's usd> --shared-cost <shared usd> [--codex-cost <usd>, first card only] --adversary ...`. Record reads the batch from the plan file: the entry names the other cards, shows only that card's tasks and the integration rows of their levels, and counts the shared cost once, under the first card.
 4. `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" import` once for the whole report, the same as the workflow-run form's step 4: its one-line output goes in the chat, an exit 1 naming Node is said in the chat and the landing goes on, and it is idempotent, a rewritten file supersedes its old row, and it never writes under the auto-memory directory.
 5. `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" record <report.json> --run <run-id> --commit <sha> --adversary ...` once for the whole report, with every card's block classes (each task carries its card in a batch report; no `--card`).
-6. `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" reflect <report.json> --run <run-id> --commit <sha> --adversary ...` once for the whole report, no `--card` (each appended lesson's card comes from its own task). A real block no longer bumps harmful; pass `--harmful <id>` once per recalled lesson the lead judges actually misled the work (it must be in a task's `memoryUsed`, else exit 1). Give `--harmful` on the report's first reflect: a rerun is "Already reflected" and ignores it.
+6. `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" reflect <report.json> --run <run-id> --commit <sha> --adversary ... --detach` once for the whole report, no `--card` (each appended lesson's card comes from its own task). A real block no longer bumps harmful; pass `--harmful <id>` once per recalled lesson the lead judges actually misled the work (it must be in a task's `memoryUsed`, else exit 1). Give `--harmful` on the report's first reflect: a rerun is "Already reflected" and ignores it. Before it starts, `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" job --earlier` reads any job an earlier landing left pending, failed, or finished unread: each line goes in the chat, a failed one with its reason, and the landing goes on. If the `--detach` start is refused (`job reflect-<id> is already running (pid <pid>) ...`), put that line in the chat verbatim, say this landing's reflect did not start because an earlier reflect holds the name, and the landing goes on (reflect is a log, not a gate); the end-of-landing `job reflect-<id> --wait 120` read then reports that running job.
 7. `node "${CLAUDE_PLUGIN_ROOT}/scripts/board.mjs" summary <report.json> --card <id> --run <run-id> --wall "<m> min" --commit <sha> --summary "<one sentence>"` per card (same `--cost` rule), and put each card's three lines in the chat. Its "Acceptance not met" line reads only that card's own tasks by their `[<card>] ` tag (or the final integration level's acceptance, when the report carries it), so another card's failing command, or a command that depends on a level not yet run, never shows as this card's; the line names which source it used. In a batch, each card's landing block (one per card) goes in the final message verbatim.
+8. Reading the detached reflect is not this skill's step: the caller reads it as the last thing of the landing, after the landing commit and the follow-up step, with `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" job reflect-<run id> --wait 120` (doug-hand section 5, doug-next section 6). That read polls until the job is done or failed, or 120 s have passed. Its line (reflect's one-line summary with the measured cost) goes in the chat. `pending` after the cap is said as pending: pending is said as pending in the chat, reflect is still running and the landing goes on; the next landing's `memory.mjs job --earlier` reads it. A `failed` line (exit 1) is said in the chat with its reason and the landing goes on regardless — reflect is a log, not a gate, the same as record.
 
 ## A hand-track landing
 
@@ -43,7 +45,8 @@ With the card id, the landing commit, the wall clock, and the gate line — one
 1. `node "${CLAUDE_PLUGIN_ROOT}/scripts/board.mjs" record <id> --hand --commit <sha> --wall "<m> min" --gate "<gate line>" --summary "<one sentence>" --cost <usd>`, with `--note "<one line>"` when something about the build is worth keeping. `<usd>` is the card's measured cost, never an estimate: `node "${CLAUDE_PLUGIN_ROOT}/scripts/cost.mjs" --session <session> --since <openedAt>` prices the lead session and its subagents from the card's `openedAt` (in `.doug/.state/reports/<id>/condition.json`) to now, where `<session>` is `CLAUDE_CODE_SESSION_ID` (not the card id); take the session total's dollar figure. When nothing was measured (no condition.json, no session id, or cost.mjs exits non-zero), leave `--cost` out: the entry then has no Cost row, never a `$0`, and you never estimate one. This appends the hand-track entry to `docs/live-runs.md`; its table is the summary. It also promotes `.doug/.state/research/<id>.md` to `docs/research/<id>.md` when that note exists, printing one line saying so; add that path to the landing commit alongside `docs/live-runs.md`.
 2. `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" import`, the same as above: its one-line output goes in the chat, an exit 1 naming Node is said in the chat and the landing goes on, and it is idempotent, supersedes a rewritten file, and never writes under the auto-memory directory.
 3. `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" record <id> --hand --commit <sha> --wall "<m> min" --gate "<gate line>" [--cost <usd>] [--note "<one line>"]`, the same values step 1 used, leaving `--cost` out when step 1 did. It records one row in the local outcome log `.doug/.state/memory/memory.db` (uncommitted), keyed `hand:<sha>` so re-recording the same commit updates that row and track `hand`; a card that lands twice, in two commits, gets two rows. Its workflow-only columns (verified, review counts, adversary verdict, blocks, fix passes, budget, tokens, the report itself) are null because they do not exist on this track, never because they measured zero: no independent verifier ran, and the gate's own text is the `gate` column instead. The USD column is the measured `--cost`, null when none was given. It needs Node >=22.16 (node:sqlite). When it exits 1 naming Node, say so in the chat and go on, since the record is a log, not a gate.
-4. `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" reflect --hand <id> --commit <sha> --rounds <n> [--review "<key>=<class>: <reason>"]... (the key is "`R<n>` or `<card>/R<n>`") [--harmful <id>]... [--note "<one line>"]`. It reads the briefs, reviewer reports and lessons.json doug-hand saved, applies helpful counters to the card's memoryUsed (only lessons fetched with `lesson show <id> --card <id>`). A real block no longer bumps harmful; pass `--harmful <id>` once per recalled lesson the lead judges actually misled the work (it must be in a task's `memoryUsed`, else exit 1). Give `--harmful` on the report's first reflect: a rerun is "Already reflected" and ignores it. It proposes at most three lessons on the cheap row, filtered in code. Its one-line summary (with the measured cost) goes in the chat. An exit 1 naming the LLM pass is said in the chat and the landing goes on regardless — reflect is a log, not a gate, the same as record.
+4. `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" reflect --hand <id> --commit <sha> --rounds <n> [--review "<key>=<class>: <reason>"]... (the key is "`R<n>` or `<card>/R<n>`") [--harmful <id>]... [--note "<one line>"] --detach`. It reads the briefs, reviewer reports and lessons.json doug-hand saved, applies helpful counters to the card's memoryUsed (only lessons fetched with `lesson show <id> --card <id>`). A real block no longer bumps harmful; pass `--harmful <id>` once per recalled lesson the lead judges actually misled the work (it must be in a task's `memoryUsed`, else exit 1). Give `--harmful` on the report's first reflect: a rerun is "Already reflected" and ignores it. It proposes at most three lessons on the cheap row, filtered in code. Before it starts, `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" job --earlier` reads any job an earlier landing left pending, failed, or finished unread: each line goes in the chat, a failed one with its reason, and the landing goes on. It starts detached and returns at once, so the model call does not hold the landing; the caller reads its result at the end of the landing. Reflect is a log, not a gate, the same as record. If the `--detach` start is refused (`job reflect-<id> is already running (pid <pid>) ...`), put that line in the chat verbatim, say this landing's reflect did not start because an earlier reflect holds the name, and the landing goes on (reflect is a log, not a gate); the end-of-landing `job reflect-<id> --wait 120` read then reports that running job.
+5. Reading the detached reflect is not this skill's step: the caller reads it as the last thing of the landing, after the landing commit and the follow-up step, with `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" job reflect-<id> --wait 120` (doug-hand section 5, doug-next section 6). That read polls until the job is done or failed, or 120 s have passed. Its line (reflect's one-line summary with the measured cost) goes in the chat. `pending` after the cap is said as pending: pending is said as pending in the chat, reflect is still running and the landing goes on; the next landing's `memory.mjs job --earlier` reads it. A `failed` line (exit 1) is said in the chat with its reason and the landing goes on regardless — reflect is a log, not a gate, the same as record.
 
 Say the one-sentence summary record printed first, then the commit, the wall clock, and the gate line in the chat. In the hand form the landing block is printed by `board.mjs record` (both forms) and by `board.mjs summary --card` as their last three lines (Changed, Outcome, Learned; at most 100 words, `--note` feeds Learned); plain `summary` (no `--card`) prints no block. Your final message carries it verbatim, and the Stop gate blocks until it does.
 

package/node_modules/@dougharness/flow/workflows/card-queen.js

@@ -118,6 +118,14 @@ const BRIEF_RULES = {
     seats: ["coder", "reviewer", "tester"],
     when: "mutations",
   },
+  "suites-through-verify": {
+    text: "Run a full test suite only through `node .doug/hooks/scripts/verify.mjs`, never the gate's commands (the commands in `stopGate.commands`) directly, with or without CI=1: verify.mjs takes gate.lock, so your suite queues behind a running gate instead of overlapping it.",
+    seats: ["tester", "coder", "reviewer", "gate"],
+  },
+  "tests-take-gate-lock": {
+    text: "Run every other test command, a single test file or a mutation's test run in a scratch copy included, as `node <card worktree>/.doug/hooks/lib/gate-lock.mjs run -- <command>` with the Bash timeout set to 600000, so it waits on gate.lock instead of overlapping a gate; never wrap verify.mjs in gate-lock.mjs, since verify.mjs takes the lock itself. Put env vars right after `--` (`-- CI=1 pnpm exec vitest run <file>`) and quote a compound command as one argument (`-- 'cd dir && vitest run x'`).",
+    seats: ["tester", "coder", "reviewer"],
+  },
   "reviewer-reruns-mutations": {
     text: "Rerun every listed mutation yourself and add your own (own: true); read the diff only after running them.",
     seats: ["reviewer"],
@@ -870,15 +878,17 @@ function next(state, handBack) {
       // An evidenced major gets the same one fix pass; a major without evidence and a minor stay advisory.
       const majors = findings.filter((f) => f.severity === "major" && nonBlank(f.evidence));
       if (blockers.length === 0 && majors.length === 0) return advance(s, "gate", "ok", { acc });
-      // A reviewer round that carried a user answer and still has an open finding gets one extra coder round.
-      const answered = (s.answers || []).some(
-        (a) => a.seat === "reviewer" && (a.round ?? 1) <= (s.seatRuns.reviewer || 0),
-      );
-      if (s.counters.fixPasses >= 1 && answered && !s.answerCoderUsed) {
+      // Each user answer to a reviewer stop gets one coder round when the reviewer that carried it still has an open finding.
+      const given = s.answerCoderRounds || [];
+      const fresh = (s.answers || [])
+        .filter((a) => a.seat === "reviewer" && (a.round ?? 1) <= (s.seatRuns.reviewer || 0))
+        .map((a) => a.round ?? 1)
+        .filter((r) => !given.includes(r));
+      if (s.counters.fixPasses >= 1 && fresh.length > 0) {
         return advance(s, buildSeat(s), "blockers", {
           acc,
           fixFor: "review",
-          answerCoderUsed: true,
+          answerCoderRounds: [...given, ...fresh],
           lastFindings: findings.filter((f) => f.severity !== "minor"),
         });
       }

package/node_modules/@dougharness/gates/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "doug-gates",
   "displayName": "Doug Gates",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Deterministic guardrails for Claude Code: protected paths, bash guard, secret scan on edits and commands, format on edit, edit-loop detection, a verification gate on Stop and on SubagentStop, a snapshot of the plan and session into the anchor before compaction and re-anchoring after it, and a run trace of subagents and tool calls. Configured by .doug/config.json.",
   "author": {
     "name": "Doug contributors"

package/node_modules/@dougharness/gates/lib/block-ledger.mjs

@@ -215,6 +215,7 @@ export function appendBlockLine(dir, { hook, agent, reason, class: cls, session,
         class: cls,
         session: session ?? null,
         ...plain,
+        files: Array.isArray(plain.files) ? plain.files : [],
       }) + "\n";
     mkdirSync(join(dir, ".doug/.state"), { recursive: true });
     appendFileSync(join(dir, BLOCKS_RELPATH), line);