cclaw-cli 0.46.1 → 0.46.2

package/dist/content/stage-schema.d.ts

@@ -3,13 +3,10 @@ import type { StageAutoSubagentDispatch, StageSchema } from "./stages/schema-typ
 export type { ArtifactValidation, CrossStageTrace, ReviewSection, StageAutoSubagentDispatch, StageGate, StageSchema, StageSchemaInput } from "./stages/schema-types.js";
 /** Transition guard: agents with `mode: "mandatory"` in auto-subagent dispatch for this stage. */
 export declare function mandatoryDelegationsForStage(stage: FlowStage): string[];
-/** Conditional dispatches that become mandatory only when their `condition` predicate evaluates true. */
-export declare function conditionalDispatchesForStage(stage: FlowStage): StageAutoSubagentDispatch[];
 export declare function stageSchema(stage: FlowStage): StageSchema;
 export declare function orderedStageSchemas(): StageSchema[];
 export declare function stageGateIds(stage: FlowStage): string[];
 export declare function stageRecommendedGateIds(stage: FlowStage): string[];
-export declare function stageConditionalGateIds(stage: FlowStage): string[];
 export declare function nextCclawCommand(stage: FlowStage): string;
 export declare function buildTransitionRules(): TransitionRule[];
 export declare function stagePolicyNeedles(stage: FlowStage): string[];

package/dist/content/stage-schema.js

@@ -10,7 +10,6 @@ import { BRAINSTORM, SCOPE, DESIGN, SPEC, PLAN, TDD, REVIEW, SHIP } from "./stag
  * Gate tiers:
  * - required: blocking for stage completion.
  * - recommended: quality signal; unmet -> DONE_WITH_CONCERNS, not BLOCKED.
- * - conditional: becomes blocking only when triggered.
  */
 const REQUIRED_GATE_IDS = {
     brainstorm: [
@@ -196,8 +195,7 @@ const STAGE_AUTO_SUBAGENT_DISPATCH = {
         },
         {
             agent: "reviewer",
-            mode: "conditional",
-            condition: "diff_lines_gt:100||files_touched_gt:10||trust_boundary_changed",
+            mode: "proactive",
             when: "When the diff exceeds 100 changed lines, touches more than 10 files, or modifies trust boundaries — dispatch a SECOND, independent reviewer with the adversarial-review skill loaded so the review army has at least two voices on a high-blast-radius change.",
             purpose: "Adversarial second-opinion review on large or trust-sensitive diffs. The second reviewer treats the implementation as hostile and tries to break it (hostile-user, future-maintainer, competitor lenses) instead of sympathetically explaining it.",
             requiresUserGate: false,
@@ -227,10 +225,6 @@ export function mandatoryDelegationsForStage(stage) {
         .filter((d) => d.mode === "mandatory")
         .map((d) => d.agent);
 }
-/** Conditional dispatches that become mandatory only when their `condition` predicate evaluates true. */
-export function conditionalDispatchesForStage(stage) {
-    return STAGE_AUTO_SUBAGENT_DISPATCH[stage].filter((d) => d.mode === "conditional");
-}
 export function stageSchema(stage) {
     const base = STAGE_SCHEMA_MAP[stage];
     const tieredGates = tieredStageGates(stage, base.requiredGates);
@@ -255,11 +249,6 @@ export function stageRecommendedGateIds(stage) {
         .filter((gate) => gate.tier === "recommended")
         .map((gate) => gate.id);
 }
-export function stageConditionalGateIds(stage) {
-    // Conditional gate DSL removed in favor of explicit required/recommended tiers.
-    void stage;
-    return [];
-}
 export function nextCclawCommand(stage) {
     const next = stageSchema(stage).next;
     return next === "done" ? "none" : `/cc-${next}`;

package/dist/content/stages/schema-types.d.ts

@@ -2,9 +2,7 @@ import type { FlowStage } from "../../types.js";
 export interface StageGate {
     id: string;
     description: string;
-    tier?: "required" | "recommended" | "conditional";
-    /** Used when tier=conditional. Predicate syntax mirrors conditional delegation rules. */
-    condition?: string;
+    tier?: "required" | "recommended";
 }
 export interface ReviewSection {
     title: string;
@@ -19,9 +17,7 @@ export interface CrossStageTrace {
 export interface ArtifactValidation {
     section: string;
     required: boolean;
-    tier?: "required" | "recommended" | "conditional";
-    /** Optional predicate for conditional validations. */
-    condition?: string;
+    tier?: "required" | "recommended";
     validationRule: string;
 }
 export interface StageAutoSubagentDispatch {
@@ -29,20 +25,11 @@ export interface StageAutoSubagentDispatch {
     /**
      * - `mandatory` — must be dispatched (or explicitly waived) before stage transition.
      * - `proactive` — should be dispatched automatically when context matches `when`.
-     * - `conditional` — dispatched only when `condition` evaluates true at runtime; counted as
-     *   mandatory **only when the condition holds**.
      */
-    mode: "mandatory" | "proactive" | "conditional";
+    mode: "mandatory" | "proactive";
     when: string;
     purpose: string;
     requiresUserGate: boolean;
-    /**
-     * Optional machine-friendly trigger expression for `conditional` rows.
-     * Supported predicates: `diff_lines_gt:<N>`, `files_touched_gt:<N>`,
-     * `trust_boundary_changed`, `release_blast_radius_high`.
-     * Multiple predicates joined by `||` mean ANY trigger satisfies the condition.
-     */
-    condition?: string;
     /** Optional skill folder the dispatched agent should load as additional context. */
     skill?: string;
 }

package/dist/content/subagents.js

@@ -599,146 +599,6 @@ Process (mandatory):
    - Report: FILES_EDITED, GREEN_COMMAND_RUN, REFACTOR_NOTES, STATUS: DONE|BLOCKED.
 \`\`\`
 
-`;
-}
-function repoResearchAnalystEnhancedBody() {
-    return `
-
-## Task Tool Delegation
-
-Launch **read-only repo exploration** at the start of brainstorm/scope/design so the primary agent plans on a grounded map, not guesses. Use this as an in-thread research procedure.
-
-\`\`\`
-You are a repo research analyst subagent.
-
-TASK DOMAIN: {1-sentence description of the feature/fix/refactor being planned}
-REPO HINTS: {known directories, module names, patterns the primary agent already knows}
-OUT OF SCOPE: {paths not to read (large vendor dirs, generated code)}
-
-Deliverables:
-- Relevant modules: list of \`path — purpose\` (cite file:line on ambiguous claims).
-- Reuse candidates: list of \`file:line — why this absorbs the change\`.
-- Ownership hints: CODEOWNERS / README / comment signals.
-- Gaps: capabilities NOT yet present that the task would need.
-
-Rules:
-- Read-only. Do NOT edit files.
-- Cite file:line for every claim; never invent paths.
-- If the scope is too large to fully explore, say so and bound your search.
-\`\`\`
-
-`;
-}
-function learningsResearcherEnhancedBody() {
-    return `
-
-## Task Tool Delegation
-
-Dispatch before any non-trivial stage to stream \`.cclaw/knowledge.jsonl\` and surface prior learnings. Cheap \`fast\` tier — fan out with other research agents.
-
-\`\`\`
-You are a learnings researcher subagent.
-
-TASK DESCRIPTION: {verbatim prompt + current stage}
-DOMAIN HINTS: {keywords from Task Classification / Origin Docs}
-
-Deliverables:
-- Matched rules: list of \`trigger → action (confidence)\`.
-- Matched patterns: list of \`trigger → action (confidence)\`.
-- Matched lessons: list of \`trigger → action (confidence)\`.
-- Matched compounds: list of \`trigger → action (confidence)\`.
-- No-match note (if nothing relevant exists).
-
-Rules:
-- Read-only; NEVER rewrite or delete entries.
-- Return at most 10 entries, ranked by confidence then recency.
-- Quote the entries verbatim — do NOT paraphrase.
-\`\`\`
-
-`;
-}
-function frameworkDocsResearcherEnhancedBody() {
-    return `
-
-## Task Tool Delegation
-
-Use for any task that depends on a specific framework/library/SDK/CLI. Prefer context7 MCP when available for version-accurate docs; otherwise WebSearch/WebFetch official sources.
-
-\`\`\`
-You are a framework documentation researcher subagent.
-
-LIBRARY + VERSION: {name + resolved version from lockfile / pyproject / go.mod / Cargo.toml / pom.xml / build.gradle}
-TASK USAGE: {which APIs the task will actually call}
-CONTEXT7: {"available" | "not available"}
-
-Deliverables:
-- Key APIs: list of signatures the task will touch.
-- Breaking changes since the last major release relevant to the task.
-- Gotchas: deprecated paths, version-gated flags, platform caveats.
-- Source: URL(s) or MCP reference used.
-
-Rules:
-- Never invent APIs. Prefer silence + UNKNOWN over speculation.
-- Tie every statement to an authoritative source; avoid blog posts when official docs exist.
-\`\`\`
-
-`;
-}
-function bestPracticesResearcherEnhancedBody() {
-    return `
-
-## Task Tool Delegation
-
-Use when the task touches a well-known domain (auth, caching, rate limiting, observability, accessibility, etc.) and the primary agent needs a short, citable best-practice summary.
-
-\`\`\`
-You are a best-practices researcher subagent.
-
-DOMAIN: {one word, e.g. auth, caching, rate-limiting, a11y, observability, retries}
-SUB-PROBLEM: {narrow one-sentence statement of what the task is actually deciding}
-
-Deliverables:
-- Recommended practices: 5-8 entries of \`practice — rationale — source\`.
-- Common traps / anti-patterns: list of \`trap — why it fails — source\`.
-- Decision hooks: 1-3 explicit questions the primary agent must answer.
-
-Rules:
-- Cite 3-5 authoritative sources (official docs, IETF/W3C/OWASP, well-known standards).
-- If the domain has no authoritative answer, say so; do NOT substitute opinion.
-\`\`\`
-
-`;
-}
-function gitHistoryAnalyzerEnhancedBody() {
-    return `
-
-## Task Tool Delegation
-
-Use when the task touches existing code, so the primary agent can see prior attempts, reverts, and owners before proposing changes.
-
-\`\`\`
-You are a git history analyzer subagent.
-
-IMPACTED PATHS: {list of files/directories the task plans to touch}
-WINDOW: {default 90 days; adjust only if explicitly needed}
-
-Commands to run (read-only):
-- git log --follow -n 20 -- <path>
-- git blame <path>
-- git log --since="<window>" --grep="revert|regression" -- <path>
-- git log --since="<window>" --format="%an" -- <path> | sort | uniq -c | sort -nr
-
-Deliverables:
-- Recent themes: 3-5 bullets on what changed lately per path.
-- Revert/regression signals: list with commit SHAs.
-- Owners: best-guess from blame + committer frequency.
-- Collision risks: in-flight refactors/migrations visible in log.
-
-Rules:
-- Read-only. Never amend history, never git push.
-- If a path is new (no history), say so explicitly rather than fabricating context.
-\`\`\`
-
 `;
 }
 function docUpdaterEnhancedBody() {

package/dist/delegation.d.ts

@@ -1,6 +1,6 @@
 import { type SubagentFallback } from "./harness-adapters.js";
 import type { FlowStage } from "./types.js";
-export type DelegationMode = "mandatory" | "proactive" | "conditional";
+export type DelegationMode = "mandatory" | "proactive";
 export type DelegationStatus = "scheduled" | "completed" | "failed" | "waived";
 /**
  * How a delegation was actually fulfilled. Advisory — mirrors the harness
@@ -45,10 +45,7 @@ export type DelegationEntry = {
      * consumers treat missing runId as unscoped (conservatively excluded from current-run checks).
      */
     runId?: string;
-    /**
-     * For `conditional` rows: the trigger predicate that fired (e.g. `diff_lines_gt:100`).
-     * Recorded for audit so reviewers can see why the second pass was required.
-     */
+    /** Legacy field kept for backward compatibility with historical ledgers. */
     conditionTrigger?: string;
     /** Optional token usage captured from the delegated run. */
     tokens?: DelegationTokenUsage;

package/dist/delegation.js

@@ -30,7 +30,7 @@ function isDelegationEntry(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return false;
     const o = value;
-    const modeOk = o.mode === "mandatory" || o.mode === "proactive" || o.mode === "conditional";
+    const modeOk = o.mode === "mandatory" || o.mode === "proactive";
     const statusOk = o.status === "scheduled" ||
         o.status === "completed" ||
         o.status === "failed" ||

package/dist/doctor.js

@@ -20,6 +20,7 @@ import { reconcileAndWriteCurrentStageGateCatalog, verifyCompletedStagesGateClos
 import { parseTddCycleLog, validateTddCycleOrder } from "./tdd-cycle.js";
 import { stageSkillFolder } from "./content/skills.js";
 import { doctorCheckMetadata } from "./doctor-registry.js";
+import { resolveTrackFromPrompt } from "./track-heuristics.js";
 import { classifyCodexHooksFlag, codexConfigPath, readCodexConfig } from "./codex-feature-flag.js";
 import { LANGUAGE_RULE_PACK_DIR, LANGUAGE_RULE_PACK_FILES, LEGACY_LANGUAGE_RULE_PACK_FOLDERS, UTILITY_SKILL_FOLDERS } from "./content/utility-skills.js";
 import { CONTEXT_MODES, DEFAULT_CONTEXT_MODE } from "./content/contexts.js";
@@ -95,6 +96,18 @@ function collectHookCommands(value) {
     const nested = collectHookCommands(obj.hooks);
     return [...direct, ...nested];
 }
+function extractUserPromptFromIdeaArtifact(markdown) {
+    const normalized = markdown.replace(/\r\n?/gu, "\n");
+    const heading = /^##\s+User prompt\s*$/imu.exec(normalized);
+    if (!heading || heading.index === undefined) {
+        return null;
+    }
+    const sectionStart = heading.index + heading[0].length;
+    const tail = normalized.slice(sectionStart).replace(/^\s*\n/gu, "");
+    const nextHeadingIndex = tail.search(/^##\s+/mu);
+    const body = (nextHeadingIndex >= 0 ? tail.slice(0, nextHeadingIndex) : tail).trim();
+    return body.length > 0 ? body : null;
+}
 async function commandAvailable(command) {
     try {
         await execFileAsync("bash", ["-lc", `command -v ${command} >/dev/null 2>&1`]);
@@ -1221,6 +1234,41 @@ export async function doctorChecks(projectRoot, options = {}) {
             ? `active track "${activeTrack}" (${trackStageList.length}/${COMMAND_FILE_ORDER.length} stages: ${trackStageList.join(" → ")})${expectedSkipped.length > 0 ? `; skippedStages=${expectedSkipped.join(", ")}` : ""}`
             : `track "${activeTrack}" expects skippedStages=[${expectedSkipped.join(", ")}] but flow-state has [${skippedFromState.join(", ")}] — run \`cclaw sync\` to repair`
     });
+    if (parsedConfig?.trackHeuristics) {
+        const ideaArtifactPath = path.join(projectRoot, RUNTIME_ROOT, "artifacts", "00-idea.md");
+        let heuristicsAligned = true;
+        let heuristicsDetails = "trackHeuristics configured; advisory alignment check skipped.";
+        if (!(await exists(ideaArtifactPath))) {
+            heuristicsDetails = `trackHeuristics configured but ${RUNTIME_ROOT}/artifacts/00-idea.md is missing; advisory alignment check skipped.`;
+        }
+        else {
+            const ideaMarkdown = await fs.readFile(ideaArtifactPath, "utf8");
+            if (/^Reclassification:\s*/imu.test(ideaMarkdown)) {
+                heuristicsDetails = "00-idea.md contains Reclassification entry; advisory heuristic mismatch check skipped.";
+            }
+            else {
+                const userPrompt = extractUserPromptFromIdeaArtifact(ideaMarkdown);
+                if (!userPrompt) {
+                    heuristicsDetails = "00-idea.md has no `## User prompt` section; advisory heuristic mismatch check skipped.";
+                }
+                else {
+                    const resolution = resolveTrackFromPrompt(userPrompt, parsedConfig.trackHeuristics);
+                    const tokenNote = resolution.matchedTokens.length > 0
+                        ? `matched: ${resolution.matchedTokens.join(", ")}`
+                        : "matched: none (fallback)";
+                    heuristicsAligned = resolution.track === activeTrack;
+                    heuristicsDetails = heuristicsAligned
+                        ? `trackHeuristics advisory matches active track "${activeTrack}" (${tokenNote}).`
+                        : `warning: trackHeuristics advisory predicts "${resolution.track}" (${tokenNote}; ${resolution.reason}) but flow-state track is "${activeTrack}". Re-run classification or add Reclassification in 00-idea.md if override was intentional.`;
+                }
+            }
+        }
+        checks.push({
+            name: "warning:track_heuristics:advisory_alignment",
+            ok: heuristicsAligned,
+            details: heuristicsDetails
+        });
+    }
     checks.push({
         name: "flow_state:track_completed_in_track",
         ok: flowState.completedStages.every((stage) => trackStageList.includes(stage) || expectedSkipped.includes(stage)),

package/dist/flow-state.js

@@ -1,5 +1,5 @@
 import { COMMAND_FILE_ORDER } from "./constants.js";
-import { buildTransitionRules, orderedStageSchemas, stageConditionalGateIds, stageGateIds, stageRecommendedGateIds } from "./content/stage-schema.js";
+import { buildTransitionRules, orderedStageSchemas, stageGateIds, stageRecommendedGateIds } from "./content/stage-schema.js";
 import { FLOW_STAGES, FLOW_TRACKS, TRACK_STAGES } from "./types.js";
 export const TRANSITION_RULES = buildTransitionRules();
 /**
@@ -63,7 +63,7 @@ export function createInitialFlowState(activeRunIdOrOptions = "active", maybeTra
         stageGateCatalog[schema.stage] = {
             required: stageGateIds(schema.stage),
             recommended: stageRecommendedGateIds(schema.stage),
-            conditional: stageConditionalGateIds(schema.stage),
+            conditional: [],
             triggered: [],
             passed: [],
             blocked: []

package/dist/gate-evidence.js

@@ -42,13 +42,10 @@ export async function verifyCurrentStageGateEvidence(projectRoot, flowState) {
     const recommended = schema.requiredGates
         .filter((gate) => gate.tier === "recommended")
         .map((gate) => gate.id);
-    const conditional = schema.requiredGates
-        .filter((gate) => gate.tier === "conditional")
-        .map((gate) => gate.id);
+    const conditional = [];
     const requiredSet = new Set(required);
     const recommendedSet = new Set(recommended);
-    const conditionalSet = new Set(conditional);
-    const allowedSet = new Set([...required, ...recommended, ...conditional]);
+    const allowedSet = new Set([...required, ...recommended]);
     const issues = [];
     const catalogRequired = unique(catalog.required);
     const catalogRecommended = unique(catalog.recommended ?? []);
@@ -58,8 +55,6 @@ export async function verifyCurrentStageGateEvidence(projectRoot, flowState) {
     const unexpectedInCatalog = catalogRequired.filter((gateId) => !requiredSet.has(gateId));
     const missingRecommendedInCatalog = recommended.filter((gateId) => !catalogRecommended.includes(gateId));
     const unexpectedRecommendedInCatalog = catalogRecommended.filter((gateId) => !recommendedSet.has(gateId));
-    const missingConditionalInCatalog = conditional.filter((gateId) => !catalogConditional.includes(gateId));
-    const unexpectedConditionalInCatalog = catalogConditional.filter((gateId) => !conditionalSet.has(gateId));
     for (const gateId of missingInCatalog) {
         issues.push(`gate "${gateId}" missing from stageGateCatalog.required for stage "${stage}".`);
     }
@@ -72,16 +67,11 @@ export async function verifyCurrentStageGateEvidence(projectRoot, flowState) {
     for (const gateId of unexpectedRecommendedInCatalog) {
         issues.push(`unexpected gate "${gateId}" found in stageGateCatalog.recommended for stage "${stage}".`);
     }
-    for (const gateId of missingConditionalInCatalog) {
-        issues.push(`gate "${gateId}" missing from stageGateCatalog.conditional for stage "${stage}".`);
-    }
-    for (const gateId of unexpectedConditionalInCatalog) {
-        issues.push(`unexpected gate "${gateId}" found in stageGateCatalog.conditional for stage "${stage}".`);
+    for (const gateId of catalogConditional) {
+        issues.push(`stale conditional gate "${gateId}" found in stageGateCatalog.conditional for stage "${stage}" (conditional gate DSL removed).`);
     }
     for (const gateId of catalogTriggered) {
-        if (!conditionalSet.has(gateId)) {
-            issues.push(`triggered gate "${gateId}" is not defined as conditional for stage "${stage}".`);
-        }
+        issues.push(`stale triggered conditional gate "${gateId}" found in stageGateCatalog.triggered for stage "${stage}" (conditional gate DSL removed).`);
     }
     const blockedSet = new Set(catalog.blocked);
     for (const gateId of catalog.passed) {
@@ -126,23 +116,15 @@ export async function verifyCurrentStageGateEvidence(projectRoot, flowState) {
         }
     }
     const passedSet = new Set(catalog.passed);
-    const triggeredConditionalSet = new Set([
-        ...catalogTriggered.filter((gateId) => conditionalSet.has(gateId)),
-        ...catalog.passed.filter((gateId) => conditionalSet.has(gateId)),
-        ...catalog.blocked.filter((gateId) => conditionalSet.has(gateId))
-    ]);
     const missingRequired = required.filter((gateId) => !passedSet.has(gateId));
     const missingRecommended = recommended.filter((gateId) => !passedSet.has(gateId));
-    const missingTriggeredConditional = [...triggeredConditionalSet].filter((gateId) => !passedSet.has(gateId));
-    const blockingBlocked = catalog.blocked.filter((gateId) => requiredSet.has(gateId) || triggeredConditionalSet.has(gateId));
-    const complete = missingRequired.length === 0 && missingTriggeredConditional.length === 0 && blockingBlocked.length === 0;
+    const missingTriggeredConditional = [];
+    const blockingBlocked = catalog.blocked.filter((gateId) => requiredSet.has(gateId));
+    const complete = missingRequired.length === 0 && blockingBlocked.length === 0;
     if (flowState.completedStages.includes(stage) && !complete) {
         if (missingRequired.length > 0) {
             issues.push(`stage "${stage}" is marked completed but required gates are not passed: ${missingRequired.join(", ")}.`);
         }
-        if (missingTriggeredConditional.length > 0) {
-            issues.push(`stage "${stage}" is marked completed but triggered conditional gates are not passed: ${missingTriggeredConditional.join(", ")}.`);
-        }
         if (blockingBlocked.length > 0) {
             issues.push(`stage "${stage}" is marked completed but has blocking blocked gates: ${blockingBlocked.join(", ")}.`);
         }
@@ -154,7 +136,7 @@ export async function verifyCurrentStageGateEvidence(projectRoot, flowState) {
         requiredCount: required.length,
         recommendedCount: recommended.length,
         conditionalCount: conditional.length,
-        triggeredConditionalCount: triggeredConditionalSet.size,
+        triggeredConditionalCount: 0,
         passedCount: catalog.passed.length,
         blockedCount: catalog.blocked.length,
         complete,
@@ -172,19 +154,10 @@ export function verifyCompletedStagesGateClosure(flowState) {
         const required = schema.requiredGates
             .filter((gate) => gate.tier === "required")
             .map((gate) => gate.id);
-        const conditional = schema.requiredGates
-            .filter((gate) => gate.tier === "conditional")
-            .map((gate) => gate.id);
-        const conditionalSet = new Set(conditional);
         const passedSet = new Set(catalog.passed);
-        const triggeredSet = new Set([
-            ...(catalog.triggered ?? []).filter((gateId) => conditionalSet.has(gateId)),
-            ...catalog.passed.filter((gateId) => conditionalSet.has(gateId)),
-            ...catalog.blocked.filter((gateId) => conditionalSet.has(gateId))
-        ]);
         const missingRequired = required.filter((gateId) => !passedSet.has(gateId));
-        const missingTriggeredConditional = [...triggeredSet].filter((gateId) => !passedSet.has(gateId));
-        const blockingBlocked = catalog.blocked.filter((gateId) => required.includes(gateId) || triggeredSet.has(gateId));
+        const missingTriggeredConditional = [];
+        const blockingBlocked = catalog.blocked.filter((gateId) => required.includes(gateId));
         if (missingRequired.length > 0 || missingTriggeredConditional.length > 0 || blockingBlocked.length > 0) {
             openStages.push({
                 stage,
@@ -195,9 +168,6 @@ export function verifyCompletedStagesGateClosure(flowState) {
             if (missingRequired.length > 0) {
                 issues.push(`completed stage "${stage}" has unpassed required gates: ${missingRequired.join(", ")}.`);
             }
-            if (missingTriggeredConditional.length > 0) {
-                issues.push(`completed stage "${stage}" has unpassed triggered conditional gates: ${missingTriggeredConditional.join(", ")}.`);
-            }
             if (blockingBlocked.length > 0) {
                 issues.push(`completed stage "${stage}" still has blocking blocked gates: ${blockingBlocked.join(", ")}.`);
             }
@@ -213,13 +183,10 @@ export function reconcileCurrentStageGateCatalog(flowState) {
     const recommended = stageSchema(stage).requiredGates
         .filter((gate) => gate.tier === "recommended")
         .map((gate) => gate.id);
-    const conditional = stageSchema(stage).requiredGates
-        .filter((gate) => gate.tier === "conditional")
-        .map((gate) => gate.id);
+    const conditional = [];
     const requiredSet = new Set(required);
     const recommendedSet = new Set(recommended);
-    const conditionalSet = new Set(conditional);
-    const allowedSet = new Set([...required, ...recommended, ...conditional]);
+    const allowedSet = new Set([...required, ...recommended]);
     const catalog = flowState.stageGateCatalog[stage];
     const notes = [];
     const before = {
@@ -244,17 +211,13 @@ export function reconcileCurrentStageGateCatalog(flowState) {
         }
         return keep;
     }));
-    const triggeredSet = new Set(unique(catalog.triggered).filter((gateId) => {
-        const keep = conditionalSet.has(gateId);
-        if (!keep) {
-            notes.push(`removed unknown triggered gate "${gateId}"`);
-        }
-        return keep;
-    }));
-    for (const gateId of [...passedSet, ...blockedSet]) {
-        if (conditionalSet.has(gateId)) {
-            triggeredSet.add(gateId);
-        }
+    const staleConditional = unique(catalog.conditional).filter((gateId) => !allowedSet.has(gateId));
+    for (const gateId of staleConditional) {
+        notes.push(`removed stale conditional gate "${gateId}" (conditional gate DSL removed)`);
+    }
+    const staleTriggered = unique(catalog.triggered);
+    for (const gateId of staleTriggered) {
+        notes.push(`removed stale triggered gate "${gateId}" (conditional gate DSL removed)`);
     }
     for (const gateId of [...passedSet]) {
         if (!blockedSet.has(gateId))
@@ -280,9 +243,9 @@ export function reconcileCurrentStageGateCatalog(flowState) {
         required: [...required],
         recommended: [...recommended],
         conditional: [...conditional],
-        triggered: conditional.filter((gateId) => triggeredSet.has(gateId)),
-        passed: [...required, ...recommended, ...conditional].filter((gateId) => passedSet.has(gateId)),
-        blocked: [...required, ...recommended, ...conditional].filter((gateId) => blockedSet.has(gateId) && !passedSet.has(gateId))
+        triggered: [],
+        passed: [...required, ...recommended].filter((gateId) => passedSet.has(gateId)),
+        blocked: [...required, ...recommended].filter((gateId) => blockedSet.has(gateId) && !passedSet.has(gateId))
     };
     const changed = !sameStringArray(before.required, after.required) ||
         !sameStringArray(before.recommended, after.recommended) ||

package/dist/hook-schema.js

@@ -12,6 +12,65 @@ function toObject(value) {
     }
     return value;
 }
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function isPositiveNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function validateCursorEvent(eventName, eventEntries, errors) {
+    for (let index = 0; index < eventEntries.length; index += 1) {
+        const rawEntry = eventEntries[index];
+        const entry = toObject(rawEntry);
+        if (!entry) {
+            errors.push(`hooks.${eventName}[${index}] must be an object`);
+            continue;
+        }
+        if (!isNonEmptyString(entry.command)) {
+            errors.push(`hooks.${eventName}[${index}].command must be a non-empty string`);
+        }
+        if (entry.matcher !== undefined && typeof entry.matcher !== "string") {
+            errors.push(`hooks.${eventName}[${index}].matcher must be a string when present`);
+        }
+        if (entry.timeout !== undefined && !isPositiveNumber(entry.timeout)) {
+            errors.push(`hooks.${eventName}[${index}].timeout must be a positive number when present`);
+        }
+    }
+}
+function validateClaudeLikeEvent(eventName, eventEntries, errors) {
+    for (let index = 0; index < eventEntries.length; index += 1) {
+        const rawEntry = eventEntries[index];
+        const entry = toObject(rawEntry);
+        if (!entry) {
+            errors.push(`hooks.${eventName}[${index}] must be an object`);
+            continue;
+        }
+        if (entry.matcher !== undefined && typeof entry.matcher !== "string") {
+            errors.push(`hooks.${eventName}[${index}].matcher must be a string when present`);
+        }
+        if (!Array.isArray(entry.hooks) || entry.hooks.length === 0) {
+            errors.push(`hooks.${eventName}[${index}].hooks must be a non-empty array`);
+            continue;
+        }
+        for (let hookIndex = 0; hookIndex < entry.hooks.length; hookIndex += 1) {
+            const rawHook = entry.hooks[hookIndex];
+            const hook = toObject(rawHook);
+            if (!hook) {
+                errors.push(`hooks.${eventName}[${index}].hooks[${hookIndex}] must be an object`);
+                continue;
+            }
+            if (hook.type !== "command") {
+                errors.push(`hooks.${eventName}[${index}].hooks[${hookIndex}].type must be "command"`);
+            }
+            if (!isNonEmptyString(hook.command)) {
+                errors.push(`hooks.${eventName}[${index}].hooks[${hookIndex}].command must be a non-empty string`);
+            }
+            if (hook.timeout !== undefined && !isPositiveNumber(hook.timeout)) {
+                errors.push(`hooks.${eventName}[${index}].hooks[${hookIndex}].timeout must be a positive number when present`);
+            }
+        }
+    }
+}
 export function validateHookDocument(harness, document) {
     const descriptor = SCHEMA_MAP[harness];
     const root = toObject(document);
@@ -35,6 +94,13 @@ export function validateHookDocument(harness, document) {
             const eventValue = hooks[eventName];
             if (!Array.isArray(eventValue) || eventValue.length === 0) {
                 errors.push(`missing required event array "${eventName}"`);
+                continue;
+            }
+            if (harness === "cursor") {
+                validateCursorEvent(eventName, eventValue, errors);
+            }
+            else {
+                validateClaudeLikeEvent(eventName, eventValue, errors);
             }
         }
     }

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

@@ -7,6 +7,7 @@
         "SessionStart",
         "PreToolUse",
         "PostToolUse",
-        "Stop"
+        "Stop",
+        "PreCompact"
     ]
 }

package/dist/runs.js

@@ -374,6 +374,19 @@ async function uniqueArchiveId(projectRoot, baseId) {
 function retroArtifactPath(projectRoot) {
     return path.join(activeArtifactsPath(projectRoot), "09-retro.md");
 }
+function parseIsoTimestamp(value) {
+    if (!value || value.trim().length === 0)
+        return null;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function inInclusiveWindow(timestamp, windowStartMs, windowEndMs) {
+    if (windowStartMs !== null && timestamp < windowStartMs)
+        return false;
+    if (windowEndMs !== null && timestamp > windowEndMs)
+        return false;
+    return true;
+}
 async function evaluateRetroGate(projectRoot, state) {
     const required = state.completedStages.includes("ship");
     const artifactFile = retroArtifactPath(projectRoot);
@@ -387,11 +400,15 @@ async function evaluateRetroGate(projectRoot, state) {
             hasRetroArtifact = false;
         }
     }
+    let compoundEntries = state.retro.compoundEntries;
+    const windowStartMs = parseIsoTimestamp(state.closeout.retroDraftedAt);
+    const windowEndMs = parseIsoTimestamp(state.closeout.retroAcceptedAt) ?? parseIsoTimestamp(state.retro.completedAt);
+    const shouldFallbackScan = compoundEntries <= 0 && (windowStartMs !== null || windowEndMs !== null);
     const knowledgeFile = path.join(projectRoot, RUNTIME_ROOT, "knowledge.jsonl");
-    let compoundEntries = 0;
-    if (await exists(knowledgeFile)) {
+    if (shouldFallbackScan && (await exists(knowledgeFile))) {
         try {
             const raw = await fs.readFile(knowledgeFile, "utf8");
+            compoundEntries = 0;
             for (const line of raw.split(/\r?\n/)) {
                 const trimmed = line.trim();
                 if (!trimmed)
@@ -401,6 +418,10 @@ async function evaluateRetroGate(projectRoot, state) {
                     if (parsed.type !== "compound") {
                         continue;
                     }
+                    const created = typeof parsed.created === "string" ? parseIsoTimestamp(parsed.created) : null;
+                    if (created === null || !inInclusiveWindow(created, windowStartMs, windowEndMs)) {
+                        continue;
+                    }
                     const source = typeof parsed.source === "string"
                         ? parsed.source.trim().toLowerCase()
                         : null;
@@ -580,7 +601,7 @@ export async function archiveRun(projectRoot, featureName, options = {}) {
         typeof sourceState.closeout.retroSkipReason === "string" &&
         sourceState.closeout.retroSkipReason.trim().length > 0;
     const readyForArchive = sourceState.closeout.shipSubstate === "ready_to_archive";
-    if (shipCompleted && !readyForArchive && !skipRetro && !retroSkippedInCloseout) {
+    if (shipCompleted && !readyForArchive && !skipRetro) {
         throw new Error("Archive blocked: closeout is not ready_to_archive. " +
             "Resume /cc-next until closeout reaches ready_to_archive, " +
             "or run `cclaw archive --skip-retro --retro-reason=<text>` for CLI-only flows.");

package/package.json

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