cclaw-cli 0.10.1 → 0.11.0

package/dist/gate-evidence.js

@@ -36,21 +36,56 @@ export async function verifyCurrentStageGateEvidence(projectRoot, flowState) {
     const stage = flowState.currentStage;
     const schema = stageSchema(stage);
     const catalog = flowState.stageGateCatalog[stage];
-    const required = schema.requiredGates.map((gate) => gate.id);
+    const required = schema.requiredGates
+        .filter((gate) => gate.tier === "required")
+        .map((gate) => gate.id);
+    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 requiredSet = new Set(required);
+    const recommendedSet = new Set(recommended);
+    const conditionalSet = new Set(conditional);
+    const allowedSet = new Set([...required, ...recommended, ...conditional]);
     const issues = [];
     const catalogRequired = unique(catalog.required);
+    const catalogRecommended = unique(catalog.recommended ?? []);
+    const catalogConditional = unique(catalog.conditional ?? []);
+    const catalogTriggered = unique(catalog.triggered ?? []);
     const missingInCatalog = required.filter((gateId) => !catalogRequired.includes(gateId));
     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}".`);
     }
     for (const gateId of unexpectedInCatalog) {
         issues.push(`unexpected gate "${gateId}" found in stageGateCatalog.required for stage "${stage}".`);
     }
+    for (const gateId of missingRecommendedInCatalog) {
+        issues.push(`gate "${gateId}" missing from stageGateCatalog.recommended for stage "${stage}".`);
+    }
+    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 catalogTriggered) {
+        if (!conditionalSet.has(gateId)) {
+            issues.push(`triggered gate "${gateId}" is not defined as conditional for stage "${stage}".`);
+        }
+    }
     const blockedSet = new Set(catalog.blocked);
     for (const gateId of catalog.passed) {
-        if (!requiredSet.has(gateId)) {
+        if (!allowedSet.has(gateId)) {
             issues.push(`passed gate "${gateId}" is not defined for stage "${stage}".`);
             continue;
         }
@@ -63,7 +98,7 @@ export async function verifyCurrentStageGateEvidence(projectRoot, flowState) {
         }
     }
     for (const gateId of catalog.blocked) {
-        if (!requiredSet.has(gateId)) {
+        if (!allowedSet.has(gateId)) {
             issues.push(`blocked gate "${gateId}" is not defined for stage "${stage}".`);
         }
     }
@@ -91,14 +126,25 @@ 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 complete = missingRequired.length === 0 && catalog.blocked.length === 0;
+    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;
     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 (catalog.blocked.length > 0) {
-            issues.push(`stage "${stage}" is marked completed but has blocked gates: ${catalog.blocked.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(", ")}.`);
         }
     }
     return {
@@ -106,10 +152,15 @@ export async function verifyCurrentStageGateEvidence(projectRoot, flowState) {
         stage,
         issues,
         requiredCount: required.length,
+        recommendedCount: recommended.length,
+        conditionalCount: conditional.length,
+        triggeredConditionalCount: triggeredConditionalSet.size,
         passedCount: catalog.passed.length,
         blockedCount: catalog.blocked.length,
         complete,
-        missingRequired
+        missingRequired,
+        missingRecommended,
+        missingTriggeredConditional
     };
 }
 export function verifyCompletedStagesGateClosure(flowState) {
@@ -118,16 +169,37 @@ export function verifyCompletedStagesGateClosure(flowState) {
     for (const stage of flowState.completedStages) {
         const schema = stageSchema(stage);
         const catalog = flowState.stageGateCatalog[stage];
-        const required = schema.requiredGates.map((gate) => gate.id);
+        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));
-        if (missingRequired.length > 0 || catalog.blocked.length > 0) {
-            openStages.push({ stage, missingRequired, blocked: [...catalog.blocked] });
+        const missingTriggeredConditional = [...triggeredSet].filter((gateId) => !passedSet.has(gateId));
+        const blockingBlocked = catalog.blocked.filter((gateId) => required.includes(gateId) || triggeredSet.has(gateId));
+        if (missingRequired.length > 0 || missingTriggeredConditional.length > 0 || blockingBlocked.length > 0) {
+            openStages.push({
+                stage,
+                missingRequired,
+                missingTriggeredConditional,
+                blocked: [...blockingBlocked]
+            });
             if (missingRequired.length > 0) {
                 issues.push(`completed stage "${stage}" has unpassed required gates: ${missingRequired.join(", ")}.`);
             }
-            if (catalog.blocked.length > 0) {
-                issues.push(`completed stage "${stage}" still has blocked gates: ${catalog.blocked.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(", ")}.`);
             }
         }
     }
@@ -135,29 +207,55 @@ export function verifyCompletedStagesGateClosure(flowState) {
 }
 export function reconcileCurrentStageGateCatalog(flowState) {
     const stage = flowState.currentStage;
-    const required = stageSchema(stage).requiredGates.map((gate) => gate.id);
+    const required = stageSchema(stage).requiredGates
+        .filter((gate) => gate.tier === "required")
+        .map((gate) => gate.id);
+    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 requiredSet = new Set(required);
+    const recommendedSet = new Set(recommended);
+    const conditionalSet = new Set(conditional);
+    const allowedSet = new Set([...required, ...recommended, ...conditional]);
     const catalog = flowState.stageGateCatalog[stage];
     const notes = [];
     const before = {
         required: [...catalog.required],
+        recommended: [...catalog.recommended],
+        conditional: [...catalog.conditional],
+        triggered: [...catalog.triggered],
         passed: [...catalog.passed],
         blocked: [...catalog.blocked]
     };
     const passedSet = new Set(unique(catalog.passed).filter((gateId) => {
-        const keep = requiredSet.has(gateId);
+        const keep = allowedSet.has(gateId);
         if (!keep) {
             notes.push(`removed unknown passed gate "${gateId}"`);
         }
         return keep;
     }));
     const blockedSet = new Set(unique(catalog.blocked).filter((gateId) => {
-        const keep = requiredSet.has(gateId);
+        const keep = allowedSet.has(gateId);
         if (!keep) {
             notes.push(`removed unknown blocked gate "${gateId}"`);
         }
         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);
+        }
+    }
     for (const gateId of [...passedSet]) {
         if (!blockedSet.has(gateId))
             continue;
@@ -180,10 +278,16 @@ export function reconcileCurrentStageGateCatalog(flowState) {
     }
     const after = {
         required: [...required],
-        passed: required.filter((gateId) => passedSet.has(gateId)),
-        blocked: required.filter((gateId) => blockedSet.has(gateId) && !passedSet.has(gateId))
+        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))
     };
     const changed = !sameStringArray(before.required, after.required) ||
+        !sameStringArray(before.recommended, after.recommended) ||
+        !sameStringArray(before.conditional, after.conditional) ||
+        !sameStringArray(before.triggered, after.triggered) ||
         !sameStringArray(before.passed, after.passed) ||
         !sameStringArray(before.blocked, after.blocked);
     const nextState = changed

package/dist/install.js

@@ -15,8 +15,10 @@ import { sessionHooksSkillMarkdown } from "./content/session-hooks.js";
 import { sessionStartScript, stopCheckpointScript, preCompactScript, opencodePluginJs, claudeHooksJson, cursorHooksJson, codexHooksJson } from "./content/hooks.js";
 import { contextMonitorScript, promptGuardScript, workflowGuardScript } from "./content/observe.js";
 import { META_SKILL_NAME, usingCclawSkillMarkdown } from "./content/meta-skill.js";
+import { decisionProtocolMarkdown, completionProtocolMarkdown, ethosProtocolMarkdown } from "./content/protocols.js";
 import { ARTIFACT_TEMPLATES, CURSOR_WORKFLOW_RULE_MDC, RULEBOOK_MARKDOWN, buildRulesJson } from "./content/templates.js";
 import { TDD_WAVE_WALKTHROUGH_MARKDOWN, stageSkillFolder, stageSkillMarkdown } from "./content/skills.js";
+import { stageCommonGuidanceMarkdown } from "./content/stage-common-guidance.js";
 import { STAGE_EXAMPLES_REFERENCE_DIR, stageExamplesReferenceMarkdown } from "./content/examples.js";
 import { LANGUAGE_RULE_PACK_DIR, LANGUAGE_RULE_PACK_FILES, LANGUAGE_RULE_PACK_GENERATORS, LEGACY_LANGUAGE_RULE_PACK_FOLDERS, UTILITY_SKILL_FOLDERS, UTILITY_SKILL_MAP } from "./content/utility-skills.js";
 import { HARNESS_TOOL_REFS_DIR, HARNESS_TOOL_REFS_INDEX_MD, harnessToolRefMarkdown } from "./content/harness-tool-refs.js";
@@ -185,6 +187,7 @@ async function writeSkills(projectRoot, config) {
     // always-rendered TDD skill stays under the line-budget and the reference
     // is loaded on demand.
     await writeFileSafe(runtimePath(projectRoot, ...STAGE_EXAMPLES_REFERENCE_DIR.split("/"), "tdd-wave-walkthrough.md"), TDD_WAVE_WALKTHROUGH_MARKDOWN);
+    await writeFileSafe(runtimePath(projectRoot, ...STAGE_EXAMPLES_REFERENCE_DIR.split("/"), "common-guidance.md"), stageCommonGuidanceMarkdown());
     // Utility skills (not flow stages)
     await writeFileSafe(runtimePath(projectRoot, "skills", "learnings", "SKILL.md"), learnSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", "flow-next-step", "SKILL.md"), nextCommandSkillMarkdown());
@@ -194,6 +197,9 @@ 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", META_SKILL_NAME, "SKILL.md"), usingCclawSkillMarkdown());
+    await writeFileSafe(runtimePath(projectRoot, "references", "protocols", "decision.md"), decisionProtocolMarkdown());
+    await writeFileSafe(runtimePath(projectRoot, "references", "protocols", "completion.md"), completionProtocolMarkdown());
+    await writeFileSafe(runtimePath(projectRoot, "references", "protocols", "ethos.md"), ethosProtocolMarkdown());
     for (const folder of UTILITY_SKILL_FOLDERS) {
         const generator = UTILITY_SKILL_MAP[folder];
         await writeFileSafe(runtimePath(projectRoot, "skills", folder, "SKILL.md"), generator());
@@ -773,6 +779,10 @@ async function ensureSessionStateFiles(projectRoot) {
     if (!(await exists(contextModePath))) {
         await writeFileSafe(contextModePath, `${JSON.stringify(createInitialContextModeState(), null, 2)}\n`);
     }
+    const knowledgeDigestPath = path.join(stateDir, "knowledge-digest.md");
+    if (!(await exists(knowledgeDigestPath))) {
+        await writeFileSafe(knowledgeDigestPath, "# Knowledge digest (auto-generated)\n\n(no entries yet)\n");
+    }
 }
 async function writeRulebook(projectRoot) {
     await writeFileSafe(runtimePath(projectRoot, "rules", "RULES.md"), RULEBOOK_MARKDOWN);

package/dist/policy.js

@@ -40,16 +40,15 @@ export async function policyChecks(projectRoot, options = {}) {
             "## Process",
             "## Verification",
             "## Interaction Protocol",
-            "## Common Rationalizations",
             "## Anti-Patterns & Red Flags",
             "## HARD-GATE",
             "## Checklist",
             "## Context Loading",
             "## Automatic Subagent Dispatch",
-            "## Cognitive Patterns",
             "## Cross-Stage Traceability",
-            "## Completion Status",
-            "## Artifact Validation"
+            "## Artifact Validation",
+            "## Completion Parameters",
+            "## Shared Stage Guidance"
         ]) {
             rules.push({
                 filePath: skillFile,
@@ -102,15 +101,17 @@ export async function policyChecks(projectRoot, options = {}) {
         { file: runtimeFile("skills/session/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:session:hard_gate" },
         { file: runtimeFile("skills/session/SKILL.md"), needle: "## Session Start Protocol", name: "utility_skill:session:start" },
         { file: runtimeFile("skills/session/SKILL.md"), needle: "## Session Stop Protocol", name: "utility_skill:session:stop" },
-        { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "## Skill Discovery Flowchart", name: "meta_skill:discovery" },
-        { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "## Activation Rules", name: "meta_skill:activation" },
-        { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "## Stage Quick Reference", name: "meta_skill:reference" },
-        { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "## Failure Modes", name: "meta_skill:failure_modes" },
-        { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "## Contextual Skills", name: "meta_skill:contextual_skills" },
-        { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "## Decision Protocol", name: "meta_skill:decision_protocol" },
-        { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "## Progressive Disclosure (Depth / See Also)", name: "meta_skill:progressive_disclosure" },
+        { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "## Routing flow", name: "meta_skill:routing_flow" },
+        { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "## Task classification", name: "meta_skill:task_classification" },
+        { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "## Stage quick map", name: "meta_skill:stage_quick_map" },
+        { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "## Contextual skill activation", name: "meta_skill:contextual_skills" },
+        { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "## Protocol references", name: "meta_skill:protocol_refs" },
+        { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "## Failure guardrails", name: "meta_skill:failure_guardrails" },
+        { file: runtimeFile("references/protocols/decision.md"), needle: "# Decision Protocol", name: "protocol:decision" },
+        { file: runtimeFile("references/protocols/completion.md"), needle: "# Stage Completion Protocol", name: "protocol:completion" },
+        { file: runtimeFile("references/protocols/ethos.md"), needle: "# Engineering Ethos", name: "protocol:ethos" },
         { file: runtimeFile("skills/session/SKILL.md"), needle: "## Session Resume Protocol", name: "utility_skill:session:resume" },
-        { file: runtimeFile("skills/brainstorming/SKILL.md"), needle: "## Progressive Disclosure", name: "stage_skill:progressive_disclosure" },
+        { file: runtimeFile("skills/brainstorming/SKILL.md"), needle: "common-guidance.md", name: "stage_skill:shared_guidance_reference" },
         { file: runtimeFile("skills/security/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:security:hard_gate" },
         { file: runtimeFile("skills/security/SKILL.md"), needle: "## Checklist", name: "utility_skill:security:checklist" },
         { file: runtimeFile("skills/security/SKILL.md"), needle: "## Severity Classification", name: "utility_skill:security:severity" },
@@ -153,7 +154,9 @@ export async function policyChecks(projectRoot, options = {}) {
         { file: runtimeFile("hooks/workflow-guard.sh"), needle: "stage_invocation_without_recent_flow_read", name: "hooks:workflow_guard:flow_read_reason" },
         { file: runtimeFile("hooks/workflow-guard.sh"), needle: "stage_jump_", name: "hooks:workflow_guard:stage_jump_reason" },
         { file: runtimeFile("hooks/context-monitor.sh"), needle: "remaining is", name: "hooks:context:threshold_warning" },
-        { file: runtimeFile("hooks/opencode-plugin.mjs"), needle: "activeRunId", name: "hooks:opencode:active_run" }
+        { file: runtimeFile("hooks/opencode-plugin.mjs"), needle: "activeRunId", name: "hooks:opencode:active_run" },
+        { file: runtimeFile("hooks/session-start.sh"), needle: "Knowledge digest", name: "hooks:session_start:knowledge_digest" },
+        { file: runtimeFile("hooks/opencode-plugin.mjs"), needle: "Knowledge digest", name: "hooks:opencode:knowledge_digest" }
     ];
     if (activeHarnesses.has("opencode")) {
         utilitySkillChecks.push({

package/dist/runs.js

@@ -128,11 +128,15 @@ function sanitizeGuardEvidence(value) {
     return next;
 }
 function sanitizeStageGateCatalog(value, fallback) {
+    const uniqueStrings = (items) => [...new Set(items)];
     const next = {};
     for (const stage of COMMAND_FILE_ORDER) {
         const base = fallback[stage];
         next[stage] = {
             required: [...base.required],
+            recommended: [...base.recommended],
+            conditional: [...base.conditional],
+            triggered: [...base.triggered],
             passed: [...base.passed],
             blocked: [...base.blocked]
         };
@@ -147,11 +151,24 @@ function sanitizeStageGateCatalog(value, fallback) {
             continue;
         }
         const typed = rawStage;
-        const allowedGateIds = new Set(next[stage].required);
+        const stageState = next[stage];
+        const allowedGateIds = new Set([
+            ...stageState.required,
+            ...stageState.recommended,
+            ...stageState.conditional
+        ]);
+        const conditionalGateIds = new Set(stageState.conditional);
+        const passed = sanitizeStringArray(typed.passed).filter((gate) => allowedGateIds.has(gate));
+        const blocked = sanitizeStringArray(typed.blocked).filter((gate) => allowedGateIds.has(gate));
+        const triggeredFromState = sanitizeStringArray(typed.triggered).filter((gate) => conditionalGateIds.has(gate));
+        const touchedConditionals = [...passed, ...blocked].filter((gate) => conditionalGateIds.has(gate));
         next[stage] = {
-            required: [...next[stage].required],
-            passed: sanitizeStringArray(typed.passed).filter((gate) => allowedGateIds.has(gate)),
-            blocked: sanitizeStringArray(typed.blocked).filter((gate) => allowedGateIds.has(gate))
+            required: [...stageState.required],
+            recommended: [...stageState.recommended],
+            conditional: [...stageState.conditional],
+            triggered: uniqueStrings([...triggeredFromState, ...touchedConditionals]),
+            passed,
+            blocked
         };
     }
     return next;

package/dist/track-heuristics.d.ts

@@ -0,0 +1,12 @@
+import type { FlowTrack, TrackHeuristicRule, TrackHeuristicsConfig } from "./types.js";
+export interface TrackResolution {
+    track: FlowTrack;
+    reason: string;
+    matchedTokens: string[];
+}
+export declare function resolveTrackFromPrompt(prompt: string, config: TrackHeuristicsConfig | undefined): TrackResolution;
+export declare const TRACK_HEURISTICS_DEFAULTS: {
+    readonly fallback: "standard";
+    readonly priority: ("quick" | "medium" | "standard")[];
+    readonly tracks: Record<"quick" | "medium" | "standard", TrackHeuristicRule>;
+};

package/dist/track-heuristics.js

@@ -0,0 +1,144 @@
+import { FLOW_TRACKS } from "./types.js";
+const DEFAULT_RULES = {
+    quick: {
+        triggers: [
+            "bug",
+            "bugfix",
+            "fix",
+            "hotfix",
+            "patch",
+            "typo",
+            "regression",
+            "copy change",
+            "rename",
+            "bump",
+            "upgrade dep",
+            "config tweak",
+            "docs only",
+            "comment",
+            "lint",
+            "format",
+            "small",
+            "tiny",
+            "one-liner",
+            "revert"
+        ]
+    },
+    medium: {
+        triggers: [
+            "add endpoint",
+            "add field",
+            "extend existing",
+            "wire integration",
+            "small migration",
+            "new screen following existing pattern"
+        ]
+    },
+    standard: {
+        triggers: [
+            "new feature",
+            "refactor",
+            "migration",
+            "platform",
+            "architecture",
+            "schema",
+            "integrate",
+            "workflow",
+            "onboarding"
+        ]
+    }
+};
+const DEFAULT_PRIORITY = ["standard", "medium", "quick"];
+const DEFAULT_FALLBACK = "standard";
+function hasToken(promptLower, token) {
+    return promptLower.includes(token.toLowerCase());
+}
+function matchRule(promptLower, rule) {
+    if (!rule)
+        return [];
+    const matches = [];
+    for (const trigger of rule.triggers ?? []) {
+        if (hasToken(promptLower, trigger)) {
+            matches.push(trigger);
+        }
+    }
+    for (const pattern of rule.patterns ?? []) {
+        try {
+            const regex = new RegExp(pattern, "iu");
+            if (regex.test(promptLower)) {
+                matches.push(`/${pattern}/`);
+            }
+        }
+        catch {
+            // Ignore invalid custom regex entries; config validation should catch these.
+        }
+    }
+    return [...new Set(matches)];
+}
+function isValidTrack(value) {
+    return FLOW_TRACKS.includes(value);
+}
+function mergeRules(base, overrides) {
+    const merged = { ...base };
+    const over = overrides?.tracks;
+    if (!over)
+        return merged;
+    for (const track of FLOW_TRACKS) {
+        const rule = over[track];
+        if (!rule)
+            continue;
+        merged[track] = {
+            triggers: rule.triggers ?? merged[track].triggers,
+            patterns: rule.patterns ?? merged[track].patterns,
+            veto: rule.veto ?? merged[track].veto
+        };
+    }
+    return merged;
+}
+function resolvePriority(config) {
+    const configured = config?.priority ?? [];
+    const filtered = configured.filter((track) => isValidTrack(track));
+    const unique = [...new Set(filtered)];
+    if (unique.length === 0)
+        return [...DEFAULT_PRIORITY];
+    // Ensure all tracks are still represented in deterministic order.
+    for (const track of FLOW_TRACKS) {
+        if (!unique.includes(track))
+            unique.push(track);
+    }
+    return unique;
+}
+function resolveFallback(config) {
+    return config?.fallback && isValidTrack(config.fallback) ? config.fallback : DEFAULT_FALLBACK;
+}
+export function resolveTrackFromPrompt(prompt, config) {
+    const promptLower = prompt.toLowerCase();
+    const rules = mergeRules(DEFAULT_RULES, config);
+    const priority = resolvePriority(config);
+    const fallback = resolveFallback(config);
+    for (const track of priority) {
+        const rule = rules[track];
+        const vetoes = rule.veto ?? [];
+        if (vetoes.some((token) => hasToken(promptLower, token))) {
+            continue;
+        }
+        const matched = matchRule(promptLower, rule);
+        if (matched.length > 0) {
+            return {
+                track,
+                reason: `matched ${track} heuristic`,
+                matchedTokens: matched
+            };
+        }
+    }
+    return {
+        track: fallback,
+        reason: `no explicit match, fallback=${fallback}`,
+        matchedTokens: []
+    };
+}
+export const TRACK_HEURISTICS_DEFAULTS = {
+    fallback: DEFAULT_FALLBACK,
+    priority: DEFAULT_PRIORITY,
+    tracks: DEFAULT_RULES
+};

package/dist/types.d.ts

@@ -1,11 +1,13 @@
 export declare const FLOW_STAGES: readonly ["brainstorm", "scope", "design", "spec", "plan", "tdd", "review", "ship"];
 export type FlowStage = (typeof FLOW_STAGES)[number];
-export declare const FLOW_TRACKS: readonly ["quick", "standard"];
+export declare const FLOW_TRACKS: readonly ["quick", "medium", "standard"];
 export type FlowTrack = (typeof FLOW_TRACKS)[number];
 /**
  * Ordered stages that make up each flow track.
  *
  * - `standard` runs the full 8-stage pipeline (default — same as before tracks existed).
+ * - `medium` keeps product framing but skips heavy scope/design lock-in:
+ *   brainstorm -> spec -> plan -> tdd -> review -> ship.
  * - `quick` skips the upstream product stages (brainstorm/scope/design/plan) for
  *   small bug fixes or single-purpose changes where the spec is already known.
  *   It still keeps the non-negotiable safety gates: spec → tdd → review → ship.
@@ -16,8 +18,8 @@ export type HarnessId = (typeof HARNESS_IDS)[number];
 /**
  * Init profiles pre-fill `cclaw init` flags for common install shapes.
  *
- * - `minimal` — single-harness (claude), quick track default, no git hook guards. For solo
- *   contributors or bugfix-heavy repos where most work is \`quick\` scope.
+ * - `minimal` — single-harness (claude), medium track default, no git hook guards. For solo
+ *   contributors who still want brainstorm/spec/plan rigor without full scope+design overhead.
  * - `standard` — default harness set, standard track, no git hook guards, advisory guards.
  *   Matches the pre-profile default behavior.
  * - `full` — default harness set, standard track, git hook guards on, strict prompt guards.
@@ -35,6 +37,22 @@ export type InitProfile = (typeof INIT_PROFILES)[number];
  */
 export declare const LANGUAGE_RULE_PACKS: readonly ["typescript", "python", "go"];
 export type LanguageRulePack = (typeof LANGUAGE_RULE_PACKS)[number];
+export interface TrackHeuristicRule {
+    triggers?: string[];
+    patterns?: string[];
+    veto?: string[];
+}
+export interface TrackHeuristicsConfig {
+    /** Track used when no trigger/pattern matches. */
+    fallback?: FlowTrack;
+    /**
+     * Track evaluation order. First matching track wins.
+     * Example: ["standard", "medium", "quick"].
+     */
+    priority?: FlowTrack[];
+    /** Per-track matching rules. */
+    tracks?: Partial<Record<FlowTrack, TrackHeuristicRule>>;
+}
 export interface VibyConfig {
     version: string;
     flowVersion: string;
@@ -54,6 +72,11 @@ export interface VibyConfig {
      * the language in question. Disabled packs have no on-disk footprint.
      */
     languageRulePacks?: LanguageRulePack[];
+    /**
+     * Optional prompt-to-track mapping overrides for /cc classification.
+     * If omitted, cclaw uses built-in defaults.
+     */
+    trackHeuristics?: TrackHeuristicsConfig;
 }
 export interface TransitionRule {
     from: FlowStage;

package/dist/types.js

@@ -8,25 +8,28 @@ export const FLOW_STAGES = [
     "review",
     "ship"
 ];
-export const FLOW_TRACKS = ["quick", "standard"];
+export const FLOW_TRACKS = ["quick", "medium", "standard"];
 /**
  * Ordered stages that make up each flow track.
  *
  * - `standard` runs the full 8-stage pipeline (default — same as before tracks existed).
+ * - `medium` keeps product framing but skips heavy scope/design lock-in:
+ *   brainstorm -> spec -> plan -> tdd -> review -> ship.
  * - `quick` skips the upstream product stages (brainstorm/scope/design/plan) for
  *   small bug fixes or single-purpose changes where the spec is already known.
  *   It still keeps the non-negotiable safety gates: spec → tdd → review → ship.
  */
 export const TRACK_STAGES = {
     standard: FLOW_STAGES,
+    medium: ["brainstorm", "spec", "plan", "tdd", "review", "ship"],
     quick: ["spec", "tdd", "review", "ship"]
 };
 export const HARNESS_IDS = ["claude", "cursor", "opencode", "codex"];
 /**
  * Init profiles pre-fill `cclaw init` flags for common install shapes.
  *
- * - `minimal` — single-harness (claude), quick track default, no git hook guards. For solo
- *   contributors or bugfix-heavy repos where most work is \`quick\` scope.
+ * - `minimal` — single-harness (claude), medium track default, no git hook guards. For solo
+ *   contributors who still want brainstorm/spec/plan rigor without full scope+design overhead.
  * - `standard` — default harness set, standard track, no git hook guards, advisory guards.
  *   Matches the pre-profile default behavior.
  * - `full` — default harness set, standard track, git hook guards on, strict prompt guards.

package/package.json

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