cclaw-cli 0.55.2 → 1.0.0

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/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,7 @@ 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 { 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 +470,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 +489,7 @@ 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", 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 +901,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 +942,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();
@@ -1196,6 +1229,7 @@ async function materializeRuntime(projectRoot, config, forceStateReset, operatio
             writeEntryCommands(projectRoot),
             writeSkills(projectRoot, config),
             writeArtifactTemplates(projectRoot),
+            writeWavePlansScaffold(projectRoot),
             writeRulebook(projectRoot)
         ]);
         await writeState(projectRoot, config, forceStateReset);

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

@@ -168,7 +168,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) {

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}).`;

package/dist/knowledge-store.d.ts

@@ -2,8 +2,6 @@ import { type FlowStage } from "./types.js";
 export type KnowledgeEntryType = "rule" | "pattern" | "lesson" | "compound";
 export type KnowledgeEntryConfidence = "high" | "medium" | "low";
 export type KnowledgeEntrySeverity = "critical" | "important" | "suggestion";
-export type KnowledgeEntryUniversality = "project" | "personal" | "universal";
-export type KnowledgeEntryMaturity = "raw" | "lifted-to-rule" | "lifted-to-enforcement";
 export type KnowledgeEntrySource = "stage" | "retro" | "compound" | "idea" | "manual";
 export interface KnowledgeEntry {
     type: KnowledgeEntryType;
@@ -11,20 +9,14 @@ export interface KnowledgeEntry {
     action: string;
     confidence: KnowledgeEntryConfidence;
     severity?: KnowledgeEntrySeverity;
-    domain: string | null;
     stage: FlowStage | null;
     origin_stage: FlowStage | null;
-    origin_run: string | null;
     frequency: number;
-    universality: KnowledgeEntryUniversality;
-    maturity: KnowledgeEntryMaturity;
     created: string;
     first_seen_ts: string;
     last_seen_ts: string;
     project: string | null;
     source?: KnowledgeEntrySource | null;
-    supersedes?: string[];
-    superseded_by?: string;
 }
 export interface KnowledgeSeedEntry {
     type: KnowledgeEntryType;
@@ -32,25 +24,18 @@ export interface KnowledgeSeedEntry {
     action: string;
     confidence: KnowledgeEntryConfidence;
     severity?: KnowledgeEntrySeverity;
-    domain?: string | null;
     stage?: FlowStage | null;
     origin_stage?: FlowStage | null;
-    origin_run?: string | null;
     frequency?: number;
-    universality?: KnowledgeEntryUniversality;
-    maturity?: KnowledgeEntryMaturity;
     created?: string;
     first_seen_ts?: string;
     last_seen_ts?: string;
     project?: string | null;
     source?: KnowledgeEntrySource | null;
-    supersedes?: string[];
-    superseded_by?: string;
 }
 export interface AppendKnowledgeDefaults {
     stage?: FlowStage | null;
     originStage?: FlowStage | null;
-    originRun?: string | null;
     project?: string | null;
     source?: KnowledgeEntrySource | null;
     nowIso?: string;
@@ -98,8 +83,6 @@ export interface CompoundReadinessCluster {
     lastSeenTs: string;
     /** Entry types observed (rule/pattern/lesson/compound). */
     types: KnowledgeEntryType[];
-    /** Distinct maturity values observed across the cluster. */
-    maturity: KnowledgeEntryMaturity[];
 }
 export interface CompoundReadiness {
     schemaVersion: 2;
@@ -167,9 +150,8 @@ export declare function effectiveCompoundThreshold(baseThreshold: number, archiv
  *
  * Clustering key: `(type, normalizeText(trigger), normalizeText(action))`
  * which mirrors the compound readiness clustering in runtime state.
- * Entries with `maturity === "lifted-to-enforcement"` or `superseded_by`
- * are excluded — they were already promoted/replaced and should not re-appear
- * as ready.
+ * The readiness surface intentionally stays simple: no maturity/supersede
+ * suppression logic in this pass.
  */
 export declare function computeCompoundReadiness(entries: KnowledgeEntry[], options?: ComputeCompoundReadinessOptions): CompoundReadiness;
 export declare function validateKnowledgeEntry(entry: unknown): {