From a9e86811fee4d92880d7007ceb179cb29eaf8bdd Mon Sep 17 00:00:00 2001
From: Bacsystem Solutions EIRL <dbacilio88@outlook.es>
Date: Tue, 21 Jul 2026 07:35:25 -0500
Subject: [PATCH 01/11] fix(review-package): raise git execFileSync maxBuffer
 to 1GB
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Default Node execFileSync buffer (1MB) is too small for a real diff
package spanning many files (hit during the bs-inventory pilot's
Task 13, a 207-file MUI Premium/Pro removal) — git commands would
throw ENOBUFS/maxBuffer exceeded instead of returning the diff.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0145sjAtP5b5kvhR1XCgg3K3
---
 bin/review-package.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bin/review-package.js b/bin/review-package.js
index a0dc66f..5719d75 100644
--- a/bin/review-package.js
+++ b/bin/review-package.js
@@ -12,7 +12,7 @@ if (!repoPath || !baseSha || !headSha || !outDir) {
 // execFile (sin shell) con -C: los SHAs y rutas llegan de otros agentes — nada se
 // interpola en una línea de shell.
 function git(...args) {
-  return execFileSync('git', ['-C', repoPath, ...args], { encoding: 'utf8' });
+  return execFileSync('git', ['-C', repoPath, ...args], { encoding: 'utf8', maxBuffer: 1024 * 1024 * 1024 });
 }
 
 let commits, stat, diff;

From c30f69dee5e64380380608b999863934c251d58b Mon Sep 17 00:00:00 2001
From: Bacsystem Solutions EIRL <dbacilio88@outlook.es>
Date: Tue, 21 Jul 2026 07:35:46 -0500
Subject: [PATCH 02/11] fix(state): ask the state/ledger agents to verify, not
 just assert
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The 2026-07-18 fix for the safety-classifier blocking state-write calls
("frame the content as already-verified bookkeeping") turned out not to
resolve the problem — it's exactly that framing that kept getting
flagged as Instruction Poisoning across two real bs-inventory pilot runs
(2026-07-20/21). An isolated agent with no memory of the run has no way
to confirm "trust me, this already happened," which reads exactly like
an injection attempt.

Evidence from those same runs: agents that independently verified
against real repo state (git log, task reports) before writing passed
the classifier without issue. So writeState()/deleteState()/
appendLedger() now instruct the agent to verify the content against the
actual repo (git log, git merge-base, .cys/task-<id>-report.md) before
writing, with an explicit "don't write, report the discrepancy instead"
escape hatch if verification fails — turning the task from "copy this
claim" into "verify and record," which is the pattern that already
worked in practice.

Full context in .cys/pending.md (reopened the 2026-07-18 entry rather
than filing a new one).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0145sjAtP5b5kvhR1XCgg3K3
---
 tests/build-workflow.test.js                  | 23 +++++++++--
 .../parallel-plan-executor.template.js        | 41 ++++++++++++-------
 workflows/parallel-plan-executor.js           | 41 ++++++++++++-------
 3 files changed, 74 insertions(+), 31 deletions(-)

diff --git a/tests/build-workflow.test.js b/tests/build-workflow.test.js
index fa62159..cd90ce9 100644
--- a/tests/build-workflow.test.js
+++ b/tests/build-workflow.test.js
@@ -315,10 +315,27 @@ test('built workflow tags .cys/state.json writes with their own phase, not Merge
   );
 });
 
-test('built workflow frames the state-write prompt as verified bookkeeping, not new claims (safety-classifier block, pending.md bug)', () => {
+test('built workflow instructs the state-write agent to verify against real repo state, not just assert the content is true (safety-classifier block, pending.md bug reopened 2026-07-21)', () => {
+  const writeStateIndex = output.indexOf('function writeState()');
+  assert.ok(writeStateIndex >= 0, 'debe existir writeState()');
+  const writeStateBody = output.slice(writeStateIndex, writeStateIndex + 1600);
+  assert.ok(
+    writeStateBody.includes('independently verify') && writeStateBody.includes('git log') && writeStateBody.includes('git merge-base'),
+    'la primera corrección (afirmarle al agente "esto ya es verdad, escríbelo") seguía siendo bloqueada por el clasificador en corridas reales — el prompt debe pedirle al agente que verifique el contenido contra el repo real antes de escribir, no solo confiar en la afirmación'
+  );
+  assert.ok(
+    writeStateBody.includes('do not write the file') || writeStateBody.includes("don't write the file"),
+    'el agente debe tener una salida explícita para cuando la verificación falla, en vez de escribir igual'
+  );
+});
+
+test('built workflow instructs the ledger-append agent to spot-check the line against real evidence before appending (safety-classifier block, pending.md bug reopened 2026-07-21)', () => {
+  const appendLedgerIndex = output.indexOf('function appendLedger(');
+  assert.ok(appendLedgerIndex >= 0, 'debe existir appendLedger()');
+  const appendLedgerBody = output.slice(appendLedgerIndex, appendLedgerIndex + 1200);
   assert.ok(
-    output.includes('bookkeeping snapshot') && output.includes('already completed and verified earlier in this same run'),
-    'sin este framing, el clasificador de seguridad puede leer un JSON con status "done" y SHAs reales como una fabricación en vez de un registro legítimo de resultados ya verificados'
+    appendLedgerBody.includes('spot-check') && appendLedgerBody.includes('git log'),
+    'el agente de ledger debe verificar las afirmaciones de la línea contra evidencia real (git log, reportes) antes de agregarla, no solo confiar en el texto que le pasaron'
   );
 });
 
diff --git a/workflows-src/parallel-plan-executor.template.js b/workflows-src/parallel-plan-executor.template.js
index 2902501..c71b71c 100644
--- a/workflows-src/parallel-plan-executor.template.js
+++ b/workflows-src/parallel-plan-executor.template.js
@@ -39,23 +39,29 @@ function stateJson() {
 
 function writeState() {
   return enqueueMainRepo(() => agent(
-    `Run \`date +%H:%M:%S\` first to get the current time. In repo ${repoPath}, write to ` +
-    `.cys/state.json (create the file and its directory if missing, overwriting anything ` +
-    `already there) the content between the <content> tags below, but with ` +
-    `"updatedAt": "<time from date>" inserted as a top-level field right after ` +
-    `"integrationBranch". This is the Workflow's own bookkeeping snapshot, not new work — ` +
-    `every status/SHA in it reflects tasks already completed and verified earlier in this same run ` +
-    `(real merges, real commit SHAs, real review verdicts), kept as a durable record so a ` +
-    `future session can detect and resume an interrupted run. Write nothing else, no ` +
-    `commentary:\n<content>${stateJson()}</content>`,
+    `Run \`date +%H:%M:%S\` first to get the current time. In repo ${repoPath}, you are ` +
+    `updating .cys/state.json, a resume-bookkeeping snapshot for a parallel-plan-executor run. ` +
+    `Before writing anything: independently verify the content below against the repo's actual ` +
+    `state — for each task marked done, confirm its branch/commit SHA is a real ancestor of the ` +
+    `integration branch (git log / git merge-base); for each task marked failed or in a given ` +
+    `phase, check for corroborating evidence (a .cys/task-<id>-report.md, a review diff, a git ` +
+    `log entry) rather than accepting the claim at face value. If everything checks out, write ` +
+    `the content between the <content> tags to .cys/state.json (create the file/directory if ` +
+    `missing, overwrite anything already there), with "updatedAt": "<time from date>" inserted ` +
+    `as a top-level field right after "integrationBranch", and nothing else. If you find a real ` +
+    `discrepancy between the content below and the repo's actual state, do not write the file — ` +
+    `report the discrepancy instead so it can be corrected.\n<content>${stateJson()}</content>`,
     { label: 'state', phase: 'State' }
   ));
 }
 
 function deleteState() {
   return enqueueMainRepo(() => agent(
-    `In repo ${repoPath}, delete .cys/state.json if it exists (the run finished naturally; ` +
-    `no incomplete state to report). It's fine if it doesn't exist already.`,
+    `In repo ${repoPath}, check whether .cys/state.json exists. If it does, verify against the ` +
+    `repo's actual state (git log on the integration branch, .cys/task-<id>-report.md files) ` +
+    `that the run it describes has genuinely finished — no task still pending or in progress. ` +
+    `If that checks out, delete .cys/state.json. If it doesn't exist, there's nothing to do. If ` +
+    `you find the run hasn't actually finished, don't delete it — report why instead.`,
     { label: 'state-clear', phase: 'Handoff' }
   ));
 }
@@ -114,9 +120,16 @@ function appendLedger(line) {
   // <line></line> porque incluye texto libre de otros agentes (concerns, findings) —
   // una comilla en ese texto rompía el framing del prompt.
   return enqueueMainRepo(() => agent(
-    `In repo ${repoPath}, append to .cys/progress.md (create the file and ` +
-    `its directory if missing) exactly the single line between the <line> tags below, ` +
-    `without the tags:\n<line>${line}</line>`,
+    `In repo ${repoPath}, you are appending one line to .cys/progress.md, a human-readable ` +
+    `log of this parallel-plan-executor run. The proposed line is between the <line> tags ` +
+    `below, written by an earlier step in this same run. Before appending it, spot-check its ` +
+    `factual claims against real evidence you can inspect yourself — a referenced commit SHA ` +
+    `should exist in \`git log\`, a referenced merge/conflict should be visible in the repo's ` +
+    `actual state or a .cys/task-<id>-report.md, a referenced review verdict should match a ` +
+    `real review diff. If it checks out, append it verbatim (create the file/directory if ` +
+    `missing), without the tags. If you find it describes something that didn't actually ` +
+    `happen, don't append it — report the discrepancy instead so the line can be corrected.` +
+    `\n<line>${line}</line>`,
     { label: 'ledger', phase: 'Merge' }
   ));
 }
diff --git a/workflows/parallel-plan-executor.js b/workflows/parallel-plan-executor.js
index 37fee36..03f7100 100644
--- a/workflows/parallel-plan-executor.js
+++ b/workflows/parallel-plan-executor.js
@@ -347,23 +347,29 @@ function stateJson() {
 
 function writeState() {
   return enqueueMainRepo(() => agent(
-    `Run \`date +%H:%M:%S\` first to get the current time. In repo ${repoPath}, write to ` +
-    `.cys/state.json (create the file and its directory if missing, overwriting anything ` +
-    `already there) the content between the <content> tags below, but with ` +
-    `"updatedAt": "<time from date>" inserted as a top-level field right after ` +
-    `"integrationBranch". This is the Workflow's own bookkeeping snapshot, not new work — ` +
-    `every status/SHA in it reflects tasks already completed and verified earlier in this same run ` +
-    `(real merges, real commit SHAs, real review verdicts), kept as a durable record so a ` +
-    `future session can detect and resume an interrupted run. Write nothing else, no ` +
-    `commentary:\n<content>${stateJson()}</content>`,
+    `Run \`date +%H:%M:%S\` first to get the current time. In repo ${repoPath}, you are ` +
+    `updating .cys/state.json, a resume-bookkeeping snapshot for a parallel-plan-executor run. ` +
+    `Before writing anything: independently verify the content below against the repo's actual ` +
+    `state — for each task marked done, confirm its branch/commit SHA is a real ancestor of the ` +
+    `integration branch (git log / git merge-base); for each task marked failed or in a given ` +
+    `phase, check for corroborating evidence (a .cys/task-<id>-report.md, a review diff, a git ` +
+    `log entry) rather than accepting the claim at face value. If everything checks out, write ` +
+    `the content between the <content> tags to .cys/state.json (create the file/directory if ` +
+    `missing, overwrite anything already there), with "updatedAt": "<time from date>" inserted ` +
+    `as a top-level field right after "integrationBranch", and nothing else. If you find a real ` +
+    `discrepancy between the content below and the repo's actual state, do not write the file — ` +
+    `report the discrepancy instead so it can be corrected.\n<content>${stateJson()}</content>`,
     { label: 'state', phase: 'State' }
   ));
 }
 
 function deleteState() {
   return enqueueMainRepo(() => agent(
-    `In repo ${repoPath}, delete .cys/state.json if it exists (the run finished naturally; ` +
-    `no incomplete state to report). It's fine if it doesn't exist already.`,
+    `In repo ${repoPath}, check whether .cys/state.json exists. If it does, verify against the ` +
+    `repo's actual state (git log on the integration branch, .cys/task-<id>-report.md files) ` +
+    `that the run it describes has genuinely finished — no task still pending or in progress. ` +
+    `If that checks out, delete .cys/state.json. If it doesn't exist, there's nothing to do. If ` +
+    `you find the run hasn't actually finished, don't delete it — report why instead.`,
     { label: 'state-clear', phase: 'Handoff' }
   ));
 }
@@ -422,9 +428,16 @@ function appendLedger(line) {
   // <line></line> porque incluye texto libre de otros agentes (concerns, findings) —
   // una comilla en ese texto rompía el framing del prompt.
   return enqueueMainRepo(() => agent(
-    `In repo ${repoPath}, append to .cys/progress.md (create the file and ` +
-    `its directory if missing) exactly the single line between the <line> tags below, ` +
-    `without the tags:\n<line>${line}</line>`,
+    `In repo ${repoPath}, you are appending one line to .cys/progress.md, a human-readable ` +
+    `log of this parallel-plan-executor run. The proposed line is between the <line> tags ` +
+    `below, written by an earlier step in this same run. Before appending it, spot-check its ` +
+    `factual claims against real evidence you can inspect yourself — a referenced commit SHA ` +
+    `should exist in \`git log\`, a referenced merge/conflict should be visible in the repo's ` +
+    `actual state or a .cys/task-<id>-report.md, a referenced review verdict should match a ` +
+    `real review diff. If it checks out, append it verbatim (create the file/directory if ` +
+    `missing), without the tags. If you find it describes something that didn't actually ` +
+    `happen, don't append it — report the discrepancy instead so the line can be corrected.` +
+    `\n<line>${line}</line>`,
     { label: 'ledger', phase: 'Merge' }
   ));
 }

From 63865cd81228ab242da4fc6ad8f3ebcc17ceaa9e Mon Sep 17 00:00:00 2001
From: Bacsystem Solutions EIRL <dbacilio88@outlook.es>
Date: Tue, 21 Jul 2026 07:43:49 -0500
Subject: [PATCH 03/11] docs(cys:plan): add caller-cardinality and
 spec-field-literalness self-review checks
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Two real bugs shipped past cys:plan's existing self-review checklist in
the bs-inventory pilot (2026-07-20/21), both caught only by the
executor's adversarial reviewer, not by writing the plan itself:

- BuildKardex used one shared balance accumulator, tested with a single
  product/warehouse; two other tasks' sample code fed it a whole
  tenant's multi-product/multi-warehouse movements, silently mixing
  balances — invisible without tracing the real call sites.
- PLE field 4 used the warehouse's internal ID instead of
  Warehouse.rucEstablishmentCode, which the design spec named explicitly
  — written from a general sense of "the warehouse" rather than the
  spec's literal field mapping.

Neither "does every function have a test" nor "do types match across
tasks" catches either class, so both are now explicit self-review steps.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0145sjAtP5b5kvhR1XCgg3K3
---
 skills/plan/SKILL.md | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/skills/plan/SKILL.md b/skills/plan/SKILL.md
index 5c4048b..50045f5 100644
--- a/skills/plan/SKILL.md
+++ b/skills/plan/SKILL.md
@@ -93,6 +93,24 @@ Each step is one 2-5 minute action, with complete content — never
   An empty warnings array is not proof the graph is right, only that the
   parser didn't flag anything; a plan-authoring mistake can still produce
   a graph that's silently wrong.
+- **Caller-cardinality check:** for any function whose sample code you
+  write once and other tasks' sample code then calls, find every one of
+  those call sites and check the multiplicity they actually feed it — not
+  just the single trivial case your own task's test happens to cover. A
+  `bs-inventory` pilot (2026-07-20) shipped a compliance ledger function
+  with a single shared running-balance accumulator, tested with one
+  product at one warehouse; two *other* tasks' sample code fed it a whole
+  tenant's movements across many products/warehouses, silently mixing
+  unrelated balances — invisible until a reviewer traced the real callers,
+  not caught by the function's own task's test.
+- **Spec-field literalness check:** for any sample code that maps a
+  specific field to a specific spec-mandated value (compliance/legal
+  fields especially), re-read that exact line of the design spec at
+  write time and grep for it — don't write the field from memory of the
+  general idea. Same pilot: the design spec said field 4 must be
+  `Warehouse.rucEstablishmentCode`; the plan's sample code used the
+  warehouse's internal ID instead, because it was written from a general
+  sense of "the warehouse" rather than the spec's literal mapping.
 - **Exhaustive-coverage claims:** if the spec states a test suite "covers
   every case in this table" (or similar), the plan's test steps must
   enumerate each row as its own explicit test step — a summary claim

From 8c12b6a36b18e5309b8bc74fa33f1a49557eab77 Mon Sep 17 00:00:00 2001
From: Bacsystem Solutions EIRL <dbacilio88@outlook.es>
Date: Tue, 21 Jul 2026 08:00:43 -0500
Subject: [PATCH 04/11] fix(state): let the state-write agent self-correct
 instead of just refusing
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fixing the classifier false-positive (previous commit) surfaced a real
follow-on gap: writeState()'s snapshot is built when the write is
queued, but enqueueMainRepo serializes it behind other real repo work,
so by the time the agent actually runs, the content can be genuinely
stale — not fabricated, just overtaken by real progress. The agent was
correctly verifying this (as designed) but only knew how to refuse and
report, with no automatic retry anywhere in the script — so state.json
stayed frozen at whatever the last accepted write was, observed in a
live bs-inventory pilot run staying pinned at the very first snapshot
(before any task had even started) for the rest of the run.

writeState() now tells the agent that staleness alone isn't a red flag,
and to correct the specific task entries itself from what it verifies
(real branch/SHA for done tasks; status "in_progress" *and* a "phase"
for started-but-unmerged tasks — a status with no phase is an
incomplete correction) rather than stopping at "this doesn't match,
I won't write it." Refusal is now reserved for entries that look
fabricated outright (a "done" SHA that doesn't exist anywhere in the
repo's history), not merely out of date.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0145sjAtP5b5kvhR1XCgg3K3
---
 tests/build-workflow.test.js                  | 12 ++++++---
 .../parallel-plan-executor.template.js        | 26 ++++++++++++++-----
 workflows/parallel-plan-executor.js           | 26 ++++++++++++++-----
 3 files changed, 48 insertions(+), 16 deletions(-)

diff --git a/tests/build-workflow.test.js b/tests/build-workflow.test.js
index cd90ce9..f078f92 100644
--- a/tests/build-workflow.test.js
+++ b/tests/build-workflow.test.js
@@ -318,14 +318,18 @@ test('built workflow tags .cys/state.json writes with their own phase, not Merge
 test('built workflow instructs the state-write agent to verify against real repo state, not just assert the content is true (safety-classifier block, pending.md bug reopened 2026-07-21)', () => {
   const writeStateIndex = output.indexOf('function writeState()');
   assert.ok(writeStateIndex >= 0, 'debe existir writeState()');
-  const writeStateBody = output.slice(writeStateIndex, writeStateIndex + 1600);
+  const writeStateBody = output.slice(writeStateIndex, writeStateIndex + 2600);
   assert.ok(
     writeStateBody.includes('independently verify') && writeStateBody.includes('git log') && writeStateBody.includes('git merge-base'),
     'la primera corrección (afirmarle al agente "esto ya es verdad, escríbelo") seguía siendo bloqueada por el clasificador en corridas reales — el prompt debe pedirle al agente que verifique el contenido contra el repo real antes de escribir, no solo confiar en la afirmación'
   );
   assert.ok(
-    writeStateBody.includes('do not write the file') || writeStateBody.includes("don't write the file"),
-    'el agente debe tener una salida explícita para cuando la verificación falla, en vez de escribir igual'
+    writeStateBody.includes("don't refuse to write") && writeStateBody.includes('correct that task'),
+    'una foto desactualizada por la cola de encolado es esperable, no un bloqueo — el agente debe autocorregir la entrada de la tarea con lo que verificó, no negarse a escribir sin más (el primer intento de este arreglo solo pedía "no escribas, reportá", lo que dejaba state.json congelado indefinidamente)'
+  );
+  assert.ok(
+    writeStateBody.includes('"status": "in_progress"') && writeStateBody.includes('"phase"'),
+    'la corrección debe incluir tanto status como phase para una tarea en curso — un status sin phase es una corrección incompleta (pedido explícito del usuario tras ver state.json sin fase)'
   );
 });
 
@@ -342,7 +346,7 @@ test('built workflow instructs the ledger-append agent to spot-check the line ag
 test('built workflow adds updatedAt to .cys/state.json via the write agent\'s own date command (pending.md gap, Fase 4b design)', () => {
   const writeStateIndex = output.indexOf('function writeState()');
   assert.ok(writeStateIndex >= 0, 'debe existir writeState()');
-  const writeStateBody = output.slice(writeStateIndex, writeStateIndex + 1400);
+  const writeStateBody = output.slice(writeStateIndex, writeStateIndex + 2600);
   assert.ok(
     writeStateBody.includes('date +%H:%M:%S'),
     'el timestamp no puede venir de Date.now()/new Date() (prohibido en el sandbox de Workflow) — debe pedirle al agente que corra date'
diff --git a/workflows-src/parallel-plan-executor.template.js b/workflows-src/parallel-plan-executor.template.js
index c71b71c..b7d0a88 100644
--- a/workflows-src/parallel-plan-executor.template.js
+++ b/workflows-src/parallel-plan-executor.template.js
@@ -45,12 +45,26 @@ function writeState() {
     `state — for each task marked done, confirm its branch/commit SHA is a real ancestor of the ` +
     `integration branch (git log / git merge-base); for each task marked failed or in a given ` +
     `phase, check for corroborating evidence (a .cys/task-<id>-report.md, a review diff, a git ` +
-    `log entry) rather than accepting the claim at face value. If everything checks out, write ` +
-    `the content between the <content> tags to .cys/state.json (create the file/directory if ` +
-    `missing, overwrite anything already there), with "updatedAt": "<time from date>" inserted ` +
-    `as a top-level field right after "integrationBranch", and nothing else. If you find a real ` +
-    `discrepancy between the content below and the repo's actual state, do not write the file — ` +
-    `report the discrepancy instead so it can be corrected.\n<content>${stateJson()}</content>`,
+    `log entry) rather than accepting the claim at face value. This content can go stale between ` +
+    `when it was queued and when you actually run (other tasks keep progressing in the ` +
+    `meantime) — that's expected, not a red flag by itself. If you find a task whose real state ` +
+    `has moved on (e.g. its branch is now a real ancestor of the integration branch but the ` +
+    `content still marks it pending, or a report/review-diff exists showing further progress ` +
+    `than stated), don't refuse to write — correct that task's own entry yourself based on what ` +
+    `you verified: if it's merged, "status": "done" plus its real branch/commit SHA; if its ` +
+    `branch exists but isn't merged yet, "status": "in_progress" **and** a "phase" field (e.g. ` +
+    `"Implement", "Review", or "Merge", picked from what the evidence shows it has reached — a ` +
+    `bare "status" with no "phase" for a task that has actually started is itself an incomplete ` +
+    `correction). Keep the exact same JSON shape and field vocabulary the other task entries in ` +
+    `this content already use (don't invent new status values or fields). Only refuse to write ` +
+    `if something looks actually fabricated rather than merely stale — e.g. a "done" entry ` +
+    `whose branch/SHA doesn't ` +
+    `actually fabricated rather than merely stale — e.g. a "done" entry whose branch/SHA doesn't ` +
+    `exist anywhere in the repo's history at all. Write the (corrected, if needed) content ` +
+    `between the <content> tags to .cys/state.json (create the file/directory if missing, ` +
+    `overwrite anything already there), with "updatedAt": "<time from date>" inserted as a ` +
+    `top-level field right after "integrationBranch", and nothing else.` +
+    `\n<content>${stateJson()}</content>`,
     { label: 'state', phase: 'State' }
   ));
 }
diff --git a/workflows/parallel-plan-executor.js b/workflows/parallel-plan-executor.js
index 03f7100..037d389 100644
--- a/workflows/parallel-plan-executor.js
+++ b/workflows/parallel-plan-executor.js
@@ -353,12 +353,26 @@ function writeState() {
     `state — for each task marked done, confirm its branch/commit SHA is a real ancestor of the ` +
     `integration branch (git log / git merge-base); for each task marked failed or in a given ` +
     `phase, check for corroborating evidence (a .cys/task-<id>-report.md, a review diff, a git ` +
-    `log entry) rather than accepting the claim at face value. If everything checks out, write ` +
-    `the content between the <content> tags to .cys/state.json (create the file/directory if ` +
-    `missing, overwrite anything already there), with "updatedAt": "<time from date>" inserted ` +
-    `as a top-level field right after "integrationBranch", and nothing else. If you find a real ` +
-    `discrepancy between the content below and the repo's actual state, do not write the file — ` +
-    `report the discrepancy instead so it can be corrected.\n<content>${stateJson()}</content>`,
+    `log entry) rather than accepting the claim at face value. This content can go stale between ` +
+    `when it was queued and when you actually run (other tasks keep progressing in the ` +
+    `meantime) — that's expected, not a red flag by itself. If you find a task whose real state ` +
+    `has moved on (e.g. its branch is now a real ancestor of the integration branch but the ` +
+    `content still marks it pending, or a report/review-diff exists showing further progress ` +
+    `than stated), don't refuse to write — correct that task's own entry yourself based on what ` +
+    `you verified: if it's merged, "status": "done" plus its real branch/commit SHA; if its ` +
+    `branch exists but isn't merged yet, "status": "in_progress" **and** a "phase" field (e.g. ` +
+    `"Implement", "Review", or "Merge", picked from what the evidence shows it has reached — a ` +
+    `bare "status" with no "phase" for a task that has actually started is itself an incomplete ` +
+    `correction). Keep the exact same JSON shape and field vocabulary the other task entries in ` +
+    `this content already use (don't invent new status values or fields). Only refuse to write ` +
+    `if something looks actually fabricated rather than merely stale — e.g. a "done" entry ` +
+    `whose branch/SHA doesn't ` +
+    `actually fabricated rather than merely stale — e.g. a "done" entry whose branch/SHA doesn't ` +
+    `exist anywhere in the repo's history at all. Write the (corrected, if needed) content ` +
+    `between the <content> tags to .cys/state.json (create the file/directory if missing, ` +
+    `overwrite anything already there), with "updatedAt": "<time from date>" inserted as a ` +
+    `top-level field right after "integrationBranch", and nothing else.` +
+    `\n<content>${stateJson()}</content>`,
     { label: 'state', phase: 'State' }
   ));
 }

From b688136ca503bc2adc7e963ff8087c1813b64f7e Mon Sep 17 00:00:00 2001
From: Bacsystem Solutions EIRL <dbacilio88@outlook.es>
Date: Tue, 21 Jul 2026 08:16:34 -0500
Subject: [PATCH 05/11] fix(state): coalesce concurrent state-write requests
 into one agent
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

settle() and markInProgress() each called writeState() directly, so
every task transition dispatched its own [state] agent — with several
tasks settling close together (a common pattern: every dependency-free
task starting around the same time) this meant one agent per
transition, even though a single fresh write right after the cluster
would capture the same information.

requestWriteState() now coalesces: if a write is already in flight when
a new request arrives, it just flags "there's more to record" instead
of spawning another agent; the in-flight write's own loop notices the
flag once it finishes and does one more pass (reading fresh state at
that point) before settling. Crash-resume safety is unchanged — it still
writes at least once per settling wave — but the agent count drops with
how much settling clusters in real runs.

Also fixed a duplicated sentence left over from the previous commit's
writeState() prompt edit (harmless but confusing repeated text).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0145sjAtP5b5kvhR1XCgg3K3
---
 tests/build-workflow.test.js                  | 14 ++++++++
 .../parallel-plan-executor.template.js        | 34 ++++++++++++++++---
 workflows/parallel-plan-executor.js           | 34 ++++++++++++++++---
 3 files changed, 72 insertions(+), 10 deletions(-)

diff --git a/tests/build-workflow.test.js b/tests/build-workflow.test.js
index f078f92..caf682e 100644
--- a/tests/build-workflow.test.js
+++ b/tests/build-workflow.test.js
@@ -343,6 +343,20 @@ test('built workflow instructs the ledger-append agent to spot-check the line ag
   );
 });
 
+test('built workflow coalesces concurrent state-write requests instead of dispatching one [state] agent per settle()/markInProgress() call', () => {
+  const requestIndex = output.indexOf('function requestWriteState()');
+  assert.ok(requestIndex >= 0, 'debe existir requestWriteState(), el wrapper de coalescing sobre writeState()');
+  const requestBody = output.slice(requestIndex, requestIndex + 500);
+  assert.ok(
+    requestBody.includes('stateWriteDirty') && requestBody.includes('while'),
+    'el coalescing debe usar una bandera "dirty" y un loop que reintente mientras haya pedidos nuevos, no lanzar un agente por cada llamada'
+  );
+  assert.ok(
+    output.includes('await requestWriteState()') && output.includes('return requestWriteState()'),
+    'settle() y markInProgress() deben pasar por requestWriteState(), no llamar a writeState() directo (si no, el coalescing no tiene efecto)'
+  );
+});
+
 test('built workflow adds updatedAt to .cys/state.json via the write agent\'s own date command (pending.md gap, Fase 4b design)', () => {
   const writeStateIndex = output.indexOf('function writeState()');
   assert.ok(writeStateIndex >= 0, 'debe existir writeState()');
diff --git a/workflows-src/parallel-plan-executor.template.js b/workflows-src/parallel-plan-executor.template.js
index b7d0a88..f7256f8 100644
--- a/workflows-src/parallel-plan-executor.template.js
+++ b/workflows-src/parallel-plan-executor.template.js
@@ -58,9 +58,8 @@ function writeState() {
     `correction). Keep the exact same JSON shape and field vocabulary the other task entries in ` +
     `this content already use (don't invent new status values or fields). Only refuse to write ` +
     `if something looks actually fabricated rather than merely stale — e.g. a "done" entry ` +
-    `whose branch/SHA doesn't ` +
-    `actually fabricated rather than merely stale — e.g. a "done" entry whose branch/SHA doesn't ` +
-    `exist anywhere in the repo's history at all. Write the (corrected, if needed) content ` +
+    `whose branch/SHA doesn't exist anywhere in the repo's history at all. Write the ` +
+    `(corrected, if needed) content ` +
     `between the <content> tags to .cys/state.json (create the file/directory if missing, ` +
     `overwrite anything already there), with "updatedAt": "<time from date>" inserted as a ` +
     `top-level field right after "integrationBranch", and nothing else.` +
@@ -69,6 +68,31 @@ function writeState() {
   ));
 }
 
+// Coalesces concurrent state-write requests into one dispatched agent per
+// "wave" instead of one per settle()/markInProgress() call: several tasks
+// settling close together (a common real pattern — e.g. every dependency-
+// free task starting around the same time) used to fire one [state] agent
+// each. If a write is already in flight when a new request comes in, this
+// just flags "there's more to record" and lets the in-flight write's own
+// follow-up pass (which reads taskStates — and so stateJson() — fresh at
+// that later point) pick it up, rather than spawning another agent. Still
+// writes at least once per wave, so crash-resume safety is unchanged; the
+// count of actual [state] agents drops with how much settling clusters.
+let stateWriteChain = null;
+let stateWriteDirty = false;
+function requestWriteState() {
+  stateWriteDirty = true;
+  if (stateWriteChain) return stateWriteChain;
+  stateWriteChain = (async () => {
+    while (stateWriteDirty) {
+      stateWriteDirty = false;
+      await writeState();
+    }
+    stateWriteChain = null;
+  })();
+  return stateWriteChain;
+}
+
 function deleteState() {
   return enqueueMainRepo(() => agent(
     `In repo ${repoPath}, check whether .cys/state.json exists. If it does, verify against the ` +
@@ -181,7 +205,7 @@ async function settle(taskId, status, label, extra = {}) {
   settledCount += 1;
   taskStates.set(taskId, { status, ...extra });
   log(`${progressBar()} — Task ${taskId} (branch task-${taskId}) ${label}`);
-  await writeState();
+  await requestWriteState();
 }
 
 // Sin esto, .cys/state.json muestra 'pending' desde que arranca la corrida hasta que la
@@ -191,7 +215,7 @@ async function settle(taskId, status, label, extra = {}) {
 // leyendo state.json durante una corrida en curso.
 function markInProgress(taskId, phase) {
   taskStates.set(taskId, { status: 'in_progress', phase });
-  return writeState();
+  return requestWriteState();
 }
 
 // agent() devuelve null si el usuario saltea el agente o si murió por un error terminal
diff --git a/workflows/parallel-plan-executor.js b/workflows/parallel-plan-executor.js
index 037d389..380ff79 100644
--- a/workflows/parallel-plan-executor.js
+++ b/workflows/parallel-plan-executor.js
@@ -366,9 +366,8 @@ function writeState() {
     `correction). Keep the exact same JSON shape and field vocabulary the other task entries in ` +
     `this content already use (don't invent new status values or fields). Only refuse to write ` +
     `if something looks actually fabricated rather than merely stale — e.g. a "done" entry ` +
-    `whose branch/SHA doesn't ` +
-    `actually fabricated rather than merely stale — e.g. a "done" entry whose branch/SHA doesn't ` +
-    `exist anywhere in the repo's history at all. Write the (corrected, if needed) content ` +
+    `whose branch/SHA doesn't exist anywhere in the repo's history at all. Write the ` +
+    `(corrected, if needed) content ` +
     `between the <content> tags to .cys/state.json (create the file/directory if missing, ` +
     `overwrite anything already there), with "updatedAt": "<time from date>" inserted as a ` +
     `top-level field right after "integrationBranch", and nothing else.` +
@@ -377,6 +376,31 @@ function writeState() {
   ));
 }
 
+// Coalesces concurrent state-write requests into one dispatched agent per
+// "wave" instead of one per settle()/markInProgress() call: several tasks
+// settling close together (a common real pattern — e.g. every dependency-
+// free task starting around the same time) used to fire one [state] agent
+// each. If a write is already in flight when a new request comes in, this
+// just flags "there's more to record" and lets the in-flight write's own
+// follow-up pass (which reads taskStates — and so stateJson() — fresh at
+// that later point) pick it up, rather than spawning another agent. Still
+// writes at least once per wave, so crash-resume safety is unchanged; the
+// count of actual [state] agents drops with how much settling clusters.
+let stateWriteChain = null;
+let stateWriteDirty = false;
+function requestWriteState() {
+  stateWriteDirty = true;
+  if (stateWriteChain) return stateWriteChain;
+  stateWriteChain = (async () => {
+    while (stateWriteDirty) {
+      stateWriteDirty = false;
+      await writeState();
+    }
+    stateWriteChain = null;
+  })();
+  return stateWriteChain;
+}
+
 function deleteState() {
   return enqueueMainRepo(() => agent(
     `In repo ${repoPath}, check whether .cys/state.json exists. If it does, verify against the ` +
@@ -489,7 +513,7 @@ async function settle(taskId, status, label, extra = {}) {
   settledCount += 1;
   taskStates.set(taskId, { status, ...extra });
   log(`${progressBar()} — Task ${taskId} (branch task-${taskId}) ${label}`);
-  await writeState();
+  await requestWriteState();
 }
 
 // Sin esto, .cys/state.json muestra 'pending' desde que arranca la corrida hasta que la
@@ -499,7 +523,7 @@ async function settle(taskId, status, label, extra = {}) {
 // leyendo state.json durante una corrida en curso.
 function markInProgress(taskId, phase) {
   taskStates.set(taskId, { status: 'in_progress', phase });
-  return writeState();
+  return requestWriteState();
 }
 
 // agent() devuelve null si el usuario saltea el agente o si murió por un error terminal

From 9a3b9a43c0c3d6cfb12a2a9972a88f7027dc1e11 Mon Sep 17 00:00:00 2001
From: Bacsystem Solutions EIRL <dbacilio88@outlook.es>
Date: Tue, 21 Jul 2026 08:22:53 -0500
Subject: [PATCH 06/11] fix(ledger): coalesce concurrent appendLedger() calls
 into one batch
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Same pattern as the state-write coalescing (previous commit): each
appendLedger() call dispatched its own [ledger] agent, so several
lines queued close together (e.g. multiple tasks failing/conflicting
around the same time) fired one agent per line. appendLedger() is now
a thin coalescing wrapper — concurrent calls join a pending batch, and
one [ledger] agent appends (and spot-checks) all of them together via
the new appendLedgerBatch(). Public call sites are unchanged (still
appendLedger(line)).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0145sjAtP5b5kvhR1XCgg3K3
---
 tests/build-workflow.test.js                  | 27 ++++++++---
 .../parallel-plan-executor.template.js        | 45 ++++++++++++++-----
 workflows/parallel-plan-executor.js           | 45 ++++++++++++++-----
 3 files changed, 87 insertions(+), 30 deletions(-)

diff --git a/tests/build-workflow.test.js b/tests/build-workflow.test.js
index caf682e..66c7e61 100644
--- a/tests/build-workflow.test.js
+++ b/tests/build-workflow.test.js
@@ -131,8 +131,9 @@ test('built workflow serializes every main-repo working-tree operation through o
 
 test('built workflow frames ledger content so free-form agent text cannot break the prompt', () => {
   assert.ok(
-    output.includes('<line>${line}</line>'),
-    'la línea del ledger debe ir delimitada, no incrustada entre comillas'
+    output.includes('<line>${l}</line>') || output.includes('<line>${line}</line>'),
+    'cada línea del ledger debe ir delimitada con <line></line>, no incrustada entre comillas — ' +
+    'sigue siendo cierto tras el coalescing de appendLedger(), que arma el XML por línea vía .map()'
   );
 });
 
@@ -334,15 +335,29 @@ test('built workflow instructs the state-write agent to verify against real repo
 });
 
 test('built workflow instructs the ledger-append agent to spot-check the line against real evidence before appending (safety-classifier block, pending.md bug reopened 2026-07-21)', () => {
-  const appendLedgerIndex = output.indexOf('function appendLedger(');
-  assert.ok(appendLedgerIndex >= 0, 'debe existir appendLedger()');
-  const appendLedgerBody = output.slice(appendLedgerIndex, appendLedgerIndex + 1200);
+  const appendLedgerBatchIndex = output.indexOf('function appendLedgerBatch(');
+  assert.ok(appendLedgerBatchIndex >= 0, 'debe existir appendLedgerBatch()');
+  const appendLedgerBatchBody = output.slice(appendLedgerBatchIndex, appendLedgerBatchIndex + 1200);
   assert.ok(
-    appendLedgerBody.includes('spot-check') && appendLedgerBody.includes('git log'),
+    appendLedgerBatchBody.includes('spot-check') && appendLedgerBatchBody.includes('git log'),
     'el agente de ledger debe verificar las afirmaciones de la línea contra evidencia real (git log, reportes) antes de agregarla, no solo confiar en el texto que le pasaron'
   );
 });
 
+test('built workflow coalesces concurrent appendLedger() calls into one batched [ledger] agent', () => {
+  const appendLedgerIndex = output.indexOf('function appendLedger(line)');
+  assert.ok(appendLedgerIndex >= 0, 'debe existir appendLedger(line), el wrapper público de coalescing');
+  const appendLedgerBody = output.slice(appendLedgerIndex, appendLedgerIndex + 500);
+  assert.ok(
+    appendLedgerBody.includes('ledgerPending') && appendLedgerBody.includes('while'),
+    'appendLedger() debe encolar en ledgerPending y reintentar con un loop mientras haya líneas nuevas, no lanzar un agente por cada llamada'
+  );
+  assert.ok(
+    output.includes('appendLedgerBatch(batch)'),
+    'el batch acumulado debe pasarse completo a appendLedgerBatch(), no una línea a la vez'
+  );
+});
+
 test('built workflow coalesces concurrent state-write requests instead of dispatching one [state] agent per settle()/markInProgress() call', () => {
   const requestIndex = output.indexOf('function requestWriteState()');
   assert.ok(requestIndex >= 0, 'debe existir requestWriteState(), el wrapper de coalescing sobre writeState()');
diff --git a/workflows-src/parallel-plan-executor.template.js b/workflows-src/parallel-plan-executor.template.js
index f7256f8..a9fbb48 100644
--- a/workflows-src/parallel-plan-executor.template.js
+++ b/workflows-src/parallel-plan-executor.template.js
@@ -152,26 +152,47 @@ const HANDOFF_SCHEMA = {
   required: ['handoffFile'],
 };
 
-function appendLedger(line) {
+function appendLedgerBatch(lines) {
   // Pasa por la misma cola que fixes y merges: dos tareas fallando a la vez hacían
-  // append concurrente sobre el mismo archivo del repo principal. El contenido va entre
+  // append concurrente sobre el mismo archivo del repo principal. Cada línea va entre
   // <line></line> porque incluye texto libre de otros agentes (concerns, findings) —
   // una comilla en ese texto rompía el framing del prompt.
+  const linesXml = lines.map((l) => `<line>${l}</line>`).join('\n');
   return enqueueMainRepo(() => agent(
-    `In repo ${repoPath}, you are appending one line to .cys/progress.md, a human-readable ` +
-    `log of this parallel-plan-executor run. The proposed line is between the <line> tags ` +
-    `below, written by an earlier step in this same run. Before appending it, spot-check its ` +
-    `factual claims against real evidence you can inspect yourself — a referenced commit SHA ` +
-    `should exist in \`git log\`, a referenced merge/conflict should be visible in the repo's ` +
-    `actual state or a .cys/task-<id>-report.md, a referenced review verdict should match a ` +
-    `real review diff. If it checks out, append it verbatim (create the file/directory if ` +
-    `missing), without the tags. If you find it describes something that didn't actually ` +
-    `happen, don't append it — report the discrepancy instead so the line can be corrected.` +
-    `\n<line>${line}</line>`,
+    `In repo ${repoPath}, you are appending ${lines.length} line(s) to .cys/progress.md, a ` +
+    `human-readable log of this parallel-plan-executor run. The proposed lines are the ` +
+    `<line> tags below, each written by an earlier step in this same run. Before appending ` +
+    `each one, spot-check its factual claims against real evidence you can inspect yourself — ` +
+    `a referenced commit SHA should exist in \`git log\`, a referenced merge/conflict should ` +
+    `be visible in the repo's actual state or a .cys/task-<id>-report.md, a referenced review ` +
+    `verdict should match a real review diff. Append the ones that check out verbatim, one ` +
+    `per line, in the given order (create the file/directory if missing), without the tags. ` +
+    `If any line describes something that didn't actually happen, don't append that one — ` +
+    `report the discrepancy instead so it can be corrected; still append the rest that do ` +
+    `check out.\n${linesXml}`,
     { label: 'ledger', phase: 'Merge' }
   ));
 }
 
+// Coalesces concurrent appendLedger() calls the same way requestWriteState()
+// coalesces state writes: if a batch is already in flight, new lines just
+// join the next batch instead of each spawning its own [ledger] agent.
+let ledgerChain = null;
+let ledgerPending = [];
+function appendLedger(line) {
+  ledgerPending.push(line);
+  if (ledgerChain) return ledgerChain;
+  ledgerChain = (async () => {
+    while (ledgerPending.length > 0) {
+      const batch = ledgerPending;
+      ledgerPending = [];
+      await appendLedgerBatch(batch);
+    }
+    ledgerChain = null;
+  })();
+  return ledgerChain;
+}
+
 // Serializa TODA operación que toca el working tree de repoPath: los merges (checkout de
 // la rama de integración) y los fixes (checkout de task-<id> sin worktree propio). Un
 // repo git solo puede tener una rama checked out a la vez, así que dos colas
diff --git a/workflows/parallel-plan-executor.js b/workflows/parallel-plan-executor.js
index 380ff79..1b8cd75 100644
--- a/workflows/parallel-plan-executor.js
+++ b/workflows/parallel-plan-executor.js
@@ -460,26 +460,47 @@ const HANDOFF_SCHEMA = {
   required: ['handoffFile'],
 };
 
-function appendLedger(line) {
+function appendLedgerBatch(lines) {
   // Pasa por la misma cola que fixes y merges: dos tareas fallando a la vez hacían
-  // append concurrente sobre el mismo archivo del repo principal. El contenido va entre
+  // append concurrente sobre el mismo archivo del repo principal. Cada línea va entre
   // <line></line> porque incluye texto libre de otros agentes (concerns, findings) —
   // una comilla en ese texto rompía el framing del prompt.
+  const linesXml = lines.map((l) => `<line>${l}</line>`).join('\n');
   return enqueueMainRepo(() => agent(
-    `In repo ${repoPath}, you are appending one line to .cys/progress.md, a human-readable ` +
-    `log of this parallel-plan-executor run. The proposed line is between the <line> tags ` +
-    `below, written by an earlier step in this same run. Before appending it, spot-check its ` +
-    `factual claims against real evidence you can inspect yourself — a referenced commit SHA ` +
-    `should exist in \`git log\`, a referenced merge/conflict should be visible in the repo's ` +
-    `actual state or a .cys/task-<id>-report.md, a referenced review verdict should match a ` +
-    `real review diff. If it checks out, append it verbatim (create the file/directory if ` +
-    `missing), without the tags. If you find it describes something that didn't actually ` +
-    `happen, don't append it — report the discrepancy instead so the line can be corrected.` +
-    `\n<line>${line}</line>`,
+    `In repo ${repoPath}, you are appending ${lines.length} line(s) to .cys/progress.md, a ` +
+    `human-readable log of this parallel-plan-executor run. The proposed lines are the ` +
+    `<line> tags below, each written by an earlier step in this same run. Before appending ` +
+    `each one, spot-check its factual claims against real evidence you can inspect yourself — ` +
+    `a referenced commit SHA should exist in \`git log\`, a referenced merge/conflict should ` +
+    `be visible in the repo's actual state or a .cys/task-<id>-report.md, a referenced review ` +
+    `verdict should match a real review diff. Append the ones that check out verbatim, one ` +
+    `per line, in the given order (create the file/directory if missing), without the tags. ` +
+    `If any line describes something that didn't actually happen, don't append that one — ` +
+    `report the discrepancy instead so it can be corrected; still append the rest that do ` +
+    `check out.\n${linesXml}`,
     { label: 'ledger', phase: 'Merge' }
   ));
 }
 
+// Coalesces concurrent appendLedger() calls the same way requestWriteState()
+// coalesces state writes: if a batch is already in flight, new lines just
+// join the next batch instead of each spawning its own [ledger] agent.
+let ledgerChain = null;
+let ledgerPending = [];
+function appendLedger(line) {
+  ledgerPending.push(line);
+  if (ledgerChain) return ledgerChain;
+  ledgerChain = (async () => {
+    while (ledgerPending.length > 0) {
+      const batch = ledgerPending;
+      ledgerPending = [];
+      await appendLedgerBatch(batch);
+    }
+    ledgerChain = null;
+  })();
+  return ledgerChain;
+}
+
 // Serializa TODA operación que toca el working tree de repoPath: los merges (checkout de
 // la rama de integración) y los fixes (checkout de task-<id> sin worktree propio). Un
 // repo git solo puede tener una rama checked out a la vez, así que dos colas

From 0cd2fcf6d58901f3b1e930636ac832c44bb73b0d Mon Sep 17 00:00:00 2001
From: Bacsystem Solutions EIRL <dbacilio88@outlook.es>
Date: Tue, 21 Jul 2026 08:31:06 -0500
Subject: [PATCH 07/11] feat(state,ledger): log how many writes/lines got
 coalesced into one agent
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Both requestWriteState() and appendLedger() now log a line
("[state] agrupó N pedidos..." / "[ledger] agrupó N líneas...")
whenever a batch actually groups more than one request, so it's
visible in the run's own log output — not just inferable from
comparing agent counts — whether the coalescing is doing anything in
a given run.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0145sjAtP5b5kvhR1XCgg3K3
---
 tests/build-workflow.test.js                     | 8 ++++++++
 workflows-src/parallel-plan-executor.template.js | 6 ++++++
 workflows/parallel-plan-executor.js              | 6 ++++++
 3 files changed, 20 insertions(+)

diff --git a/tests/build-workflow.test.js b/tests/build-workflow.test.js
index 66c7e61..d9d1d52 100644
--- a/tests/build-workflow.test.js
+++ b/tests/build-workflow.test.js
@@ -356,6 +356,10 @@ test('built workflow coalesces concurrent appendLedger() calls into one batched
     output.includes('appendLedgerBatch(batch)'),
     'el batch acumulado debe pasarse completo a appendLedgerBatch(), no una línea a la vez'
   );
+  assert.ok(
+    output.includes('agrupó') && output.includes('batch.length'),
+    'debe loguear cuántas líneas se agruparon en un solo agente, para que se pueda confirmar en vivo que el coalescing está funcionando (pedido explícito del usuario)'
+  );
 });
 
 test('built workflow coalesces concurrent state-write requests instead of dispatching one [state] agent per settle()/markInProgress() call', () => {
@@ -370,6 +374,10 @@ test('built workflow coalesces concurrent state-write requests instead of dispat
     output.includes('await requestWriteState()') && output.includes('return requestWriteState()'),
     'settle() y markInProgress() deben pasar por requestWriteState(), no llamar a writeState() directo (si no, el coalescing no tiene efecto)'
   );
+  assert.ok(
+    output.includes('agrupó') && output.includes('stateWriteRequests'),
+    'debe loguear cuántos pedidos de escritura se agruparon en un solo agente, para que se pueda confirmar en vivo que el coalescing está funcionando (pedido explícito del usuario)'
+  );
 });
 
 test('built workflow adds updatedAt to .cys/state.json via the write agent\'s own date command (pending.md gap, Fase 4b design)', () => {
diff --git a/workflows-src/parallel-plan-executor.template.js b/workflows-src/parallel-plan-executor.template.js
index a9fbb48..caf803d 100644
--- a/workflows-src/parallel-plan-executor.template.js
+++ b/workflows-src/parallel-plan-executor.template.js
@@ -80,12 +80,17 @@ function writeState() {
 // count of actual [state] agents drops with how much settling clusters.
 let stateWriteChain = null;
 let stateWriteDirty = false;
+let stateWriteRequests = 0;
 function requestWriteState() {
   stateWriteDirty = true;
+  stateWriteRequests += 1;
   if (stateWriteChain) return stateWriteChain;
   stateWriteChain = (async () => {
     while (stateWriteDirty) {
       stateWriteDirty = false;
+      const batched = stateWriteRequests;
+      stateWriteRequests = 0;
+      if (batched > 1) log(`[state] agrupó ${batched} pedidos de escritura en 1 solo agente`);
       await writeState();
     }
     stateWriteChain = null;
@@ -186,6 +191,7 @@ function appendLedger(line) {
     while (ledgerPending.length > 0) {
       const batch = ledgerPending;
       ledgerPending = [];
+      if (batch.length > 1) log(`[ledger] agrupó ${batch.length} líneas en 1 solo agente`);
       await appendLedgerBatch(batch);
     }
     ledgerChain = null;
diff --git a/workflows/parallel-plan-executor.js b/workflows/parallel-plan-executor.js
index 1b8cd75..8a4cd92 100644
--- a/workflows/parallel-plan-executor.js
+++ b/workflows/parallel-plan-executor.js
@@ -388,12 +388,17 @@ function writeState() {
 // count of actual [state] agents drops with how much settling clusters.
 let stateWriteChain = null;
 let stateWriteDirty = false;
+let stateWriteRequests = 0;
 function requestWriteState() {
   stateWriteDirty = true;
+  stateWriteRequests += 1;
   if (stateWriteChain) return stateWriteChain;
   stateWriteChain = (async () => {
     while (stateWriteDirty) {
       stateWriteDirty = false;
+      const batched = stateWriteRequests;
+      stateWriteRequests = 0;
+      if (batched > 1) log(`[state] agrupó ${batched} pedidos de escritura en 1 solo agente`);
       await writeState();
     }
     stateWriteChain = null;
@@ -494,6 +499,7 @@ function appendLedger(line) {
     while (ledgerPending.length > 0) {
       const batch = ledgerPending;
       ledgerPending = [];
+      if (batch.length > 1) log(`[ledger] agrupó ${batch.length} líneas en 1 solo agente`);
       await appendLedgerBatch(batch);
     }
     ledgerChain = null;

From 5e0112c387c541ff13796085df7830dbdd2e8025 Mon Sep 17 00:00:00 2001
From: Bacsystem Solutions EIRL <dbacilio88@outlook.es>
Date: Tue, 21 Jul 2026 12:12:33 -0500
Subject: [PATCH 08/11] perf(state,ledger): run bookkeeping agents at effort
 low

state/ledger/state-clear agents inherit the session's reasoning effort,
spending implementation-grade reasoning on mechanical work (verify git,
write a JSON file, append log lines). Real pilot data (bs-inventory,
2026-07-21): bookkeeping agents accounted for 35 of 77 dispatched
agents. effort:'low' cuts their per-call cost without touching the
quality-bearing agents (implement/review/fix/merge/final-review).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0145sjAtP5b5kvhR1XCgg3K3
---
 workflows-src/parallel-plan-executor.template.js | 8 +++++---
 workflows/parallel-plan-executor.js              | 8 +++++---
 2 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/workflows-src/parallel-plan-executor.template.js b/workflows-src/parallel-plan-executor.template.js
index caf803d..39cbfc4 100644
--- a/workflows-src/parallel-plan-executor.template.js
+++ b/workflows-src/parallel-plan-executor.template.js
@@ -64,7 +64,9 @@ function writeState() {
     `overwrite anything already there), with "updatedAt": "<time from date>" inserted as a ` +
     `top-level field right after "integrationBranch", and nothing else.` +
     `\n<content>${stateJson()}</content>`,
-    { label: 'state', phase: 'State' }
+    // effort:'low' — verificar git y escribir un JSON es trabajo mecánico; heredar el
+    // esfuerzo de la sesión gastaba razonamiento de nivel implementación en bookkeeping.
+    { label: 'state', phase: 'State', effort: 'low' }
   ));
 }
 
@@ -105,7 +107,7 @@ function deleteState() {
     `that the run it describes has genuinely finished — no task still pending or in progress. ` +
     `If that checks out, delete .cys/state.json. If it doesn't exist, there's nothing to do. If ` +
     `you find the run hasn't actually finished, don't delete it — report why instead.`,
-    { label: 'state-clear', phase: 'Handoff' }
+    { label: 'state-clear', phase: 'Handoff', effort: 'low' }
   ));
 }
 
@@ -175,7 +177,7 @@ function appendLedgerBatch(lines) {
     `If any line describes something that didn't actually happen, don't append that one — ` +
     `report the discrepancy instead so it can be corrected; still append the rest that do ` +
     `check out.\n${linesXml}`,
-    { label: 'ledger', phase: 'Merge' }
+    { label: 'ledger', phase: 'Merge', effort: 'low' }
   ));
 }
 
diff --git a/workflows/parallel-plan-executor.js b/workflows/parallel-plan-executor.js
index 8a4cd92..27af605 100644
--- a/workflows/parallel-plan-executor.js
+++ b/workflows/parallel-plan-executor.js
@@ -372,7 +372,9 @@ function writeState() {
     `overwrite anything already there), with "updatedAt": "<time from date>" inserted as a ` +
     `top-level field right after "integrationBranch", and nothing else.` +
     `\n<content>${stateJson()}</content>`,
-    { label: 'state', phase: 'State' }
+    // effort:'low' — verificar git y escribir un JSON es trabajo mecánico; heredar el
+    // esfuerzo de la sesión gastaba razonamiento de nivel implementación en bookkeeping.
+    { label: 'state', phase: 'State', effort: 'low' }
   ));
 }
 
@@ -413,7 +415,7 @@ function deleteState() {
     `that the run it describes has genuinely finished — no task still pending or in progress. ` +
     `If that checks out, delete .cys/state.json. If it doesn't exist, there's nothing to do. If ` +
     `you find the run hasn't actually finished, don't delete it — report why instead.`,
-    { label: 'state-clear', phase: 'Handoff' }
+    { label: 'state-clear', phase: 'Handoff', effort: 'low' }
   ));
 }
 
@@ -483,7 +485,7 @@ function appendLedgerBatch(lines) {
     `If any line describes something that didn't actually happen, don't append that one — ` +
     `report the discrepancy instead so it can be corrected; still append the rest that do ` +
     `check out.\n${linesXml}`,
-    { label: 'ledger', phase: 'Merge' }
+    { label: 'ledger', phase: 'Merge', effort: 'low' }
   ));
 }
 

From 5e6fcdc3aa1062a347942169bc2e0c702bfcff4f Mon Sep 17 00:00:00 2001
From: Bacsystem Solutions EIRL <dbacilio88@outlook.es>
Date: Tue, 21 Jul 2026 15:16:28 -0500
Subject: [PATCH 09/11] fix(runTask): fast-exit re-dispatched tasks that are
 already merged
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The Workflow resume cache invalidates by prefix — any edit to the first
agent call's prompt (e.g. the writeState fixes) re-runs EVERYTHING after
it live. Combined with mid-run stop/resume cycles, already-finished
tasks kept getting re-dispatched from scratch: the bs-inventory pilot
(2026-07-21) re-invoked tasks 4/5/6 three to five times each, and every
re-invocation paid a full re-implementation check (testcontainers suite
included), a fresh adversarial review, and a merge attempt — 63 review
agents and 57 merge agents for a 10-task run, with three implementers
independently reporting "this task was already done, why was I
dispatched?" in their concerns.

Two-part fix:
- The implementer prompt now opens with a FAST-EXIT CHECK: if branch
  task-N exists AND is already an ancestor of the integration branch,
  report alreadyMerged: true immediately (two read-only git commands,
  no test re-runs, no worktree).
- runTask short-circuits on impl.alreadyMerged: settle(done) directly,
  skipping the review and merge stages entirely — there is nothing new
  to review or merge.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0145sjAtP5b5kvhR1XCgg3K3
---
 tests/build-workflow.test.js                  | 15 +++++++++++
 .../parallel-plan-executor.template.js        | 25 +++++++++++++++++++
 workflows/parallel-plan-executor.js           | 25 +++++++++++++++++++
 3 files changed, 65 insertions(+)

diff --git a/tests/build-workflow.test.js b/tests/build-workflow.test.js
index d9d1d52..7a9d145 100644
--- a/tests/build-workflow.test.js
+++ b/tests/build-workflow.test.js
@@ -380,6 +380,21 @@ test('built workflow coalesces concurrent state-write requests instead of dispat
   );
 });
 
+test('built workflow fast-exits re-dispatched already-merged tasks without re-review or re-merge (pilot bs-inventory 2026-07-21)', () => {
+  assert.ok(
+    output.includes('FAST-EXIT CHECK') && output.includes('alreadyMerged: true'),
+    'el prompt del implementador debe chequear primero (branch existe + es ancestro de la rama de integración) y reportar alreadyMerged sin re-correr tests — cada re-despacho pagaba una re-verificación completa con testcontainers'
+  );
+  assert.ok(
+    output.includes('if (impl.alreadyMerged)') && output.includes('skipping review and merge'),
+    'runTask debe cortocircuitar a settle(done) cuando el implementador confirma alreadyMerged — sin esto, cada re-despacho pagaba revisión + merge completos sobre trabajo ya integrado (63 reviews / 57 merges para 10 tareas en el piloto)'
+  );
+  assert.ok(
+    output.indexOf('if (impl.alreadyMerged)') < output.indexOf("await markInProgress(taskId, 'Review')"),
+    'el cortocircuito debe evaluarse ANTES de entrar a la fase de Review'
+  );
+});
+
 test('built workflow adds updatedAt to .cys/state.json via the write agent\'s own date command (pending.md gap, Fase 4b design)', () => {
   const writeStateIndex = output.indexOf('function writeState()');
   assert.ok(writeStateIndex >= 0, 'debe existir writeState()');
diff --git a/workflows-src/parallel-plan-executor.template.js b/workflows-src/parallel-plan-executor.template.js
index 39cbfc4..6c06ea4 100644
--- a/workflows-src/parallel-plan-executor.template.js
+++ b/workflows-src/parallel-plan-executor.template.js
@@ -124,6 +124,7 @@ const IMPLEMENTER_SCHEMA = {
     concerns: { type: 'string' },
     startedAt: { type: 'string', description: 'HH:MM:SS wall-clock time when work began (from `date +%H:%M:%S`)' },
     finishedAt: { type: 'string', description: 'HH:MM:SS wall-clock time right before reporting' },
+    alreadyMerged: { type: 'boolean', description: 'true ONLY when the task branch already existed AND was already an ancestor of the integration branch before this agent did anything — i.e. a re-dispatch of finished work' },
   },
   required: ['status', 'branch', 'baseSha', 'headSha', 'reportFile', 'startedAt', 'finishedAt'],
 };
@@ -274,6 +275,16 @@ async function implement(task) {
   return agent(
     `You are implementing Task ${task.id}: "${task.title}", from the plan at ${planPath}, ` +
     `in repo ${repoPath}.\n\n` +
+    `FAST-EXIT CHECK, before anything else: run \`git -C ${repoPath} show-ref --verify ` +
+    `--quiet refs/heads/task-${task.id}\` and, if the branch exists, \`git -C ${repoPath} ` +
+    `merge-base --is-ancestor task-${task.id} ${integrationBranch}\`. If BOTH succeed, this ` +
+    `task was already implemented, reviewed, and merged in a prior invocation of this same ` +
+    `run (a re-dispatch, e.g. after a resume) — do NOT re-implement, re-run tests, or ` +
+    `re-verify anything beyond those two git commands. Report immediately with ` +
+    `alreadyMerged: true, status DONE, the branch's real head SHA (\`git -C ${repoPath} ` +
+    `rev-parse task-${task.id}\`) as headSha, and a one-line commitSummary saying the work ` +
+    `was found already merged. Real pilot data: re-dispatched tasks each burned a full ` +
+    `test-suite re-verification (testcontainers included) for zero new information.\n\n` +
     `Other tasks run in parallel against that same repository — NEVER switch branches or ` +
     `edit files in ${repoPath} itself. Your very first repo action: create your own ` +
     `isolated worktree by running \`git -C ${repoPath} worktree add ${worktreeDir} ` +
@@ -405,6 +416,20 @@ async function executeTask(taskId) {
   let impl = ensureAgentResult(taskId, await implement(task), 'implementer');
   await assertNotBlocked(taskId, impl);
 
+  // Salida rápida (piloto bs-inventory 2026-07-21): una tarea re-despachada tras un
+  // resume (el caché invalida por prefijo, así que pasa seguido) volvía a pagar
+  // revisión + merge completos sobre trabajo ya integrado — 63 agentes de review y
+  // 57 de merge para 10 tareas. Si el implementador confirmó vía git que la rama ya
+  // es ancestro de la rama de integración, no hay nada nuevo que revisar ni mergear.
+  if (impl.alreadyMerged) {
+    log(`Task ${taskId}: already merged in a prior invocation — skipping review and merge`);
+    await settle(taskId, 'done', 'already merged (re-dispatch fast-exit)', {
+      branch: `task-${taskId}`,
+      headSha: impl.headSha,
+    });
+    return impl;
+  }
+
   await markInProgress(taskId, 'Review');
   let verdict = ensureAgentResult(taskId, await review(task, impl), 'reviewer');
   if (verdict.qualityVerdict === 'NEEDS_FIXES' || verdict.specVerdict === 'FAIL') {
diff --git a/workflows/parallel-plan-executor.js b/workflows/parallel-plan-executor.js
index 27af605..46276dd 100644
--- a/workflows/parallel-plan-executor.js
+++ b/workflows/parallel-plan-executor.js
@@ -432,6 +432,7 @@ const IMPLEMENTER_SCHEMA = {
     concerns: { type: 'string' },
     startedAt: { type: 'string', description: 'HH:MM:SS wall-clock time when work began (from `date +%H:%M:%S`)' },
     finishedAt: { type: 'string', description: 'HH:MM:SS wall-clock time right before reporting' },
+    alreadyMerged: { type: 'boolean', description: 'true ONLY when the task branch already existed AND was already an ancestor of the integration branch before this agent did anything — i.e. a re-dispatch of finished work' },
   },
   required: ['status', 'branch', 'baseSha', 'headSha', 'reportFile', 'startedAt', 'finishedAt'],
 };
@@ -582,6 +583,16 @@ async function implement(task) {
   return agent(
     `You are implementing Task ${task.id}: "${task.title}", from the plan at ${planPath}, ` +
     `in repo ${repoPath}.\n\n` +
+    `FAST-EXIT CHECK, before anything else: run \`git -C ${repoPath} show-ref --verify ` +
+    `--quiet refs/heads/task-${task.id}\` and, if the branch exists, \`git -C ${repoPath} ` +
+    `merge-base --is-ancestor task-${task.id} ${integrationBranch}\`. If BOTH succeed, this ` +
+    `task was already implemented, reviewed, and merged in a prior invocation of this same ` +
+    `run (a re-dispatch, e.g. after a resume) — do NOT re-implement, re-run tests, or ` +
+    `re-verify anything beyond those two git commands. Report immediately with ` +
+    `alreadyMerged: true, status DONE, the branch's real head SHA (\`git -C ${repoPath} ` +
+    `rev-parse task-${task.id}\`) as headSha, and a one-line commitSummary saying the work ` +
+    `was found already merged. Real pilot data: re-dispatched tasks each burned a full ` +
+    `test-suite re-verification (testcontainers included) for zero new information.\n\n` +
     `Other tasks run in parallel against that same repository — NEVER switch branches or ` +
     `edit files in ${repoPath} itself. Your very first repo action: create your own ` +
     `isolated worktree by running \`git -C ${repoPath} worktree add ${worktreeDir} ` +
@@ -713,6 +724,20 @@ async function executeTask(taskId) {
   let impl = ensureAgentResult(taskId, await implement(task), 'implementer');
   await assertNotBlocked(taskId, impl);
 
+  // Salida rápida (piloto bs-inventory 2026-07-21): una tarea re-despachada tras un
+  // resume (el caché invalida por prefijo, así que pasa seguido) volvía a pagar
+  // revisión + merge completos sobre trabajo ya integrado — 63 agentes de review y
+  // 57 de merge para 10 tareas. Si el implementador confirmó vía git que la rama ya
+  // es ancestro de la rama de integración, no hay nada nuevo que revisar ni mergear.
+  if (impl.alreadyMerged) {
+    log(`Task ${taskId}: already merged in a prior invocation — skipping review and merge`);
+    await settle(taskId, 'done', 'already merged (re-dispatch fast-exit)', {
+      branch: `task-${taskId}`,
+      headSha: impl.headSha,
+    });
+    return impl;
+  }
+
   await markInProgress(taskId, 'Review');
   let verdict = ensureAgentResult(taskId, await review(task, impl), 'reviewer');
   if (verdict.qualityVerdict === 'NEEDS_FIXES' || verdict.specVerdict === 'FAIL') {

From c1b521fefbd2543d7846d2c00df75ed4bb61f322 Mon Sep 17 00:00:00 2001
From: Bacsystem Solutions EIRL <dbacilio88@outlook.es>
Date: Tue, 21 Jul 2026 15:32:29 -0500
Subject: [PATCH 10/11] fix(runTask): fast-exit must not treat an empty stub
 branch as merged work
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Edge case found before it ever ran: a task branch created right before
a run was cut off (e.g. session limit hitting between branch creation
and the first commit) points at the integration tip with zero commits
of its own — trivially "an ancestor," which the fast-exit would have
read as "already merged" and silently skipped the task's entire
implementation. Real instance: bs-inventory's task-10 stub after the
2026-07-21 session-limit cutoff.

The check now also requires the branch to carry real commits of its own
in the integration branch's history; an empty stub gets deleted and the
task implements normally.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0145sjAtP5b5kvhR1XCgg3K3
---
 .../parallel-plan-executor.template.js        | 26 ++++++++++++-------
 workflows/parallel-plan-executor.js           | 26 ++++++++++++-------
 2 files changed, 34 insertions(+), 18 deletions(-)

diff --git a/workflows-src/parallel-plan-executor.template.js b/workflows-src/parallel-plan-executor.template.js
index 6c06ea4..f164b54 100644
--- a/workflows-src/parallel-plan-executor.template.js
+++ b/workflows-src/parallel-plan-executor.template.js
@@ -276,15 +276,23 @@ async function implement(task) {
     `You are implementing Task ${task.id}: "${task.title}", from the plan at ${planPath}, ` +
     `in repo ${repoPath}.\n\n` +
     `FAST-EXIT CHECK, before anything else: run \`git -C ${repoPath} show-ref --verify ` +
-    `--quiet refs/heads/task-${task.id}\` and, if the branch exists, \`git -C ${repoPath} ` +
-    `merge-base --is-ancestor task-${task.id} ${integrationBranch}\`. If BOTH succeed, this ` +
-    `task was already implemented, reviewed, and merged in a prior invocation of this same ` +
-    `run (a re-dispatch, e.g. after a resume) — do NOT re-implement, re-run tests, or ` +
-    `re-verify anything beyond those two git commands. Report immediately with ` +
-    `alreadyMerged: true, status DONE, the branch's real head SHA (\`git -C ${repoPath} ` +
-    `rev-parse task-${task.id}\`) as headSha, and a one-line commitSummary saying the work ` +
-    `was found already merged. Real pilot data: re-dispatched tasks each burned a full ` +
-    `test-suite re-verification (testcontainers included) for zero new information.\n\n` +
+    `--quiet refs/heads/task-${task.id}\`; if the branch exists, \`git -C ${repoPath} ` +
+    `merge-base --is-ancestor task-${task.id} ${integrationBranch}\`; and if that also ` +
+    `succeeds, \`git -C ${repoPath} rev-list --count ${integrationBranch}..task-${task.id}\` ` +
+    `PLUS confirm the branch actually contains this task's own commits (an EMPTY stub branch ` +
+    `pointing at the integration tip is trivially "an ancestor" — that means the branch was ` +
+    `created but the work never happened, e.g. a run cut off right after branch creation; in ` +
+    `that case delete the stub with \`git -C ${repoPath} branch -D task-${task.id}\` and ` +
+    `proceed to implement normally). Only when the branch exists, is an ancestor, AND carries ` +
+    `real commits of its own merged into ${integrationBranch} (check \`git -C ${repoPath} log ` +
+    `${integrationBranch} --oneline -20\` for this task's commits) was the task already ` +
+    `implemented, reviewed, and merged in a prior invocation (a re-dispatch, e.g. after a ` +
+    `resume) — then do NOT re-implement, re-run tests, or re-verify anything beyond these git ` +
+    `commands. Report immediately with alreadyMerged: true, status DONE, the branch's real ` +
+    `head SHA (\`git -C ${repoPath} rev-parse task-${task.id}\`) as headSha, and a one-line ` +
+    `commitSummary saying the work was found already merged. Real pilot data: re-dispatched ` +
+    `tasks each burned a full test-suite re-verification (testcontainers included) for zero ` +
+    `new information.\n\n` +
     `Other tasks run in parallel against that same repository — NEVER switch branches or ` +
     `edit files in ${repoPath} itself. Your very first repo action: create your own ` +
     `isolated worktree by running \`git -C ${repoPath} worktree add ${worktreeDir} ` +
diff --git a/workflows/parallel-plan-executor.js b/workflows/parallel-plan-executor.js
index 46276dd..618369c 100644
--- a/workflows/parallel-plan-executor.js
+++ b/workflows/parallel-plan-executor.js
@@ -584,15 +584,23 @@ async function implement(task) {
     `You are implementing Task ${task.id}: "${task.title}", from the plan at ${planPath}, ` +
     `in repo ${repoPath}.\n\n` +
     `FAST-EXIT CHECK, before anything else: run \`git -C ${repoPath} show-ref --verify ` +
-    `--quiet refs/heads/task-${task.id}\` and, if the branch exists, \`git -C ${repoPath} ` +
-    `merge-base --is-ancestor task-${task.id} ${integrationBranch}\`. If BOTH succeed, this ` +
-    `task was already implemented, reviewed, and merged in a prior invocation of this same ` +
-    `run (a re-dispatch, e.g. after a resume) — do NOT re-implement, re-run tests, or ` +
-    `re-verify anything beyond those two git commands. Report immediately with ` +
-    `alreadyMerged: true, status DONE, the branch's real head SHA (\`git -C ${repoPath} ` +
-    `rev-parse task-${task.id}\`) as headSha, and a one-line commitSummary saying the work ` +
-    `was found already merged. Real pilot data: re-dispatched tasks each burned a full ` +
-    `test-suite re-verification (testcontainers included) for zero new information.\n\n` +
+    `--quiet refs/heads/task-${task.id}\`; if the branch exists, \`git -C ${repoPath} ` +
+    `merge-base --is-ancestor task-${task.id} ${integrationBranch}\`; and if that also ` +
+    `succeeds, \`git -C ${repoPath} rev-list --count ${integrationBranch}..task-${task.id}\` ` +
+    `PLUS confirm the branch actually contains this task's own commits (an EMPTY stub branch ` +
+    `pointing at the integration tip is trivially "an ancestor" — that means the branch was ` +
+    `created but the work never happened, e.g. a run cut off right after branch creation; in ` +
+    `that case delete the stub with \`git -C ${repoPath} branch -D task-${task.id}\` and ` +
+    `proceed to implement normally). Only when the branch exists, is an ancestor, AND carries ` +
+    `real commits of its own merged into ${integrationBranch} (check \`git -C ${repoPath} log ` +
+    `${integrationBranch} --oneline -20\` for this task's commits) was the task already ` +
+    `implemented, reviewed, and merged in a prior invocation (a re-dispatch, e.g. after a ` +
+    `resume) — then do NOT re-implement, re-run tests, or re-verify anything beyond these git ` +
+    `commands. Report immediately with alreadyMerged: true, status DONE, the branch's real ` +
+    `head SHA (\`git -C ${repoPath} rev-parse task-${task.id}\`) as headSha, and a one-line ` +
+    `commitSummary saying the work was found already merged. Real pilot data: re-dispatched ` +
+    `tasks each burned a full test-suite re-verification (testcontainers included) for zero ` +
+    `new information.\n\n` +
     `Other tasks run in parallel against that same repository — NEVER switch branches or ` +
     `edit files in ${repoPath} itself. Your very first repo action: create your own ` +
     `isolated worktree by running \`git -C ${repoPath} worktree add ${worktreeDir} ` +

From 957218f3b72a8a3449ff1e9804d9a0f2a9efb8b2 Mon Sep 17 00:00:00 2001
From: Bacsystem Solutions EIRL <dbacilio88@outlook.es>
Date: Tue, 21 Jul 2026 23:53:45 -0500
Subject: [PATCH 11/11] chore(release): bump version to 0.6.21

---
 .claude-plugin/plugin.json |  2 +-
 .cursor-plugin/plugin.json |  2 +-
 CHANGELOG.md               | 53 ++++++++++++++++++++++++++++++++++++++
 gemini-extension.json      |  2 +-
 package.json               |  2 +-
 5 files changed, 57 insertions(+), 4 deletions(-)

diff --git a/.claude-plugin/plugin.json b/.claude-plugin/plugin.json
index 63f7942..7674b1f 100644
--- a/.claude-plugin/plugin.json
+++ b/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "cys",
-  "version": "0.6.20",
+  "version": "0.6.21",
   "description": "Development methodology skills with parallel plan execution: design, plan, run, check, ship. Named after the author's twin daughters, Cielo y Sophia.",
   "author": { "name": "Christian Bacilio" },
   "repository": "https://github.com/bacsystem/parallel-plan-executor",
diff --git a/.cursor-plugin/plugin.json b/.cursor-plugin/plugin.json
index b404b09..7a2820b 100644
--- a/.cursor-plugin/plugin.json
+++ b/.cursor-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "cys",
-  "version": "0.6.20",
+  "version": "0.6.21",
   "description": "Development methodology skills for design, plan, check, and ship — parallel plan execution (cys:run) is Claude Code only for now.",
   "author": { "name": "Christian Bacilio" },
   "repository": "https://github.com/bacsystem/parallel-plan-executor",
diff --git a/CHANGELOG.md b/CHANGELOG.md
index fe19d83..b01efb9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,59 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.6.21 — 2026-07-21
+
+Added:
+
+- `requestWriteState()`/`appendLedger()` now log how many pending
+  writes/lines got coalesced into a single agent, so batching is visible
+  in the run's own log output instead of only inferable from agent counts.
+- `cys:plan`'s self-review checklist gained two checks caught only by the
+  executor's adversarial reviewer in a real `bs-inventory` pilot
+  (2026-07-20/21), not by writing the plan itself: caller-cardinality
+  (trace every real call site's multiplicity, not just your own task's
+  test case) and spec-field literalness (re-read and grep the spec's
+  exact field mapping instead of writing it from memory).
+
+Fixed:
+
+- `bin/review-package.js`: raised `execFileSync`'s `maxBuffer` to 1GB —
+  the 1MB Node default threw `ENOBUFS`/maxBuffer-exceeded on a real diff
+  package spanning many files (207-file MUI removal in the
+  `bs-inventory` pilot's Task 13).
+- `writeState()`/`deleteState()`/`appendLedger()` now instruct the agent
+  to verify content against real repo state (git log, git merge-base,
+  task reports) before writing, with a "report the discrepancy instead"
+  escape hatch — the previous "frame it as already-verified" wording
+  kept getting flagged as Instruction Poisoning by the safety classifier
+  across two real pilot runs.
+- The state-write agent now self-corrects stale-but-genuine entries
+  (queued-then-overtaken-by-real-progress) instead of only refusing and
+  leaving `state.json` frozen at its first snapshot for the rest of the
+  run; refusal is reserved for entries that look fabricated outright.
+- `requestWriteState()`/`appendLedger()` now coalesce concurrent calls
+  into one agent instead of dispatching one `[state]`/`[ledger]` agent
+  per transition/line — real pilot data showed bookkeeping agents alone
+  accounting for 35 of 77 dispatched agents in one run.
+- `runTask` now fast-exits tasks whose branch is already merged into the
+  integration branch (two read-only git checks, no re-implementation,
+  review, or merge) instead of re-dispatching already-finished work on
+  every resume — one pilot run re-invoked three tasks 3-5 times each,
+  costing 63 review agents and 57 merge agents on a 10-task plan. The
+  fast-exit also requires the branch to carry real commits of its own
+  (not just be a trivial ancestor), so an empty stub branch from a
+  session cut short between branch creation and first commit still
+  implements normally instead of being silently skipped.
+
+Changed:
+
+- Bookkeeping agents (`state`/`ledger`/`state-clear`) now run at
+  `effort: 'low'` instead of inheriting the session's reasoning effort,
+  since real pilot data showed they're a plurality of all dispatched
+  agents doing purely mechanical work (verify git, write JSON, append
+  log lines) — quality-bearing agents (implement/review/fix/merge/
+  final-review) are unaffected.
+
 ## 0.6.20 — 2026-07-19
 
 Added:
diff --git a/gemini-extension.json b/gemini-extension.json
index 8cfe1cc..0c2ae1d 100644
--- a/gemini-extension.json
+++ b/gemini-extension.json
@@ -1,6 +1,6 @@
 {
   "name": "cys",
-  "version": "0.6.20",
+  "version": "0.6.21",
   "description": "Development methodology skills for design, plan, check, and ship — parallel plan execution (cys:run) is Claude Code only for now.",
   "repository": "https://github.com/bacsystem/parallel-plan-executor",
   "license": "MIT"
diff --git a/package.json b/package.json
index faa4a7f..8dde7c6 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "parallel-plan-executor",
-  "version": "0.6.20",
+  "version": "0.6.21",
   "author": "Christian Bacilio",
   "private": true,
   "type": "module",