cclaw-cli 0.46.0 → 0.46.2

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/internal/advance-stage.js

@@ -380,15 +380,24 @@ async function runAdvanceStage(projectRoot, args, io) {
         ...nextPassed.filter((gateId) => conditional.has(gateId)),
         ...nextBlocked.filter((gateId) => conditional.has(gateId))
     ]);
+    const missingGuardEvidence = nextPassed.filter((gateId) => {
+        const existing = flowState.guardEvidence[gateId];
+        if (typeof existing === "string" && existing.trim().length > 0) {
+            return false;
+        }
+        const provided = args.evidenceByGate[gateId];
+        return !(typeof provided === "string" && provided.trim().length > 0);
+    });
+    if (missingGuardEvidence.length > 0) {
+        io.stderr.write(`cclaw internal advance-stage: missing --evidence-json entries for passed gates: ${missingGuardEvidence.join(", ")}.\n`);
+        return 1;
+    }
     const nextGuardEvidence = { ...flowState.guardEvidence };
     for (const gateId of nextPassed) {
-        const existing = nextGuardEvidence[gateId];
-        if (typeof existing === "string" && existing.trim().length > 0)
-            continue;
         const provided = args.evidenceByGate[gateId];
-        nextGuardEvidence[gateId] = provided && provided.trim().length > 0
-            ? provided.trim()
-            : `stage-complete helper auto-evidence for ${gateId} @ ${new Date().toISOString()} (${schema.artifactFile})`;
+        if (typeof provided === "string" && provided.trim().length > 0) {
+            nextGuardEvidence[gateId] = provided.trim();
+        }
     }
     const nextStageCatalog = {
         required: [...catalog.required],

package/dist/knowledge-store.d.ts

@@ -3,6 +3,7 @@ export type KnowledgeEntryType = "rule" | "pattern" | "lesson" | "compound";
 export type KnowledgeEntryConfidence = "high" | "medium" | "low";
 export type KnowledgeEntryUniversality = "project" | "personal" | "universal";
 export type KnowledgeEntryMaturity = "raw" | "lifted-to-rule" | "lifted-to-enforcement";
+export type KnowledgeEntrySource = "stage" | "retro" | "compound" | "ideate" | "manual";
 export interface KnowledgeEntry {
     type: KnowledgeEntryType;
     trigger: string;
@@ -19,6 +20,7 @@ export interface KnowledgeEntry {
     first_seen_ts: string;
     last_seen_ts: string;
     project: string | null;
+    source?: KnowledgeEntrySource | null;
 }
 export interface KnowledgeSeedEntry {
     type: KnowledgeEntryType;
@@ -36,12 +38,14 @@ export interface KnowledgeSeedEntry {
     first_seen_ts?: string;
     last_seen_ts?: string;
     project?: string | null;
+    source?: KnowledgeEntrySource | null;
 }
 export interface AppendKnowledgeDefaults {
     stage?: FlowStage | null;
     originStage?: FlowStage | null;
     originFeature?: string | null;
     project?: string | null;
+    source?: KnowledgeEntrySource | null;
     nowIso?: string;
 }
 export interface AppendKnowledgeResult {

package/dist/knowledge-store.js

@@ -7,6 +7,13 @@ const KNOWLEDGE_TYPE_SET = new Set(["rule", "pattern", "lesson", "compound"]);
 const KNOWLEDGE_CONFIDENCE_SET = new Set(["high", "medium", "low"]);
 const KNOWLEDGE_UNIVERSALITY_SET = new Set(["project", "personal", "universal"]);
 const KNOWLEDGE_MATURITY_SET = new Set(["raw", "lifted-to-rule", "lifted-to-enforcement"]);
+const KNOWLEDGE_SOURCE_SET = new Set([
+    "stage",
+    "retro",
+    "compound",
+    "ideate",
+    "manual"
+]);
 const FLOW_STAGE_SET = new Set(FLOW_STAGES);
 const KNOWLEDGE_REQUIRED_KEYS = [
     "type",
@@ -26,6 +33,7 @@ const KNOWLEDGE_REQUIRED_KEYS = [
     "project"
 ];
 const KNOWLEDGE_ALLOWED_KEYS = new Set(KNOWLEDGE_REQUIRED_KEYS);
+KNOWLEDGE_ALLOWED_KEYS.add("source");
 function knowledgePath(projectRoot) {
     return path.join(projectRoot, RUNTIME_ROOT, "knowledge.jsonl");
 }
@@ -51,7 +59,8 @@ function dedupeKey(entry) {
         entry.origin_stage ?? "null",
         entry.origin_feature === null ? "null" : normalizeText(entry.origin_feature),
         entry.universality,
-        entry.project === null ? "null" : normalizeText(entry.project)
+        entry.project === null ? "null" : normalizeText(entry.project),
+        entry.source === undefined || entry.source === null ? "null" : entry.source
     ].join("|");
 }
 function isIsoUtcTimestamp(value) {
@@ -123,13 +132,19 @@ export function validateKnowledgeEntry(entry) {
     if (!isNullableString(obj.project)) {
         errors.push("project must be string or null.");
     }
+    if (obj.source !== undefined &&
+        obj.source !== null &&
+        (typeof obj.source !== "string" || !KNOWLEDGE_SOURCE_SET.has(obj.source))) {
+        errors.push("source must be one of: stage, retro, compound, ideate, manual, or null.");
+    }
     return { ok: errors.length === 0, errors };
 }
 export function materializeKnowledgeEntry(seed, defaults = {}) {
     const now = normalizeUtcIso(defaults.nowIso ?? nowUtcIso());
     const stage = seed.stage ?? defaults.stage ?? null;
     const originStage = seed.origin_stage ?? defaults.originStage ?? stage ?? null;
-    return {
+    const source = seed.source ?? defaults.source ?? null;
+    const entry = {
         type: seed.type,
         trigger: seed.trigger.trim(),
         action: seed.action.trim(),
@@ -146,6 +161,10 @@ export function materializeKnowledgeEntry(seed, defaults = {}) {
         last_seen_ts: normalizeUtcIso(seed.last_seen_ts ?? now),
         project: seed.project ?? defaults.project ?? null
     };
+    if (source !== null) {
+        entry.source = source;
+    }
+    return entry;
 }
 async function readExistingKnowledgeKeys(filePath) {
     const keys = new Set();