cclaw-cli 6.1.0 → 6.2.0

package/dist/internal/advance-stage/verify.d.ts

@@ -1,4 +1,3 @@
-import { type StageAutoSubagentDispatch } from "../../content/stage-schema.js";
 import { type FlowState, type StageGateState } from "../../flow-state.js";
 import { type FlowStage, type FlowTrack } from "../../types.js";
 import type { VerifyCurrentStateArgs, VerifyFlowStateDiffArgs } from "./parsers.js";
@@ -7,9 +6,6 @@ interface InternalIo {
     stdout: Writable;
     stderr: Writable;
 }
-interface ProactiveDelegationTraceResult {
-    missingRules: StageAutoSubagentDispatch[];
-}
 export declare function runVerifyFlowStateDiff(projectRoot: string, args: VerifyFlowStateDiffArgs, io: InternalIo): Promise<number>;
 export declare function runVerifyCurrentState(projectRoot: string, args: VerifyCurrentStateArgs, io: InternalIo): Promise<number>;
 export declare function firstIncompleteStageForTrack(track: FlowTrack, completedStages: FlowStage[]): FlowStage;
@@ -18,10 +14,6 @@ export declare function carriedCompletedStageCatalog(current: FlowState, fresh:
     evidence: Record<string, string>;
 };
 export declare function completedStageClosureEvidenceIssues(flowState: FlowState): string[];
-export declare function ensureProactiveDelegationTrace(projectRoot: string, stage: FlowStage, options: {
-    acceptWaiver: boolean;
-    waiverReason?: string;
-}): Promise<ProactiveDelegationTraceResult>;
 export declare function pathExists(projectRoot: string, relPath: string): Promise<boolean>;
 export declare function listExistingFiles(projectRoot: string, relPaths: string[]): Promise<string[]>;
 export declare function listFilesUnder(projectRoot: string, relDir: string, limit?: number): Promise<string[]>;

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

@@ -1,7 +1,6 @@
 import path from "node:path";
 import { RUNTIME_ROOT } from "../../constants.js";
-import { stageAutoSubagentDispatch, stageSchema } from "../../content/stage-schema.js";
-import { appendDelegation, readDelegationLedger } from "../../delegation.js";
+import { stageSchema } from "../../content/stage-schema.js";
 import { readFlowState } from "../../runs.js";
 import { TRACK_STAGES } from "../../types.js";
 import { coerceCandidateFlowState } from "./flow-state-coercion.js";
@@ -87,7 +86,7 @@ export function carriedCompletedStageCatalog(current, fresh, stage) {
 export function completedStageClosureEvidenceIssues(flowState) {
     const issues = [];
     for (const stage of flowState.completedStages) {
-        const schema = stageSchema(stage, flowState.track);
+        const schema = stageSchema(stage, flowState.track, flowState.discoveryMode, flowState.taskClass ?? null);
         const catalog = flowState.stageGateCatalog[stage];
         const required = schema.requiredGates
             .filter((gate) => gate.tier === "required")
@@ -103,33 +102,6 @@ export function completedStageClosureEvidenceIssues(flowState) {
     }
     return issues;
 }
-export async function ensureProactiveDelegationTrace(projectRoot, stage, options) {
-    const proactiveRules = stageAutoSubagentDispatch(stage).filter((rule) => rule.mode === "proactive");
-    if (proactiveRules.length === 0)
-        return { missingRules: [] };
-    const ledger = await readDelegationLedger(projectRoot);
-    const currentRunEntries = ledger.entries.filter((entry) => entry.runId === ledger.runId);
-    const missingRules = proactiveRules.filter((rule) => !currentRunEntries.some((entry) => entry.stage === stage && entry.agent === rule.agent && entry.mode === "proactive"));
-    if (missingRules.length === 0)
-        return { missingRules: [] };
-    if (!options.acceptWaiver)
-        return { missingRules };
-    const waiverReason = options.waiverReason?.trim() || "accepted via --accept-proactive-waiver";
-    for (const rule of missingRules) {
-        await appendDelegation(projectRoot, {
-            stage,
-            agent: rule.agent,
-            mode: "proactive",
-            status: "waived",
-            waiverReason,
-            acceptedBy: "user-flag",
-            conditionTrigger: rule.when,
-            skill: rule.skill,
-            ts: new Date().toISOString()
-        });
-    }
-    return { missingRules: [] };
-}
 export async function pathExists(projectRoot, relPath) {
     try {
         await fs.stat(path.join(projectRoot, relPath));

package/dist/run-persistence.js

@@ -1,7 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { RUNTIME_ROOT } from "./constants.js";
-import { nextStage, createInitialCloseoutState, createInitialFlowState, FLOW_STATE_SCHEMA_VERSION, isFlowTrack, skippedStagesForTrack, SHIP_SUBSTATES } from "./flow-state.js";
+import { nextStage, createInitialCloseoutState, createInitialFlowState, FLOW_STATE_SCHEMA_VERSION, isDiscoveryMode, isFlowTrack, skippedStagesForTrack, SHIP_SUBSTATES } from "./flow-state.js";
 import { ensureDir, exists, withDirectoryLock, writeFileSafe } from "./fs-utils.js";
 import { FLOW_STAGES } from "./types.js";
 export class InvalidStageTransitionError extends Error {
@@ -30,6 +30,9 @@ function validateFlowTransition(prev, next) {
     if (prev.track !== next.track) {
         throw new InvalidStageTransitionError(prev.currentStage, next.currentStage, `cannot change track from "${prev.track}" to "${next.track}" mid-run (activeRunId="${prev.activeRunId}"). Archive the run and start a new one to switch tracks.`);
     }
+    if (prev.discoveryMode !== next.discoveryMode) {
+        throw new InvalidStageTransitionError(prev.currentStage, next.currentStage, `cannot change discoveryMode from "${prev.discoveryMode}" to "${next.discoveryMode}" mid-run (activeRunId="${prev.activeRunId}"). Reclassify through start-flow or start a new run.`);
+    }
     const newRewind = next.rewinds.length === prev.rewinds.length + 1
         ? next.rewinds[next.rewinds.length - 1]
         : undefined;
@@ -159,6 +162,32 @@ function sanitizeStageGateCatalog(value, fallback) {
 function coerceTrack(value) {
     return isFlowTrack(value) ? value : "standard";
 }
+function coerceDiscoveryMode(value) {
+    return isDiscoveryMode(value) ? value : "guided";
+}
+/**
+ * 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)) {
@@ -349,11 +378,13 @@ function sanitizeCloseoutState(value) {
 }
 function coerceFlowState(parsed) {
     const track = coerceTrack(parsed.track);
-    const next = createInitialFlowState({ track });
+    const discoveryMode = coerceDiscoveryMode(parsed.discoveryMode);
+    const next = createInitialFlowState({ track, discoveryMode });
     const activeRunIdRaw = parsed.activeRunId;
     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 +393,8 @@ function coerceFlowState(parsed) {
         guardEvidence: sanitizeGuardEvidence(parsed.guardEvidence),
         stageGateCatalog: sanitizeStageGateCatalog(parsed.stageGateCatalog, next.stageGateCatalog),
         track,
+        discoveryMode,
+        ...(taskClass !== undefined ? { taskClass } : {}),
         skippedStages: sanitizeSkippedStages(parsed.skippedStages, track),
         staleStages: sanitizeStaleStages(parsed.staleStages),
         rewinds: sanitizeRewinds(parsed.rewinds),

package/dist/track-heuristics.d.ts

@@ -1,4 +1,4 @@
-import type { FlowStage, FlowTrack, TrackHeuristicRule, TrackHeuristicsConfig } from "./types.js";
+import type { DiscoveryMode, FlowStage, FlowTrack, TrackHeuristicRule, TrackHeuristicsConfig } from "./types.js";
 export interface TrackResolution {
     track: FlowTrack;
     reason: string;
@@ -19,7 +19,7 @@ export interface QuestionBudgetHint {
  * "advisory" language.
  */
 export declare function resolveTrackFromPrompt(prompt: string, config: TrackHeuristicsConfig | undefined): TrackResolution;
-export declare function questionBudgetHint(track: FlowTrack, stage: FlowStage): QuestionBudgetHint;
+export declare function questionBudgetHint(modeOrTrack: DiscoveryMode | FlowTrack, stage: FlowStage): QuestionBudgetHint;
 export declare const TRACK_HEURISTICS_DEFAULTS: {
     readonly fallback: "standard";
     readonly evaluationOrder: readonly ("quick" | "medium" | "standard")[];

package/dist/track-heuristics.js

@@ -55,10 +55,10 @@ const DEFAULT_RULES = {
 const EVALUATION_ORDER = ["standard", "medium", "quick"];
 const DEFAULT_FALLBACK = "standard";
 const ADAPTIVE_ELICITATION_STAGES = new Set(["brainstorm", "scope", "design"]);
-const QUESTION_BUDGET_HINTS_BY_TRACK = {
-    quick: { min: 2, recommended: 3, hardCapWarning: 4 },
-    medium: { min: 5, recommended: 6, hardCapWarning: 8 },
-    standard: { min: 10, recommended: 12, hardCapWarning: 14 }
+const QUESTION_BUDGET_HINTS_BY_DISCOVERY_MODE = {
+    lean: { min: 3, recommended: 4, hardCapWarning: 6 },
+    guided: { min: 5, recommended: 7, hardCapWarning: 10 },
+    deep: { min: 7, recommended: 10, hardCapWarning: 14 }
 };
 function hasToken(promptLower, token) {
     return promptLower.includes(token.toLowerCase());
@@ -136,11 +136,16 @@ export function resolveTrackFromPrompt(prompt, config) {
         overrideGuidance: "Confirm or override before state is written; choose quick only for known low-blast-radius work, medium for known architecture with product framing, standard for uncertainty."
     };
 }
-export function questionBudgetHint(track, stage) {
+export function questionBudgetHint(modeOrTrack, stage) {
     if (!ADAPTIVE_ELICITATION_STAGES.has(stage)) {
         return { min: 0, recommended: 0, hardCapWarning: 0 };
     }
-    return QUESTION_BUDGET_HINTS_BY_TRACK[track];
+    if (modeOrTrack === "lean" || modeOrTrack === "guided" || modeOrTrack === "deep") {
+        return QUESTION_BUDGET_HINTS_BY_DISCOVERY_MODE[modeOrTrack];
+    }
+    if (modeOrTrack === "quick")
+        return QUESTION_BUDGET_HINTS_BY_DISCOVERY_MODE.lean;
+    return QUESTION_BUDGET_HINTS_BY_DISCOVERY_MODE.guided;
 }
 export const TRACK_HEURISTICS_DEFAULTS = {
     fallback: DEFAULT_FALLBACK,

package/dist/types.d.ts

@@ -2,6 +2,8 @@ export declare const FLOW_STAGES: readonly ["brainstorm", "scope", "design", "sp
 export type FlowStage = (typeof FLOW_STAGES)[number];
 export declare const FLOW_TRACKS: readonly ["quick", "medium", "standard"];
 export type FlowTrack = (typeof FLOW_TRACKS)[number];
+export declare const DISCOVERY_MODES: readonly ["lean", "guided", "deep"];
+export type DiscoveryMode = (typeof DISCOVERY_MODES)[number];
 /**
  * Ordered stages that make up each flow track.
  *

package/dist/types.js

@@ -9,6 +9,7 @@ export const FLOW_STAGES = [
     "ship"
 ];
 export const FLOW_TRACKS = ["quick", "medium", "standard"];
+export const DISCOVERY_MODES = ["lean", "guided", "deep"];
 /**
  * Ordered stages that make up each flow track.
  *

package/package.json

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