cclaw-cli 0.11.0 → 0.13.0

package/README.md

@@ -41,7 +41,7 @@ sequenceDiagram
 - **Low cognitive load:** one canonical stage flow instead of dozens of competing paths.
 - **Installer-first architecture:** generates files and hooks; does not run a hidden control plane.
 - **Hard-gated quality:** each stage has non-skippable constraints that reduce AI drift.
-- **Cross-harness parity:** same behavior model across Claude Code, Cursor, Codex, OpenCode.
+- **Tiered harness coverage:** transparent capability tiers across Claude Code, Cursor, Codex, OpenCode.
 - **Compounding context:** flow state + project knowledge get rehydrated on new sessions automatically.
 - **Incremental delivery:** active artifacts stay in one place; `cclaw archive` snapshots completed features into dated run folders.
 
@@ -114,16 +114,17 @@ Required repository secret:
 ├── commands/
 ├── hooks/
 ├── templates/
+├── references/
 ├── artifacts/                # active feature artifacts
 ├── state/
-├── knowledge.md              # append-only rule/pattern/lesson log
+├── knowledge.jsonl           # append-only strict-schema rule/pattern/lesson log
 └── runs/                     # archived feature snapshots (YYYY-MM-DD-feature-name)
 ```
 
 ## Harness Integration
 
 Supported harnesses: `claude`, `cursor`, `opencode`, `codex`. The full
-per-harness install surface, feature matrix, and lifecycle details live in
+per-harness tier/capability matrix, install surface, and lifecycle details live in
 [docs/harnesses.md](./docs/harnesses.md).
 
 ## License

package/dist/cli.d.ts

@@ -6,8 +6,16 @@ interface ParsedArgs {
     harnesses?: HarnessId[];
     track?: FlowTrack;
     profile?: InitProfile;
+    dryRun?: boolean;
+    interactive?: boolean;
     reconcileGates?: boolean;
+    doctorJson?: boolean;
+    doctorExplain?: boolean;
+    doctorQuiet?: boolean;
+    doctorOnly?: string[];
     archiveName?: string;
+    archiveSkipRetro?: boolean;
+    archiveSkipRetroReason?: string;
     showHelp?: boolean;
     showVersion?: boolean;
 }

package/dist/cli.js

@@ -2,6 +2,7 @@
 import { readFileSync, realpathSync } from "node:fs";
 import process from "node:process";
 import path from "node:path";
+import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
 import { FLOW_TRACKS, HARNESS_IDS, INIT_PROFILES } from "./types.js";
 import { doctorChecks, doctorSucceeded } from "./doctor.js";
@@ -9,6 +10,9 @@ import { initCclaw, syncCclaw, uninstallCclaw, upgradeCclaw } from "./install.js
 import { error, info } from "./logger.js";
 import { archiveRun } from "./runs.js";
 import { RUNTIME_ROOT } from "./constants.js";
+import { createDefaultConfig, createProfileConfig } from "./config.js";
+import { detectHarnesses } from "./init-detect.js";
+import { HARNESS_ADAPTERS } from "./harness-adapters.js";
 const INSTALLER_COMMANDS = ["init", "sync", "doctor", "upgrade", "uninstall", "archive"];
 export function usage() {
     return `cclaw - installer-first flow toolkit
@@ -22,12 +26,21 @@ Commands:
   init       Bootstrap .cclaw runtime, state, and harness shims in this project.
              Flags: --profile=<id>      Pre-fill defaults. One of: minimal | standard | full. Default: standard.
                     --harnesses=<list>  Comma list of harnesses (claude,cursor,opencode,codex). Overrides the profile default.
-                    --track=<id>        Flow track for new runs (standard | quick). Overrides the profile default.
+                    --track=<id>        Flow track for new runs (standard | medium | quick). Overrides the profile default.
+                    --interactive       Force interactive prompts (TTY only).
+                    --no-interactive    Skip interactive prompts even on TTY.
+                    --dry-run           Print resolved config + generated surfaces without writing files.
   sync       Regenerate harness shim files from the current .cclaw config (non-destructive).
-  doctor     Run health checks against the local .cclaw runtime. Exit code 2 on failure.
+  doctor     Run health checks against the local .cclaw runtime. Exit code 2 when any error-severity check fails.
              Flags: --reconcile-gates   Recompute current-stage gate evidence before checks.
+                    --json              Emit machine-readable JSON output.
+                    --only=<filter>     Comma list of severities/check-name filters (error,warning,info,trace:,hook:...).
+                    --explain           Include fix + doc reference per check in text mode.
+                    --quiet             Print only failing checks (and totals).
   archive    Move .cclaw/artifacts into .cclaw/runs/<date>-<slug> and reset flow state.
              Flags: --name=<feature>    Feature slug (default: inferred from 00-idea.md).
+                    --skip-retro       Bypass mandatory retro gate (requires --retro-reason).
+                    --retro-reason=<t> Reason for bypassing retro gate.
   upgrade    Refresh generated files in .cclaw without modifying user artifacts.
   uninstall  Remove .cclaw runtime and the generated harness shim files.
 
@@ -94,6 +107,208 @@ function parseProfile(raw) {
     }
     return trimmed;
 }
+function isInitPromptAllowed(ctx) {
+    return Boolean(process.stdin.isTTY && ctx.stdout.isTTY);
+}
+function buildInitSurfacePreview(harnesses) {
+    const lines = [
+        ".cclaw/config.yaml",
+        ".cclaw/commands/*.md",
+        ".cclaw/skills/*/SKILL.md",
+        ".cclaw/state/*.json|*.jsonl",
+        ".cclaw/references/**",
+        "AGENTS.md (managed block)"
+    ];
+    for (const harness of harnesses) {
+        const adapter = HARNESS_ADAPTERS[harness];
+        lines.push(`${adapter.commandDir}/cc*.md`);
+        if (harness === "claude") {
+            lines.push(".claude/hooks/hooks.json");
+        }
+        if (harness === "cursor") {
+            lines.push(".cursor/hooks.json");
+            lines.push(".cursor/rules/cclaw-workflow.mdc");
+        }
+        if (harness === "codex") {
+            lines.push(".codex/hooks.json");
+        }
+        if (harness === "opencode") {
+            lines.push(".opencode/plugins/cclaw-plugin.mjs");
+            lines.push("opencode.json(.c) plugin registration");
+        }
+    }
+    return lines;
+}
+function inferTrackDefault(profile, track) {
+    if (track)
+        return track;
+    if (!profile)
+        return "standard";
+    return createProfileConfig(profile).defaultTrack ?? "standard";
+}
+async function promptInitConfig(defaults, ctx) {
+    const rl = createInterface({
+        input: process.stdin,
+        output: ctx.stdout
+    });
+    const pickSingle = async (label, options, fallback) => {
+        while (true) {
+            ctx.stdout.write(`\n${label}\n`);
+            options.forEach((option, index) => {
+                const marker = option === fallback ? " (default)" : "";
+                ctx.stdout.write(`  ${index + 1}) ${option}${marker}\n`);
+            });
+            const answer = (await rl.question("> ")).trim();
+            if (answer.length === 0) {
+                return fallback;
+            }
+            const numeric = Number(answer);
+            if (Number.isInteger(numeric) && numeric >= 1 && numeric <= options.length) {
+                return options[numeric - 1];
+            }
+            if (options.includes(answer)) {
+                return answer;
+            }
+            ctx.stdout.write("Invalid selection. Use option number or value.\n");
+        }
+    };
+    const pickHarnesses = async (fallback) => {
+        const fallbackText = fallback.join(",");
+        while (true) {
+            const answer = (await rl.question(`\nHarnesses (comma list from ${HARNESS_IDS.join(", ")}) [${fallbackText}]: `)).trim();
+            if (answer.length === 0) {
+                return fallback;
+            }
+            try {
+                const parsed = parseHarnesses(answer);
+                if (parsed.length === 0) {
+                    ctx.stdout.write("Select at least one harness.\n");
+                    continue;
+                }
+                return parsed;
+            }
+            catch (err) {
+                ctx.stdout.write(`${err instanceof Error ? err.message : "Invalid harness list"}\n`);
+            }
+        }
+    };
+    try {
+        const profile = await pickSingle("Select init profile:", INIT_PROFILES, defaults.profile);
+        const trackDefault = inferTrackDefault(profile, defaults.track);
+        const track = await pickSingle("Select default flow track:", FLOW_TRACKS, trackDefault);
+        const harnesses = await pickHarnesses(defaults.harnesses);
+        return { profile, track, harnesses };
+    }
+    finally {
+        rl.close();
+    }
+}
+async function resolveInitInputs(parsed, ctx) {
+    const detectedHarnesses = parsed.harnesses ? [] : await detectHarnesses(ctx.cwd);
+    const autoHarnesses = parsed.harnesses
+        ? parsed.harnesses
+        : (detectedHarnesses.length > 0 ? detectedHarnesses : undefined);
+    const promptRequested = parsed.interactive === true;
+    const promptForbidden = parsed.interactive === false;
+    const implicitPrompt = !promptForbidden &&
+        isInitPromptAllowed(ctx) &&
+        parsed.profile === undefined &&
+        parsed.track === undefined &&
+        parsed.harnesses === undefined;
+    const shouldPrompt = promptRequested || implicitPrompt;
+    if (!shouldPrompt) {
+        return {
+            profile: parsed.profile,
+            track: parsed.track,
+            harnesses: autoHarnesses,
+            detectedHarnesses
+        };
+    }
+    if (!isInitPromptAllowed(ctx)) {
+        throw new Error("Interactive init requires a TTY. Remove --interactive or run in a terminal.");
+    }
+    const defaults = {
+        profile: parsed.profile ?? "standard",
+        track: inferTrackDefault(parsed.profile, parsed.track),
+        harnesses: autoHarnesses ?? HARNESS_IDS.slice()
+    };
+    const prompted = await promptInitConfig(defaults, ctx);
+    return {
+        profile: prompted.profile,
+        track: prompted.track,
+        harnesses: prompted.harnesses,
+        detectedHarnesses
+    };
+}
+function parseDoctorOnly(raw) {
+    return raw
+        .split(",")
+        .map((item) => item.trim().toLowerCase())
+        .filter((item) => item.length > 0);
+}
+function filterDoctorChecks(checks, filters) {
+    if (!filters || filters.length === 0) {
+        return checks;
+    }
+    return checks.filter((check) => {
+        const name = check.name.toLowerCase();
+        return filters.some((filter) => {
+            if (filter === "error" || filter === "warning" || filter === "info") {
+                return check.severity === filter;
+            }
+            return name.includes(filter);
+        });
+    });
+}
+function doctorCountsBySeverity(checks) {
+    const result = {
+        error: { total: 0, failing: 0 },
+        warning: { total: 0, failing: 0 },
+        info: { total: 0, failing: 0 }
+    };
+    for (const check of checks) {
+        const bucket = result[check.severity];
+        bucket.total += 1;
+        if (!check.ok) {
+            bucket.failing += 1;
+        }
+    }
+    return result;
+}
+function printDoctorText(ctx, checks, options) {
+    const orderedSeverities = ["error", "warning", "info"];
+    const view = options.quiet ? checks.filter((check) => !check.ok) : checks;
+    for (const severity of orderedSeverities) {
+        const inBucket = view.filter((check) => check.severity === severity);
+        if (inBucket.length === 0)
+            continue;
+        ctx.stdout.write(`\n[${severity.toUpperCase()}]\n`);
+        for (const check of inBucket) {
+            const status = check.ok ? "PASS" : "FAIL";
+            ctx.stdout.write(`${status} ${check.name} :: ${check.summary}\n`);
+            if (!options.quiet) {
+                ctx.stdout.write(`  details: ${check.details}\n`);
+            }
+            if (options.explain) {
+                ctx.stdout.write(`  fix: ${check.fix}\n`);
+                if (check.docRef) {
+                    ctx.stdout.write(`  docs: ${check.docRef}\n`);
+                }
+            }
+        }
+    }
+    const counts = doctorCountsBySeverity(checks);
+    const failingErrors = checks.filter((check) => check.severity === "error" && !check.ok).length;
+    ctx.stdout.write(`\nTotals: error ${counts.error.failing}/${counts.error.total} failing, ` +
+        `warning ${counts.warning.failing}/${counts.warning.total} failing, ` +
+        `info ${counts.info.failing}/${counts.info.total} failing\n`);
+    if (failingErrors > 0) {
+        ctx.stdout.write(`Doctor status: BLOCKED (${failingErrors} failing error checks)\n`);
+    }
+    else {
+        ctx.stdout.write("Doctor status: HEALTHY (no failing error checks)\n");
+    }
+}
 function parseArgs(argv) {
     const parsed = {};
     const helpFlag = argv.find((arg) => arg === "--help" || arg === "-h");
@@ -121,12 +336,48 @@ function parseArgs(argv) {
             parsed.profile = parseProfile(flag.replace("--profile=", ""));
             continue;
         }
+        if (flag === "--interactive") {
+            parsed.interactive = true;
+            continue;
+        }
+        if (flag === "--no-interactive") {
+            parsed.interactive = false;
+            continue;
+        }
+        if (flag === "--dry-run") {
+            parsed.dryRun = true;
+            continue;
+        }
         if (flag === "--reconcile-gates") {
             parsed.reconcileGates = true;
             continue;
         }
+        if (flag === "--json") {
+            parsed.doctorJson = true;
+            continue;
+        }
+        if (flag === "--explain") {
+            parsed.doctorExplain = true;
+            continue;
+        }
+        if (flag === "--quiet") {
+            parsed.doctorQuiet = true;
+            continue;
+        }
+        if (flag.startsWith("--only=")) {
+            parsed.doctorOnly = parseDoctorOnly(flag.replace("--only=", ""));
+            continue;
+        }
         if (flag.startsWith("--name=")) {
             parsed.archiveName = flag.replace("--name=", "").trim();
+            continue;
+        }
+        if (flag === "--skip-retro") {
+            parsed.archiveSkipRetro = true;
+            continue;
+        }
+        if (flag.startsWith("--retro-reason=")) {
+            parsed.archiveSkipRetroReason = flag.replace("--retro-reason=", "").trim();
         }
     }
     return parsed;
@@ -146,14 +397,44 @@ async function runCommand(parsed, ctx) {
         return 1;
     }
     if (command === "init") {
+        const resolved = await resolveInitInputs(parsed, ctx);
+        const effectiveProfile = resolved.profile;
+        const effectiveTrack = resolved.track;
+        const effectiveHarnesses = resolved.harnesses;
+        if (parsed.dryRun === true) {
+            const previewConfig = effectiveProfile
+                ? createProfileConfig(effectiveProfile, {
+                    harnesses: effectiveHarnesses,
+                    defaultTrack: effectiveTrack
+                })
+                : createDefaultConfig(effectiveHarnesses, effectiveTrack);
+            const previewSurfaces = buildInitSurfacePreview(previewConfig.harnesses);
+            info(ctx, "Dry run: no files were written.");
+            if (resolved.detectedHarnesses.length > 0 && parsed.harnesses === undefined) {
+                info(ctx, `Detected harnesses from repo: ${resolved.detectedHarnesses.join(", ")}`);
+            }
+            ctx.stdout.write(`${JSON.stringify({
+                profile: effectiveProfile ?? "standard(default)",
+                track: previewConfig.defaultTrack ?? "standard",
+                harnesses: previewConfig.harnesses,
+                promptGuardMode: previewConfig.promptGuardMode,
+                gitHookGuards: previewConfig.gitHookGuards,
+                languageRulePacks: previewConfig.languageRulePacks,
+                generatedSurfaces: previewSurfaces
+            }, null, 2)}\n`);
+            return 0;
+        }
         await initCclaw({
             projectRoot: ctx.cwd,
-            harnesses: parsed.harnesses,
-            track: parsed.track,
-            profile: parsed.profile
+            harnesses: effectiveHarnesses,
+            track: effectiveTrack,
+            profile: effectiveProfile
         });
-        const profileNote = parsed.profile ? ` profile=${parsed.profile}` : "";
-        const trackNote = parsed.track ? ` track=${parsed.track}` : "";
+        if (resolved.detectedHarnesses.length > 0 && parsed.harnesses === undefined) {
+            info(ctx, `Detected harnesses from repo: ${resolved.detectedHarnesses.join(", ")}`);
+        }
+        const profileNote = effectiveProfile ? ` profile=${effectiveProfile}` : "";
+        const trackNote = effectiveTrack ? ` track=${effectiveTrack}` : "";
         const suffix = profileNote || trackNote ? ` (${(profileNote + trackNote).trim()})` : "";
         info(ctx, `Initialized .cclaw runtime and generated harness shims${suffix}`);
         return 0;
@@ -167,8 +448,25 @@ async function runCommand(parsed, ctx) {
         const checks = await doctorChecks(ctx.cwd, {
             reconcileCurrentStageGates: parsed.reconcileGates === true
         });
-        for (const check of checks) {
-            ctx.stdout.write(`${check.ok ? "PASS" : "FAIL"} ${check.name} :: ${check.details}\n`);
+        const filteredChecks = filterDoctorChecks(checks, parsed.doctorOnly);
+        const explain = parsed.doctorExplain === true;
+        const quiet = parsed.doctorQuiet === true;
+        if (parsed.doctorJson === true) {
+            const counts = doctorCountsBySeverity(filteredChecks);
+            ctx.stdout.write(`${JSON.stringify({
+                ok: doctorSucceeded(checks),
+                filters: parsed.doctorOnly ?? [],
+                counts,
+                checks: filteredChecks
+            }, null, 2)}\n`);
+        }
+        else {
+            if (filteredChecks.length === 0) {
+                ctx.stdout.write("No checks matched the --only filter.\n");
+            }
+            else {
+                printDoctorText(ctx, filteredChecks, { explain, quiet });
+            }
         }
         return doctorSucceeded(checks) ? 0 : 2;
     }
@@ -178,7 +476,10 @@ async function runCommand(parsed, ctx) {
         return 0;
     }
     if (command === "archive") {
-        const archived = await archiveRun(ctx.cwd, parsed.archiveName);
+        const archived = await archiveRun(ctx.cwd, parsed.archiveName, {
+            skipRetro: parsed.archiveSkipRetro === true,
+            skipRetroReason: parsed.archiveSkipRetroReason
+        });
         const snapshotSummary = archived.snapshottedStateFiles.length > 0
             ? ` Snapshotted ${archived.snapshottedStateFiles.length} state file(s) under ${archived.archivePath}/state and wrote archive-manifest.json.`
             : "";

package/dist/config.js

@@ -17,6 +17,8 @@ const ALLOWED_CONFIG_KEYS = new Set([
     "harnesses",
     "autoAdvance",
     "promptGuardMode",
+    "tddEnforcement",
+    "tddTestGlobs",
     "gitHookGuards",
     "defaultTrack",
     "languageRulePacks",
@@ -60,6 +62,8 @@ export function createDefaultConfig(harnesses = DEFAULT_HARNESSES, defaultTrack
         harnesses,
         autoAdvance: false,
         promptGuardMode: "advisory",
+        tddEnforcement: "advisory",
+        tddTestGlobs: ["**/*.test.*", "**/*.spec.*", "**/test/**"],
         gitHookGuards: false,
         defaultTrack,
         languageRulePacks: []
@@ -79,6 +83,7 @@ export function createProfileConfig(profile, overrides = {}) {
                 harnesses: overrides.harnesses ?? ["claude"],
                 autoAdvance: false,
                 promptGuardMode: "advisory",
+                tddEnforcement: "advisory",
                 gitHookGuards: false,
                 defaultTrack: overrides.defaultTrack ?? "medium",
                 languageRulePacks: overrides.languageRulePacks ?? []
@@ -89,6 +94,7 @@ export function createProfileConfig(profile, overrides = {}) {
                 harnesses: overrides.harnesses ?? DEFAULT_HARNESSES,
                 autoAdvance: false,
                 promptGuardMode: "advisory",
+                tddEnforcement: "advisory",
                 gitHookGuards: false,
                 defaultTrack: overrides.defaultTrack ?? "standard",
                 languageRulePacks: overrides.languageRulePacks ?? []
@@ -99,6 +105,7 @@ export function createProfileConfig(profile, overrides = {}) {
                 harnesses: overrides.harnesses ?? DEFAULT_HARNESSES,
                 autoAdvance: false,
                 promptGuardMode: "strict",
+                tddEnforcement: "strict",
                 gitHookGuards: true,
                 defaultTrack: overrides.defaultTrack ?? "standard",
                 languageRulePacks: overrides.languageRulePacks ?? [...LANGUAGE_RULE_PACKS]
@@ -149,6 +156,16 @@ export async function readConfig(projectRoot) {
         throw configValidationError(fullPath, `"promptGuardMode" must be "advisory" or "strict"`);
     }
     const promptGuardMode = promptGuardModeRaw === "strict" ? "strict" : "advisory";
+    const tddEnforcementRaw = parsed.tddEnforcement;
+    if (Object.prototype.hasOwnProperty.call(parsed, "tddEnforcement") &&
+        tddEnforcementRaw !== "advisory" &&
+        tddEnforcementRaw !== "strict") {
+        throw configValidationError(fullPath, `"tddEnforcement" must be "advisory" or "strict"`);
+    }
+    const tddEnforcement = tddEnforcementRaw === "strict" ? "strict" : "advisory";
+    const tddTestGlobsRaw = parsed.tddTestGlobs;
+    const tddTestGlobs = validateStringArray(tddTestGlobsRaw, "tddTestGlobs", fullPath)
+        ?? ["**/*.test.*", "**/*.spec.*", "**/test/**"];
     const gitHookGuardsRaw = parsed.gitHookGuards;
     if (Object.prototype.hasOwnProperty.call(parsed, "gitHookGuards") &&
         typeof gitHookGuardsRaw !== "boolean") {
@@ -246,6 +263,8 @@ export async function readConfig(projectRoot) {
         harnesses,
         autoAdvance,
         promptGuardMode,
+        tddEnforcement,
+        tddTestGlobs,
         gitHookGuards,
         defaultTrack,
         languageRulePacks,

package/dist/constants.d.ts

@@ -4,9 +4,9 @@ export declare const RUNTIME_ROOT = ".cclaw";
 export declare const CCLAW_VERSION = "0.1.1";
 export declare const FLOW_VERSION = "1.0.0";
 export declare const DEFAULT_HARNESSES: HarnessId[];
-export declare const REQUIRED_DIRS: readonly [".cclaw", ".cclaw/commands", ".cclaw/skills", ".cclaw/contexts", ".cclaw/templates", ".cclaw/artifacts", ".cclaw/state", ".cclaw/runs", ".cclaw/rules", ".cclaw/adapters", ".cclaw/agents", ".cclaw/hooks", ".cclaw/custom-skills"];
+export declare const REQUIRED_DIRS: readonly [".cclaw", ".cclaw/commands", ".cclaw/skills", ".cclaw/contexts", ".cclaw/templates", ".cclaw/artifacts", ".cclaw/features", ".cclaw/state", ".cclaw/runs", ".cclaw/rules", ".cclaw/adapters", ".cclaw/agents", ".cclaw/hooks", ".cclaw/custom-skills"];
 export declare const REQUIRED_GITIGNORE_PATTERNS: readonly ["# cclaw generated artifacts", ".cclaw/", ".claude/commands/cc-*.md", ".claude/commands/cc.md", ".cursor/commands/cc-*.md", ".cursor/commands/cc.md", ".opencode/commands/cc-*.md", ".opencode/commands/cc.md", ".codex/commands/cc-*.md", ".codex/commands/cc.md", ".claude/hooks/hooks.json", ".cursor/hooks.json", ".codex/hooks.json", ".opencode/plugins/cclaw-plugin.mjs", ".cursor/rules/cclaw-workflow.mdc"];
 export declare const COMMAND_FILE_ORDER: FlowStage[];
-export declare const UTILITY_COMMANDS: readonly ["learn", "next", "status"];
+export declare const UTILITY_COMMANDS: readonly ["learn", "next", "status", "tree", "diff", "feature", "tdd-log", "retro", "rewind", "rewind-ack"];
 export declare const SUBAGENT_SKILL_FOLDERS: readonly ["subagent-dev", "parallel-dispatch"];
 export type UtilityCommand = (typeof UTILITY_COMMANDS)[number];

package/dist/constants.js

@@ -15,6 +15,7 @@ export const REQUIRED_DIRS = [
     `${RUNTIME_ROOT}/contexts`,
     `${RUNTIME_ROOT}/templates`,
     `${RUNTIME_ROOT}/artifacts`,
+    `${RUNTIME_ROOT}/features`,
     `${RUNTIME_ROOT}/state`,
     `${RUNTIME_ROOT}/runs`,
     `${RUNTIME_ROOT}/rules`,
@@ -50,7 +51,18 @@ export const COMMAND_FILE_ORDER = [
     "review",
     "ship"
 ];
-export const UTILITY_COMMANDS = ["learn", "next", "status"];
+export const UTILITY_COMMANDS = [
+    "learn",
+    "next",
+    "status",
+    "tree",
+    "diff",
+    "feature",
+    "tdd-log",
+    "retro",
+    "rewind",
+    "rewind-ack"
+];
 export const SUBAGENT_SKILL_FOLDERS = [
     "subagent-dev",
     "parallel-dispatch"

package/dist/content/core-agents.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Agent persona content for cclaw.
+ *
+ * cclaw materializes markdown agent definitions (`.md` with YAML frontmatter)
+ * under `.cclaw/agents/` for harness delegation. Research work that does not
+ * need isolated subagent context lives in `.cclaw/skills/research/*.md`
+ * playbooks and is executed in-thread by the primary agent.
+ */
+export interface AgentDefinition {
+    /** Kebab-case identifier, e.g. `"reviewer"`. */
+    name: string;
+    /** When to invoke — include PROACTIVE / MUST BE USED guidance. */
+    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 roster (core-5) materialized 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 for the core-5 agent roster.
+ */
+export declare function agentCostTierTable(): string;
+/**
+ * AGENTS.md-ready section describing cclaw’s specialist delegation model.
+ */
+export declare function agentsAgentsMdBlock(): string;