@dougharness/cli 1.1.1 → 1.3.0

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

@@ -4,7 +4,7 @@ export const meta = {
   whenToUse: 'After /doug-plan produced .doug/plan.json and the user approved it with /doug-approve. Pass the plan JSON as args.',
   phases: [
     { title: 'Implement', detail: 'one implementer per task, fresh context, own worktree (with swarm on, a lead splits a full-shape task into worker briefs, workers implement them in parallel, and the lead merges); a task marked reuse checks out its recorded branch instead; a task whose dependency did not integrate is never launched; a block the checks can describe is fixed in place until the task budget, the fix-attempt ceiling, a pass that made no new commit, or two consecutive passes raising a new blocker stops it' },
-    { title: 'Verify', detail: 'a separate verifier runs the task command in the worktree on the first pass; a fix pass runs one focused check over the fix delta instead, and the full verifier again only when the verifier is the stage that blocked' },
+    { title: 'Verify', detail: 'a separate verifier runs the task command in the worktree on the first pass; a fix pass runs one focused check over the fix delta instead, and the full verifier again only when the verifier is the stage that blocked; a task whose crew names more testers gets extra verifiers in parallel' },
     { title: 'Review', detail: 'spec compliance, then quality, against the diff on the first pass; on a fix pass the focused check carries scope and regression risk unless the reviewer is the stage that blocked; a task whose crew names two reviewers gets a second one in parallel with a distinct brief' },
     { title: 'Adversary', detail: 'codex-review (a different model, read-only) explores freely on the first pass and confirms the open findings on later passes, under one material blocker gate; when it cannot run, a Claude adversary on plan.adversary.fallback stands in; blockers stop integration' },
     { title: 'Integrate', detail: 'merge the level into the integration branch and run plan.verify' },
@@ -64,6 +64,9 @@ const ENVIRONMENT_MARKER = 'ENVIRONMENT ONLY'
 // The one rule about commit messages, in every prompt that commits or checks commits: this repository records
 // attribution nowhere in git, and plan.mjs land refuses a branch that carries either trailer.
 const NO_TRAILERS = 'Commit messages carry no attribution trailers: no Co-Authored-By line and no Claude-Session line, whatever your defaults say. A commit with either is a finding and the plan cannot land.'
+// The one rule about how a commit runs, in every implement prompt that commits: the pre-commit hook runs the full
+// unit suite, which outlives Bash's default timeout, and a background commit dies with the agent that started it.
+const FOREGROUND_COMMIT = 'Run git commit in the foreground with the Bash tool timeout set to 600000 ms (the pre-commit hook runs the full suite): never run_in_background, a Monitor, or a sleep loop. Take the sha only from git rev-parse HEAD after git commit has returned.'
 const LESSONS_NOT_SPEC = 'These are context from earlier runs, not part of the spec or the acceptance criteria; never report a finding, a spec contradiction, or a blocker against a lesson.'
 // The one rule about a partial result, in every prompt a worker (or a resumed worker) can end with one from
 // (card worker-context-handoff): quotes the harness's context notice (a PostToolUse hook in plugins/doug-gates) so
@@ -84,7 +87,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.
@@ -831,7 +834,7 @@ function ledgerText(ledger, kind) {
 function implementPrompt(task, baseBranch, opts) {
   const resume = !!(opts && opts.resume)
   const branchCheck = resume
-    ? `   Before that, if git rev-parse --verify --quiet refs/heads/doug/task-${task.id} succeeds, the branch doug/task-${task.id} was created by the previous agent for this task in this same run, which stopped without returning a result; it is yours, not stale. Find that agent's worktree with git worktree list --porcelain (the one with branch refs/heads/doug/task-${task.id}); if none is listed, go straight to the checkout. If it has uncommitted changes to owned files, commit them there first with a message starting "${task.id}: ". ${NO_TRAILERS} Then remove that worktree with git worktree remove --force <path>, then git checkout doug/task-${task.id} in your own worktree and continue the task from that branch's state (do not recreate the branch or reset it). Never return blocked for the branch existing.`
+    ? `   Before that, if git rev-parse --verify --quiet refs/heads/doug/task-${task.id} succeeds, the branch doug/task-${task.id} was created by the previous agent for this task in this same run, which stopped without returning a result; it is yours, not stale. Find that agent's worktree with git worktree list --porcelain (the one with branch refs/heads/doug/task-${task.id}); if none is listed, go straight to the checkout. If it has uncommitted changes to owned files, commit them there first with a message starting "${task.id}: ". ${NO_TRAILERS} ${FOREGROUND_COMMIT} Then remove that worktree with git worktree remove --force <path>, then git checkout doug/task-${task.id} in your own worktree and continue the task from that branch's state (do not recreate the branch or reset it). Never return blocked for the branch existing.`
     : `   Before that, if git rev-parse --verify --quiet refs/heads/doug/task-${task.id} succeeds, the branch is a leftover of an earlier run: do not check it out or build on it; change nothing and return blocked=true with blockedReason "stale branch doug/task-${task.id} already exists; run plan.mjs replan, which renames it".`
   return [
     `You are implementing exactly one task from an approved plan. Work only in your own git worktree.`,
@@ -854,7 +857,7 @@ function implementPrompt(task, baseBranch, opts) {
     `   A fresh worktree has no installed dependencies: if the verification command needs them, run the project's install command first${plan.install ? ` (${plan.install})` : ''}. Installing is not a file change you own; do not commit lockfile changes it makes.`,
     `2. Touch no file outside your owned list. If the task cannot be done without another file, stop and report blocked=true with the reason.`,
     `3. Run the verification command before finishing and report each command with its real exit status. Never report a command you did not run.`,
-    `4. Commit your work on the branch with a message starting "${task.id}: ". ${NO_TRAILERS}`,
+    `4. Commit your work on the branch with a message starting "${task.id}: ". ${NO_TRAILERS} ${FOREGROUND_COMMIT}`,
     `5. Return the structured result. filesTouched must come from git, not memory, and commit must be the output of git rev-parse HEAD in your worktree after that commit.`,
     `6. ${PARTIAL_RULE}`,
   ].join('\n')
@@ -885,7 +888,7 @@ function reusePrompt(task, baseBranch) {
 function leadPrompt(task, baseBranch, opts) {
   const resume = !!(opts && opts.resume)
   const branchCheck = resume
-    ? `   Before that, if git rev-parse --verify --quiet refs/heads/doug/task-${task.id} succeeds, the branch doug/task-${task.id} was created by the previous agent for this task in this same run, which stopped without returning a result; it is yours, not stale. Find that agent's worktree with git worktree list --porcelain (the one with branch refs/heads/doug/task-${task.id}); if none is listed, go straight to the checkout. If it has uncommitted changes to owned files, commit them there first with a message starting "${task.id}: ". ${NO_TRAILERS} Then remove that worktree with git worktree remove --force <path>, then git checkout doug/task-${task.id} in your own worktree and continue the task from that branch's state (do not recreate the branch or reset it). Never return blocked for the branch existing.`
+    ? `   Before that, if git rev-parse --verify --quiet refs/heads/doug/task-${task.id} succeeds, the branch doug/task-${task.id} was created by the previous agent for this task in this same run, which stopped without returning a result; it is yours, not stale. Find that agent's worktree with git worktree list --porcelain (the one with branch refs/heads/doug/task-${task.id}); if none is listed, go straight to the checkout. If it has uncommitted changes to owned files, commit them there first with a message starting "${task.id}: ". ${NO_TRAILERS} ${FOREGROUND_COMMIT} Then remove that worktree with git worktree remove --force <path>, then git checkout doug/task-${task.id} in your own worktree and continue the task from that branch's state (do not recreate the branch or reset it). Never return blocked for the branch existing.`
     : `   Before that, if git rev-parse --verify --quiet refs/heads/doug/task-${task.id} succeeds, the branch is a leftover of an earlier run: do not check it out or build on it; change nothing and return blocked=true with blockedReason "stale branch doug/task-${task.id} already exists; run plan.mjs replan, which renames it".`
   return [
     `You are the lead of a swarm for exactly one task of an approved plan. You split the task into worker briefs; you do not implement anything and you edit no file. Work only in your own git worktree.`,
@@ -944,7 +947,7 @@ function workerPrompt(task, brief, n, lead) {
     `   A fresh worktree has no installed dependencies: if the verification command needs them, run the project's install command first${plan.install ? ` (${plan.install})` : ''}. Installing is not a file change you own; do not commit lockfile changes it makes.`,
     `2. Touch no file outside your owned list. If the brief cannot be done without another file, stop and report blocked=true with a blockedReason that names exactly what you need - the file, the symbol or interface, or the decision - because the lead may re-brief you once on it; a vague reason wastes that chance.`,
     `3. Run the verification command before finishing and report each command with its real exit status. Never report a command you did not run.`,
-    `4. Commit your work on the branch with a message starting "${task.id}: w${n} ". ${NO_TRAILERS}`,
+    `4. Commit your work on the branch with a message starting "${task.id}: w${n} ". ${NO_TRAILERS} ${FOREGROUND_COMMIT}`,
     `5. Return the structured result. filesTouched must come from git diff --name-only ${lead.branch}...HEAD, and commit must be the output of git rev-parse HEAD in your worktree after that commit.`,
     `6. ${PARTIAL_RULE}`,
   ].join('\n')
@@ -1048,7 +1051,7 @@ function fixPrompt(task, r, pass, baseBranch, ledger, brief) {
   lines.push(`1. Touch no file outside your owned list. If a finding can only be met by changing another file, stop and return blocked=true with the reason.`)
   lines.push(`2. Do not delete, skip, or weaken any test to make a check pass; make the code satisfy it. If that is impossible within the spec, return blocked=true and say why.`)
   lines.push(`3. Run the verification command before finishing; it must pass. Report every command with its real exit status and never one you did not run.`)
-  lines.push(`4. Commit on ${r.impl.branch} with a message starting "${task.id}: fix ". Do not amend or rewrite earlier commits. A pass that ends with no new commit stops the task. ${NO_TRAILERS}`)
+  lines.push(`4. Commit on ${r.impl.branch} with a message starting "${task.id}: fix ". Do not amend or rewrite earlier commits. A pass that ends with no new commit stops the task. ${NO_TRAILERS} ${FOREGROUND_COMMIT}`)
   lines.push(`5. Return the structured result with taskId="${task.id}", branch="${r.impl.branch}", worktreePath${r.worktreeGone ? ' = the absolute path of your worktree (git rev-parse --show-toplevel)' : `="${r.impl.worktreePath}"`}, filesTouched from git diff --name-only ${baseBranch}...HEAD, commit from git rev-parse HEAD after your commit, blocked=false.`)
   lines.push(`6. ${PARTIAL_RULE}`)
   return lines.join('\n')
@@ -1081,7 +1084,7 @@ function resumePrompt(task, prev, handoff, baseBranch, brief) {
     `Rules:`,
     `1. Touch no file outside your owned list. If the work cannot be done without another file, stop and report blocked=true with the reason.`,
     `2. Run the verification command before finishing and report each command with its real exit status. Never report a command you did not run.`,
-    `3. Commit your work on ${prev.branch} with a message starting "${task.id}: resume ". ${NO_TRAILERS}`,
+    `3. Commit your work on ${prev.branch} with a message starting "${task.id}: resume ". ${NO_TRAILERS} ${FOREGROUND_COMMIT}`,
     `4. ${PARTIAL_RULE}`,
     `5. Return the structured result. filesTouched must come from git diff --name-only ${baseBranch}...HEAD, and commit must be the output of git rev-parse HEAD in your worktree after that commit.`,
   ].join('\n')
@@ -1125,9 +1128,10 @@ function supervisePrompt(task, r, attempts, ledger, signals) {
   ].join('\n')
 }
 
-function verifyPrompt(task, impl, baseBranch) {
+function verifyPrompt(task, impl, baseBranch, seat = 1) {
   return [
     `You are a verifier. You did not write this code. Your job is to run it, not to read and approve it.`,
+    ...(seat > 1 ? [`You are crew seat ${seat} of ${crewOf(task).testers} on this task: another verifier runs the same checks at the same time. Run the verification and acceptance commands yourself, and beyond them probe the behavior the spec implies that those commands may not cover: edge cases (empty, missing, boundary, and repeated input) and error paths (invalid input, a failing dependency). A defect you find is a finding even when every command passes.`] : []),
     ``,
     `Task ${task.id}: ${task.title}`,
     `Spec:`,
@@ -1432,14 +1436,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 +1453,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 +1473,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.`,
@@ -1990,13 +1994,41 @@ async function runAdversary(task, impl, pass, baseBranch, ledger, launch, stages
 }
 
 // ---- Crew (card crew-sizing) ---------------------------------------------------
-// A task (or the plan) declares how many reviewers and adversaries read it; default one each. More coders is a
+// A task (or the plan) declares how many reviewers, adversaries and testers read it; default one each. More coders is a
 // split into more tasks, never a shared worktree, so the crew has no coders row. Researchers run before planning
 // (the research skill) and are not launched here.
 function crewOf(task) {
   const src = { ...((plan.crew && typeof plan.crew === 'object') ? plan.crew : {}), ...((task && task.crew && typeof task.crew === 'object') ? task.crew : {}) }
   const n = v => (Number.isInteger(v) && v > 0 ? v : 1)
-  return { reviewers: n(src.reviewers), adversaries: n(src.adversaries) }
+  return { reviewers: n(src.reviewers), adversaries: n(src.adversaries), testers: n(src.testers) }
+}
+
+// One verification out of several tester seats (card crew-tester-seat): passed only when every seat that returned
+// passed, findings and commands concatenated so the ledger's fingerprint collapses a duplicate, and an acceptance
+// criterion (matched by text) ok only when every seat reporting it ok. A seat that returned nothing is dropped; when
+// no seat returned anything the stage returned nothing; one seat comes back unchanged.
+function mergeVerifies(seats) {
+  const got = seats.filter(Boolean)
+  if (!got.length) return null
+  if (got.length === 1 && seats.length === 1) return got[0]
+  const acceptance = []
+  for (const v of got) {
+    for (const a of (v.acceptance || [])) {
+      const at = acceptance.findIndex(x => x.text === a.text)
+      if (at < 0) acceptance.push({ ...a })
+      else if (acceptance[at].ok && !a.ok) acceptance[at] = { ...a }
+    }
+  }
+  return {
+    taskId: got[0].taskId,
+    passed: got.every(v => v.passed),
+    commandsRun: got.flatMap(v => v.commandsRun || []),
+    findings: got.flatMap(v => v.findings || []),
+    findingFiles: got.flatMap(v => v.findingFiles || []),
+    acceptance,
+    head: got[0].head,
+    seats: got.length,
+  }
 }
 
 // One review out of several: every seat must approve, and every seat's issues are kept, so a finding one reviewer
@@ -2159,19 +2191,21 @@ async function runChecks(task, impl, pass, baseBranch, ctx) {
     // The verifier, the reviewer, and the adversary are read-only and none reads another's result, so a first pass
     // launches them together; a null from any (skipped, or dead after retries) is that stage returning nothing.
     stages.push('verify')
-    stages.push('review')
     const crew = crewOf(task)
+    for (let seat = 2; seat <= crew.testers; seat++) stages.push(`verify-${seat}`)
+    stages.push('review')
     for (let seat = 2; seat <= crew.reviewers; seat++) stages.push(`review-${seat}`)
     const withAdversary = adversaryRequired(task)
     const advStages = []
     const pair = await parallel([
       () => launch(verifyPrompt(task, impl, baseBranch), agentOpts('verify', task, { label: `verify:${task.id}`, phase: 'Verify', agentType: 'doug-flow:verifier', schema: VERIFY_SCHEMA })),
+      ...Array.from({ length: crew.testers - 1 }, (_, i) => () => launch(verifyPrompt(task, impl, baseBranch, i + 2), agentOpts('verify', task, { label: `verify-${i + 2}:${task.id}`, phase: 'Verify', agentType: 'doug-flow:verifier', schema: VERIFY_SCHEMA }))),
       () => launch(reviewPrompt(task, impl, baseBranch), agentOpts('review', task, { label: `review:${task.id}`, phase: 'Review', agentType: 'doug-flow:reviewer', schema: REVIEW_SCHEMA })),
       ...Array.from({ length: crew.reviewers - 1 }, (_, i) => () => launch(reviewPrompt(task, impl, baseBranch, i + 2), agentOpts('review', task, { label: `review-${i + 2}:${task.id}`, phase: 'Review', agentType: 'doug-flow:reviewer', schema: REVIEW_SCHEMA }))),
       ...(withAdversary ? [() => runAdversaryCrew(task, impl, pass, baseBranch, ledger, launch, advStages)] : []),
     ])
-    ver = (pair && pair[0]) || null
-    rev = pair ? mergeReviews(pair.slice(1, 1 + crew.reviewers)) : null
+    ver = pair ? mergeVerifies(pair.slice(0, crew.testers)) : null
+    rev = pair ? mergeReviews(pair.slice(crew.testers, crew.testers + crew.reviewers)) : null
     stageResults.verify = ver
     stageResults.review = rev
     // The adversary no longer waits for verify and review (card flow-adversary-parallel, 2026-10-07): waiting
@@ -2179,7 +2213,7 @@ async function runChecks(task, impl, pass, baseBranch, ctx) {
     // integration still needs all three verdicts (isReady), and the ledger reads each stage's findings.
     if (withAdversary) {
       stages.push(...advStages)
-      adv = (pair && pair[1 + crew.reviewers]) || null
+      adv = (pair && pair[crew.testers + crew.reviewers]) || null
       stageResults.adversary = adv
     }
     blockingStage = !(ver && ver.passed) ? 'verify' : !(rev && rev.approve) ? 'review' : adversaryBlocked(adv) ? 'adversary' : null
@@ -2187,7 +2221,13 @@ async function runChecks(task, impl, pass, baseBranch, ctx) {
     const first = c.blocking || 'verify'
     if (first === 'verify') {
       stages.push('verify')
-      ver = await launch(verifyPrompt(task, impl, baseBranch), agentOpts('verify', task, { label: `verify:${task.id}${suffix}`, phase: 'Verify', agentType: 'doug-flow:verifier', schema: VERIFY_SCHEMA }))
+      const testers = crewOf(task).testers
+      for (let seat = 2; seat <= testers; seat++) stages.push(`verify-${seat}`)
+      const verifyOpts = seat => agentOpts('verify', task, { label: `verify${seat > 1 ? `-${seat}` : ''}:${task.id}${suffix}`, phase: 'Verify', agentType: 'doug-flow:verifier', schema: VERIFY_SCHEMA })
+      if (testers > 1) {
+        const seats = await parallel(Array.from({ length: testers }, (_, i) => () => launch(verifyPrompt(task, impl, baseBranch, i + 1), verifyOpts(i + 1))))
+        ver = mergeVerifies(seats || [])
+      } else ver = await launch(verifyPrompt(task, impl, baseBranch), verifyOpts(1))
       stageResults.verify = ver
       if (!(ver && ver.passed)) blockingStage = 'verify'
     } else if (first === 'review') {
@@ -2422,7 +2462,7 @@ async function runTask(task, baseBranch, resume) {
     const fellBack = (r.stages || []).includes('adversary-fallback')
     const crew = crewOf(task)
     const advAgents = adversaryRequired(task) ? (fellBack ? 1 : 0) + crew.adversaries : 0
-    const firstStage = blocking === 'adversary' ? advAgents : blocking === 'review' ? crew.reviewers : 1
+    const firstStage = blocking === 'adversary' ? advAgents : blocking === 'review' ? crew.reviewers : blocking === 'verify' ? crew.testers : 1
     const nextStages = firstStage + (blocking === 'check' ? 0 : 1) + (blocking === 'adversary' ? 0 : advAgents)
     const spent = measure()
     const passesDone = attempts.length

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.3.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
   }