cclaw-cli 0.10.1 → 0.12.0

package/dist/init-detect.js

@@ -0,0 +1,45 @@
+import path from "node:path";
+import { exists } from "./fs-utils.js";
+export async function detectHarnesses(projectRoot) {
+    const detected = [];
+    const claudeHints = [
+        path.join(projectRoot, ".claude"),
+        path.join(projectRoot, "CLAUDE.md")
+    ];
+    if (await anyExists(claudeHints)) {
+        detected.push("claude");
+    }
+    const cursorHints = [
+        path.join(projectRoot, ".cursor"),
+        path.join(projectRoot, ".cursor/rules")
+    ];
+    if (await anyExists(cursorHints)) {
+        detected.push("cursor");
+    }
+    const opencodeHints = [
+        path.join(projectRoot, ".opencode"),
+        path.join(projectRoot, "opencode.json"),
+        path.join(projectRoot, "opencode.jsonc"),
+        path.join(projectRoot, ".opencode/opencode.json"),
+        path.join(projectRoot, ".opencode/opencode.jsonc")
+    ];
+    if (await anyExists(opencodeHints)) {
+        detected.push("opencode");
+    }
+    const codexHints = [
+        path.join(projectRoot, ".codex"),
+        path.join(projectRoot, ".codex/hooks.json")
+    ];
+    if (await anyExists(codexHints)) {
+        detected.push("codex");
+    }
+    return detected;
+}
+async function anyExists(paths) {
+    for (const candidate of paths) {
+        if (await exists(candidate)) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/install.js

@@ -15,15 +15,21 @@ 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 { RESEARCH_PLAYBOOKS } from "./content/research-playbooks.js";
 import { HARNESS_TOOL_REFS_DIR, HARNESS_TOOL_REFS_INDEX_MD, harnessToolRefMarkdown } from "./content/harness-tool-refs.js";
+import { DOCTOR_REFERENCE_MARKDOWN } from "./content/doctor-references.js";
+import { harnessIntegrationDocMarkdown } from "./content/harnesses-doc.js";
+import { HOOK_EVENTS_BY_HARNESS, HOOK_SEMANTIC_EVENTS } from "./content/hook-events.js";
 import { createInitialFlowState } from "./flow-state.js";
 import { ensureDir, exists, writeFileSafe } from "./fs-utils.js";
 import { ensureGitignore, removeGitignorePatterns } from "./gitignore.js";
-import { HARNESS_ADAPTERS, syncHarnessShims, removeCclawFromAgentsMd } from "./harness-adapters.js";
+import { HARNESS_ADAPTERS, harnessTier, syncHarnessShims, removeCclawFromAgentsMd } from "./harness-adapters.js";
 import { validateHookDocument } from "./hook-schema.js";
 import { ensureRunSystem, readFlowState } from "./runs.js";
 const OPENCODE_PLUGIN_REL_PATH = ".opencode/plugins/cclaw-plugin.mjs";
@@ -185,6 +191,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,10 +201,17 @@ 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());
     }
+    // In-thread research procedures (no YAML frontmatter, not delegated personas).
+    for (const [fileName, markdown] of Object.entries(RESEARCH_PLAYBOOKS)) {
+        await writeFileSafe(runtimePath(projectRoot, "skills", "research", fileName), markdown);
+    }
     // Language rule packs live under .cclaw/rules/lang/<pack>.md. They are opt-in:
     // only the packs listed in config.languageRulePacks are materialised. Any
     // legacy per-language skill folders from v0.7.0 (.cclaw/skills/language-*)
@@ -225,6 +239,11 @@ async function writeSkills(projectRoot, config) {
     for (const harness of harnessIds) {
         await writeFileSafe(runtimePath(projectRoot, ...harnessRefsDir, `${harness}.md`), harnessToolRefMarkdown(harness));
     }
+    const doctorRefsDir = ["references", "doctor"];
+    for (const [fileName, markdown] of Object.entries(DOCTOR_REFERENCE_MARKDOWN)) {
+        await writeFileSafe(runtimePath(projectRoot, ...doctorRefsDir, fileName), markdown);
+    }
+    await writeFileSafe(runtimePath(projectRoot, "references", "harnesses.md"), harnessIntegrationDocMarkdown());
 }
 async function writeUtilityCommands(projectRoot) {
     await writeFileSafe(runtimePath(projectRoot, "commands", "learn.md"), learnCommandContract());
@@ -773,6 +792,14 @@ 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");
+    }
+    const preambleLogPath = path.join(stateDir, "preamble-log.jsonl");
+    if (!(await exists(preambleLogPath))) {
+        await writeFileSafe(preambleLogPath, "");
+    }
 }
 async function writeRulebook(projectRoot) {
     await writeFileSafe(runtimePath(projectRoot, "rules", "RULES.md"), RULEBOOK_MARKDOWN);
@@ -836,6 +863,33 @@ async function writeAdapterManifest(projectRoot, harnesses) {
     };
     await writeFileSafe(runtimePath(projectRoot, "adapters", "manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`);
 }
+async function writeHarnessGapsState(projectRoot, harnesses) {
+    const report = harnesses.map((harness) => {
+        const capabilities = HARNESS_ADAPTERS[harness].capabilities;
+        const hookMap = HOOK_EVENTS_BY_HARNESS[harness];
+        const missingHookEvents = HOOK_SEMANTIC_EVENTS.filter((eventName) => !hookMap[eventName]);
+        const missingCapabilities = [];
+        if (capabilities.nativeSubagentDispatch !== "full") {
+            missingCapabilities.push(`nativeSubagentDispatch:${capabilities.nativeSubagentDispatch}`);
+        }
+        if (capabilities.hookSurface !== "full") {
+            missingCapabilities.push(`hookSurface:${capabilities.hookSurface}`);
+        }
+        if (capabilities.structuredAsk === "plain-text") {
+            missingCapabilities.push("structuredAsk:none");
+        }
+        return {
+            harness,
+            tier: harnessTier(harness),
+            missingCapabilities,
+            missingHookEvents
+        };
+    });
+    await writeFileSafe(runtimePath(projectRoot, "state", "harness-gaps.json"), `${JSON.stringify({
+        generatedAt: new Date().toISOString(),
+        harnesses: report
+    }, null, 2)}\n`);
+}
 async function cleanLegacyArtifacts(projectRoot) {
     // Remove deprecated utility skill folders from older releases.
     for (const legacyFolder of [
@@ -868,6 +922,23 @@ async function cleanLegacyArtifacts(projectRoot) {
     catch {
         // best-effort cleanup
     }
+    // Core-5 migration: remove deprecated generated agent personas.
+    for (const legacyAgentFile of [
+        "spec-reviewer.md",
+        "code-reviewer.md",
+        "repo-research-analyst.md",
+        "learnings-researcher.md",
+        "framework-docs-researcher.md",
+        "best-practices-researcher.md",
+        "git-history-analyzer.md"
+    ]) {
+        try {
+            await fs.rm(runtimePath(projectRoot, "agents", legacyAgentFile), { force: true });
+        }
+        catch {
+            // best-effort cleanup
+        }
+    }
     for (const legacyPlugin of [
         path.join(projectRoot, ".opencode/plugins/viby-plugin.mjs"),
         path.join(projectRoot, ".opencode/plugins/opencode-plugin.mjs"),
@@ -940,6 +1011,7 @@ async function materializeRuntime(projectRoot, config, forceStateReset) {
     await ensureRunSystem(projectRoot, { createIfMissing: false });
     await ensureSessionStateFiles(projectRoot);
     await writeAdapterManifest(projectRoot, harnesses);
+    await writeHarnessGapsState(projectRoot, harnesses);
     await ensureKnowledgeStore(projectRoot);
     await ensureCustomSkillsScaffold(projectRoot);
     await writeHooks(projectRoot, config);

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,
@@ -99,18 +98,25 @@ export async function policyChecks(projectRoot, options = {}) {
         { file: runtimeFile("skills/parallel-dispatch/SKILL.md"), needle: "Review Army", name: "utility_skill:parallel:review_army" },
         { file: runtimeFile("skills/parallel-dispatch/SKILL.md"), needle: "Reconciliation", name: "utility_skill:parallel:reconciliation" },
         { file: runtimeFile("skills/parallel-dispatch/SKILL.md"), needle: "## Model & Harness Routing Notes", name: "utility_skill:parallel:routing_notes" },
+        { file: runtimeFile("skills/research/repo-scan.md"), needle: "# Repo Scan Playbook", name: "utility_skill:research:repo_scan" },
+        { file: runtimeFile("skills/research/learnings-lookup.md"), needle: "# Learnings Lookup Playbook", name: "utility_skill:research:learnings_lookup" },
+        { file: runtimeFile("skills/research/framework-docs-lookup.md"), needle: "# Framework Docs Lookup Playbook", name: "utility_skill:research:framework_docs_lookup" },
+        { file: runtimeFile("skills/research/best-practices-lookup.md"), needle: "# Best Practices Lookup Playbook", name: "utility_skill:research:best_practices_lookup" },
+        { file: runtimeFile("skills/research/git-history.md"), needle: "# Git History Playbook", name: "utility_skill:research:git_history" },
         { 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 +159,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.12.0",
   "description": "Installer-first flow toolkit for coding agents",
   "type": "module",
   "bin": {
@@ -23,6 +23,7 @@
     "test:coverage": "vitest run --coverage",
     "smoke:runtime": "npm run build && node scripts/smoke-init.mjs",
     "lint:hooks": "npm run build && node scripts/lint-generated-hooks.mjs",
+    "build:harness-docs": "npm run build && node scripts/build-harness-docs.mjs",
     "build:plugin-manifests": "npm run build && node scripts/build-plugin-manifests.mjs",
     "release:check": "npm run build && npm run test && node scripts/lint-generated-hooks.mjs && node scripts/build-plugin-manifests.mjs && npm pack --dry-run && node scripts/smoke-init.mjs",
     "release:bundle": "npm run release:check && npm pack"

package/dist/content/agents.d.ts

@@ -1,48 +0,0 @@
-/**
- * Agent persona content for Cclaw.
- *
- * Cclaw emits markdown agent definitions (`.md` with YAML frontmatter) that harnesses
- * use for specialist delegation. Agents are isolated context windows with constrained
- * tools; skills remain procedural recipes.
- */
-export interface AgentDefinition {
-    /** Kebab-case identifier, e.g. `"spec-reviewer"`. */
-    name: string;
-    /** When to invoke — include PROACTIVE / MUST BE USED style guidance for harnesses. */
-    description: string;
-    /** Allowed tools for this agent (harness-specific names). */
-    tools: string[];
-    /** Model tier for routing cost/latency vs depth. */
-    model: "fast" | "balanced" | "deep";
-    /** How the harness should treat activation relative to flow context. */
-    activation: "proactive" | "on-demand" | "mandatory";
-    /** Cclaw flow stages this agent is designed to support. */
-    relatedStages: string[];
-    /** Markdown body rendered below the YAML frontmatter. */
-    body: string;
-}
-/**
- * Canonical specialist agents Cclaw can materialize under `.cclaw/agents/`.
- */
-export declare const CCLAW_AGENTS: AgentDefinition[];
-/**
- * Render a complete Cclaw agent markdown file (YAML frontmatter + body).
- */
-export declare function agentMarkdown(agent: AgentDefinition): string;
-/**
- * Markdown table mapping Cclaw stage entry points to specialist agents.
- */
-export declare function agentRoutingTable(): string;
-/**
- * Cost tier routing: keep heavy reasoning on the \`deep\` tier (planner, a
- * single post-review reconciliation), push read-only research and narrow
- * machine-only checks to the \`fast\` tier, and default review to \`balanced\`.
- * This table is emitted into AGENTS.md so harness users understand why
- * certain specialists are automatically fan-out-able without blowing the
- * context budget.
- */
-export declare function agentCostTierTable(): string;
-/**
- * AGENTS.md-ready section describing Cclaw’s specialist delegation model.
- */
-export declare function agentsAgentsMdBlock(): string;