cclaw-cli 6.1.0 → 6.1.1

package/dist/delegation.d.ts

@@ -149,7 +149,10 @@ export declare function checkMandatoryDelegations(projectRoot: string, stage: Fl
      * Optional task class for the active run. When set to
      * `"software-bugfix"`, the mandatory delegation gate is skipped
      * entirely (Wave 24). Callers that don't classify the run leave
-     * this undefined and rely on the track-based skip.
+     * this undefined; the function then falls back to
+     * `flowState.taskClass` (persisted in `flow-state.json`) so the
+     * Wave 24 bugfix-skip remains active across the `cclaw advance-stage`
+     * code path even when no caller forwards an explicit override.
      */
     taskClass?: MandatoryDelegationTaskClass | null;
 }): Promise<{

package/dist/delegation.js

@@ -473,14 +473,22 @@ export async function checkMandatoryDelegations(projectRoot, stage, options = {}
     const flowState = await readFlowState(projectRoot, {
         repairFeatureSystem: options.repairFeatureSystem
     });
-    const mandatory = mandatoryAgentsFor(stage, flowState.track, options.taskClass ?? null);
+    // Wave 24 follow-up (v6.1.1): 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
+    // the `software-bugfix` skip dead for users who classified their run
+    // via `flow-state.json`. Forward-typed `null` callers still suppress
+    // the lookup explicitly; only `undefined` triggers the fallback.
+    const resolvedTaskClass = options.taskClass !== undefined ? options.taskClass : flowState.taskClass ?? null;
+    const mandatory = mandatoryAgentsFor(stage, flowState.track, resolvedTaskClass);
     const skippedByTrack = mandatory.length === 0 &&
         stageSchema(stage, flowState.track).mandatoryDelegations.length > 0;
     if (skippedByTrack) {
         await recordMandatorySkippedByTrack(projectRoot, {
             stage,
             track: flowState.track,
-            taskClass: options.taskClass ?? null,
+            taskClass: resolvedTaskClass,
             runId: flowState.activeRunId
         });
     }

package/dist/internal/advance-stage/advance.js

@@ -160,7 +160,15 @@ export async function tryAutoHydrateAndSelectReviewLoopGate(projectRoot, stage,
     return [...selectedGateIds, gateId];
 }
 export async function buildValidationReport(projectRoot, flowState, options = {}) {
-    const delegation = await checkMandatoryDelegations(projectRoot, flowState.currentStage);
+    // Wave 24 follow-up (v6.1.1): forward `flowState.taskClass` so the
+    // bugfix-skip lights up via the `cclaw advance-stage` path. The
+    // delegation helper now has its own fallback (it reads `flowState`
+    // internally), but threading the value here keeps the call site
+    // self-documenting and survives any future refactor that drops the
+    // implicit fallback.
+    const delegation = await checkMandatoryDelegations(projectRoot, flowState.currentStage, {
+        taskClass: flowState.taskClass ?? undefined
+    });
     const gates = await verifyCurrentStageGateEvidence(projectRoot, flowState, {
         extraStageFlags: options.extraStageFlags
     });

package/dist/run-persistence.js

@@ -159,6 +159,29 @@ function sanitizeStageGateCatalog(value, fallback) {
 function coerceTrack(value) {
     return isFlowTrack(value) ? value : "standard";
 }
+/**
+ * Wave 24 follow-up (v6.1.1) — preserve `flow-state.json#taskClass`
+ * across read/write round-trips. Before this audit fix the persistence
+ * layer silently dropped the field, which made the Wave 24 bugfix-skip
+ * (`mandatoryAgentsFor` short-circuit) and the Wave 25 artifact-validation
+ * demotion both dead in practice: the only entry point that classified
+ * a run was the unit-test harness passing `options.taskClass` directly
+ * to `checkMandatoryDelegations`. The accepted union mirrors
+ * `MandatoryDelegationTaskClass` plus `null` so callers can explicitly
+ * clear the classification without dropping the property.
+ */
+function coerceTaskClass(value) {
+    if (value === undefined)
+        return undefined;
+    if (value === null)
+        return null;
+    if (value === "software-standard" ||
+        value === "software-trivial" ||
+        value === "software-bugfix") {
+        return value;
+    }
+    return undefined;
+}
 function sanitizeSkippedStages(value, track) {
     const trackDefault = skippedStagesForTrack(track);
     if (!Array.isArray(value)) {
@@ -354,6 +377,7 @@ function coerceFlowState(parsed) {
     const activeRunId = typeof activeRunIdRaw === "string" && activeRunIdRaw.trim().length > 0
         ? activeRunIdRaw.trim()
         : next.activeRunId;
+    const taskClass = coerceTaskClass(parsed.taskClass);
     const state = {
         schemaVersion: FLOW_STATE_SCHEMA_VERSION,
         activeRunId,
@@ -362,6 +386,7 @@ function coerceFlowState(parsed) {
         guardEvidence: sanitizeGuardEvidence(parsed.guardEvidence),
         stageGateCatalog: sanitizeStageGateCatalog(parsed.stageGateCatalog, next.stageGateCatalog),
         track,
+        ...(taskClass !== undefined ? { taskClass } : {}),
         skippedStages: sanitizeSkippedStages(parsed.skippedStages, track),
         staleStages: sanitizeStaleStages(parsed.staleStages),
         rewinds: sanitizeRewinds(parsed.rewinds),

package/package.json

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