cclaw-cli 7.0.3 → 7.0.5

package/dist/artifact-linter/plan.js

@@ -5,6 +5,37 @@ import { FORBIDDEN_PLACEHOLDER_TOKENS, CONFIDENCE_FINDING_REGEX_SOURCE } from ".
 import fs from "node:fs/promises";
 import path from "node:path";
 import { PLAN_SPLIT_SMALL_PLAN_THRESHOLD, parseImplementationUnits, parseImplementationUnitParallelFields } from "../internal/plan-split-waves.js";
+const PARALLEL_EXEC_MANAGED_START = "<!-- parallel-exec-managed-start -->";
+const PARALLEL_EXEC_MANAGED_END = "<!-- parallel-exec-managed-end -->";
+const TASK_ID_PATTERN = /\bT-\d{3}[a-z]?(?:\.\d{1,3})?\b/giu;
+/**
+ * Extract every distinct T-NNN[a-z]?(.NNN)? id from a markdown body.
+ *
+ * Used by the `plan_parallel_exec_full_coverage` linter to compute the
+ * authored task set (from `## Task List`) vs. the wave-claimed task set
+ * (from inside `<!-- parallel-exec-managed-start -->`).
+ */
+function extractTaskIds(body) {
+    const ids = new Set();
+    for (const match of body.matchAll(TASK_ID_PATTERN)) {
+        ids.add(match[0]);
+    }
+    return ids;
+}
+/**
+ * Return the body between the parallel-exec managed comment markers, or
+ * an empty string if the block is absent. The TDD wave parser uses the
+ * same delimiters; keeping the regex local avoids cross-package import
+ * cycles in the linter.
+ */
+function extractParallelExecManagedBody(planMarkdown) {
+    const startIdx = planMarkdown.indexOf(PARALLEL_EXEC_MANAGED_START);
+    const endIdx = planMarkdown.indexOf(PARALLEL_EXEC_MANAGED_END);
+    if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx) {
+        return "";
+    }
+    return planMarkdown.slice(startIdx + PARALLEL_EXEC_MANAGED_START.length, endIdx);
+}
 export async function lintPlanStage(ctx) {
     const { projectRoot, track, raw, absFile, sections, findings, parsedFrontmatter, brainstormShortCircuitBody, brainstormShortCircuitActivated, staleDiagramAuditEnabled, isTrivialOverride } = ctx;
     evaluateInvestigationTrace(ctx, "Implementation Units");
@@ -277,4 +308,52 @@ export async function lintPlanStage(ctx) {
                 : "Parallel-ready units detected or plan is single-unit."
         });
     }
+    // plan_parallel_exec_full_coverage: every T-NNN task listed in the
+    // plan's Task List must be assigned to a slice inside the
+    // <!-- parallel-exec-managed-start --> block. Without this, TDD
+    // cannot fan out work the plan never authored as waves; the previous
+    // failure mode was `stage-complete tdd` succeeding when only the
+    // first batch of tasks had been wave-assigned.
+    //
+    // Spike rows (`S-N`) live in the same Task List but are excluded
+    // because they are wall-clock spikes that produce evidence files
+    // and are not part of the regular slice fan-out. A task is also
+    // excluded when it appears under a `## Deferred Tasks` (or
+    // `## Backlog`) heading inside the plan with an explicit reason.
+    if (strictPlanGuards) {
+        const taskListSection = sectionBodyByName(sections, "Task List") ?? "";
+        const authoredTaskIds = extractTaskIds(taskListSection);
+        // Collect deferred / backlog task ids so they don't trigger the
+        // "uncovered" finding. Both heading variants are accepted.
+        const deferredBody = (sectionBodyByName(sections, "Deferred Tasks") ?? "") +
+            "\n" +
+            (sectionBodyByName(sections, "Backlog") ?? "");
+        const deferredIds = extractTaskIds(deferredBody);
+        const parallelExecBody = extractParallelExecManagedBody(raw);
+        const claimedIds = extractTaskIds(parallelExecBody);
+        const uncovered = [];
+        for (const id of authoredTaskIds) {
+            if (claimedIds.has(id))
+                continue;
+            if (deferredIds.has(id))
+                continue;
+            uncovered.push(id);
+        }
+        uncovered.sort();
+        const blockPresent = parallelExecBody.length > 0;
+        const taskListPresent = authoredTaskIds.size > 0;
+        findings.push({
+            section: "plan_parallel_exec_full_coverage",
+            required: taskListPresent,
+            rule: "Every T-NNN task in `## Task List` must be assigned to at least one slice inside the `<!-- parallel-exec-managed-start -->` block (or moved to an explicit `## Deferred Tasks` / `## Backlog` section). TDD cannot fan out waves the plan never authored.",
+            found: taskListPresent && blockPresent && uncovered.length === 0,
+            details: !taskListPresent
+                ? "Task List section is empty or missing T-NNN ids; full-coverage check skipped."
+                : !blockPresent
+                    ? "`<!-- parallel-exec-managed-start -->` block is missing or empty. Author the Parallel Execution Plan with W-02..W-N covering every task before plan-final-approval."
+                    : uncovered.length === 0
+                        ? `Parallel Execution Plan covers all ${authoredTaskIds.size} authored task id(s); ${deferredIds.size} task id(s) are explicitly deferred.`
+                        : `Uncovered task id(s) — author waves for: ${uncovered.slice(0, 25).join(", ")}${uncovered.length > 25 ? `, … (${uncovered.length - 25} more)` : ""}. Either add slices for them inside <!-- parallel-exec-managed-start --> or move them under \`## Deferred Tasks\` with a reason.`
+        });
+    }
 }

package/dist/content/hooks.js

@@ -838,15 +838,24 @@ async function persistEntry(root, runId, clean, event, options = {}) {
     // Rerecord semantics: replace any pre-existing row with the same spanId
     // (regardless of its status) so the legacy v1/v2 row is upgraded to v3
     // shape on disk. The append path keeps the historical dedup semantics:
-    // an exact (spanId, status) duplicate is dropped to keep retried hooks
-    // idempotent.
+    // an exact (spanId, status, phase) triple is dropped to keep retried hooks
+    // idempotent. Including \`phase\` in the dedup key is required because a
+    // single TDD slice-builder span legitimately emits FOUR rows with
+    // status=completed (one each for phase=red|green|refactor|doc); a
+    // dedup on (spanId, status) alone would silently drop GREEN/REFACTOR/DOC
+    // and leave the linter reporting tdd_slice_green_missing for slices
+    // whose work actually landed.
     if (options.replaceBySpanId) {
       ledger.entries = ledger.entries.filter((entry) => entry.spanId !== clean.spanId);
       ledger.entries.push(clean);
       ledger.runId = runId;
       ledger.schemaVersion = LEDGER_SCHEMA_VERSION;
       await writeDelegationLedgerAtomic(ledgerPath, ledger);
-    } else if (!ledger.entries.some((entry) => entry.spanId === clean.spanId && entry.status === clean.status)) {
+    } else if (!ledger.entries.some((entry) =>
+      entry.spanId === clean.spanId &&
+      entry.status === clean.status &&
+      (entry.phase ?? null) === (clean.phase ?? null)
+    )) {
       ledger.entries.push(clean);
       ledger.runId = runId;
       ledger.schemaVersion = LEDGER_SCHEMA_VERSION;

package/dist/content/stage-schema.js

@@ -294,6 +294,7 @@ const REQUIRED_GATE_IDS = {
         "plan_dependency_batches_defined",
         "plan_acceptance_mapped",
         "plan_execution_posture_recorded",
+        "plan_parallel_exec_full_coverage",
         "plan_wait_for_confirm"
     ],
     tdd: (track) => [

package/dist/content/stages/plan.js

@@ -51,6 +51,7 @@ export const PLAN = {
             "Run anti-placeholder + anti-scope-reduction scans — block `TODO/TBD/...` and phrasing like `v1`, `for now`, `later` for locked boundaries.",
             "Define validation points — mark where progress must be checked before continuing, with concrete command and expected evidence.",
             "Define execution posture — record whether execution should be sequential, dependency-batched, parallel-safe, or blocked; include risk triggers and RED/GREEN/REFACTOR checkpoint/commit expectations when the repo workflow supports them. This fulfills the `plan_execution_posture_recorded` gate.",
+            "**Author the FULL Parallel Execution Plan.** Inside the `<!-- parallel-exec-managed-start -->` block, enumerate ALL waves W-02..W-N covering EVERY T-NNN task in `## Task List` — no `we'll author waves later`, `next batch only`, or open-ended Backlog handwave is acceptable. Each task gets a slice with `sliceId | taskId | dependsOn | claimedPaths | parallelizable | riskTier | lane`. Spike rows (`S-N`) and tasks marked `deferred` in an explicit `Deferred:` column may be omitted, but every other T-NNN must be claimed. This fulfills the `plan_parallel_exec_full_coverage` gate. The TDD stage downstream is a pure consumer of these waves — if the plan does not author them, TDD cannot fan out that work.",
             "WAIT_FOR_CONFIRM — write plan artifact and explicitly pause. **STOP.** Do NOT proceed until user confirms. Then close the stage with `node .cclaw/hooks/stage-complete.mjs plan` and tell user to run `/cc`."
         ],
         interactionProtocol: [
@@ -80,6 +81,7 @@ export const PLAN = {
             { id: "plan_dependency_batches_defined", description: "Tasks are grouped into executable batches with gate checks and execution posture." },
             { id: "plan_acceptance_mapped", description: "Each task maps to a spec acceptance criterion." },
             { id: "plan_execution_posture_recorded", description: "Execution posture is recorded before implementation handoff." },
+            { id: "plan_parallel_exec_full_coverage", description: "Every T-NNN task in `## Task List` (other than spikes/explicitly-deferred) is assigned to at least one slice inside the `<!-- parallel-exec-managed-start -->` block; TDD cannot fan out work that the plan never authored as waves." },
             { id: "plan_wait_for_confirm", description: "Execution blocked until explicit user confirmation." }
         ],
         requiredEvidence: [

package/dist/delegation.js

@@ -1031,7 +1031,9 @@ export async function appendDelegation(projectRoot, entry) {
                 stamped.fulfillmentMode = expectedFulfillmentMode(fallbacks);
             }
         }
-        if (prior.entries.some((existing) => existing.spanId === stamped.spanId && existing.status === stamped.status)) {
+        if (prior.entries.some((existing) => existing.spanId === stamped.spanId &&
+            existing.status === stamped.status &&
+            (existing.phase ?? null) === (stamped.phase ?? null))) {
             return;
         }
         validateMonotonicTimestamps(stamped, prior.entries);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cclaw-cli",
-  "version": "7.0.3",
+  "version": "7.0.5",
   "description": "Installer-first flow toolkit for coding agents",
   "type": "module",
   "bin": {