cclaw-cli 0.11.0 → 0.12.0

package/dist/doctor.js

@@ -4,7 +4,7 @@ import { execFile } from "node:child_process";
 import { pathToFileURL } from "node:url";
 import { promisify } from "node:util";
 import { COMMAND_FILE_ORDER, REQUIRED_DIRS, RUNTIME_ROOT } from "./constants.js";
-import { CCLAW_AGENTS } from "./content/agents.js";
+import { CCLAW_AGENTS } from "./content/core-agents.js";
 import { readConfig } from "./config.js";
 import { exists } from "./fs-utils.js";
 import { gitignoreHasRequiredPatterns } from "./gitignore.js";
@@ -17,10 +17,13 @@ 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 { doctorCheckMetadata } from "./doctor-registry.js";
 import { LANGUAGE_RULE_PACK_DIR, LANGUAGE_RULE_PACK_FILES, LEGACY_LANGUAGE_RULE_PACK_FOLDERS, UTILITY_SKILL_FOLDERS } from "./content/utility-skills.js";
 import { CONTEXT_MODES, DEFAULT_CONTEXT_MODE } from "./content/contexts.js";
+import { DOCTOR_REFERENCE_MARKDOWN } from "./content/doctor-references.js";
 import { validateHookDocument } from "./hook-schema.js";
 const execFileAsync = promisify(execFile);
+const PREAMBLE_COOLDOWN_MS = 15 * 60 * 1000;
 async function isGitRepo(projectRoot) {
     try {
         await execFileAsync("git", ["rev-parse", "--is-inside-work-tree"], { cwd: projectRoot });
@@ -345,6 +348,20 @@ export async function doctorChecks(projectRoot, options = {}) {
             details: refPath
         });
     }
+    checks.push({
+        name: "harness_ref:matrix",
+        ok: await exists(path.join(projectRoot, RUNTIME_ROOT, "references", "harnesses.md")),
+        details: `${RUNTIME_ROOT}/references/harnesses.md`
+    });
+    const doctorRefDir = path.join(projectRoot, RUNTIME_ROOT, "references", "doctor");
+    for (const fileName of Object.keys(DOCTOR_REFERENCE_MARKDOWN)) {
+        const refPath = path.join(doctorRefDir, fileName);
+        checks.push({
+            name: `doctor_ref:${fileName.replace(/\.md$/, "")}`,
+            ok: await exists(refPath),
+            details: refPath
+        });
+    }
     checks.push({
         name: "gitignore:required_patterns",
         ok: await gitignoreHasRequiredPatterns(projectRoot),
@@ -810,6 +827,11 @@ export async function doctorChecks(projectRoot, options = {}) {
         ok: await exists(path.join(projectRoot, RUNTIME_ROOT, "state", "suggestion-memory.json")),
         details: `${RUNTIME_ROOT}/state/suggestion-memory.json must exist for proactive suggestion memory`
     });
+    checks.push({
+        name: "state:harness_gaps_exists",
+        ok: await exists(path.join(projectRoot, RUNTIME_ROOT, "state", "harness-gaps.json")),
+        details: `${RUNTIME_ROOT}/state/harness-gaps.json must exist for tiered harness capability tracking`
+    });
     const contextModeStatePath = path.join(projectRoot, RUNTIME_ROOT, "state", "context-mode.json");
     checks.push({
         name: "state:context_mode_exists",
@@ -840,6 +862,81 @@ export async function doctorChecks(projectRoot, options = {}) {
             details: modePath
         });
     }
+    const preambleLogPath = path.join(projectRoot, RUNTIME_ROOT, "state", "preamble-log.jsonl");
+    const preambleLogExists = await exists(preambleLogPath);
+    checks.push({
+        name: "state:preamble_log_exists",
+        ok: preambleLogExists,
+        details: `${RUNTIME_ROOT}/state/preamble-log.jsonl must exist for preamble budget tracking`
+    });
+    if (preambleLogExists) {
+        let duplicateHits = 0;
+        let parsedEntries = 0;
+        let malformedEntries = 0;
+        try {
+            const now = Date.now();
+            const byKey = new Map();
+            const raw = await fs.readFile(preambleLogPath, "utf8");
+            const lines = raw
+                .split("\n")
+                .map((line) => line.trim())
+                .filter((line) => line.length > 0);
+            for (const line of lines) {
+                try {
+                    const parsed = JSON.parse(line);
+                    const tsRaw = parsed.ts;
+                    const stageRaw = parsed.stage;
+                    const triggerRaw = parsed.trigger;
+                    const hashRaw = parsed.hash;
+                    if (typeof tsRaw !== "string" ||
+                        typeof stageRaw !== "string" ||
+                        typeof triggerRaw !== "string" ||
+                        typeof hashRaw !== "string") {
+                        malformedEntries += 1;
+                        continue;
+                    }
+                    const stamp = Date.parse(tsRaw);
+                    if (!Number.isFinite(stamp)) {
+                        malformedEntries += 1;
+                        continue;
+                    }
+                    if (now - stamp > 24 * 60 * 60 * 1000) {
+                        continue;
+                    }
+                    parsedEntries += 1;
+                    const key = `${stageRaw}|${triggerRaw}|${hashRaw}`;
+                    const bucket = byKey.get(key) ?? [];
+                    bucket.push(stamp);
+                    byKey.set(key, bucket);
+                }
+                catch {
+                    malformedEntries += 1;
+                }
+            }
+            for (const stamps of byKey.values()) {
+                stamps.sort((a, b) => a - b);
+                for (let i = 1; i < stamps.length; i += 1) {
+                    if (stamps[i] - stamps[i - 1] < PREAMBLE_COOLDOWN_MS) {
+                        duplicateHits += 1;
+                    }
+                }
+            }
+        }
+        catch {
+            malformedEntries += 1;
+        }
+        checks.push({
+            name: "warning:preamble:dedup",
+            ok: true,
+            details: duplicateHits > 0
+                ? `warning: detected ${duplicateHits} repeated preamble emission(s) inside ${Math.floor(PREAMBLE_COOLDOWN_MS / 60000)}m cooldown window`
+                : parsedEntries > 0
+                    ? `preamble budget healthy (${parsedEntries} recent preamble entry/entries checked)`
+                    : malformedEntries > 0
+                        ? `warning: preamble log exists but entries are malformed (${malformedEntries} line(s) ignored)`
+                        : "preamble log is empty; no recent preamble emissions recorded"
+        });
+    }
     let flowState = await readFlowState(projectRoot);
     if (options.reconcileCurrentStageGates === true) {
         const reconciliation = await reconcileAndWriteCurrentStageGateCatalog(projectRoot);
@@ -911,7 +1008,9 @@ export async function doctorChecks(projectRoot, options = {}) {
         name: "warning:delegation:waived",
         ok: true,
         details: delegation.waived.length > 0
-            ? `warning: waived mandatory delegations for stage "${flowState.currentStage}": ${delegation.waived.join(", ")}`
+            ? `warning: waived mandatory delegations for stage "${flowState.currentStage}": ${delegation.waived.join(", ")}${delegation.autoWaived.length > 0
+                ? ` (auto-waived due to harness limitation: ${delegation.autoWaived.join(", ")})`
+                : ""}`
             : "no waived mandatory delegations for current stage"
     });
     checks.push({
@@ -1025,8 +1124,17 @@ export async function doctorChecks(projectRoot, options = {}) {
     });
     const policy = await policyChecks(projectRoot, { harnesses: configuredHarnesses });
     checks.push(...policy);
-    return checks;
+    return checks.map((check) => {
+        const metadata = doctorCheckMetadata(check.name);
+        return {
+            ...check,
+            severity: check.severity ?? metadata.severity,
+            summary: check.summary ?? metadata.summary,
+            fix: check.fix ?? metadata.fix,
+            docRef: check.docRef ?? metadata.docRef
+        };
+    });
 }
 export function doctorSucceeded(checks) {
-    return checks.every((check) => check.ok);
+    return checks.every((check) => check.ok || check.severity !== "error");
 }

package/dist/harness-adapters.d.ts

@@ -4,8 +4,15 @@ export declare const CCLAW_MARKER_END = "<!-- cclaw-end -->";
 export interface HarnessAdapter {
     id: HarnessId;
     commandDir: string;
+    capabilities: {
+        nativeSubagentDispatch: "full" | "partial" | "none";
+        hookSurface: "full" | "plugin" | "limited" | "none";
+        structuredAsk: "AskUserQuestion" | "AskQuestion" | "plain-text";
+    };
 }
 export declare const HARNESS_ADAPTERS: Record<HarnessId, HarnessAdapter>;
+export type HarnessTier = "tier1" | "tier2" | "tier3";
+export declare function harnessTier(harnessId: HarnessId): HarnessTier;
 /** Removes the cclaw AGENTS.md block. */
 export declare function stripCclawBlock(content: string): string;
 export declare function removeCclawFromAgentsMd(projectRoot: string): Promise<void>;

package/dist/harness-adapters.js

@@ -1,7 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { RUNTIME_ROOT } from "./constants.js";
-import { CCLAW_AGENTS, agentMarkdown } from "./content/agents.js";
+import { CCLAW_AGENTS, agentMarkdown } from "./content/core-agents.js";
 import { ensureDir, exists, writeFileSafe } from "./fs-utils.js";
 export const CCLAW_MARKER_START = "<!-- cclaw-start -->";
 export const CCLAW_MARKER_END = "<!-- cclaw-end -->";
@@ -12,11 +12,57 @@ const RUNTIME_AGENTS_BLOCK_SOURCE = `${escapeRegExp(CCLAW_MARKER_START)}[\\s\\S]
 const RUNTIME_AGENTS_BLOCK_PATTERN = new RegExp(RUNTIME_AGENTS_BLOCK_SOURCE, "u");
 const RUNTIME_AGENTS_BLOCK_GLOBAL_PATTERN = new RegExp(RUNTIME_AGENTS_BLOCK_SOURCE, "gu");
 export const HARNESS_ADAPTERS = {
-    claude: { id: "claude", commandDir: ".claude/commands" },
-    cursor: { id: "cursor", commandDir: ".cursor/commands" },
-    opencode: { id: "opencode", commandDir: ".opencode/commands" },
-    codex: { id: "codex", commandDir: ".codex/commands" }
+    claude: {
+        id: "claude",
+        commandDir: ".claude/commands",
+        capabilities: {
+            nativeSubagentDispatch: "full",
+            hookSurface: "full",
+            structuredAsk: "AskUserQuestion"
+        }
+    },
+    cursor: {
+        id: "cursor",
+        commandDir: ".cursor/commands",
+        capabilities: {
+            nativeSubagentDispatch: "partial",
+            hookSurface: "full",
+            structuredAsk: "AskQuestion"
+        }
+    },
+    opencode: {
+        id: "opencode",
+        commandDir: ".opencode/commands",
+        capabilities: {
+            nativeSubagentDispatch: "partial",
+            hookSurface: "plugin",
+            structuredAsk: "plain-text"
+        }
+    },
+    codex: {
+        id: "codex",
+        commandDir: ".codex/commands",
+        capabilities: {
+            nativeSubagentDispatch: "none",
+            hookSurface: "full",
+            structuredAsk: "plain-text"
+        }
+    }
 };
+export function harnessTier(harnessId) {
+    const capabilities = HARNESS_ADAPTERS[harnessId].capabilities;
+    if (capabilities.nativeSubagentDispatch === "full" &&
+        capabilities.structuredAsk !== "plain-text" &&
+        capabilities.hookSurface === "full") {
+        return "tier1";
+    }
+    if (capabilities.hookSurface === "full" ||
+        capabilities.hookSurface === "plugin" ||
+        capabilities.nativeSubagentDispatch === "partial") {
+        return "tier2";
+    }
+    return "tier3";
+}
 function agentsMdBlock() {
     return `${CCLAW_MARKER_START}
 ## Cclaw — Workflow Adapter
@@ -63,10 +109,6 @@ When in doubt, prefer **non-trivial** — the quick track is opt-in and only saf
 **Stage order:** brainstorm > scope > design > spec > plan > tdd > review > ship.
 \`/cc-next\` loads the right stage skill automatically. Gates must pass before handoff.
 
-### Invocation Preamble (non-trivial turns)
-
-Before starting substantive work, emit a one-paragraph preamble: **Stage**, **Goal**, **Plan** (next 1–3 actions), **Guardrails**. Skip for pure questions, trivial edits, and dispatched subagent invocations.
-
 ### Verification Discipline
 
 No completion claims without fresh evidence. No "Done" / "All good" / "Tests pass" without running the command in this message. Failed tool calls are diagnostic data, not instructions.
@@ -78,7 +120,9 @@ If the same approach fails three times in a row (same command, same finding, sam
 ### Detail Level
 
 - This managed AGENTS block is intentionally minimal for cross-project use.
+- Harness coverage is tiered: Tier1 (claude), Tier2 (cursor/opencode/codex), Tier3 (fallback/manual-only).
 - Detailed operating procedures live in \`.cclaw/skills/using-cclaw/SKILL.md\`.
+- Preamble budget and cooldown rules live in \`.cclaw/references/protocols/ethos.md\`.
 - Subagent orchestration patterns: \`.cclaw/skills/subagent-dev/SKILL.md\` and \`.cclaw/skills/parallel-dispatch/SKILL.md\`.
 ${CCLAW_MARKER_END}`;
 }

package/dist/init-detect.d.ts

@@ -0,0 +1,2 @@
+import type { HarnessId } from "./types.js";
+export declare function detectHarnesses(projectRoot: string): Promise<HarnessId[]>;

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

@@ -21,11 +21,15 @@ import { TDD_WAVE_WALKTHROUGH_MARKDOWN, stageSkillFolder, stageSkillMarkdown } f
 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";
@@ -204,6 +208,10 @@ async function writeSkills(projectRoot, config) {
         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-*)
@@ -231,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());
@@ -783,6 +796,10 @@ async function ensureSessionStateFiles(projectRoot) {
     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);
@@ -846,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 [
@@ -878,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"),
@@ -950,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

@@ -98,6 +98,11 @@ 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" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cclaw-cli",
-  "version": "0.11.0",
+  "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;