cclaw-cli 0.5.17 → 0.7.0

package/dist/delegation.d.ts

@@ -2,7 +2,7 @@ import type { FlowStage } from "./types.js";
 export type DelegationEntry = {
     stage: string;
     agent: string;
-    mode: "mandatory" | "proactive";
+    mode: "mandatory" | "proactive" | "conditional";
     status: "scheduled" | "completed" | "failed" | "waived";
     taskId?: string;
     waiverReason?: string;
@@ -12,6 +12,11 @@ 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.
+     */
+    conditionTrigger?: string;
 };
 export type DelegationLedger = {
     runId: string;

package/dist/delegation.js

@@ -14,7 +14,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";
+    const modeOk = o.mode === "mandatory" || o.mode === "proactive" || o.mode === "conditional";
     const statusOk = o.status === "scheduled" ||
         o.status === "completed" ||
         o.status === "failed" ||
@@ -26,7 +26,8 @@ function isDelegationEntry(value) {
         typeof o.ts === "string" &&
         (o.taskId === undefined || typeof o.taskId === "string") &&
         (o.waiverReason === undefined || typeof o.waiverReason === "string") &&
-        (o.runId === undefined || typeof o.runId === "string"));
+        (o.runId === undefined || typeof o.runId === "string") &&
+        (o.conditionTrigger === undefined || typeof o.conditionTrigger === "string"));
 }
 function parseLedger(raw, runId) {
     if (!raw || typeof raw !== "object" || Array.isArray(raw)) {

package/dist/doctor.js

@@ -11,11 +11,13 @@ import { gitignoreHasRequiredPatterns } from "./gitignore.js";
 import { HARNESS_ADAPTERS, CCLAW_MARKER_START, CCLAW_MARKER_END } from "./harness-adapters.js";
 import { policyChecks } from "./policy.js";
 import { readFlowState } from "./runs.js";
+import { skippedStagesForTrack } from "./flow-state.js";
+import { TRACK_STAGES } from "./types.js";
 import { checkMandatoryDelegations } from "./delegation.js";
 import { buildTraceMatrix } from "./trace-matrix.js";
 import { reconcileAndWriteCurrentStageGateCatalog, verifyCompletedStagesGateClosure, verifyCurrentStageGateEvidence } from "./gate-evidence.js";
 import { stageSkillFolder } from "./content/skills.js";
-import { UTILITY_SKILL_FOLDERS } from "./content/utility-skills.js";
+import { LANGUAGE_RULE_PACK_FOLDERS, UTILITY_SKILL_FOLDERS } from "./content/utility-skills.js";
 import { CONTEXT_MODES, DEFAULT_CONTEXT_MODE } from "./content/contexts.js";
 import { validateHookDocument } from "./hook-schema.js";
 const execFileAsync = promisify(execFile);
@@ -406,6 +408,18 @@ export async function doctorChecks(projectRoot, options = {}) {
             details: skillPath
         });
     }
+    // Opt-in language rule packs: only check presence for packs the user enabled.
+    for (const pack of parsedConfig?.languageRulePacks ?? []) {
+        const folder = LANGUAGE_RULE_PACK_FOLDERS[pack];
+        if (!folder)
+            continue;
+        const skillPath = path.join(projectRoot, RUNTIME_ROOT, "skills", folder, "SKILL.md");
+        checks.push({
+            name: `language_rule_pack:${pack}`,
+            ok: await exists(skillPath),
+            details: skillPath
+        });
+    }
     // Agent definition files
     for (const agent of CCLAW_AGENTS) {
         const agentPath = path.join(projectRoot, RUNTIME_ROOT, "agents", `${agent.name}.md`);
@@ -743,6 +757,29 @@ export async function doctorChecks(projectRoot, options = {}) {
         ok: activeRunId.length > 0,
         details: `${RUNTIME_ROOT}/state/flow-state.json must include activeRunId`
     });
+    const activeTrack = flowState.track ?? "standard";
+    const trackStageList = TRACK_STAGES[activeTrack];
+    const skippedFromState = Array.isArray(flowState.skippedStages) ? flowState.skippedStages : [];
+    const expectedSkipped = skippedStagesForTrack(activeTrack);
+    const skippedConsistent = expectedSkipped.length === skippedFromState.length &&
+        expectedSkipped.every((stage) => skippedFromState.includes(stage));
+    checks.push({
+        name: "flow_state:track",
+        ok: skippedConsistent,
+        details: skippedConsistent
+            ? `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`
+    });
+    checks.push({
+        name: "flow_state:track_completed_in_track",
+        ok: flowState.completedStages.every((stage) => trackStageList.includes(stage) || expectedSkipped.includes(stage)),
+        details: (() => {
+            const offTrack = flowState.completedStages.filter((stage) => !trackStageList.includes(stage) && !expectedSkipped.includes(stage));
+            return offTrack.length === 0
+                ? `every completed stage belongs to track "${activeTrack}" or its skipped set`
+                : `completed stages contain entries outside track "${activeTrack}" and not in skipped set: ${offTrack.join(", ")}`;
+        })()
+    });
     checks.push({
         name: "artifacts:active_root",
         ok: await exists(path.join(projectRoot, RUNTIME_ROOT, "artifacts")),

package/dist/flow-state.d.ts

@@ -1,4 +1,4 @@
-import type { FlowStage, TransitionRule } from "./types.js";
+import type { FlowStage, FlowTrack, TransitionRule } from "./types.js";
 export declare const TRANSITION_RULES: TransitionRule[];
 export interface StageGateState {
     required: string[];
@@ -11,9 +11,21 @@ export interface FlowState {
     completedStages: FlowStage[];
     guardEvidence: Record<string, string>;
     stageGateCatalog: Record<FlowStage, StageGateState>;
+    /** Active flow track (determines which stages are in the critical path for this run). */
+    track: FlowTrack;
+    /** Stages explicitly skipped for this track (empty for standard; populated for quick). */
+    skippedStages: FlowStage[];
 }
-export declare function createInitialFlowState(activeRunId?: string): FlowState;
+export interface InitialFlowStateOptions {
+    activeRunId?: string;
+    track?: FlowTrack;
+}
+export declare function isFlowTrack(value: unknown): value is FlowTrack;
+export declare function trackStages(track: FlowTrack): FlowStage[];
+export declare function skippedStagesForTrack(track: FlowTrack): FlowStage[];
+export declare function firstStageForTrack(track: FlowTrack): FlowStage;
+export declare function createInitialFlowState(activeRunIdOrOptions?: string | InitialFlowStateOptions, maybeTrack?: FlowTrack): FlowState;
 export declare function canTransition(from: FlowStage, to: FlowStage): boolean;
 export declare function getTransitionGuards(from: FlowStage, to: FlowStage): string[];
-export declare function nextStage(stage: FlowStage): FlowStage | null;
-export declare function previousStage(stage: FlowStage): FlowStage | null;
+export declare function nextStage(stage: FlowStage, track?: FlowTrack): FlowStage | null;
+export declare function previousStage(stage: FlowStage, track?: FlowTrack): FlowStage | null;

package/dist/flow-state.js

@@ -1,7 +1,28 @@
 import { COMMAND_FILE_ORDER } from "./constants.js";
 import { buildTransitionRules, orderedStageSchemas, stageGateIds } from "./content/stage-schema.js";
+import { FLOW_STAGES, FLOW_TRACKS, TRACK_STAGES } from "./types.js";
 export const TRANSITION_RULES = buildTransitionRules();
-export function createInitialFlowState(activeRunId = "active") {
+export function isFlowTrack(value) {
+    return typeof value === "string" && FLOW_TRACKS.includes(value);
+}
+export function trackStages(track) {
+    return [...TRACK_STAGES[track]];
+}
+export function skippedStagesForTrack(track) {
+    const inTrack = new Set(TRACK_STAGES[track]);
+    return FLOW_STAGES.filter((stage) => !inTrack.has(stage));
+}
+export function firstStageForTrack(track) {
+    const stages = TRACK_STAGES[track];
+    return stages[0] ?? "brainstorm";
+}
+export function createInitialFlowState(activeRunIdOrOptions = "active", maybeTrack) {
+    const options = typeof activeRunIdOrOptions === "string"
+        ? { activeRunId: activeRunIdOrOptions, track: maybeTrack }
+        : activeRunIdOrOptions;
+    const activeRunId = options.activeRunId ?? "active";
+    const track = options.track ?? "standard";
+    const skippedStages = skippedStagesForTrack(track);
     const stageGateCatalog = {};
     for (const schema of orderedStageSchemas()) {
         stageGateCatalog[schema.stage] = {
@@ -12,10 +33,12 @@ export function createInitialFlowState(activeRunId = "active") {
     }
     return {
         activeRunId,
-        currentStage: "brainstorm",
+        currentStage: firstStageForTrack(track),
         completedStages: [],
         guardEvidence: {},
-        stageGateCatalog
+        stageGateCatalog,
+        track,
+        skippedStages
     };
 }
 export function canTransition(from, to) {
@@ -25,17 +48,33 @@ export function getTransitionGuards(from, to) {
     const match = TRANSITION_RULES.find((rule) => rule.from === from && rule.to === to);
     return match ? [...match.guards] : [];
 }
-export function nextStage(stage) {
-    const index = COMMAND_FILE_ORDER.indexOf(stage);
-    if (index < 0 || index === COMMAND_FILE_ORDER.length - 1) {
+export function nextStage(stage, track = "standard") {
+    const ordered = TRACK_STAGES[track];
+    const index = ordered.indexOf(stage);
+    if (index < 0) {
+        const fallback = COMMAND_FILE_ORDER.indexOf(stage);
+        if (fallback < 0 || fallback === COMMAND_FILE_ORDER.length - 1) {
+            return null;
+        }
+        return COMMAND_FILE_ORDER[fallback + 1];
+    }
+    if (index === ordered.length - 1) {
         return null;
     }
-    return COMMAND_FILE_ORDER[index + 1];
+    return ordered[index + 1];
 }
-export function previousStage(stage) {
-    const index = COMMAND_FILE_ORDER.indexOf(stage);
-    if (index <= 0) {
+export function previousStage(stage, track = "standard") {
+    const ordered = TRACK_STAGES[track];
+    const index = ordered.indexOf(stage);
+    if (index === 0) {
         return null;
     }
-    return COMMAND_FILE_ORDER[index - 1];
+    if (index < 0) {
+        const fallback = COMMAND_FILE_ORDER.indexOf(stage);
+        if (fallback <= 0) {
+            return null;
+        }
+        return COMMAND_FILE_ORDER[fallback - 1];
+    }
+    return ordered[index - 1];
 }

package/dist/harness-adapters.js

@@ -124,6 +124,7 @@ export async function syncHarnessShims(projectRoot, harnesses) {
         await writeFileSafe(path.join(commandDir, "cc.md"), utilityShimContent(harness, "cc", "flow-start", "start.md"));
         await writeFileSafe(path.join(commandDir, "cc-next.md"), utilityShimContent(harness, "next", "flow-next-step", "next.md"));
         await writeFileSafe(path.join(commandDir, "cc-learn.md"), utilityShimContent(harness, "learn", "learnings", "learn.md"));
+        await writeFileSafe(path.join(commandDir, "cc-status.md"), utilityShimContent(harness, "status", "flow-status", "status.md"));
     }
     await syncAgentFiles(projectRoot);
     await syncAgentsMd(projectRoot);

package/dist/install.d.ts

@@ -1,7 +1,10 @@
-import type { HarnessId } from "./types.js";
+import type { FlowTrack, HarnessId, InitProfile } from "./types.js";
 export interface InitOptions {
     projectRoot: string;
     harnesses?: HarnessId[];
+    track?: FlowTrack;
+    /** When set, pre-fills config defaults from the named profile before applying flag overrides. */
+    profile?: InitProfile;
 }
 export declare function initCclaw(options: InitOptions): Promise<void>;
 export declare function syncCclaw(projectRoot: string): Promise<void>;

package/dist/install.js

@@ -3,20 +3,21 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { promisify } from "node:util";
 import { COMMAND_FILE_ORDER, REQUIRED_DIRS, RUNTIME_ROOT, UTILITY_COMMANDS } from "./constants.js";
-import { writeConfig, createDefaultConfig, readConfig, configPath } from "./config.js";
+import { writeConfig, createDefaultConfig, createProfileConfig, readConfig, configPath } from "./config.js";
 import { commandContract } from "./content/contracts.js";
 import { contextModeFiles, createInitialContextModeState } from "./content/contexts.js";
 import { learnSkillMarkdown, learnCommandContract } from "./content/learnings.js";
 import { nextCommandContract, nextCommandSkillMarkdown } from "./content/next-command.js";
 import { startCommandContract, startCommandSkillMarkdown } from "./content/start-command.js";
+import { statusCommandContract, statusCommandSkillMarkdown } from "./content/status-command.js";
 import { subagentDrivenDevSkill, parallelAgentsSkill } from "./content/subagents.js";
 import { sessionHooksSkillMarkdown } from "./content/session-hooks.js";
-import { sessionStartScript, stopCheckpointScript, opencodePluginJs, claudeHooksJson, cursorHooksJson, codexHooksJson } from "./content/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 { ARTIFACT_TEMPLATES, CURSOR_WORKFLOW_RULE_MDC, RULEBOOK_MARKDOWN, buildRulesJson } from "./content/templates.js";
 import { stageSkillFolder, stageSkillMarkdown } from "./content/skills.js";
-import { UTILITY_SKILL_FOLDERS, UTILITY_SKILL_MAP } from "./content/utility-skills.js";
+import { LANGUAGE_RULE_PACK_FOLDERS, LANGUAGE_RULE_PACK_GENERATORS, UTILITY_SKILL_FOLDERS, UTILITY_SKILL_MAP } from "./content/utility-skills.js";
 import { createInitialFlowState } from "./flow-state.js";
 import { ensureDir, exists, writeFileSafe } from "./fs-utils.js";
 import { ensureGitignore, removeGitignorePatterns } from "./gitignore.js";
@@ -164,7 +165,7 @@ async function writeArtifactTemplates(projectRoot) {
         await writeFileSafe(runtimePath(projectRoot, "templates", fileName), content);
     }
 }
-async function writeSkills(projectRoot) {
+async function writeSkills(projectRoot, config) {
     for (const stage of COMMAND_FILE_ORDER) {
         const folder = stageSkillFolder(stage);
         await writeFileSafe(runtimePath(projectRoot, "skills", folder, "SKILL.md"), stageSkillMarkdown(stage));
@@ -173,6 +174,7 @@ async function writeSkills(projectRoot) {
     await writeFileSafe(runtimePath(projectRoot, "skills", "learnings", "SKILL.md"), learnSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", "flow-next-step", "SKILL.md"), nextCommandSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", "flow-start", "SKILL.md"), startCommandSkillMarkdown());
+    await writeFileSafe(runtimePath(projectRoot, "skills", "flow-status", "SKILL.md"), statusCommandSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", "subagent-dev", "SKILL.md"), subagentDrivenDevSkill());
     await writeFileSafe(runtimePath(projectRoot, "skills", "parallel-dispatch", "SKILL.md"), parallelAgentsSkill());
     await writeFileSafe(runtimePath(projectRoot, "skills", "session", "SKILL.md"), sessionHooksSkillMarkdown());
@@ -181,11 +183,20 @@ async function writeSkills(projectRoot) {
         const generator = UTILITY_SKILL_MAP[folder];
         await writeFileSafe(runtimePath(projectRoot, "skills", folder, "SKILL.md"), generator());
     }
+    const enabledPacks = config?.languageRulePacks ?? [];
+    for (const pack of enabledPacks) {
+        const folder = LANGUAGE_RULE_PACK_FOLDERS[pack];
+        const generator = LANGUAGE_RULE_PACK_GENERATORS[folder];
+        if (!folder || !generator)
+            continue;
+        await writeFileSafe(runtimePath(projectRoot, "skills", folder, "SKILL.md"), generator());
+    }
 }
 async function writeUtilityCommands(projectRoot) {
     await writeFileSafe(runtimePath(projectRoot, "commands", "learn.md"), learnCommandContract());
     await writeFileSafe(runtimePath(projectRoot, "commands", "next.md"), nextCommandContract());
     await writeFileSafe(runtimePath(projectRoot, "commands", "start.md"), startCommandContract());
+    await writeFileSafe(runtimePath(projectRoot, "commands", "status.md"), statusCommandContract());
 }
 function toObject(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -482,6 +493,7 @@ async function writeHooks(projectRoot, config) {
     await ensureDir(hooksDir);
     await writeFileSafe(path.join(hooksDir, "session-start.sh"), sessionStartScript());
     await writeFileSafe(path.join(hooksDir, "stop-checkpoint.sh"), stopCheckpointScript());
+    await writeFileSafe(path.join(hooksDir, "pre-compact.sh"), preCompactScript());
     await writeFileSafe(path.join(hooksDir, "prompt-guard.sh"), promptGuardScript({
         strictMode: config.promptGuardMode === "strict"
     }));
@@ -493,6 +505,7 @@ async function writeHooks(projectRoot, config) {
         for (const script of [
             "session-start.sh",
             "stop-checkpoint.sh",
+            "pre-compact.sh",
             "prompt-guard.sh",
             "workflow-guard.sh",
             "context-monitor.sh",
@@ -542,6 +555,151 @@ async function ensureKnowledgeStore(projectRoot) {
         await writeFileSafe(storePath, "# Project Knowledge\n\n");
     }
 }
+async function ensureCustomSkillsScaffold(projectRoot) {
+    const customDir = runtimePath(projectRoot, "custom-skills");
+    await ensureDir(customDir);
+    const readmePath = path.join(customDir, "README.md");
+    if (!(await exists(readmePath))) {
+        await writeFileSafe(readmePath, CUSTOM_SKILLS_README);
+    }
+    const examplePath = path.join(customDir, "example", "SKILL.md");
+    if (!(await exists(examplePath))) {
+        await writeFileSafe(examplePath, CUSTOM_SKILLS_EXAMPLE);
+    }
+}
+const CUSTOM_SKILLS_README = `# Custom Skills (sync-safe)
+
+This directory is **never overwritten** by \`cclaw sync\` or \`cclaw upgrade\`. Use it
+to add project-specific skills that complement the managed skills under
+\`.cclaw/skills/\`.
+
+## When to add a custom skill
+
+- A repeatable lens specific to **this project** (e.g. "billing-domain", "kafka-message-contracts").
+- A team convention you want every agent session to load.
+- A domain checklist that does not generalize to other projects.
+
+If the skill is general (security, performance, accessibility, etc.) prefer
+contributing it upstream instead — the managed skills receive maintenance.
+
+## File format — public API (stable contract)
+
+Each skill lives at \`.cclaw/custom-skills/<folder>/SKILL.md\`. The format is a
+**stable public API**: \`cclaw sync\` and \`cclaw upgrade\` will not rewrite
+custom skills, and the fields below are guaranteed to be respected by the
+meta-skill router and the stage hooks.
+
+### Frontmatter (YAML, required)
+
+\`\`\`yaml
+---
+# Required fields
+name: <kebab-case-skill-name>
+description: >
+  One sentence (≤180 chars) that triggers semantic routing. Include the
+  concrete situation and the expected action
+  (e.g. "Audit Kafka topic contracts when a producer or consumer signature changes").
+
+# Optional fields (omit when not applicable)
+stages: [design, spec, tdd, review]    # flow stages this skill applies to
+triggers:
+  - "kafka topic"
+  - "producer.schema"
+  - "consumer.schema"
+hardGate: false                        # true => skill body MUST include a ## HARD-GATE section
+owners: ["@team-messaging"]            # informational routing hint, not enforced
+version: 0.1.0                         # semver; bump when hardGate or algorithm changes
+---
+\`\`\`
+
+### Field contract
+
+| Field | Type | Required | Meaning |
+|---|---|---|---|
+| \`name\` | string (kebab-case) | yes | Unique id used by the router and by \`/cc-status\` diagnostics. |
+| \`description\` | string ≤180 chars (single line OR YAML \`>\` folded) | yes | Drives semantic routing. Include trigger + action. |
+| \`stages\` | array of flow stages | no | When present, the meta-skill only surfaces this skill during those stages. Omit for "any stage". |
+| \`triggers\` | array of strings | no | Extra literal substrings that route to this skill when found in the user prompt or the active artifact. |
+| \`hardGate\` | boolean | no | When \`true\`, the body MUST include a \`## HARD-GATE\` section; the agent treats the rule as non-skippable. |
+| \`owners\` | array of strings | no | Informational only — surfaced to the user, never enforced. |
+| \`version\` | semver string | no | Bump when you change the HARD-GATE or algorithm so reviewers can spot changes. |
+
+### Body sections (markdown, recommended order)
+
+\`\`\`markdown
+# <Skill title>
+
+## Overview
+One-paragraph summary; context for when this skill is loaded.
+
+## When to use
+- Bullet list of situations where this skill adds value.
+
+## When NOT to use
+- Situations where loading this skill is context bloat or wrong.
+
+## HARD-GATE   (REQUIRED when frontmatter hardGate: true)
+Phrase it as a refusal:
+> Do not <X> while <Y>.
+
+## Algorithm / checklist
+1. Concrete, observable steps with evidence (file:line, artifact, or knowledge entry).
+
+## Output protocol
+Where the artifact / chat output lives and what shape it takes.
+
+## Anti-patterns
+- Common failure modes to reject.
+\`\`\`
+
+### Stage association semantics
+
+- \`stages: []\` or missing → skill is available at any stage. The meta-skill still only surfaces it when \`description\` or \`triggers\` match the prompt.
+- \`stages: [review]\` → skill is offered only during the review stage.
+- Custom skills **never** become mandatory delegations. They are opt-in lenses. If you need a mandatory dispatch, add a proper managed specialist under \`.cclaw/skills/\` instead.
+
+## Routing
+
+Custom skills are surfaced via the \`using-cclaw\` meta-skill at session start.
+Mention the skill name in your prompt or let the agent semantic-route to it
+based on the description + triggers + stages frontmatter.
+
+## Versioning & removal
+
+Custom skills are user-owned. Bump \`version\` when you change the HARD-GATE or
+algorithm; delete or edit them at any time — \`cclaw sync\` will not touch them.
+`;
+const CUSTOM_SKILLS_EXAMPLE = `---
+name: example-custom-skill
+description: "Replace this with a one-sentence description that triggers when the skill should be used. Delete or rename this folder when you add a real skill."
+---
+
+# Example Custom Skill
+
+This is a placeholder. Use it as a starting template, then delete or rename
+the \`example/\` folder.
+
+## When to use
+
+- A real, repeatable situation in **this** project that needs a consistent lens.
+
+## HARD-GATE (optional)
+
+Drop this section if no hard rule applies. Keep it crisp:
+
+> Do not <X> while <Y>.
+
+## Algorithm
+
+1. Step one — observable, file:line evidence required.
+2. Step two — produce a named artifact, not a vibe.
+3. Step three — escalate / hand off / record knowledge entry.
+
+## Anti-patterns
+
+- Treating this skill as advisory when the situation matches the trigger.
+- Loading this skill when the situation clearly does not match (context bloat).
+`;
 async function ensureSessionStateFiles(projectRoot) {
     const stateDir = runtimePath(projectRoot, "state");
     await ensureDir(stateDir);
@@ -623,12 +781,12 @@ async function syncDisabledHarnessArtifacts(projectRoot, harnesses) {
         await removeManagedOpenCodePluginConfig(projectRoot, OPENCODE_PLUGIN_REL_PATH);
     }
 }
-async function writeState(projectRoot, forceReset = false) {
+async function writeState(projectRoot, config, forceReset = false) {
     const statePath = runtimePath(projectRoot, "state", "flow-state.json");
     if (!forceReset && (await exists(statePath))) {
         return;
     }
-    const state = createInitialFlowState();
+    const state = createInitialFlowState("active", config.defaultTrack ?? "standard");
     await writeFileSafe(statePath, `${JSON.stringify(state, null, 2)}\n`);
 }
 async function writeAdapterManifest(projectRoot, harnesses) {
@@ -736,15 +894,16 @@ async function materializeRuntime(projectRoot, config, forceStateReset) {
     await cleanStaleFiles(projectRoot);
     await writeCommandContracts(projectRoot);
     await writeUtilityCommands(projectRoot);
-    await writeSkills(projectRoot);
+    await writeSkills(projectRoot, config);
     await writeContextModes(projectRoot);
     await writeArtifactTemplates(projectRoot);
     await writeRulebook(projectRoot);
-    await writeState(projectRoot, forceStateReset);
+    await writeState(projectRoot, config, forceStateReset);
     await ensureRunSystem(projectRoot, { createIfMissing: false });
     await ensureSessionStateFiles(projectRoot);
     await writeAdapterManifest(projectRoot, harnesses);
     await ensureKnowledgeStore(projectRoot);
+    await ensureCustomSkillsScaffold(projectRoot);
     await writeHooks(projectRoot, config);
     await syncDisabledHarnessArtifacts(projectRoot, harnesses);
     await syncManagedGitHooks(projectRoot, config);
@@ -753,7 +912,12 @@ async function materializeRuntime(projectRoot, config, forceStateReset) {
     await ensureGitignore(projectRoot);
 }
 export async function initCclaw(options) {
-    const config = createDefaultConfig(options.harnesses);
+    const config = options.profile
+        ? createProfileConfig(options.profile, {
+            harnesses: options.harnesses,
+            defaultTrack: options.track
+        })
+        : createDefaultConfig(options.harnesses, options.track);
     await writeConfig(options.projectRoot, config);
     await materializeRuntime(options.projectRoot, config, true);
 }
@@ -828,7 +992,7 @@ function stripManagedHookCommands(value) {
 }
 function isManagedRuntimeHookCommand(command) {
     const normalized = command.trim().replace(/\s+/gu, " ");
-    return /(^|\s)(?:bash\s+)?(?:\.\/)?\.cclaw\/hooks\/(?:session-start|stop-checkpoint|prompt-guard|workflow-guard|context-monitor)\.sh(?:\s|$)/u.test(normalized);
+    return /(^|\s)(?:bash\s+)?(?:\.\/)?\.cclaw\/hooks\/(?:session-start|stop-checkpoint|pre-compact|prompt-guard|workflow-guard|context-monitor)\.sh(?:\s|$)/u.test(normalized);
 }
 async function removeManagedHookEntries(hookFilePath) {
     if (!(await exists(hookFilePath)))

package/dist/policy.js

@@ -85,7 +85,8 @@ export async function policyChecks(projectRoot, options = {}) {
     // --- utility skill checks ---
     const runtimeFile = (relativePath) => `${RUNTIME_ROOT}/${relativePath}`;
     const utilitySkillChecks = [
-        { file: runtimeFile("skills/learnings/SKILL.md"), needle: "## Entry format (append-only)", name: "utility_skill:learnings:entry_format" },
+        { file: runtimeFile("skills/learnings/SKILL.md"), needle: "## Entry format", name: "utility_skill:learnings:entry_format" },
+        { file: runtimeFile("skills/learnings/SKILL.md"), needle: "knowledge.jsonl", name: "utility_skill:learnings:jsonl_mirror" },
         { file: runtimeFile("skills/learnings/SKILL.md"), needle: "## Subcommands", name: "utility_skill:learnings:subcommands" },
         { file: runtimeFile("skills/learnings/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:learnings:hard_gate" },
         { file: runtimeFile("commands/learn.md"), needle: "## Subcommands", name: "utility_command:learn:subcommands" },

package/dist/runs.d.ts

@@ -24,6 +24,13 @@ export interface ArchiveRunResult {
     featureName: string;
     resetState: FlowState;
     snapshottedStateFiles: string[];
+    /** Knowledge curation hint: total active entries + soft threshold (50). */
+    knowledge: {
+        activeEntryCount: number;
+        softThreshold: number;
+        overThreshold: boolean;
+        knowledgePath: string;
+    };
 }
 export interface ArchiveManifest {
     version: 1;
@@ -48,4 +55,12 @@ export declare function writeFlowState(projectRoot: string, state: FlowState, op
 export declare function ensureRunSystem(projectRoot: string, _options?: EnsureRunSystemOptions): Promise<FlowState>;
 export declare function listRuns(projectRoot: string): Promise<CclawRunMeta[]>;
 export declare function archiveRun(projectRoot: string, featureName?: string): Promise<ArchiveRunResult>;
+/**
+ * Counts active (non-superseded) knowledge entries.
+ * An entry is a markdown H3 heading with the canonical timestamped format produced by
+ * `learn add` / `learn curate`. Entries marked `Supersedes:` themselves are still active;
+ * this helper does not currently follow supersession chains beyond raw count, which is
+ * deliberate — the curator reads the file directly to make the soft-archive plan.
+ */
+export declare function countActiveKnowledgeEntries(text: string): number;
 export {};

package/dist/runs.js

@@ -1,7 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { COMMAND_FILE_ORDER, RUNTIME_ROOT } from "./constants.js";
-import { canTransition, createInitialFlowState } from "./flow-state.js";
+import { canTransition, createInitialFlowState, isFlowTrack, skippedStagesForTrack } from "./flow-state.js";
 import { ensureDir, exists, withDirectoryLock, writeFileSafe } from "./fs-utils.js";
 export class InvalidStageTransitionError extends Error {
     from;
@@ -156,8 +156,27 @@ function sanitizeStageGateCatalog(value, fallback) {
     }
     return next;
 }
+function coerceTrack(value) {
+    return isFlowTrack(value) ? value : "standard";
+}
+function sanitizeSkippedStages(value, track) {
+    const trackDefault = skippedStagesForTrack(track);
+    if (!Array.isArray(value)) {
+        return trackDefault;
+    }
+    const seen = new Set();
+    const out = [];
+    for (const raw of value) {
+        if (isFlowStage(raw) && !seen.has(raw)) {
+            seen.add(raw);
+            out.push(raw);
+        }
+    }
+    return out.length > 0 ? out : trackDefault;
+}
 function coerceFlowState(parsed) {
-    const next = createInitialFlowState();
+    const track = coerceTrack(parsed.track);
+    const next = createInitialFlowState("active", track);
     const activeRunIdRaw = parsed.activeRunId;
     const activeRunId = typeof activeRunIdRaw === "string" && activeRunIdRaw.trim().length > 0
         ? activeRunIdRaw.trim()
@@ -167,7 +186,9 @@ function coerceFlowState(parsed) {
         currentStage: isFlowStage(parsed.currentStage) ? parsed.currentStage : next.currentStage,
         completedStages: sanitizeCompletedStages(parsed.completedStages),
         guardEvidence: sanitizeGuardEvidence(parsed.guardEvidence),
-        stageGateCatalog: sanitizeStageGateCatalog(parsed.stageGateCatalog, next.stageGateCatalog)
+        stageGateCatalog: sanitizeStageGateCatalog(parsed.stageGateCatalog, next.stageGateCatalog),
+        track,
+        skippedStages: sanitizeSkippedStages(parsed.skippedStages, track)
     };
 }
 function toArchiveDate(date = new Date()) {
@@ -373,12 +394,46 @@ export async function archiveRun(projectRoot, featureName) {
         snapshottedStateFiles
     };
     await writeFileSafe(path.join(archivePath, "archive-manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`);
+    const knowledgeStats = await readKnowledgeStats(projectRoot);
     return {
         archiveId,
         archivePath,
         archivedAt,
         featureName: feature,
         resetState,
-        snapshottedStateFiles
+        snapshottedStateFiles,
+        knowledge: knowledgeStats
     };
 }
+const KNOWLEDGE_SOFT_THRESHOLD = 50;
+async function readKnowledgeStats(projectRoot) {
+    const knowledgePath = path.join(projectRoot, RUNTIME_ROOT, "knowledge.md");
+    let activeEntryCount = 0;
+    if (await exists(knowledgePath)) {
+        const text = await fs.readFile(knowledgePath, "utf8");
+        activeEntryCount = countActiveKnowledgeEntries(text);
+    }
+    return {
+        activeEntryCount,
+        softThreshold: KNOWLEDGE_SOFT_THRESHOLD,
+        overThreshold: activeEntryCount > KNOWLEDGE_SOFT_THRESHOLD,
+        knowledgePath: `${RUNTIME_ROOT}/knowledge.md`
+    };
+}
+/**
+ * Counts active (non-superseded) knowledge entries.
+ * An entry is a markdown H3 heading with the canonical timestamped format produced by
+ * `learn add` / `learn curate`. Entries marked `Supersedes:` themselves are still active;
+ * this helper does not currently follow supersession chains beyond raw count, which is
+ * deliberate — the curator reads the file directly to make the soft-archive plan.
+ */
+export function countActiveKnowledgeEntries(text) {
+    const lines = text.split(/\r?\n/);
+    let count = 0;
+    for (const line of lines) {
+        if (/^###\s+\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z\s+\[(rule|pattern|lesson|compound)\]/u.test(line)) {
+            count += 1;
+        }
+    }
+    return count;
+}