cclaw-cli 6.14.3 → 6.14.4

package/dist/artifact-linter/tdd.js

@@ -1339,11 +1339,19 @@ function pickEventTs(rows) {
     return undefined;
 }
 /**
- * v6.14.2 — slices whose terminal `refactor` / `refactor-deferred` /
- * `resolve-conflict` row recorded a `completedTs` that PRECEDES the
- * latest `leasedUntil` for the same slice. The lease was never
- * reclaimed but the wave closed in time; the missing audit row is
- * advisory bookkeeping, not a correctness failure.
+ * v6.14.2 — slices whose terminal closure event recorded a `completedTs`
+ * that PRECEDES the latest `leasedUntil` for the same slice. The lease
+ * was never reclaimed but the wave closed in time; the missing audit
+ * row is advisory bookkeeping, not a correctness failure.
+ *
+ * v6.14.4 — also recognize stream-mode (per-slice checkpoint) closure:
+ * a `phase=green status=completed` row carrying `refactorOutcome`
+ * (`inline` or `deferred`) IS the slice closure. Without this, every
+ * stream-mode slice incorrectly fired `tdd_lease_expired_unreclaimed`
+ * once its lease expired, even though the slice was already closed
+ * (this mirrors the same predicate already used in
+ * `src/internal/wave-status.ts` for `closedSlices` tracking — same
+ * decision, just now applied to lease-closure detection).
  */
 function computeClosedBeforeLeaseExpiry(events) {
     const terminalPhases = new Set([
@@ -1353,6 +1361,15 @@ function computeClosedBeforeLeaseExpiry(events) {
     ]);
     const lastLease = new Map();
     const earliestTerminal = new Map();
+    const recordTerminal = (sliceId, completedTs) => {
+        const ts = Date.parse(completedTs);
+        if (!Number.isFinite(ts))
+            return;
+        const prev = earliestTerminal.get(sliceId);
+        if (prev === undefined || ts < prev) {
+            earliestTerminal.set(sliceId, ts);
+        }
+    };
     for (const ev of events) {
         if (ev.stage !== "tdd" || ev.agent !== "slice-implementer")
             continue;
@@ -1367,16 +1384,21 @@ function computeClosedBeforeLeaseExpiry(events) {
                 }
             }
         }
-        if (ev.status === "completed" &&
-            typeof ev.phase === "string" &&
-            terminalPhases.has(ev.phase) &&
-            typeof ev.completedTs === "string") {
-            const ts = Date.parse(ev.completedTs);
-            if (Number.isFinite(ts)) {
-                const prev = earliestTerminal.get(ev.sliceId);
-                if (prev === undefined || ts < prev) {
-                    earliestTerminal.set(ev.sliceId, ts);
-                }
+        if (ev.status !== "completed" || typeof ev.completedTs !== "string") {
+            continue;
+        }
+        if (typeof ev.phase !== "string")
+            continue;
+        if (terminalPhases.has(ev.phase)) {
+            recordTerminal(ev.sliceId, ev.completedTs);
+            continue;
+        }
+        // v6.14.4 — stream-mode closure: GREEN-only with refactorOutcome
+        // folded inline IS the slice's terminal row.
+        if (ev.phase === "green" && ev.refactorOutcome) {
+            const mode = ev.refactorOutcome.mode;
+            if (mode === "inline" || mode === "deferred") {
+                recordTerminal(ev.sliceId, ev.completedTs);
             }
         }
     }

package/dist/internal/plan-split-waves.d.ts

@@ -57,8 +57,48 @@ export declare function extractParallelExecutionManagedBody(planMarkdown: string
  */
 export declare function extractMembersListFromLine(trimmedLine: string): string | null;
 /**
- * Parse `## Parallel Execution Plan` managed block for wave headings and Members lines.
- * Malformed member tokens are skipped. Duplicate slice ids in one plan source throw.
+ * v6.14.4 — extract a `(sliceId, unitId)` pair from a markdown table data
+ * row whose first column is an `S-NN` token. Used by the wave parser to
+ * recognize the table-format Parallel Execution Plan that hox-shape
+ * projects emit alongside (or instead of) the legacy `**Members:**`
+ * bullet line.
+ *
+ * Rules:
+ * - The line must start with `|` (after trimming).
+ * - Column 1 (after stripping markdown noise) must match `^S-(\d+)$` —
+ *   header rows (`| sliceId | …`) and separator rows (`|---|---|…`) are
+ *   silently skipped.
+ * - Column 2, when present and non-empty, becomes the `unitId`
+ *   verbatim (after stripping whitespace + backticks/quotes/brackets).
+ *   This preserves the hox convention of recording task ids
+ *   (`T-010`, `T-008a`, …) in the `unit` column without forcing a
+ *   `U-NN` derivation.
+ * - When column 2 is absent or empty, fall back to the legacy
+ *   `S-NN → U-NN` derivation so the existing `**Members:**` parser path
+ *   stays bit-identical for non-table plans.
+ */
+export declare function parseTableRowMember(trimmedLine: string): ParsedParallelWaveMember | null;
+/**
+ * Parse `## Parallel Execution Plan` managed block for wave headings and
+ * member declarations. Recognizes BOTH the legacy `**Members:**` /
+ * `Members:` line shape AND the markdown-table shape
+ * (`| sliceId | unit | dependsOn | …`) used by hox-shape projects and by
+ * any plan written by `cclaw-cli sync` after v6.13.x.
+ *
+ * Wave headings accepted (case-insensitive, trailing text allowed):
+ * - `### Wave 04`
+ * - `### Wave W-04`
+ * - `### Wave W-04 — после успешного fan-in W-03 (5 lanes …)`
+ *
+ * Within a single wave the parser dedupes by `sliceId`: if the same
+ * slice appears in both `**Members:**` and a table row, the first
+ * occurrence wins (line-order). Cross-wave duplicates still throw
+ * `WavePlanDuplicateSliceError`.
+ *
+ * Malformed member tokens are skipped. Empty waves (heading present
+ * but neither a Members line nor any matching `| S-NN |` row found
+ * before the next heading) are RETURNED with `members: []` so callers
+ * can surface the boundary; classification is up to the caller.
  */
 export declare function parseParallelExecutionPlanWaves(planMarkdown: string): ParsedParallelWave[];
 /**

package/dist/internal/plan-split-waves.js

@@ -61,8 +61,73 @@ export function extractMembersListFromLine(trimmedLine) {
     return null;
 }
 /**
- * Parse `## Parallel Execution Plan` managed block for wave headings and Members lines.
- * Malformed member tokens are skipped. Duplicate slice ids in one plan source throw.
+ * v6.14.4 — extract a `(sliceId, unitId)` pair from a markdown table data
+ * row whose first column is an `S-NN` token. Used by the wave parser to
+ * recognize the table-format Parallel Execution Plan that hox-shape
+ * projects emit alongside (or instead of) the legacy `**Members:**`
+ * bullet line.
+ *
+ * Rules:
+ * - The line must start with `|` (after trimming).
+ * - Column 1 (after stripping markdown noise) must match `^S-(\d+)$` —
+ *   header rows (`| sliceId | …`) and separator rows (`|---|---|…`) are
+ *   silently skipped.
+ * - Column 2, when present and non-empty, becomes the `unitId`
+ *   verbatim (after stripping whitespace + backticks/quotes/brackets).
+ *   This preserves the hox convention of recording task ids
+ *   (`T-010`, `T-008a`, …) in the `unit` column without forcing a
+ *   `U-NN` derivation.
+ * - When column 2 is absent or empty, fall back to the legacy
+ *   `S-NN → U-NN` derivation so the existing `**Members:**` parser path
+ *   stays bit-identical for non-table plans.
+ */
+export function parseTableRowMember(trimmedLine) {
+    if (!trimmedLine.startsWith("|"))
+        return null;
+    const inner = trimmedLine.replace(/^\|/u, "").replace(/\|\s*$/u, "");
+    if (inner.length === 0)
+        return null;
+    const cells = inner.split("|").map((cell) => cell.trim());
+    if (cells.length === 0)
+        return null;
+    const stripDecorations = (raw) => raw.replace(/^[`"'[\]()]+|[`"'[\]()]+$/gu, "").trim();
+    const col1 = stripDecorations(cells[0]);
+    const sliceMatch = /^S-(\d+)$/u.exec(col1);
+    if (!sliceMatch)
+        return null;
+    const sliceNum = sliceMatch[1];
+    const sliceId = `S-${sliceNum}`;
+    let unitId = `U-${sliceNum}`;
+    if (cells.length >= 2) {
+        const col2 = stripDecorations(cells[1]);
+        if (col2.length > 0) {
+            const normalized = tokenToSliceAndUnit(col2);
+            unitId = normalized ? normalized.unitId : col2;
+        }
+    }
+    return { sliceId, unitId };
+}
+/**
+ * Parse `## Parallel Execution Plan` managed block for wave headings and
+ * member declarations. Recognizes BOTH the legacy `**Members:**` /
+ * `Members:` line shape AND the markdown-table shape
+ * (`| sliceId | unit | dependsOn | …`) used by hox-shape projects and by
+ * any plan written by `cclaw-cli sync` after v6.13.x.
+ *
+ * Wave headings accepted (case-insensitive, trailing text allowed):
+ * - `### Wave 04`
+ * - `### Wave W-04`
+ * - `### Wave W-04 — после успешного fan-in W-03 (5 lanes …)`
+ *
+ * Within a single wave the parser dedupes by `sliceId`: if the same
+ * slice appears in both `**Members:**` and a table row, the first
+ * occurrence wins (line-order). Cross-wave duplicates still throw
+ * `WavePlanDuplicateSliceError`.
+ *
+ * Malformed member tokens are skipped. Empty waves (heading present
+ * but neither a Members line nor any matching `| S-NN |` row found
+ * before the next heading) are RETURNED with `members: []` so callers
+ * can surface the boundary; classification is up to the caller.
  */
 export function parseParallelExecutionPlanWaves(planMarkdown) {
     const body = extractParallelExecutionManagedBody(planMarkdown);
@@ -72,22 +137,60 @@ export function parseParallelExecutionPlanWaves(planMarkdown) {
     const waves = [];
     let current = null;
     const seenSlices = new Set();
+    let inWaveSlicesSeen = new Set();
     const flushCurrent = () => {
-        if (current && current.members.length > 0) {
+        if (current) {
             waves.push(current);
         }
     };
+    /**
+     * Strict add: throw on duplicates within the same wave OR across waves.
+     * Used for the `**Members:**` path so v6.13.1's duplicate-detection
+     * contract is preserved bit-identically.
+     */
+    const addMemberStrict = (member) => {
+        if (!current)
+            return;
+        if (inWaveSlicesSeen.has(member.sliceId) ||
+            seenSlices.has(member.sliceId)) {
+            throw new WavePlanDuplicateSliceError(`duplicate slice ${member.sliceId} in Parallel Execution Plan managed block`);
+        }
+        seenSlices.add(member.sliceId);
+        inWaveSlicesSeen.add(member.sliceId);
+        current.members.push(member);
+    };
+    /**
+     * Lenient add: silently dedupe duplicates within the same wave (so the
+     * documented "Members + table both present" case keeps the Members
+     * declaration as authoritative); still throw on cross-wave duplicates
+     * to surface real plan-authoring bugs.
+     */
+    const addMemberDedupInWave = (member) => {
+        if (!current)
+            return;
+        if (inWaveSlicesSeen.has(member.sliceId))
+            return;
+        if (seenSlices.has(member.sliceId)) {
+            throw new WavePlanDuplicateSliceError(`duplicate slice ${member.sliceId} in Parallel Execution Plan managed block`);
+        }
+        seenSlices.add(member.sliceId);
+        inWaveSlicesSeen.add(member.sliceId);
+        current.members.push(member);
+    };
     for (const rawLine of lines) {
         const trimmed = rawLine.trim();
-        const waveMatch = /^###\s+Wave\s+(\d+)\s*$/iu.exec(trimmed);
+        const waveMatch = /^###\s+Wave\s+(?:W-)?(\d+)\b/iu.exec(trimmed);
         if (waveMatch) {
             flushCurrent();
             const n = waveMatch[1];
             current = { waveId: `W-${n.padStart(2, "0")}`, members: [] };
+            inWaveSlicesSeen = new Set();
             continue;
         }
+        if (!current)
+            continue;
         const membersCsv = extractMembersListFromLine(trimmed);
-        if (membersCsv !== null && current) {
+        if (membersCsv !== null) {
             const parts = membersCsv
                 .split(/,/u)
                 .map((p) => p.trim())
@@ -96,12 +199,13 @@ export function parseParallelExecutionPlanWaves(planMarkdown) {
                 const ids = tokenToSliceAndUnit(part);
                 if (!ids)
                     continue;
-                if (seenSlices.has(ids.sliceId)) {
-                    throw new WavePlanDuplicateSliceError(`duplicate slice ${ids.sliceId} in Parallel Execution Plan managed block`);
-                }
-                seenSlices.add(ids.sliceId);
-                current.members.push(ids);
+                addMemberStrict(ids);
             }
+            continue;
+        }
+        const tableMember = parseTableRowMember(trimmed);
+        if (tableMember) {
+            addMemberDedupInWave(tableMember);
         }
     }
     flushCurrent();

package/package.json

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