@dougharness/cli 1.1.1 → 1.2.0

package/node_modules/@dougharness/flow/workflows/doug-implement.js

@@ -84,7 +84,7 @@ function taskShape(task) {
 function adversaryRequired(task) {
   return !!adversary && taskShape(task) !== 'S'
 }
-const INTEGRATION_WORKTREE = '.claude/worktrees/doug-integration'
+const INTEGRATION_WORKTREE = plan.integrationWorktree || '.claude/worktrees/doug-integration'
 
 // What an adversarial reviewer may call a blocker. The same text is in the two adversary agent files and in
 // codex-review's own prompt; change all four together.
@@ -1432,14 +1432,14 @@ function integratePrompt(levelIndex, results, baseBranch, isLastLevel, keepWorkt
     `They are local branches of this repository (each was made in its own worktree); no fetch is needed.`,
     ``,
     `Steps:`,
-    `1. From the repository root, find or create the integration worktree at .claude/worktrees/doug-integration:`,
+    `1. From the repository root, find or create the integration worktree at ${INTEGRATION_WORKTREE}:`,
     ...(firstIntegration
       ? [
-        `   this is the run's first integration; the worktree may be a leftover of an earlier run and is never reused as is: if it exists, git worktree remove --force .claude/worktrees/doug-integration (then git worktree prune).`,
-        `   In every case create it fresh: git worktree add -B ${integrationBranch} .claude/worktrees/doug-integration ${baseBranch}`,
+        `   this is the run's first integration; the worktree may be a leftover of an earlier run and is never reused as is: if it exists, git worktree remove --force ${INTEGRATION_WORKTREE} (then git worktree prune).`,
+        `   In every case create it fresh: git worktree add -B ${integrationBranch} ${INTEGRATION_WORKTREE} ${baseBranch}`,
       ]
       : [
-        `   if it does not exist: git worktree add -B ${integrationBranch} .claude/worktrees/doug-integration ${baseBranch}`,
+        `   if it does not exist: git worktree add -B ${integrationBranch} ${INTEGRATION_WORKTREE} ${baseBranch}`,
         `   if it exists (a previous level made it): use it as is; it already has ${integrationBranch} checked out.`,
       ]),
     `   Do every following git and verify command inside that worktree (git -C or cd into it).`,
@@ -1449,7 +1449,7 @@ function integratePrompt(levelIndex, results, baseBranch, isLastLevel, keepWorkt
     ...(plan.verify.length
       ? [
         `   When .doug/hooks/scripts/verify.mjs exists, run them from the repository root (not inside the worktree) as one command, so a tree already verified is credited instead of re-run:`,
-        `   node .doug/hooks/scripts/verify.mjs --json --by integrate --cwd .claude/worktrees/doug-integration --record-dir . ${worktrees.map(w => `--credit-dir ${shellQuote(w)}`).join(' ')} ${plan.verify.map(v => `--command ${shellQuote(v)}`).join(' ')}`,
+        `   node .doug/hooks/scripts/verify.mjs --json --by integrate --cwd ${INTEGRATION_WORKTREE} --record-dir . ${worktrees.map(w => `--credit-dir ${shellQuote(w)}`).join(' ')} ${plan.verify.map(v => `--command ${shellQuote(v)}`).join(' ')}`,
         `   Copy each entry of its JSON results[] into verify as { command, ok, outputTail }, and add credited: "verified-tree" to each when the JSON's credited is not null. When verify.mjs does not exist, run the commands one by one as above.`,
       ]
       : []),
@@ -1469,7 +1469,7 @@ function integratePrompt(levelIndex, results, baseBranch, isLastLevel, keepWorkt
       ]
       : []),
     `4. If every merge succeeded, remove the merged task worktrees to leave the repository tidy: git worktree remove --force <path> for each of ${worktrees.join(', ')}. Keep their branches.`,
-    isLastLevel && !keepWorktree ? `5. This is the last level. Also remove the integration worktree (git worktree remove --force .claude/worktrees/doug-integration); the branch ${integrationBranch} keeps the result.` : isLastLevel ? `5. This is the last level, but keep the integration worktree: the adversary reviews the merged size-S tasks there, and plan.mjs land reuses and removes it.` : `5. Keep the integration worktree; the next level merges into it.`,
+    isLastLevel && !keepWorktree ? `5. This is the last level. Also remove the integration worktree (git worktree remove --force ${INTEGRATION_WORKTREE}); the branch ${integrationBranch} keeps the result.` : isLastLevel ? `5. This is the last level, but keep the integration worktree: the adversary reviews the merged size-S tasks there, and plan.mjs land reuses and removes it.` : `5. Keep the integration worktree; the next level merges into it.`,
     isLastLevel
       ? `6. ok=true only if all merges succeeded, all verify commands passed, and every acceptance command exited 0. Do not push. Do not check out anything in the main working tree.`
       : `6. ok=true only if all merges succeeded and all verify commands passed. Do not push. Do not check out anything in the main working tree.`,

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

@@ -1,7 +1,7 @@
 {
   "name": "doug-gates",
   "displayName": "Doug Gates",
-  "version": "1.1.1",
+  "version": "1.2.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/anchor.mjs

@@ -23,6 +23,28 @@ export function readPlanSummary(dir) {
   }
 }
 
+// Every active (enforced, not landed) per-card plan under .doug/plans/, as readPlanSummary shapes them.
+export function readPlanSummaries(dir) {
+  const out = [];
+  try {
+    const d = join(dir, ".doug/plans");
+    if (!existsSync(d)) return out;
+    for (const name of readdirSync(d).filter((f) => f.endsWith(".json")).sort()) {
+      try {
+        const p = JSON.parse(readFileSync(join(d, name), "utf8"));
+        if (!p || typeof p !== "object" || !Array.isArray(p.tasks) || p.landed) continue;
+        if (p.status !== "approved" && p.status !== "done") continue;
+        out.push({ title: p.title || "(untitled)", status: p.status, card: typeof p.card === "string" ? p.card : null, tasks: p.tasks.map((t) => ({ id: t.id, files: Array.isArray(t.files) ? t.files : [] })) });
+      } catch {
+        // an unreadable per-card plan is skipped
+      }
+    }
+  } catch {
+    return out;
+  }
+  return out;
+}
+
 // Short HEAD sha and current branch, tolerant of a non-repo or a git failure (moved from stop-gate.mjs; used by
 // both the Stop gate's own handoff and the PreCompact snapshot).
 export function gitHead(dir) {
@@ -55,7 +77,7 @@ export function readDecisions(dir) {
 // plan/decisions/edited-files lines (card precompact-keeps-handoff, review MAJOR): those grow unbounded with a
 // session's edited-file count, and SessionStart's re-injection caps the whole anchor at 4000 characters, so a few
 // short handoff lines must be near the top to survive that cap on a long session.
-export function snapshotSection({ plan, decisions, state, now, handoff }) {
+export function snapshotSection({ plan, plans, decisions, state, now, handoff }) {
   const lines = [`## Compaction snapshot (doug, ${now.toISOString()})`];
   if (handoff) {
     lines.push("");
@@ -70,9 +92,12 @@ export function snapshotSection({ plan, decisions, state, now, handoff }) {
     if (typeof handoff.contextPct === "number") lines.push(`Context: ${handoff.contextPct}%`);
   }
   lines.push("");
-  if (plan) {
-    lines.push(`Plan: ${plan.title} [${plan.status}]${plan.card ? ` (card ${plan.card})` : ""}`);
-    for (const t of plan.tasks) lines.push(`- ${t.id} owns ${t.files.length ? t.files.join(", ") : "(no files)"}`);
+  const shown = plan ? [plan] : plans || [];
+  if (shown.length) {
+    for (const pl of shown) {
+      lines.push(`Plan: ${pl.title} [${pl.status}]${pl.card ? ` (card ${pl.card})` : ""}`);
+      for (const t of pl.tasks) lines.push(`- ${t.id} owns ${t.files.length ? t.files.join(", ") : "(no files)"}`);
+    }
   } else lines.push("Plan: none in .doug/plan.json");
   lines.push("");
   lines.push(decisions.length ? `Decisions (docs/decisions): ${decisions.join(", ")}` : "Decisions: none under docs/decisions");

package/node_modules/@dougharness/gates/lib/bash-rules.mjs

@@ -13,8 +13,8 @@ const PM_INSTALL_VERBS = {
 // "|"/"&"/"|&"/newline, and the body of every unquoted-or-double-quoted "$(...)" or backtick substitution
 // really executes, so its pieces are split out too, recursively (research Q1.5; design decided by the lead,
 // point 3). Falls back to today's quote-blind split - checking MORE than a real shell would, never less - when
-// the scanner hits an unterminated quote or substitution (a heredoc body looks the same to it, and heredocs are
-// out of scope - point 4) or throws for any other reason (a hook reader must never throw - CLAUDE.md Gotchas).
+// the scanner hits an unterminated quote or substitution (a heredoc body looks the same to it; only the
+// package-manager rule strips heredoc bodies - stripHeredocBodies, card bash-rules-heredoc-body) or throws for any other reason (a hook reader must never throw - CLAUDE.md Gotchas).
 // A bare "&" (backgrounds the command before it, redirection forms excepted) and bash's "|&" (a pipe connector,
 // treated the same as a bare "|") joined this set in review round 5 (third review) - see scanTop's comment.
 const ALL_SEPS = new Set(["&&", "||", ";", "|", "&", "|&", "\n"]);
@@ -155,8 +155,8 @@ function words(cmd) {
 // itself sits inside (a stack, not a boolean: scanParenBody below starts its own body scan fresh in the "top"
 // state). "$((...))" is read as a substitution too (its body is "(...)" verbatim) - over-checking is fine.
 //
-// Known limits, stated as limits, not bugs: a word-initial "#" comment and a heredoc body are not recognised
-// (over-report only, never under-report - research Q1.7); zsh's RC_QUOTES, bash 5.x, and dash's lack of
+// Known limits, stated as limits, not bugs: a word-initial "#" comment and a heredoc body are not recognised by this scanner
+// (the package-manager rule alone strips heredoc bodies first - stripHeredocBodies; over-report only, never under-report - research Q1.7); zsh's RC_QUOTES, bash 5.x, and dash's lack of
 // $'...' are unverified or divergent, and the bash/zsh reading is the one this scanner takes; a "(...)" subshell
 // or "{ ...; }" group is not unwrapped (unchanged from today).
 //
@@ -1060,7 +1060,7 @@ function pipeStages(group) {
 // group's stages at "|" or "|&" (pipeStages above) - and, design point 5, recursion into every substitution
 // body's own groups too, so a curl|sh chain hidden inside a "$(...)" or backtick is still caught. Because
 // scanTop finds a substitution wherever it sits - inside an ordinary quoted argument or inside what looks like
-// inert text such as a heredoc body (heredocs carry no state of their own here, a known limit) - a "$(... curl
+// inert text such as a heredoc body (this check keeps no heredoc state, a known limit) - a "$(... curl
 // ... | sh)" written inside either is still denied even where a real shell would just treat it as literal
 // text: an over-denial on the safe side, not a miss. Falls back to the old quote-blind group split (unchanged -
 // review round 5 did not extend this fallback regex to "&"/"|&", see the coder's report) on an unterminated
@@ -1485,6 +1485,184 @@ export function commandForms(cmd, depth = 0) {
   }
 }
 
+// Card bash-rules-heredoc-body: the body of a heredoc (<<WORD, <<'WORD', <<"WORD", <<-WORD, up to the terminator
+// line) is data fed to a command's stdin, not commands, so the package-manager rule must not match prose inside
+// it (a research note quoting the npm CLI). stripHeredocBodies returns the command with those bodies removed;
+// evaluateBash feeds it to the package-manager rule ONLY - every other rule still sees the original text
+// (checks more, never less). Its own small quote-aware walk (not scanTop: a body with an apostrophe would
+// leave scanTop in an unterminated quote and send it to the quote-blind fallback). A body is kept, i.e. still
+// checked, when: its terminator line never appears (unterminated); ANY pipeline stage anywhere in the whole
+// command is a shell or source/"." (a shell reading the heredoc runs it as a script), or any group ends in a
+// trailing "|" (the receiving stage is on a later line): then nothing is stripped; or the delimiter is unquoted
+// and the body holds "$(" or a backtick (an unquoted heredoc expands substitutions, which run).
+// Known limits (accepted, not caught): a heredoc written to a file later run (cat > s.sh <<EOF ... bash s.sh),
+// xargs ... sh -c, tee >(sh), while read l; do $l; done <<EOF, ssh/docker exec (remote). "<<<" is a
+// here-string, not a heredoc; an operator inside a quote, a substitution, or a word-initial "#" comment is not
+// one either. Never throws: any error returns the command unchanged (today's behaviour).
+function heredocReadsAsScript(stage) {
+  // Compared on the raw stage and on the stage with quotes and backslashes removed ("sh", s\h): conservative.
+  for (const text of [stage, stage.replace(/["'\\]/g, "")]) {
+    if (matchesShellStage(text)) return true;
+    const r = resolveVerb(words(text), 0);
+    const verb = r.w[r.i];
+    if (verb === "source" || verb === ".") return true;
+  }
+  return false;
+}
+
+// Whole-command rule (round 2): ANY pipeline stage anywhere in the command that reads as a shell script consumer,
+// or any group ending in a trailing "|", keeps every body. A per-operator or per-group relation misses a heredoc
+// inside a compound (if/for/while/case/subshell/brace group) whose closing keyword is piped to a shell.
+function commandHasShellConsumer(str) {
+  const cut = cutOnSeparators(str, GROUP_SEPS);
+  const groups = cut ? cut.pieces : str.split(/\s*(?:&&|\|\||;)\s*|\n/).map((s) => s.trim()).filter(Boolean);
+  for (const group of groups) {
+    if (/\|&?\s*$/.test(group)) return true; // the receiving stage is on a later line: unknown, so conservative
+    if (pipeStages(group).some((st) => heredocReadsAsScript(st))) return true;
+  }
+  return false;
+}
+
+export function stripHeredocBodies(command) {
+  const str = String(command);
+  try {
+    if (!str.includes("<<")) return str;
+    if (commandHasShellConsumer(str)) return str;
+    const removals = [];
+    let pending = [];
+    let state = "top";
+    let i = 0;
+    while (i < str.length) {
+      const c = str[i];
+      if (state === "squote") { if (c === "'") state = "top"; i += 1; continue; }
+      if (state === "dquote") {
+        if (c === "\\" && isDquoteEscapable(str[i + 1])) { i += 2; continue; }
+        if (c === '"') { state = "top"; i += 1; continue; }
+        if (c === "$" && str[i + 1] === "(") {
+          const close = scanParenBody(str, i + 1);
+          if (close < 0) return str;
+          i = close + 1;
+          continue;
+        }
+        if (c === "`") {
+          const close = scanBacktickBody(str, i);
+          if (close < 0) return str;
+          i = close + 1;
+          continue;
+        }
+        i += 1;
+        continue;
+      }
+      if (state === "ansic") {
+        if (c === "\\") { i += 2; continue; }
+        if (c === "'") state = "top";
+        i += 1;
+        continue;
+      }
+      // top
+      if (c === "\\") { i += 2; continue; }
+      if (c === "'") { state = "squote"; i += 1; continue; }
+      if (c === '"') { state = "dquote"; i += 1; continue; }
+      if (c === "$" && str[i + 1] === "'") { state = "ansic"; i += 2; continue; }
+      if (c === "$" && str[i + 1] === '"') { state = "dquote"; i += 2; continue; }
+      if (c === "$" && str[i + 1] === "(") {
+        const close = scanParenBody(str, i + 1);
+        if (close < 0) return str;
+        i = close + 1;
+        continue;
+      }
+      if (c === "`") {
+        const close = scanBacktickBody(str, i);
+        if (close < 0) return str;
+        i = close + 1;
+        continue;
+      }
+      if (c === "#" && (i === 0 || /[\s;&|()]/.test(str[i - 1]))) {
+        while (i < str.length && str[i] !== "\n") i += 1;
+        continue;
+      }
+      if (c === "<" && str[i + 1] === "<") {
+        if (str[i + 2] === "<") { i += 3; continue; } // here-string
+        let j = i + 2;
+        const dash = str[j] === "-";
+        if (dash) j += 1;
+        while (str[j] === " " || str[j] === "\t") j += 1;
+        let word = "";
+        let quoted = false;
+        let dollarQuoted = false;
+        while (j < str.length && !/[\s;&|<>()]/.test(str[j])) {
+          const ch = str[j];
+          if (ch === "\\") { quoted = true; word += str[j + 1] ?? ""; j += 2; continue; }
+          if (ch === "$" && (str[j + 1] === "'" || str[j + 1] === '"')) { dollarQuoted = true; j += 1; continue; }
+          if (ch === "'" || ch === '"') {
+            const close = str.indexOf(ch, j + 1);
+            if (close < 0) return str;
+            quoted = true;
+            word += str.slice(j + 1, close);
+            j = close + 1;
+            continue;
+          }
+          word += ch;
+          j += 1;
+        }
+        if (word) pending.push({ word, dash, quoted, shellFed: dollarQuoted || word[0] === "$" });
+        i = Math.max(j, i + 2);
+        continue;
+      }
+      const sep =
+        (c === "&" && str[i + 1] === "&") || (c === "|" && str[i + 1] === "|") ? 2
+          : c === ";" ? 1
+            : c === "&" && str[i + 1] !== ">" && str[i - 1] !== ">" && str[i - 1] !== "<" && str[i - 1] !== "|" ? 1
+              : 0;
+      if (sep) {
+        i += sep;
+        continue;
+      }
+      if (c === "\n") {
+        const ops = pending;
+        pending = [];
+        let pos = i + 1;
+        let lastEnd = -1;
+        for (const op of ops) {
+          const bodyStart = pos;
+          let found = -1;
+          while (pos <= str.length) {
+            const nl = str.indexOf("\n", pos);
+            const lineEnd = nl < 0 ? str.length : nl;
+            const line = str.slice(pos, lineEnd);
+            if ((op.dash ? line.replace(/^\t+/, "") : line) === op.word) { found = lineEnd; break; }
+            if (lineEnd >= str.length) break;
+            pos = lineEnd + 1;
+          }
+          if (found < 0) return removals.length ? applyRemovals(str, removals) : str; // unterminated: stop here
+          const body = str.slice(bodyStart, found);
+          const expands = !op.quoted && /\$\(|`/.test(body);
+          if (!op.shellFed && !expands) removals.push([bodyStart, found]);
+          lastEnd = found;
+          pos = found + 1;
+        }
+        if (lastEnd >= 0) { i = lastEnd; continue; }
+        i += 1;
+        continue;
+      }
+      i += 1;
+    }
+    return removals.length ? applyRemovals(str, removals) : str;
+  } catch {
+    return str;
+  }
+}
+
+function applyRemovals(str, removals) {
+  let out = "";
+  let at = 0;
+  for (const [a, b] of removals) {
+    out += str.slice(at, a);
+    at = b;
+  }
+  return out + str.slice(at);
+}
+
 export function checkPackageManager(cmd, expected) {
   if (!expected) return null;
   const m = /^(npm|pnpm|yarn|bun)\s*(.*)$/.exec(cmd);
@@ -1506,6 +1684,8 @@ export function evaluateBash(command, { config, currentBranch }) {
     const pipeReason = checkPipeToShell(command);
     if (pipeReason) reasons.push(pipeReason);
   }
+  const pmCommand = config.bash.packageManagerGuard ? stripHeredocBodies(command) : command;
+  const pmSeparate = pmCommand !== command;
   for (const cmd of splitCommands(command)) {
     // Card bash-rules-prefixed-commands: run the five per-command checks (each anchored on the start of the
     // string it's given) on every form commandForms resolves for this split command - cmd itself, a prefix
@@ -1521,9 +1701,19 @@ export function evaluateBash(command, { config, currentBranch }) {
         checks.push(checkResetHardOnProtected(form, config.bash.denyForcePushTo, currentBranch));
       }
       if (config.bash.denyDestructive) checks.push(checkDestructive(form));
-      if (config.bash.packageManagerGuard) checks.push(checkPackageManager(form, config.packageManager));
+      if (config.bash.packageManagerGuard && !pmSeparate) checks.push(checkPackageManager(form, config.packageManager));
       for (const r of checks) if (r && !reasons.includes(r)) reasons.push(r);
     }
   }
+  // Card bash-rules-heredoc-body: with a data heredoc body present, the package-manager rule reads the command
+  // with those bodies stripped (stripHeredocBodies); the other rules above already ran on the original text.
+  if (pmSeparate) {
+    for (const cmd of splitCommands(pmCommand)) {
+      for (const form of commandForms(cmd)) {
+        const r = checkPackageManager(form, config.packageManager);
+        if (r && !reasons.includes(r)) reasons.push(r);
+      }
+    }
+  }
   return reasons;
 }

package/node_modules/@dougharness/gates/lib/gate-lock.mjs

@@ -1,15 +1,45 @@
 // The gate.lock helpers shared by the Stop gate (scripts/stop-gate.mjs) and verify.mjs (card
 // verify-takes-gate-lock). Moved verbatim from stop-gate.mjs; the Stop gate's behaviour is unchanged.
 
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { accessSync, constants, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { dirname, join, resolve } from "node:path";
 
 // Single-runner lock (card stop-gate-process-storm, goal 3): only one gate runs the verification commands
 // at a time per project, so concurrent SubagentStops share one suite instead of each starting its own (the
-// 2026-09-16 process storm). `.doug/.state/gate.lock` holds `{ pid, session, at }` while a gate's commands
-// run.
+// 2026-09-16 process storm). gate.lock holds `{ pid, session, at }` while a gate's commands run. Card
+// gate-lock-shared (ADR 0015): it lives at `<git common dir>/doug/gate.lock`, a path every worktree of the
+// repo shares, so gates in parallel worktrees queue instead of running full suites concurrently. It falls
+// back to the per-checkout `.doug/.state/gate.lock` when git is unavailable, `dir` is not in a repo, or the
+// common dir is not writable; resolution never throws.
 const GATE_LOCK_RELPATH = ".doug/.state/gate.lock";
+// Memoized per dir for the life of the process (a fallback result too): one gate run must see one path,
+// or a poll that fell back under load would read no lock and take over a live holder's shared lock.
+const lockPathMemo = new Map();
 export function gateLockPath(dir) {
+  if (lockPathMemo.has(dir)) return lockPathMemo.get(dir);
+  const p = resolveGateLockPath(dir);
+  lockPathMemo.set(dir, p);
+  return p;
+}
+function resolveGateLockPath(dir) {
+  try {
+    const out = execFileSync("git", ["rev-parse", "--path-format=absolute", "--git-common-dir"], {
+      cwd: dir,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 5000,
+    }).trim();
+    if (out) {
+      const common = resolve(dir, out);
+      const lockDir = join(common, "doug");
+      accessSync(common, constants.W_OK);
+      if (existsSync(lockDir)) accessSync(lockDir, constants.W_OK);
+      return join(lockDir, "gate.lock");
+    }
+  } catch {
+    // fall through to the per-checkout path
+  }
   return join(dir, GATE_LOCK_RELPATH);
 }
 
@@ -43,8 +73,9 @@ export function pidIsLive(pid) {
 // Creates gate.lock exclusively (throws EEXIST when one is already there, or any other fs error). The
 // caller decides what a failure means.
 export function writeGateLock(dir, sessionId) {
-  mkdirSync(join(dir, ".doug/.state"), { recursive: true });
-  writeFileSync(gateLockPath(dir), JSON.stringify({ pid: process.pid, session: sessionId, at: Date.now() }), { flag: "wx" });
+  const p = gateLockPath(dir);
+  mkdirSync(dirname(p), { recursive: true });
+  writeFileSync(p, JSON.stringify({ pid: process.pid, session: sessionId, at: Date.now() }), { flag: "wx" });
 }
 
 // Overwrites gate.lock with this gate's own pid/session, whether it was stale (a dead pid) or its holder
@@ -53,8 +84,9 @@ export function writeGateLock(dir, sessionId) {
 // does not hold).
 export function takeOverGateLock(dir, sessionId) {
   try {
-    mkdirSync(join(dir, ".doug/.state"), { recursive: true });
-    writeFileSync(gateLockPath(dir), JSON.stringify({ pid: process.pid, session: sessionId, at: Date.now() }));
+    const p = gateLockPath(dir);
+    mkdirSync(dirname(p), { recursive: true });
+    writeFileSync(p, JSON.stringify({ pid: process.pid, session: sessionId, at: Date.now() }));
   } catch {
     // best-effort takeover only
   }

package/node_modules/@dougharness/gates/lib/proposals.mjs

@@ -37,6 +37,11 @@ const MAX_VERIFIED_ROWS = 20;
 // Every spawned git call gets a hard ceiling (ms) so a hung or adversarially slow git invocation cannot itself
 // become the way to blow the Stop-gate timeout (review MINOR 7).
 const GIT_TIMEOUT_MS = 5000;
+// Most commits (newest first) that touched a target since the session baseline whose parent is tried as a
+// re-derivation ref (card ledger-two-committed-applies): a bound, so a long session cannot make the walk costly.
+const MAX_PARENT_REFS = 10;
+// A git commit sha, abbreviated or full (same shape lib/baseline.mjs accepts for baselineHead).
+const GIT_SHA_RE = /^[0-9a-f]{7,64}$/;
 
 // Every well-formed line, tolerant of a missing file or a torn line (a crashed process mid-write) - never fatal.
 export function readAppliedLedger(dir) {
@@ -139,18 +144,48 @@ function diffAppliesAtRef(dir, relPath, diffAbsPath, currentSha, ref) {
   }
 }
 
+// The parents of the commits since `base` that touched relPath, newest first, capped at MAX_PARENT_REFS: each
+// `<commit>^` holds relPath as it was just before that commit, which is where an in-session apply's preimage
+// lives once a later apply is also committed (card ledger-two-committed-applies). Empty when `base` is not a
+// usable sha, or the git call fails or times out (GIT_TIMEOUT_MS); never throws.
+function parentRefsSince(dir, relPath, base) {
+  try {
+    const listed = spawnSync("git", ["rev-list", `--max-count=${MAX_PARENT_REFS}`, `${base}..HEAD`, "--", relPath], {
+      cwd: dir,
+      timeout: GIT_TIMEOUT_MS,
+      encoding: "utf8",
+    });
+    if (listed.status !== 0 || typeof listed.stdout !== "string") return [];
+    return listed.stdout
+      .split("\n")
+      .map((line) => line.trim())
+      .filter((line) => /^[0-9a-f]{7,64}$/.test(line))
+      .map((sha) => `${sha}^`);
+  } catch {
+    return [];
+  }
+}
+
 // `base` (card stop-scan-committed-changes) is the session's baseline HEAD when known, tried first: a diff
 // that created `relPath` after that baseline still applies onto "absent" even once the session has since
 // committed `relPath` itself (HEAD would otherwise already equal the current bytes, and git apply refuses to
 // create a file that already exists there). M1 fix: when the base attempt fails, HEAD is also tried before
 // giving up, not only when `base` is null/omitted - a second approved apply on the same target, committed
 // in-session after the first (so its preimage is the first version, not the pre-session base), re-derives
-// correctly onto HEAD even though it cannot re-derive onto the pre-session base at all. Every other check
+// correctly onto HEAD even though it cannot re-derive onto the pre-session base at all. Card
+// ledger-two-committed-applies: once two or more applies on one target are committed in-session, the earlier
+// ones' preimage is neither the base nor HEAD; when both fail and `base` is known, the parent of each commit
+// since `base` that touched `relPath` (parentRefsSince, newest first, capped) is tried too. Every other check
 // (row shape, containment, diffSha256, diffNamesOnly) is unchanged; this only widens which ref the content
 // re-derivation itself is allowed to succeed against.
 function diffReproducesCurrentContent(dir, relPath, diffAbsPath, currentSha, base) {
-  const refs = typeof base === "string" && base && base !== "HEAD" ? [base, "HEAD"] : ["HEAD"];
-  return refs.some((ref) => diffAppliesAtRef(dir, relPath, diffAbsPath, currentSha, ref));
+  // `base` is agent-writable state (state.baselineHead): only a hex sha ever reaches git, so a value such as
+  // "--output=<path>" is dropped here and can neither be read as an option nor name a revision.
+  const hasBase = typeof base === "string" && GIT_SHA_RE.test(base);
+  const refs = hasBase ? [base, "HEAD"] : ["HEAD"];
+  if (refs.some((ref) => diffAppliesAtRef(dir, relPath, diffAbsPath, currentSha, ref))) return true;
+  if (!hasBase) return false;
+  return parentRefsSince(dir, relPath, base).some((ref) => diffAppliesAtRef(dir, relPath, diffAbsPath, currentSha, ref));
 }
 
 // One row's full verification, wrapped so that no exception - a malformed field of any type, an unreadable
@@ -182,8 +217,9 @@ function rowIsGenuine(dir, relPath, sha, learnDirAbs, row, base) {
 // before the session started, not only against HEAD (which, once the target is committed, already equals the
 // current bytes and would make a new-file diff fail to apply there). HEAD is always tried too (M1 review
 // fix) - a second approved apply on the same target, committed in-session after the first, has the first
-// version as its preimage and can only re-derive onto HEAD, not onto the pre-session base. With `base` null
-// or omitted, only HEAD is tried, exactly as before this card.
+// version as its preimage and can only re-derive onto HEAD, not onto the pre-session base. With several applies
+// committed in-session (card ledger-two-committed-applies), the parent of each commit since `base` that touched
+// the target is tried as well. With `base` null or omitted, only HEAD is tried, exactly as before this card.
 export function isAppliedContent(dir, relPath, { base = null } = {}) {
   const sha = currentSha256(dir, relPath);
   const learnDirAbs = resolve(dir, LEARN_STATE_RELPATH);

package/node_modules/@dougharness/gates/lib/scope.mjs

@@ -2,7 +2,7 @@
 // the files its tasks own is the only thing a session may change.
 // Pure functions plus one reader; the stop gate decides, this file only computes.
 
-import { readFileSync, existsSync } from "node:fs";
+import { readFileSync, existsSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { globToRegExp, matchAny, normalizePath } from "./glob.mjs";
 
@@ -10,18 +10,56 @@ export const PLAN_RELPATH = ".doug/plan.json";
 export const ENFORCED_STATUSES = ["approved", "done"];
 // The flow's own files change during a run and are never out of scope. Per-session hook state too.
 // board.json moves uncommitted with the live board server; it lands in the card's landing commit.
-export const ALWAYS_ALLOWED = [".doug/plan.json", ".doug/anchor.md", ".doug/.state/**", ".doug/board.json"];
+export const ALWAYS_ALLOWED = [".doug/plan.json", ".doug/plans/**", ".doug/anchor.md", ".doug/.state/**", ".doug/board.json"];
 
 // Returns { plan, reason }. plan is set only when the file exists, parses, has tasks, and is in an
 // enforced status; reason says why not otherwise ("no-plan", "unreadable", "status:draft", "invalid").
 export function loadScopePlan(dir) {
+  const single = loadSinglePlan(dir);
+  if (single.plan) return single;
+  // card parallel-card-queens: with no enforced .doug/plan.json, the enforced, not-landed per-card plans
+  // under .doug/plans/ hold scope together.
+  const cards = loadCardPlans(dir);
+  if (cards.plan || cards.reason === "unreadable") return cards;
+  return single;
+}
+
+// Union of every approved/done, not-landed .doug/plans/*.json. Never throws: an unreadable file is skipped,
+// and reported as reason "unreadable" only when it leaves no plan holding scope.
+function loadCardPlans(dir) {
+  let names = [];
+  try {
+    names = readdirSync(join(dir, ".doug/plans")).filter((f) => f.endsWith(".json")).sort();
+  } catch {
+    return { plan: null, reason: "no-plan" };
+  }
+  const plans = [];
+  for (const name of names) {
+    try {
+      const p = JSON.parse(readFileSync(join(dir, ".doug/plans", name), "utf8"));
+      if (!p || typeof p !== "object" || !Array.isArray(p.tasks)) continue;
+      if (!ENFORCED_STATUSES.includes(p.status) || p.landed) continue;
+      plans.push(p);
+    } catch (err) {
+      // fail open: any unreadable per-card file means the union is unknown, so scope is not checked
+      return { plan: null, reason: "unreadable", error: String(err && err.message), file: `.doug/plans/${name}` };
+    }
+  }
+  if (!plans.length) return { plan: null, reason: "no-plan" };
+  const status = plans.some((p) => p.status === "approved") ? "approved" : "done";
+  const cards = plans.map((p) => p.card || p.title || "?");
+  const title = `per-card plans (${cards.join(", ")})`;
+  return { plan: { version: 1, title, status, perCard: cards, tasks: plans.flatMap((p) => p.tasks) }, reason: null };
+}
+
+function loadSinglePlan(dir) {
   const file = join(dir, PLAN_RELPATH);
   if (!existsSync(file)) return { plan: null, reason: "no-plan" };
   let plan;
   try {
     plan = JSON.parse(readFileSync(file, "utf8"));
   } catch (err) {
-    return { plan: null, reason: "unreadable", error: String(err.message) };
+    return { plan: null, reason: "unreadable", error: String(err.message), file: PLAN_RELPATH };
   }
   if (!plan || typeof plan !== "object" || !Array.isArray(plan.tasks)) return { plan: null, reason: "invalid" };
   if (!ENFORCED_STATUSES.includes(plan.status)) return { plan: null, reason: `status:${plan.status}` };
@@ -104,7 +142,8 @@ export function scopeViolations(changed, plan, { ignore = [] } = {}) {
 }
 
 export function describeViolations(violations, plan) {
-  const lines = [`Files changed outside the ${plan.status} plan "${plan.title}" (${PLAN_RELPATH}):`];
+  const source = Array.isArray(plan.perCard) ? `per-card plans ${plan.perCard.join(", ")} (.doug/plans/)` : `plan "${plan.title}" (${PLAN_RELPATH})`;
+  const lines = [`Files changed outside the ${plan.status} ${source}:`];
   for (const v of violations) {
     const near = v.nearest.length ? `nearest task${v.nearest.length > 1 ? "s" : ""}: ${v.nearest.map((n) => `${n.id} (owns ${n.via})`).join(", ")}` : "no task owns anything near it";
     lines.push(`  ${v.file}  ${near}`);

package/node_modules/@dougharness/gates/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dougharness/gates",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "private": true,
   "description": "Deterministic Claude Code hooks: protected paths, bash guard, secret scan on edits and commands, format on edit, edit-loop detection, stop gate, re-anchor after compaction.",
   "type": "module",

package/node_modules/@dougharness/gates/scripts/reanchor.mjs

@@ -19,7 +19,7 @@ import { join } from "node:path";
 import { runHook, allow, addContext, systemMessage } from "../lib/io.mjs";
 import { loadConfig, projectDir } from "../lib/config.mjs";
 import { loadState, saveState } from "../lib/state.mjs";
-import { gitHead, mergeSnapshot, readDecisions, readPlanSummary, snapshotSection, splitSnapshot } from "../lib/anchor.mjs";
+import { gitHead, mergeSnapshot, readDecisions, readPlanSummary, readPlanSummaries, snapshotSection, splitSnapshot } from "../lib/anchor.mjs";
 
 runHook("reanchor", async (input) => {
   const dir = projectDir(input);
@@ -30,6 +30,7 @@ runHook("reanchor", async (input) => {
     const state = loadState(dir, input.session_id);
     const section = snapshotSection({
       plan: readPlanSummary(dir),
+      plans: readPlanSummaries(dir),
       decisions: readDecisions(dir),
       state,
       now: new Date(),