cclaw-cli 0.55.2 → 2.0.0

package/dist/flow-state.d.ts

@@ -32,14 +32,13 @@ export interface RetroState {
 /**
  * Ship closeout substate machine.
  *
- * After ship completes, cclaw auto-chains retro → compound → archive.
+ * After ship completes, cclaw auto-chains post-ship review → archive.
  * Each step is interruptible: `/cc` reads `shipSubstate` and resumes
  * from the correct step even across sessions.
  *
  * - `idle` — ship not complete, or closeout not yet started.
- * - `retro_review` — 09-retro.md draft exists; awaiting user edit/accept/skip.
- * - `compound_review` — retro accepted; compound pass awaiting execution
- *   (or user skip).
+ * - `post_ship_review` — unified closeout leg: retro acceptance/edit/skip
+ *   plus compound pass execution (or explicit skip).
  * - `ready_to_archive` — retro + compound done; archive is the next
  *   automatic step.
  * - `archived` — archive completed in this session (transient — archive
@@ -53,7 +52,7 @@ export interface RetroState {
  * These are not duplicates: `done` lives in stage transitions; `archived` /
  * `idle` live in closeout lifecycle state.
  */
-export declare const SHIP_SUBSTATES: readonly ["idle", "retro_review", "compound_review", "ready_to_archive", "archived"];
+export declare const SHIP_SUBSTATES: readonly ["idle", "post_ship_review", "ready_to_archive", "archived"];
 export type ShipSubstate = (typeof SHIP_SUBSTATES)[number];
 export interface CloseoutState {
     shipSubstate: ShipSubstate;
@@ -83,11 +82,18 @@ export interface FlowState {
     staleStages: Partial<Record<FlowStage, StaleStageMarker>>;
     /** Chronological rewind operations for the active run. */
     rewinds: RewindRecord[];
+    /** Optional per-stage interaction hints carried from prior stage transitions. */
+    interactionHints?: Partial<Record<FlowStage, StageInteractionHint>>;
     /** Mandatory retrospective gate status before archive. */
     retro: RetroState;
-    /** Ship → retro → compound → archive substate for resumable closeout. */
+    /** Ship → post_ship_review → archive substate for resumable closeout. */
     closeout: CloseoutState;
 }
+export interface StageInteractionHint {
+    skipQuestions?: boolean;
+    sourceStage?: FlowStage;
+    recordedAt?: string;
+}
 export interface InitialFlowStateOptions {
     activeRunId?: string;
     track?: FlowTrack;

package/dist/flow-state.js

@@ -5,14 +5,13 @@ export const FLOW_STATE_SCHEMA_VERSION = 1;
 /**
  * Ship closeout substate machine.
  *
- * After ship completes, cclaw auto-chains retro → compound → archive.
+ * After ship completes, cclaw auto-chains post-ship review → archive.
  * Each step is interruptible: `/cc` reads `shipSubstate` and resumes
  * from the correct step even across sessions.
  *
  * - `idle` — ship not complete, or closeout not yet started.
- * - `retro_review` — 09-retro.md draft exists; awaiting user edit/accept/skip.
- * - `compound_review` — retro accepted; compound pass awaiting execution
- *   (or user skip).
+ * - `post_ship_review` — unified closeout leg: retro acceptance/edit/skip
+ *   plus compound pass execution (or explicit skip).
  * - `ready_to_archive` — retro + compound done; archive is the next
  *   automatic step.
  * - `archived` — archive completed in this session (transient — archive
@@ -28,8 +27,7 @@ export const FLOW_STATE_SCHEMA_VERSION = 1;
  */
 export const SHIP_SUBSTATES = [
     "idle",
-    "retro_review",
-    "compound_review",
+    "post_ship_review",
     "ready_to_archive",
     "archived"
 ];
@@ -92,6 +90,7 @@ export function createInitialFlowState(activeRunIdOrOptions = {}, maybeTrack) {
         skippedStages,
         staleStages: {},
         rewinds: [],
+        interactionHints: {},
         retro: {
             required: false,
             completedAt: undefined,

package/dist/gate-evidence.d.ts

@@ -29,37 +29,6 @@ export interface CompletedStagesClosureResult {
         blocked: string[];
     }>;
 }
-export declare const RECONCILIATION_NOTICES_REL_PATH = ".cclaw/state/reconciliation-notices.json";
-export type ReconciliationNoticeKind = "gate_demotion" | "closeout_substate_demotion";
-export interface CloseoutSubstateDemotionPayload {
-    previous: string;
-    next: string;
-    reason: string;
-}
-export interface ReconciliationNotice {
-    id: string;
-    runId: string;
-    stage: FlowStage;
-    gateId: string;
-    reason: string;
-    demotedAt: string;
-    kind?: ReconciliationNoticeKind;
-    payload?: CloseoutSubstateDemotionPayload;
-}
-export interface ReconciliationNoticesPayload {
-    schemaVersion: number;
-    notices: ReconciliationNotice[];
-    parseOk: boolean;
-    schemaOk: boolean;
-}
-export interface ReconciliationNoticeBuckets {
-    activeBlocked: ReconciliationNotice[];
-    currentStageBlocked: ReconciliationNotice[];
-    unsynced: ReconciliationNotice[];
-    staleRun: ReconciliationNotice[];
-}
-export declare function readReconciliationNotices(projectRoot: string): Promise<ReconciliationNoticesPayload>;
-export declare function classifyReconciliationNotices(flowState: FlowState, notices: ReconciliationNotice[]): ReconciliationNoticeBuckets;
 export declare function verifyCurrentStageGateEvidence(projectRoot: string, flowState: FlowState): Promise<GateEvidenceCheckResult>;
 export declare function verifyCompletedStagesGateClosure(flowState: FlowState): CompletedStagesClosureResult;
 export interface GateReconciliationResult {

package/dist/gate-evidence.js

@@ -6,14 +6,12 @@ import { readConfig } from "./config.js";
 import { RUNTIME_ROOT } from "./constants.js";
 import { stageSchema } from "./content/stage-schema.js";
 import { readDelegationLedger } from "./delegation.js";
-import { ensureDir, exists, writeFileSafe } from "./fs-utils.js";
+import { exists } from "./fs-utils.js";
 import { computeEarlyLoopStatus, isEarlyLoopStage, normalizeEarlyLoopMaxIterations } from "./early-loop.js";
 import { detectPublicApiChanges } from "./internal/detect-public-api-changes.js";
 import { readFlowState, writeFlowState } from "./runs.js";
 import { parseTddCycleLog, validateTddCycleOrder } from "./tdd-cycle.js";
 import { validateTddVerificationEvidence } from "./tdd-verification-evidence.js";
-import { buildTraceMatrix } from "./trace-matrix.js";
-import { FLOW_STAGES } from "./types.js";
 async function currentStageArtifactExists(projectRoot, stage, track) {
     const resolved = await resolveArtifactPath(stage, {
         projectRoot,
@@ -107,8 +105,7 @@ async function discoverRealTestCommands(projectRoot) {
     return unique(commands);
 }
 async function verifyDiscoveredCommandEvidence(projectRoot, stage, gateId, flowState) {
-    if (!(stage === "tdd" && gateId === "tdd_verified_before_complete") &&
-        !(stage === "review" && gateId === "review_trace_matrix_clean")) {
+    if (!(stage === "tdd" && gateId === "tdd_verified_before_complete")) {
         return null;
     }
     const commands = await discoverRealTestCommands(projectRoot);
@@ -207,8 +204,6 @@ async function readEarlyLoopGateSnapshot(projectRoot, flowState) {
         };
     }
 }
-const RECONCILIATION_NOTICES_FILE = "reconciliation-notices.json";
-const RECONCILIATION_NOTICES_SCHEMA_VERSION = 1;
 const DESIGN_RESEARCH_REQUIRED_SECTIONS = [
     "Stack Analysis",
     "Features & Patterns",
@@ -216,123 +211,6 @@ const DESIGN_RESEARCH_REQUIRED_SECTIONS = [
     "Pitfalls & Risks",
     "Synthesis"
 ];
-export const RECONCILIATION_NOTICES_REL_PATH = `${RUNTIME_ROOT}/state/${RECONCILIATION_NOTICES_FILE}`;
-function isFlowStageValue(value) {
-    return typeof value === "string" && FLOW_STAGES.includes(value);
-}
-function reconciliationNoticesPath(projectRoot) {
-    return path.join(projectRoot, RUNTIME_ROOT, "state", RECONCILIATION_NOTICES_FILE);
-}
-function defaultReconciliationNoticesPayload() {
-    return {
-        schemaVersion: RECONCILIATION_NOTICES_SCHEMA_VERSION,
-        notices: [],
-        parseOk: true,
-        schemaOk: true
-    };
-}
-function sanitizeReconciliationNotice(raw) {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-        return null;
-    }
-    const typed = raw;
-    if (typeof typed.id !== "string" ||
-        typeof typed.runId !== "string" ||
-        !isFlowStageValue(typed.stage) ||
-        typeof typed.gateId !== "string" ||
-        typeof typed.reason !== "string" ||
-        typeof typed.demotedAt !== "string") {
-        return null;
-    }
-    const kind = typed.kind === "closeout_substate_demotion"
-        ? "closeout_substate_demotion"
-        : "gate_demotion";
-    let payload;
-    if (kind === "closeout_substate_demotion" && typed.payload && typeof typed.payload === "object" && !Array.isArray(typed.payload)) {
-        const payloadTyped = typed.payload;
-        if (typeof payloadTyped.previous === "string" &&
-            typeof payloadTyped.next === "string" &&
-            typeof payloadTyped.reason === "string") {
-            payload = {
-                previous: payloadTyped.previous,
-                next: payloadTyped.next,
-                reason: payloadTyped.reason
-            };
-        }
-    }
-    return {
-        id: typed.id,
-        runId: typed.runId,
-        stage: typed.stage,
-        gateId: typed.gateId,
-        reason: typed.reason,
-        demotedAt: typed.demotedAt,
-        kind,
-        payload
-    };
-}
-export async function readReconciliationNotices(projectRoot) {
-    const filePath = reconciliationNoticesPath(projectRoot);
-    if (!(await exists(filePath))) {
-        return defaultReconciliationNoticesPayload();
-    }
-    try {
-        const raw = JSON.parse(await fs.readFile(filePath, "utf8"));
-        const schemaOk = raw.schemaVersion === RECONCILIATION_NOTICES_SCHEMA_VERSION;
-        const notices = Array.isArray(raw.notices)
-            ? raw.notices
-                .map((value) => sanitizeReconciliationNotice(value))
-                .filter((value) => value !== null)
-            : [];
-        return {
-            schemaVersion: RECONCILIATION_NOTICES_SCHEMA_VERSION,
-            notices,
-            parseOk: true,
-            schemaOk
-        };
-    }
-    catch {
-        return {
-            ...defaultReconciliationNoticesPayload(),
-            parseOk: false,
-            schemaOk: false
-        };
-    }
-}
-async function writeReconciliationNotices(projectRoot, payload) {
-    const filePath = reconciliationNoticesPath(projectRoot);
-    await ensureDir(path.dirname(filePath));
-    await writeFileSafe(filePath, `${JSON.stringify({
-        schemaVersion: RECONCILIATION_NOTICES_SCHEMA_VERSION,
-        notices: payload.notices
-    }, null, 2)}\n`, { mode: 0o600 });
-}
-export function classifyReconciliationNotices(flowState, notices) {
-    const activeBlocked = [];
-    const currentStageBlocked = [];
-    const unsynced = [];
-    const staleRun = [];
-    for (const notice of notices) {
-        if (notice.runId !== flowState.activeRunId) {
-            staleRun.push(notice);
-            continue;
-        }
-        if (notice.kind === "closeout_substate_demotion") {
-            continue;
-        }
-        const stageCatalog = flowState.stageGateCatalog[notice.stage];
-        const blocked = stageCatalog.blocked.includes(notice.gateId);
-        if (!blocked) {
-            unsynced.push(notice);
-            continue;
-        }
-        activeBlocked.push(notice);
-        if (notice.stage === flowState.currentStage) {
-            currentStageBlocked.push(notice);
-        }
-    }
-    return { activeBlocked, currentStageBlocked, unsynced, staleRun };
-}
 export async function verifyCurrentStageGateEvidence(projectRoot, flowState) {
     const stage = flowState.currentStage;
     const schema = stageSchema(stage, flowState.track);
@@ -448,23 +326,6 @@ export async function verifyCurrentStageGateEvidence(projectRoot, flowState) {
             if (!securityAttestation.ok) {
                 issues.push(`review security attestation failed: ${securityAttestation.errors.join("; ")}`);
             }
-            const traceGateRequired = schema.requiredGates.some((gate) => gate.id === "review_trace_matrix_clean" && gate.tier === "required");
-            if (traceGateRequired) {
-                const trace = await buildTraceMatrix(projectRoot);
-                const traceIssues = [];
-                if (trace.orphanedCriteria.length > 0) {
-                    traceIssues.push(`orphaned criteria: ${trace.orphanedCriteria.join(", ")}`);
-                }
-                if (trace.orphanedTasks.length > 0) {
-                    traceIssues.push(`orphaned tasks: ${trace.orphanedTasks.join(", ")}`);
-                }
-                if (trace.orphanedTests.length > 0) {
-                    traceIssues.push(`orphaned tests: ${trace.orphanedTests.join(", ")}`);
-                }
-                if (traceIssues.length > 0) {
-                    issues.push(`review trace-matrix gate blocked (review_trace_matrix_clean): ${traceIssues.join("; ")}.`);
-                }
-            }
         }
         if (stage === "design") {
             const researchGateRequired = schema.requiredGates.some((gate) => gate.id === "design_research_complete" && gate.tier === "required");
@@ -739,47 +600,8 @@ export function reconcileCurrentStageGateCatalog(flowState) {
 export async function reconcileAndWriteCurrentStageGateCatalog(projectRoot) {
     const state = await readFlowState(projectRoot);
     const { nextState, reconciliation } = reconcileCurrentStageGateCatalog(state);
-    const effectiveState = reconciliation.changed ? nextState : state;
     if (reconciliation.changed) {
-        await writeFlowState(projectRoot, effectiveState);
-    }
-    const noticesPayload = await readReconciliationNotices(projectRoot);
-    let noticesChanged = false;
-    const noticeBuckets = classifyReconciliationNotices(effectiveState, noticesPayload.notices);
-    if (noticeBuckets.unsynced.length > 0 || noticeBuckets.staleRun.length > 0) {
-        const dropIds = new Set([...noticeBuckets.unsynced, ...noticeBuckets.staleRun].map((notice) => notice.id));
-        noticesPayload.notices = noticesPayload.notices.filter((notice) => !dropIds.has(notice.id));
-        noticesChanged = true;
-    }
-    if (reconciliation.demotedGateIds.length > 0) {
-        const existing = new Set(noticesPayload.notices.map((notice) => `${notice.runId}:${notice.stage}:${notice.gateId}:${notice.kind ?? "gate_demotion"}`));
-        for (const gateId of reconciliation.demotedGateIds) {
-            const dedupeKey = `${effectiveState.activeRunId}:${reconciliation.stage}:${gateId}:gate_demotion`;
-            if (existing.has(dedupeKey)) {
-                continue;
-            }
-            const ts = new Date().toISOString();
-            noticesPayload.notices.push({
-                id: `${dedupeKey}:${ts}`,
-                runId: effectiveState.activeRunId,
-                stage: reconciliation.stage,
-                gateId,
-                reason: "demoted from passed to blocked during gate reconciliation (missing evidence)",
-                demotedAt: ts,
-                kind: "gate_demotion"
-            });
-            existing.add(dedupeKey);
-            noticesChanged = true;
-        }
-    }
-    if (noticesChanged) {
-        noticesPayload.notices.sort((a, b) => {
-            if (a.demotedAt === b.demotedAt) {
-                return a.id.localeCompare(b.id);
-            }
-            return a.demotedAt.localeCompare(b.demotedAt);
-        });
-        await writeReconciliationNotices(projectRoot, noticesPayload);
+        await writeFlowState(projectRoot, nextState);
     }
     return {
         ...reconciliation,

package/dist/harness-adapters.js

@@ -378,7 +378,7 @@ When in doubt, prefer **non-trivial** — the quick track is opt-in and only saf
 Knowledge capture and curation run automatically as part of stage completion
 protocols via the internal \`learnings\` skill — no user-facing command.
 Reusable entries land in \`.cclaw/knowledge.jsonl\` as strict JSONL with
-\`type\`, \`trigger\`, \`action\`, and \`origin_run\` metadata.
+\`type\`, \`trigger\`, \`action\`, \`confidence\`, \`stage\`, and \`origin_stage\` metadata.
 
 **Stage order:** brainstorm > scope > design > spec > plan > tdd > review > ship, then closeout: retro > compound > archive. Use \`/cc\` to keep moving through normal work and post-ship closeout; use \`/cc-cancel\` for cancelled/abandoned runs. Gates must pass before handoff.
 

package/dist/hook-schemas/claude-hooks.v1.json

@@ -2,12 +2,11 @@
     "$schema": "https://json-schema.org/draft/2020-12/schema",
     "$id": "cclaw://hooks/claude/v1",
     "harness": "claude",
-    "schemaVersion": 1,
+    "schemaVersion": 2,
     "requiredEvents": [
         "SessionStart",
         "PreToolUse",
         "PostToolUse",
-        "Stop",
-        "PreCompact"
+        "Stop"
     ]
 }

package/dist/hook-schemas/codex-hooks.v1.json

@@ -2,7 +2,7 @@
     "$schema": "https://json-schema.org/draft/2020-12/schema",
     "$id": "cclaw://hooks/codex/v1",
     "harness": "codex",
-    "schemaVersion": 1,
+    "schemaVersion": 2,
     "requiredEvents": [
         "SessionStart",
         "UserPromptSubmit",

package/dist/hook-schemas/cursor-hooks.v1.json

@@ -2,7 +2,7 @@
     "$schema": "https://json-schema.org/draft/2020-12/schema",
     "$id": "cclaw://hooks/cursor/v1",
     "harness": "cursor",
-    "schemaVersion": 1,
+    "schemaVersion": 2,
     "requiredEvents": [
         "sessionStart",
         "sessionResume",

package/dist/install.js

@@ -6,7 +6,7 @@ import { CCLAW_VERSION, FLOW_VERSION, REQUIRED_DIRS, RUNTIME_ROOT } from "./cons
 import { writeConfig, createDefaultConfig, readConfig, configPath, detectLanguageRulePacks, detectAdvancedKeys } from "./config.js";
 import { learnSkillMarkdown } from "./content/learnings.js";
 import { stageCommandShimMarkdown } from "./content/stage-command.js";
-import { ideaCommandContract, ideaCommandSkillMarkdown } from "./content/idea-command.js";
+import { ideaCommandContract, ideaCommandSkillMarkdown } from "./content/idea.js";
 import { startCommandContract, startCommandSkillMarkdown } from "./content/start-command.js";
 import { viewCommandContract, viewCommandSkillMarkdown } from "./content/view-command.js";
 import { cancelCommandContract, cancelCommandSkillMarkdown } from "./content/cancel-command.js";
@@ -19,7 +19,8 @@ import { META_SKILL_NAME, usingCclawSkillMarkdown } from "./content/meta-skill.j
 import { ARTIFACT_TEMPLATES, CURSOR_WORKFLOW_RULE_MDC, RULEBOOK_MARKDOWN, buildRulesJson } from "./content/templates.js";
 import { STATE_CONTRACTS } from "./content/state-contracts.js";
 import { REVIEW_PROMPTS } from "./content/review-prompts.js";
-import { stageSkillFolder, stageSkillMarkdown } from "./content/skills.js";
+import { stageSkillFolder, stageSkillMarkdown, executingWavesSkillMarkdown } from "./content/skills.js";
+import { adaptiveElicitationSkillMarkdown } from "./content/skills-elicitation.js";
 import { LANGUAGE_RULE_PACK_DIR, LANGUAGE_RULE_PACK_FILES, LANGUAGE_RULE_PACK_GENERATORS, LEGACY_LANGUAGE_RULE_PACK_FOLDERS } from "./content/utility-skills.js";
 import { RESEARCH_PLAYBOOKS } from "./content/research-playbooks.js";
 import { SUBAGENT_CONTEXT_SKILLS } from "./content/subagent-context-skills.js";
@@ -470,6 +471,9 @@ async function writeArtifactTemplates(projectRoot) {
         await writeFileSafe(runtimePath(projectRoot, "templates", "state-contracts", fileName), content);
     }));
 }
+async function writeWavePlansScaffold(projectRoot) {
+    await writeFileSafe(runtimePath(projectRoot, "wave-plans", ".gitkeep"), "");
+}
 async function writeSkills(projectRoot, config) {
     const skillTrack = config?.defaultTrack ?? "standard";
     for (const stage of FLOW_STAGES) {
@@ -486,6 +490,8 @@ async function writeSkills(projectRoot, config) {
     await writeFileSafe(runtimePath(projectRoot, "skills", "parallel-dispatch", "SKILL.md"), parallelAgentsSkill());
     await writeFileSafe(runtimePath(projectRoot, "skills", "session", "SKILL.md"), sessionHooksSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", "iron-laws", "SKILL.md"), ironLawsSkillMarkdown());
+    await writeFileSafe(runtimePath(projectRoot, "skills", "executing-waves", "SKILL.md"), executingWavesSkillMarkdown());
+    await writeFileSafe(runtimePath(projectRoot, "skills", "adaptive-elicitation", "SKILL.md"), adaptiveElicitationSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", META_SKILL_NAME, "SKILL.md"), usingCclawSkillMarkdown());
     // In-thread research procedures (no YAML frontmatter, not delegated personas).
     for (const [fileName, markdown] of Object.entries(RESEARCH_PLAYBOOKS)) {
@@ -897,6 +903,33 @@ async function writeMergedHookJson(projectRoot, hookFilePath, generatedJson) {
     }
     await writeFileSafe(hookFilePath, `${JSON.stringify(mergedDoc, null, 2)}\n`);
 }
+async function readBundledRunHookRuntimeScript(options) {
+    const bundleUrl = new URL("./runtime/run-hook.mjs", import.meta.url);
+    try {
+        await fs.stat(bundleUrl);
+    }
+    catch {
+        return null;
+    }
+    try {
+        const moduleUrl = `${bundleUrl.href}?ts=${Date.now()}`;
+        const loaded = await import(moduleUrl);
+        const factory = typeof loaded.buildRunHookRuntimeScript === "function"
+            ? loaded.buildRunHookRuntimeScript
+            : typeof loaded.default === "function"
+                ? loaded.default
+                : null;
+        if (!factory)
+            return null;
+        const script = factory(options);
+        if (typeof script !== "string")
+            return null;
+        return script.trim().length > 0 ? script : null;
+    }
+    catch {
+        return null;
+    }
+}
 async function writeHooks(projectRoot, config) {
     const harnesses = config.harnesses;
     const hooksDir = runtimePath(projectRoot, "hooks");
@@ -911,14 +944,16 @@ async function writeHooks(projectRoot, config) {
     await writeFileSafe(path.join(hooksDir, "stage-complete.mjs"), stageCompleteScript());
     await writeFileSafe(path.join(hooksDir, "start-flow.mjs"), startFlowScript());
     await writeFileSafe(path.join(hooksDir, "cancel-run.mjs"), cancelRunScript());
-    await writeFileSafe(path.join(hooksDir, "run-hook.mjs"), nodeHookRuntimeScript({
+    const hookRuntimeOptions = {
         strictness: effectiveStrictness,
         tddTestPathPatterns: config.tdd?.testPathPatterns ?? config.tddTestGlobs,
         tddProductionPathPatterns: config.tdd?.productionPathPatterns,
         compoundRecurrenceThreshold: config.compound?.recurrenceThreshold,
         earlyLoopEnabled: config.earlyLoop?.enabled,
         earlyLoopMaxIterations: config.earlyLoop?.maxIterations
-    }));
+    };
+    const bundledHookRuntime = await readBundledRunHookRuntimeScript(hookRuntimeOptions);
+    await writeFileSafe(path.join(hooksDir, "run-hook.mjs"), bundledHookRuntime ?? nodeHookRuntimeScript(hookRuntimeOptions));
     await writeFileSafe(path.join(hooksDir, "run-hook.cmd"), runHookCmdScript());
     await writeFileSafe(path.join(hooksDir, "delegation-record.mjs"), delegationRecordScript());
     const opencodePluginSource = opencodePluginJs();
@@ -1047,8 +1082,13 @@ async function syncDisabledHarnessArtifacts(projectRoot, harnesses) {
     }
 }
 async function writeState(projectRoot, config, forceReset = false) {
+    // Fresh init no longer materializes flow-state.json. The first managed
+    // `/cc <idea>` start-flow call creates the state file.
+    if (!forceReset) {
+        return;
+    }
     const statePath = runtimePath(projectRoot, "state", "flow-state.json");
-    if (!forceReset && (await exists(statePath))) {
+    if (await exists(statePath)) {
         return;
     }
     const state = createInitialFlowState({ track: config.defaultTrack ?? "standard" });
@@ -1196,6 +1236,7 @@ async function materializeRuntime(projectRoot, config, forceStateReset, operatio
             writeEntryCommands(projectRoot),
             writeSkills(projectRoot, config),
             writeArtifactTemplates(projectRoot),
+            writeWavePlansScaffold(projectRoot),
             writeRulebook(projectRoot)
         ]);
         await writeState(projectRoot, config, forceStateReset);
@@ -1260,7 +1301,9 @@ export async function initCclaw(options) {
     // and only appear in the on-disk file when the user sets them explicitly
     // or a non-default value was detected (e.g. languageRulePacks).
     await writeConfig(options.projectRoot, config, { mode: "minimal" });
-    await materializeRuntime(options.projectRoot, config, true, "init");
+    // Init should scaffold runtime surfaces but leave flow-state creation to the
+    // first managed start-flow invocation.
+    await materializeRuntime(options.projectRoot, config, false, "init");
 }
 export async function syncCclaw(projectRoot, options = {}) {
     if (options.harnesses !== undefined && options.harnesses.length === 0) {
@@ -1384,7 +1427,7 @@ function isManagedRuntimeHookCommand(command) {
     // (e.g. `node .cclaw\hooks\run-hook.mjs ...`) still round-trip through
     // sync without being duplicated alongside freshly generated entries.
     const normalized = command.trim().replace(/\s+/gu, " ").replace(/\\/gu, "/");
-    if (/(^|\s)(?:node\s+)?(?:"|')?(?:\.\/)?\.cclaw\/hooks\/run-hook\.(?:mjs|cmd)(?:"|')?\s+(?:session-start|stop-handoff|stop-checkpoint|pre-compact|prompt-guard|workflow-guard|context-monitor|verify-current-state)(?:\s|$)/u.test(normalized)) {
+    if (/(^|\s)(?:node\s+)?(?:"|')?(?:\.\/)?\.cclaw\/hooks\/run-hook\.(?:mjs|cmd)(?:"|')?\s+(?:session-start|stop-handoff|stop-checkpoint|pre-compact|prompt-guard|workflow-guard|pre-tool-pipeline|prompt-pipeline|context-monitor|verify-current-state)(?:\s|$)/u.test(normalized)) {
         return true;
     }
     // Codex UserPromptSubmit non-blocking state nudge.

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

@@ -40,6 +40,23 @@ function resolveSuccessorTransition(stage, track, transitionTargets, satisfiedGu
     }
     return natural;
 }
+function nextInteractionHints(flowState, args, successor) {
+    const hints = { ...(flowState.interactionHints ?? {}) };
+    delete hints[args.stage];
+    if (successor) {
+        if (args.skipQuestions) {
+            hints[successor] = {
+                skipQuestions: true,
+                sourceStage: args.stage,
+                recordedAt: new Date().toISOString()
+            };
+        }
+        else {
+            delete hints[successor];
+        }
+    }
+    return hints;
+}
 export async function hydrateReviewLoopEvidenceFromArtifact(projectRoot, stage, track, selectedGateIds, evidenceByGate) {
     const gateId = AUTO_REVIEW_LOOP_GATE_BY_STAGE[stage];
     if (!gateId)
@@ -168,7 +185,6 @@ export async function harvestStageLearnings(projectRoot, stage, track) {
     const appendResult = await appendKnowledge(projectRoot, parsed.entries, {
         stage,
         originStage: stage,
-        originRun: null,
         project: path.basename(projectRoot)
     });
     if (appendResult.invalid > 0) {
@@ -244,6 +260,7 @@ export async function runAdvanceStage(projectRoot, args, io) {
                 mode: "mandatory",
                 status: "waived",
                 waiverReason,
+                runId: flowState.activeRunId,
                 fulfillmentMode: "role-switch",
                 ts: new Date().toISOString()
             });
@@ -453,10 +470,12 @@ export async function runAdvanceStage(projectRoot, args, io) {
         : flowState.completedStages.includes(args.stage)
             ? [...flowState.completedStages]
             : [...flowState.completedStages, args.stage];
+    const interactionHints = nextInteractionHints(flowState, args, successor);
     const finalState = {
         ...candidateState,
         completedStages,
-        currentStage: successor ?? args.stage
+        currentStage: successor ?? args.stage,
+        interactionHints
     };
     await writeFlowState(projectRoot, finalState);
     if (!args.quiet) {
@@ -467,6 +486,7 @@ export async function runAdvanceStage(projectRoot, args, io) {
             nextStage: successor,
             currentStage: finalState.currentStage,
             completedStages: finalState.completedStages,
+            skipQuestionsHint: args.skipQuestions,
             learnings: {
                 parsed: learningsHarvest.parsedEntries,
                 appended: learningsHarvest.appendedEntries,

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

@@ -8,6 +8,7 @@ export interface AdvanceStageArgs {
     waiverReason?: string;
     acceptProactiveWaiver: boolean;
     acceptProactiveWaiverReason?: string;
+    skipQuestions: boolean;
     quiet: boolean;
     json: boolean;
 }

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

@@ -12,6 +12,7 @@ export function parseAdvanceStageArgs(tokens) {
     let waiverReason;
     let acceptProactiveWaiver = false;
     let acceptProactiveWaiverReason;
+    let skipQuestions = false;
     let quiet = false;
     let json = false;
     for (let i = 0; i < flagTokens.length; i += 1) {
@@ -80,6 +81,10 @@ export function parseAdvanceStageArgs(tokens) {
             acceptProactiveWaiver = true;
             continue;
         }
+        if (token === "--skip-questions") {
+            skipQuestions = true;
+            continue;
+        }
         if (token === "--accept-proactive-waiver-reason") {
             if (!nextToken || nextToken.startsWith("--")) {
                 throw new Error("--accept-proactive-waiver-reason requires a text value.");
@@ -102,6 +107,7 @@ export function parseAdvanceStageArgs(tokens) {
         waiverReason,
         acceptProactiveWaiver,
         acceptProactiveWaiverReason,
+        skipQuestions,
         quiet,
         json
     };

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

@@ -1,5 +1,5 @@
 import { SHIP_FINALIZATION_MODES } from "../../constants.js";
-import { PASS_STATUS_PATTERN, TEST_COMMAND_HINT_PATTERN, validateTddVerificationEvidence } from "../../tdd-verification-evidence.js";
+import { validateTddVerificationEvidence } from "../../tdd-verification-evidence.js";
 import { asRecord } from "./helpers.js";
 export const AUTO_REVIEW_LOOP_GATE_BY_STAGE = {
     design: "design_architecture_locked"
@@ -134,15 +134,6 @@ export function validateUserApprovalEvidence(evidence) {
 // guaranteed to carry the structural breadcrumbs downstream tooling
 // expects. Previously only `tdd:tdd_verified_before_complete` was checked.
 const GATE_EVIDENCE_VALIDATORS = {
-    "review:review_trace_matrix_clean": (evidence) => {
-        if (!TEST_COMMAND_HINT_PATTERN.test(evidence)) {
-            return "must include the fresh verification command that was run before ship handoff (for example `npm test`, `pytest`, `go test`, or equivalent).";
-        }
-        if (!PASS_STATUS_PATTERN.test(evidence)) {
-            return "must include explicit success status (for example `PASS` or `GREEN`).";
-        }
-        return null;
-    },
     "ship:ship_finalization_executed": (evidence) => {
         if (!SHIP_FINALIZATION_MODE_PATTERN.test(evidence)) {
             return `must name the finalization mode that ran (for example ${SHIP_FINALIZATION_MODE_HINT}).`;