cclaw-cli 6.14.3 → 7.0.0

package/dist/delegation.js

@@ -8,7 +8,6 @@ import { exists, withDirectoryLock, writeFileSafe } from "./fs-utils.js";
 import { HARNESS_ADAPTERS } from "./harness-adapters.js";
 import { readFlowState } from "./runs.js";
 import { mandatoryAgentsFor, stageSchema } from "./content/stage-schema.js";
-import { effectiveWorktreeExecutionMode } from "./flow-state.js";
 import { compareCanonicalUnitIds, mergeParallelWaveDefinitions, parseImplementationUnitParallelFields, parseImplementationUnits, parseParallelExecutionPlanWaves, parseWavePlanDirectory } from "./internal/plan-split-waves.js";
 const execFileAsync = promisify(execFile);
 const TERMINAL_DELEGATION_STATUSES = new Set(["completed", "failed", "waived", "stale"]);
@@ -21,6 +20,10 @@ export const DELEGATION_DISPATCH_SURFACES = [
     "role-switch",
     "manual"
 ];
+/** Agents that declare `claimedPaths` for parallel/disjoint scheduling and fan-out caps. */
+export function isParallelTddSliceWorker(agent) {
+    return agent === "slice-builder";
+}
 /**
  * Per-surface allowed agent-definition path prefixes. Used by the generated
  * `.cclaw/hooks/delegation-record.mjs` helper to reject mismatched
@@ -237,27 +240,10 @@ function isDelegationEntry(value) {
         (o.supersededBy === undefined || typeof o.supersededBy === "string") &&
         (o.claimedPaths === undefined ||
             (Array.isArray(o.claimedPaths) && o.claimedPaths.every((item) => typeof item === "string"))) &&
-        (o.sliceId === undefined ||
-            (typeof o.sliceId === "string" && o.sliceId.length > 0)) &&
+        (o.sliceId === undefined || typeof o.sliceId === "string") &&
         (o.phase === undefined ||
             (typeof o.phase === "string" &&
                 DELEGATION_PHASES.includes(o.phase))) &&
-        (o.claimToken === undefined || typeof o.claimToken === "string") &&
-        (o.ownerLaneId === undefined || typeof o.ownerLaneId === "string") &&
-        (o.leasedUntil === undefined || typeof o.leasedUntil === "string") &&
-        (o.leaseState === undefined ||
-            o.leaseState === "claimed" ||
-            o.leaseState === "expired" ||
-            o.leaseState === "released" ||
-            o.leaseState === "reclaimed") &&
-        (o.dependsOn === undefined ||
-            (Array.isArray(o.dependsOn) && o.dependsOn.every((item) => typeof item === "string"))) &&
-        (o.integrationState === undefined ||
-            o.integrationState === "pending" ||
-            o.integrationState === "applied" ||
-            o.integrationState === "conflict" ||
-            o.integrationState === "resolved" ||
-            o.integrationState === "abandoned") &&
         (o.refactorOutcome === undefined || isRefactorOutcomeShape(o.refactorOutcome)) &&
         (o.riskTier === undefined ||
             o.riskTier === "low" ||
@@ -374,7 +360,7 @@ export async function readDelegationLedger(projectRoot) {
     }
 }
 /**
- * Wave 24 (v6.0.0) audit-only event types that live in
+ * Audit-only event types that live in
  * `delegation-events.jsonl` but do NOT carry a delegation lifecycle
  * payload (no agent/spanId). The parser must accept them so they
  * don't show up as corrupt lines.
@@ -388,7 +374,8 @@ const NON_DELEGATION_AUDIT_EVENTS = new Set([
     "cclaw_fanin_conflict",
     "cclaw_fanin_resolved",
     "cclaw_fanin_abandoned",
-    "cclaw_integration_overseer_skipped"
+    "cclaw_integration_overseer_skipped",
+    "slice-completed"
 ]);
 function isAuditEventLine(parsed) {
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
@@ -396,47 +383,13 @@ function isAuditEventLine(parsed) {
     const evt = parsed.event;
     return typeof evt === "string" && NON_DELEGATION_AUDIT_EVENTS.has(evt);
 }
-const FAN_IN_AUDIT_EVENT_KINDS = new Set([
-    "cclaw_fanin_applied",
-    "cclaw_fanin_conflict",
-    "cclaw_fanin_resolved",
-    "cclaw_fanin_abandoned"
-]);
-function isFanInAuditRecord(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return false;
-    const o = value;
-    const evt = o.event;
-    if (typeof evt !== "string" || !FAN_IN_AUDIT_EVENT_KINDS.has(evt)) {
-        return false;
-    }
-    return typeof o.ts === "string" && o.ts.length > 0;
-}
-/**
- * Append a deterministic fan-in audit row (not a delegation lifecycle event).
- */
-export async function recordCclawFanInAudit(projectRoot, params) {
-    const filePath = delegationEventsPath(projectRoot);
-    const payload = {
-        event: params.kind,
-        runId: params.runId,
-        laneId: params.laneId,
-        sliceIds: params.sliceIds,
-        integrationBranch: params.integrationBranch,
-        details: params.details,
-        ts: new Date().toISOString()
-    };
-    await fs.mkdir(path.dirname(filePath), { recursive: true });
-    await fs.appendFile(filePath, `${JSON.stringify(payload)}\n`, { encoding: "utf8", mode: 0o600 });
-}
 export async function readDelegationEvents(projectRoot) {
     const filePath = delegationEventsPath(projectRoot);
     if (!(await exists(filePath))) {
-        return { events: [], corruptLines: [], fanInAudits: [] };
+        return { events: [], corruptLines: [] };
     }
     const events = [];
     const corruptLines = [];
-    const fanInAudits = [];
     const text = await fs.readFile(filePath, "utf8").catch(() => "");
     const lines = text.split(/\r?\n/gu);
     for (let index = 0; index < lines.length; index += 1) {
@@ -448,11 +401,8 @@ export async function readDelegationEvents(projectRoot) {
             if (isDelegationEvent(parsed)) {
                 events.push(parsed);
             }
-            else if (isFanInAuditRecord(parsed)) {
-                fanInAudits.push(parsed);
-            }
             else if (isAuditEventLine(parsed)) {
-                // Wave 24 audit-only row (e.g. mandatory_delegations_skipped_by_track).
+                // Audit-only row (e.g. mandatory_delegations_skipped_by_track).
                 // Not a delegation lifecycle event but valid audit content.
                 continue;
             }
@@ -464,7 +414,7 @@ export async function readDelegationEvents(projectRoot) {
             corruptLines.push(index + 1);
         }
     }
-    return { events, corruptLines, fanInAudits };
+    return { events, corruptLines };
 }
 async function appendDelegationEvent(projectRoot, event) {
     const filePath = delegationEventsPath(projectRoot);
@@ -537,7 +487,7 @@ export function computeActiveSubagents(entries) {
     return folded;
 }
 /**
- * v6.8.0 — thrown by `validateMonotonicTimestamps` when an incoming row
+ * Thrown by `validateMonotonicTimestamps` when an incoming row
  * would push a span's timeline backwards. Carries enough context that
  * the CLI / hook surface can format a `delegation_timestamp_non_monotonic`
  * JSON payload without re-deriving the offending field.
@@ -558,7 +508,7 @@ export class DelegationTimestampError extends Error {
     }
 }
 /**
- * v6.8.0 — enforce that lifecycle timestamps on a delegation span move
+ * Enforce that lifecycle timestamps on a delegation span move
  * forward (or stay equal). Validates both per-row invariants
  * (`startTs ≤ launchedTs ≤ ackTs ≤ completedTs`) and a cross-row
  * invariant: the union of prior rows for this `spanId` plus the
@@ -616,7 +566,7 @@ export function validateMonotonicTimestamps(stamped, prior) {
     }
 }
 /**
- * v6.8.0 — thrown by `appendDelegation` when the operator opens a
+ * Thrown by `appendDelegation` when the operator opens a
  * second `scheduled` span on the same `(stage, agent)` pair while an
  * earlier span on the same pair is still active. Callers can catch and
  * either pass the existing span id via `--supersede=<id>` (which
@@ -639,13 +589,12 @@ export class DispatchDuplicateError extends Error {
     }
 }
 /**
- * v6.10.0 (P1) — thrown by `validateFileOverlap` when a new
- * `slice-implementer` is scheduled on a TDD stage with at least one
- * `claimedPaths` entry that overlaps an active span. The cclaw scheduler
- * auto-allows parallel dispatch when paths are disjoint, so an explicit
- * overlap is treated as a serialization signal: the operator must wait
- * for the existing span to terminate or pass `--allow-parallel`
- * deliberately to acknowledge the conflict.
+ * Thrown by `validateFileOverlap` when a new `slice-builder` is scheduled
+ * on a TDD stage with at least one `claimedPaths` entry that overlaps an
+ * active span. The scheduler auto-allows parallel dispatch when paths are
+ * disjoint, so an explicit overlap is treated as a serialization signal:
+ * the operator must wait for the existing span to terminate or pass
+ * `--allow-parallel` deliberately to acknowledge the conflict.
  */
 export class DispatchOverlapError extends Error {
     existingSpanId;
@@ -653,7 +602,7 @@ export class DispatchOverlapError extends Error {
     pair;
     conflictingPaths;
     constructor(params) {
-        super(`dispatch_overlap — slice-implementer span ${params.newSpanId} claims path(s) ${params.conflictingPaths.join(", ")} already held by active spanId=${params.existingSpanId} on stage=${params.pair.stage}. ` +
+        super(`dispatch_overlap — slice-builder span ${params.newSpanId} claims path(s) ${params.conflictingPaths.join(", ")} already held by active spanId=${params.existingSpanId} on stage=${params.pair.stage}. ` +
             `Wait for ${params.existingSpanId} to finish, dispatch a non-overlapping slice, or pass --allow-parallel to acknowledge the conflict.`);
         this.name = "DispatchOverlapError";
         this.existingSpanId = params.existingSpanId;
@@ -663,11 +612,10 @@ export class DispatchOverlapError extends Error {
     }
 }
 /**
- * v6.10.0 (P2) — thrown when the count of active `slice-implementer`
- * spans (after fold) reaches `MAX_PARALLEL_SLICE_IMPLEMENTERS` and a new
- * scheduled row would push it past the cap. Cap can be overridden once
- * via `--override-cap=N` on the hook flag or globally via
- * `CCLAW_MAX_PARALLEL_SLICE_IMPLEMENTERS=<N>` env.
+ * Thrown when the count of active `slice-builder` spans reaches
+ * `MAX_PARALLEL_SLICE_BUILDERS` and a new scheduled row would push it past
+ * the cap. Cap can be overridden once via `--override-cap=N` on the hook
+ * flag or globally via `CCLAW_MAX_PARALLEL_SLICE_BUILDERS=<N>` env.
  */
 export class DispatchCapError extends Error {
     cap;
@@ -675,7 +623,7 @@ export class DispatchCapError extends Error {
     pair;
     constructor(params) {
         super(`dispatch_cap — ${params.active} active ${params.pair.agent}(s) at the cap of ${params.cap}. ` +
-            `Complete one before scheduling another, or pass --override-cap=N (or CCLAW_MAX_PARALLEL_SLICE_IMPLEMENTERS=N) to lift the cap for this run.`);
+            `Complete one before scheduling another, or pass --override-cap=N (or CCLAW_MAX_PARALLEL_SLICE_BUILDERS=N) to lift the cap for this run.`);
         this.name = "DispatchCapError";
         this.cap = params.cap;
         this.active = params.active;
@@ -683,27 +631,16 @@ export class DispatchCapError extends Error {
     }
 }
 /**
- * v6.13.0 — claim / lease contract violation for worktree-first TDD rows.
+ * Default cap on active `slice-builder` spans in a single TDD run. Override
+ * via `CCLAW_MAX_PARALLEL_SLICE_BUILDERS=<int>` (validated `>=1`).
  */
-export class DispatchClaimInvalidError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "DispatchClaimInvalidError";
-    }
-}
-/**
- * v6.10.0 (P2) — default cap on active `slice-implementer` spans in a
- * single TDD run. Aligned with evanflow's parallel cap. Override via
- * `CCLAW_MAX_PARALLEL_SLICE_IMPLEMENTERS=<int>` (validated `>=1`).
- */
-export const MAX_PARALLEL_SLICE_IMPLEMENTERS = 5;
+export const MAX_PARALLEL_SLICE_BUILDERS = 5;
 /**
  * Return up to `cap` slice units whose dependsOn are satisfied, avoiding
  * `claimedPaths` intersections with already-selected units and active holders.
  */
 export function selectReadySlices(units, opts) {
-    const pool = opts.legacyContinuation ? units.filter((u) => u.parallelizable) : units;
-    const ordered = [...pool].sort((a, b) => compareCanonicalUnitIds(a.unitId, b.unitId));
+    const ordered = [...units].sort((a, b) => compareCanonicalUnitIds(a.unitId, b.unitId));
     const selected = [];
     const blockedPaths = new Set();
     for (const holder of opts.activePathHolders) {
@@ -747,7 +684,7 @@ export function selectReadySlices(units, opts) {
     return selected;
 }
 /**
- * v6.13.1 — build scheduler rows from merged parallel wave definitions + plan units.
+ * Build scheduler rows from merged parallel wave definitions + plan units.
  */
 export function readySliceUnitsFromMergedWaves(mergedWaves, planMarkdown, options) {
     const units = parseImplementationUnits(planMarkdown);
@@ -787,7 +724,25 @@ export function readySliceUnitsFromMergedWaves(mergedWaves, planMarkdown, option
     }
     return out;
 }
-export function integrationCheckRequired(events, fanInAudits) {
+/**
+ * Heuristic helper deciding whether a multi-slice wave needs
+ * the `integration-overseer` dispatch.
+ *
+ * Triggers (any one):
+ *   - **two or more closed slices share import boundaries** (heuristic:
+ *     two slices declare a `claimedPaths` whose first 2 path segments
+ *     match — same package/module directory);
+ *   - any slice has `riskTier === "high"`.
+ *
+ * When none fire, the verdict is `{ required: false, reasons: ["disjoint-paths"] }`
+ * and the caller should record a `cclaw_integration_overseer_skipped`
+ * audit before bypassing the dispatch.
+ *
+ * Note on inputs: this function reads from the supplied delegation
+ * events list directly so callers can inject synthetic data in tests.
+ * Use `readDelegationEvents(projectRoot)` in production paths.
+ */
+export function integrationCheckRequired(events) {
     const reasons = [];
     // Closed slices = ones whose phase=green or phase=refactor row is
     // completed. We collect each unique sliceId's representative paths
@@ -858,18 +813,13 @@ export function integrationCheckRequired(events, fanInAudits) {
     }
     if (sharedFound)
         reasons.push("shared-import-boundary");
-    // Fan-in conflict trigger — any `cclaw_fanin_conflict` in the supplied
-    // audits forces the overseer regardless of paths/risk.
-    if (Array.isArray(fanInAudits) && fanInAudits.some((a) => a.event === "cclaw_fanin_conflict")) {
-        reasons.push("fanin-conflict");
-    }
     if (reasons.length > 0) {
         return { required: true, reasons };
     }
     return { required: false, reasons: ["disjoint-paths"] };
 }
 /**
- * v6.14.0 — append a non-delegation audit event recording that the
+ * Append a non-delegation audit event recording that the
  * integration-overseer dispatch was skipped because
  * `integrationCheckRequired()` returned `required: false`. Best-effort;
  * never throws.
@@ -892,14 +842,14 @@ export async function recordIntegrationOverseerSkipped(projectRoot, params) {
     }
 }
 /**
- * v6.13.1 — load merged wave plan (Parallel Execution Plan block + wave-plans/) and map to `ReadySliceUnit[]`.
+ * Load merged wave plan (Parallel Execution Plan block + wave-plans/) and map to `ReadySliceUnit[]`.
  */
 export async function loadTddReadySlicePool(planMarkdown, artifactsDir, options) {
     const merged = mergeParallelWaveDefinitions(parseParallelExecutionPlanWaves(planMarkdown), await parseWavePlanDirectory(artifactsDir));
     return readySliceUnitsFromMergedWaves(merged, planMarkdown, options);
 }
 function readMaxParallelOverrideFromEnv() {
-    const raw = process.env.CCLAW_MAX_PARALLEL_SLICE_IMPLEMENTERS;
+    const raw = process.env.CCLAW_MAX_PARALLEL_SLICE_BUILDERS;
     if (typeof raw !== "string" || raw.trim().length === 0)
         return null;
     const parsed = Number(raw);
@@ -908,17 +858,16 @@ function readMaxParallelOverrideFromEnv() {
     return parsed;
 }
 /**
- * v6.10.0 (P1) — when scheduling a `slice-implementer` on a TDD stage,
- * compare `claimedPaths` against every currently active span on the
- * same `(stage, agent)` pair. Overlap → throw `DispatchOverlapError`;
- * disjoint paths → return `{ autoParallel: true }` so the caller can
- * mark the new entry `allowParallel = true` without explicit operator
- * intent. When the agent is not a slice-implementer or no
- * `claimedPaths` are supplied, the function returns
- * `{ autoParallel: false }` and the legacy dedup path takes over.
+ * When scheduling a `slice-builder` on a TDD stage, compare `claimedPaths`
+ * against every currently active span on the same `(stage, agent)` pair.
+ * Overlap → throw `DispatchOverlapError`; disjoint paths → return
+ * `{ autoParallel: true }` so the caller can mark the new entry
+ * `allowParallel = true` without explicit operator intent. When the agent
+ * is not a slice-builder or no `claimedPaths` are supplied, the function
+ * returns `{ autoParallel: false }` and the standard dedup path takes over.
  */
 export function validateFileOverlap(stamped, activeEntries) {
-    if (stamped.agent !== "slice-implementer" || stamped.stage !== "tdd") {
+    if (!isParallelTddSliceWorker(stamped.agent) || stamped.stage !== "tdd") {
         return { autoParallel: false };
     }
     const newPaths = Array.isArray(stamped.claimedPaths) ? stamped.claimedPaths : [];
@@ -935,7 +884,7 @@ export function validateFileOverlap(stamped, activeEntries) {
         const existingPaths = Array.isArray(existing.claimedPaths) ? existing.claimedPaths : [];
         if (existingPaths.length === 0) {
             // We can't prove disjoint without the other side declaring paths;
-            // be conservative and let the legacy dedup error path fire.
+            // be conservative and let the standard dedup error path fire.
             return { autoParallel: false };
         }
         const overlap = newPaths.filter((p) => existingPaths.includes(p));
@@ -951,24 +900,25 @@ export function validateFileOverlap(stamped, activeEntries) {
     return { autoParallel: true };
 }
 /**
- * v6.10.0 (P2) — enforce the slice-implementer fan-out cap. The new
- * scheduled row pushes the active count from N to N+1; if that would
- * exceed the cap (default 5, env-overridable), throw `DispatchCapError`.
+ * Enforce the slice-builder fan-out cap. The new scheduled row pushes the
+ * active count from N to N+1; if that would exceed the cap (default 5,
+ * env-overridable via `CCLAW_MAX_PARALLEL_SLICE_BUILDERS`), throw
+ * `DispatchCapError`.
  *
- * Caller passes the already-folded list of active entries (latest row
- * per spanId, ACTIVE statuses only). The function counts entries that
- * match the agent on the same `stage`. The new row's own spanId is
- * excluded so re-recording a `scheduled` doesn't trip the cap on a
- * span that's already counted.
+ * Caller passes the already-folded list of active entries (latest row per
+ * spanId, ACTIVE statuses only). The function counts entries that match
+ * the agent on the same `stage`. The new row's own spanId is excluded so
+ * re-recording a `scheduled` doesn't trip the cap on a span that's already
+ * counted.
  */
 export function validateFanOutCap(stamped, activeEntries, override) {
-    if (stamped.agent !== "slice-implementer" || stamped.stage !== "tdd")
+    if (!isParallelTddSliceWorker(stamped.agent) || stamped.stage !== "tdd")
         return;
     if (stamped.status !== "scheduled")
         return;
     const cap = (override !== null && override !== undefined && Number.isInteger(override) && override >= 1)
         ? override
-        : (readMaxParallelOverrideFromEnv() ?? MAX_PARALLEL_SLICE_IMPLEMENTERS);
+        : (readMaxParallelOverrideFromEnv() ?? MAX_PARALLEL_SLICE_BUILDERS);
     const sameLaneActive = activeEntries.filter((entry) => entry.stage === stamped.stage &&
         entry.agent === stamped.agent &&
         entry.spanId !== stamped.spanId);
@@ -981,18 +931,18 @@ export function validateFanOutCap(stamped, activeEntries, override) {
     }
 }
 /**
- * v6.9.0 — find the latest active span for a given `(stage, agent)`
+ * Find the latest active span for a given `(stage, agent)`
  * pair in the supplied ledger entries. Returns the row whose latest
  * status (after the latest-by-spanId fold) is still in the active set
  * (`scheduled | launched | acknowledged`).
  *
  * Run-scope is **strict**: only entries whose `runId` matches the
  * supplied `runId` are folded. Entries with empty/missing `runId`
- * (legacy ledgers from v6.8 and earlier) are treated as NOT belonging
+ * (older ledgers without explicit run scoping) are treated as NOT belonging
  * to the current run, so they cannot keep an old span "active" across
  * a fresh dispatch and trip a spurious `dispatch_duplicate`. This
- * fixes R7: a slice-implementer that ran in run-1 must not block a
- * slice-implementer scheduled in run-2.
+ * Ensures a slice-builder that ran in run-1 does not block a
+ * slice-builder scheduled in run-2.
  *
  * keep in sync with the inline copy in
  * `src/content/hooks.ts::delegationRecordScript`.
@@ -1027,51 +977,12 @@ async function writeSubagentTracker(projectRoot, entries) {
     }));
     await writeFileSafe(subagentsStatePath(projectRoot), `${JSON.stringify({ active, updatedAt: new Date().toISOString() }, null, 2)}\n`, { mode: 0o600 });
 }
-function latestClaimTokenForSpan(entries, spanId) {
-    if (!spanId)
-        return null;
-    let latest = null;
-    for (const e of entries) {
-        if (e.spanId !== spanId)
-            continue;
-        if (typeof e.claimToken === "string" && e.claimToken.trim().length > 0) {
-            latest = e.claimToken.trim();
-        }
-    }
-    return latest;
-}
-function assertSliceClaimInvariant(flow, stamped, prior) {
-    if (stamped.stage !== "tdd" || stamped.agent !== "slice-implementer")
-        return;
-    if (effectiveWorktreeExecutionMode(flow) !== "worktree-first")
-        return;
-    if (stamped.status === "scheduled" && typeof stamped.sliceId === "string" && stamped.sliceId.length > 0) {
-        const tok = stamped.claimToken?.trim() ?? "";
-        if (tok.length === 0) {
-            throw new DispatchClaimInvalidError("dispatch_claim_invalid — worktree-first requires --claim-token when scheduling slice-implementer with --slice");
-        }
-    }
-    if (!TERMINAL_DELEGATION_STATUSES.has(stamped.status))
-        return;
-    if (stamped.status === "waived" || stamped.status === "stale")
-        return;
-    const expected = latestClaimTokenForSpan(prior, stamped.spanId);
-    if (!expected)
-        return;
-    const got = stamped.claimToken?.trim() ?? "";
-    if (got !== expected) {
-        throw new DispatchClaimInvalidError("dispatch_claim_invalid — claimToken must match the scheduled claim for this span");
-    }
-}
 export async function appendDelegation(projectRoot, entry) {
     const flowState = await readFlowState(projectRoot);
     const { activeRunId } = flowState;
     await withDirectoryLock(delegationLockPath(projectRoot), async () => {
         const filePath = delegationLogPath(projectRoot);
         const prior = await readDelegationLedger(projectRoot);
-        // Span start anchor: prefer explicit `startTs`; otherwise fall back to
-        // the earliest provided lifecycle marker so the monotonic validator
-        // never sees a synthetic `now` overshoot a real event timestamp.
         const lifecycleCandidates = [
             entry.startTs,
             entry.launchedTs,
@@ -1120,21 +1031,11 @@ export async function appendDelegation(projectRoot, entry) {
                 stamped.fulfillmentMode = expectedFulfillmentMode(fallbacks);
             }
         }
-        // Idempotency: a retried hook may replay the same lifecycle row. Allow a
-        // terminal row to close an existing scheduled span, but drop exact same
-        // span/status duplicates so checks do not mis-count repeated writes.
         if (prior.entries.some((existing) => existing.spanId === stamped.spanId && existing.status === stamped.status)) {
             return;
         }
-        assertSliceClaimInvariant(flowState, stamped, prior.entries);
         validateMonotonicTimestamps(stamped, prior.entries);
         if (stamped.status === "scheduled") {
-            // v6.10.0 (P1+P2): for slice-implementer rows with declared
-            // claimedPaths, the file-overlap scheduler runs first. Disjoint
-            // paths auto-promote the row to allowParallel so the legacy
-            // dispatch_duplicate guard does not fire. Overlapping paths
-            // throw DispatchOverlapError. The fan-out cap then runs against
-            // the active set (excluding the new row's spanId).
             const sameRunPrior = prior.entries.filter((entry) => entry.runId === activeRunId);
             const activeForRun = computeActiveSubagents(sameRunPrior);
             const overlap = validateFileOverlap(stamped, activeForRun);
@@ -1164,39 +1065,6 @@ export async function appendDelegation(projectRoot, entry) {
         await writeSubagentTracker(projectRoot, ledger.entries);
     });
 }
-/**
- * Scan delegation events for expired `leasedUntil` timestamps and append
- * best-effort `cclaw_slice_lease_expired` audit rows (one per span/slice key).
- */
-export async function reclaimExpiredDelegationClaims(projectRoot, now = new Date()) {
-    const { events } = await readDelegationEvents(projectRoot);
-    const seen = new Set();
-    let count = 0;
-    const ts = now.toISOString();
-    const filePath = delegationEventsPath(projectRoot);
-    const cutoff = Date.parse(ts);
-    for (const e of events) {
-        if (e.leaseState !== "claimed")
-            continue;
-        if (typeof e.leasedUntil !== "string" || e.leasedUntil.length === 0)
-            continue;
-        if (Date.parse(e.leasedUntil) > cutoff)
-            continue;
-        const key = `${e.spanId ?? ""}|${e.sliceId ?? ""}`;
-        if (seen.has(key))
-            continue;
-        seen.add(key);
-        await fs.appendFile(filePath, `${JSON.stringify({
-            event: "cclaw_slice_lease_expired",
-            spanId: e.spanId,
-            sliceId: e.sliceId,
-            leasedUntil: e.leasedUntil,
-            eventTs: ts
-        })}\n`, { encoding: "utf8", mode: 0o600 });
-        count += 1;
-    }
-    return count;
-}
 /**
  * Aggregate the fulfillment mode cclaw expects for the active harness set.
  * Priority native > generic-dispatch > role-switch > waiver — the best
@@ -1218,7 +1086,7 @@ export async function checkMandatoryDelegations(projectRoot, stage, options = {}
     const flowState = await readFlowState(projectRoot, {
         repairFeatureSystem: options.repairFeatureSystem
     });
-    // Wave 24 follow-up (v6.1.1): read `flowState.taskClass` as a fallback
+    // Read `flowState.taskClass` as a fallback
     // when the caller doesn't pass an explicit override. The
     // `cclaw advance-stage` path (`buildValidationReport` →
     // `checkMandatoryDelegations`) never forwarded `taskClass`, which left
@@ -1343,7 +1211,7 @@ export async function checkMandatoryDelegations(projectRoot, stage, options = {}
     };
 }
 /**
- * Wave 24 (v6.0.0) — append a non-delegation audit event to
+ * Append a non-delegation audit event to
  * `delegation-events.jsonl` recording that the mandatory delegation
  * gate was skipped because of the active track / task class. Plays the
  * same audit role as a `waived` row but does NOT carry an agent —
@@ -1373,12 +1241,12 @@ async function recordMandatorySkippedByTrack(projectRoot, params) {
     }
 }
 /**
- * Wave 25 (v6.1.0) — append a non-delegation audit event recording
+ * Append a non-delegation audit event recording
  * that one or more required artifact-validation findings were
  * demoted from blocking to advisory because the active run is on a
  * small-fix lane (`track === "quick"` or `taskClass === "software-bugfix"`).
  *
- * The event mirrors the Wave 24 `mandatory_delegations_skipped_by_track`
+ * The event mirrors `mandatory_delegations_skipped_by_track`
  * audit pattern: best-effort write to `delegation-events.jsonl`, no
  * agent payload, recognized by `readDelegationEvents` so it does not
  * corrupt downstream parsers. Failures are swallowed.
@@ -1405,12 +1273,12 @@ export async function recordArtifactValidationDemotedByTrack(projectRoot, params
     }
 }
 /**
- * Wave 25 (v6.1.0) — append a non-delegation audit event recording
+ * Append a non-delegation audit event recording
  * that the scope-stage Expansion Strategist (`product-discovery`)
  * delegation requirement was skipped because the active run is on a
  * small-fix lane (`track === "quick"` or `taskClass === "software-bugfix"`).
  *
- * Mirrors the Wave 24 `mandatory_delegations_skipped_by_track`
+ * Mirrors the `mandatory_delegations_skipped_by_track`
  * audit pattern: best-effort write to `delegation-events.jsonl`, no
  * agent payload, recognized by `readDelegationEvents` so it does not
  * corrupt downstream parsers. Failures are swallowed.

package/dist/early-loop.js

@@ -137,7 +137,7 @@ export function parseEarlyLoopLog(text, options = {}) {
                 continue;
             }
         }
-        // v6.9.0 schema repair: legacy logs may carry rows with no runId
+        // schema repair: legacy logs may carry rows with no runId
         // (the prior parser silently coerced them to "active", which then
         // collided across runs). Surface a structured warning on read but
         // skip the row so derived status doesn't fold cross-run state.