cclaw-cli 0.11.0 → 0.13.0

package/dist/runs.js

@@ -1,8 +1,10 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { COMMAND_FILE_ORDER, RUNTIME_ROOT } from "./constants.js";
-import { canTransition, createInitialFlowState, isFlowTrack, skippedStagesForTrack } from "./flow-state.js";
+import { canTransition, createInitialFlowState, isFlowTrack, skippedStagesForTrack, trackStages } from "./flow-state.js";
+import { ensureFeatureSystem, readActiveFeature, syncActiveFeatureSnapshot } from "./feature-system.js";
 import { ensureDir, exists, withDirectoryLock, writeFileSafe } from "./fs-utils.js";
+import { stageSchema } from "./content/stage-schema.js";
 export class InvalidStageTransitionError extends Error {
     from;
     to;
@@ -34,6 +36,8 @@ const FLOW_STATE_REL_PATH = `${RUNTIME_ROOT}/state/flow-state.json`;
 const RUNS_DIR_REL_PATH = `${RUNTIME_ROOT}/runs`;
 const ACTIVE_ARTIFACTS_REL_PATH = `${RUNTIME_ROOT}/artifacts`;
 const STATE_DIR_REL_PATH = `${RUNTIME_ROOT}/state`;
+const REWIND_LOG_REL_PATH = `${RUNTIME_ROOT}/state/rewind-log.jsonl`;
+const REWIND_ARCHIVE_DIR_NAME = "_rewind-archive";
 const FLOW_STAGE_SET = new Set(COMMAND_FILE_ORDER);
 /** State filenames explicitly excluded from the archive snapshot. */
 const STATE_SNAPSHOT_EXCLUDE = new Set([
@@ -55,6 +59,12 @@ function activeArtifactsPath(projectRoot) {
 function stateDirPath(projectRoot) {
     return path.join(projectRoot, STATE_DIR_REL_PATH);
 }
+function rewindLogPath(projectRoot) {
+    return path.join(projectRoot, REWIND_LOG_REL_PATH);
+}
+function rewindArchivePath(projectRoot, rewindId) {
+    return path.join(activeArtifactsPath(projectRoot), REWIND_ARCHIVE_DIR_NAME, rewindId);
+}
 async function snapshotStateDirectory(projectRoot, destinationRoot) {
     const sourceDir = stateDirPath(projectRoot);
     if (!(await exists(sourceDir))) {
@@ -191,6 +201,86 @@ function sanitizeSkippedStages(value, track) {
     }
     return out.length > 0 ? out : trackDefault;
 }
+function sanitizeStaleStages(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return {};
+    }
+    const out = {};
+    for (const [stage, raw] of Object.entries(value)) {
+        if (!isFlowStage(stage))
+            continue;
+        if (!raw || typeof raw !== "object" || Array.isArray(raw))
+            continue;
+        const typed = raw;
+        const rewindId = typeof typed.rewindId === "string" ? typed.rewindId : "";
+        const reason = typeof typed.reason === "string" ? typed.reason : "";
+        const markedAt = typeof typed.markedAt === "string" ? typed.markedAt : "";
+        const acknowledgedAt = typeof typed.acknowledgedAt === "string" ? typed.acknowledgedAt : undefined;
+        if (!rewindId || !reason || !markedAt) {
+            continue;
+        }
+        out[stage] = {
+            rewindId,
+            reason,
+            markedAt,
+            acknowledgedAt
+        };
+    }
+    return out;
+}
+function sanitizeRewinds(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const out = [];
+    for (const raw of value) {
+        if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+            continue;
+        }
+        const typed = raw;
+        if (typeof typed.id !== "string" ||
+            !isFlowStage(typed.fromStage) ||
+            !isFlowStage(typed.toStage) ||
+            typeof typed.reason !== "string" ||
+            typeof typed.timestamp !== "string") {
+            continue;
+        }
+        const invalidatedStages = Array.isArray(typed.invalidatedStages)
+            ? typed.invalidatedStages.filter((stage) => isFlowStage(stage))
+            : [];
+        out.push({
+            id: typed.id,
+            fromStage: typed.fromStage,
+            toStage: typed.toStage,
+            reason: typed.reason,
+            timestamp: typed.timestamp,
+            invalidatedStages
+        });
+    }
+    return out;
+}
+function sanitizeRetroState(value) {
+    const fallback = {
+        required: false,
+        completedAt: undefined,
+        compoundEntries: 0
+    };
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return fallback;
+    }
+    const typed = value;
+    const required = typeof typed.required === "boolean" ? typed.required : false;
+    const completedAt = typeof typed.completedAt === "string" ? typed.completedAt : undefined;
+    const compoundEntriesRaw = typed.compoundEntries;
+    const compoundEntries = typeof compoundEntriesRaw === "number" && Number.isFinite(compoundEntriesRaw) && compoundEntriesRaw >= 0
+        ? Math.floor(compoundEntriesRaw)
+        : 0;
+    return {
+        required,
+        completedAt,
+        compoundEntries
+    };
+}
 function coerceFlowState(parsed) {
     const track = coerceTrack(parsed.track);
     const next = createInitialFlowState("active", track);
@@ -205,7 +295,10 @@ function coerceFlowState(parsed) {
         guardEvidence: sanitizeGuardEvidence(parsed.guardEvidence),
         stageGateCatalog: sanitizeStageGateCatalog(parsed.stageGateCatalog, next.stageGateCatalog),
         track,
-        skippedStages: sanitizeSkippedStages(parsed.skippedStages, track)
+        skippedStages: sanitizeSkippedStages(parsed.skippedStages, track),
+        staleStages: sanitizeStaleStages(parsed.staleStages),
+        rewinds: sanitizeRewinds(parsed.rewinds),
+        retro: sanitizeRetroState(parsed.retro)
     };
 }
 function toArchiveDate(date = new Date()) {
@@ -255,6 +348,71 @@ async function uniqueArchiveId(projectRoot, baseId) {
     }
     return candidate;
 }
+function rewindTimestampId(date = new Date()) {
+    return date
+        .toISOString()
+        .replace(/[-:]/gu, "")
+        .replace(/\.\d{3}Z$/u, "Z");
+}
+function staleArtifactFileName(fileName) {
+    const ext = path.extname(fileName);
+    if (!ext) {
+        return `${fileName}.stale`;
+    }
+    const base = fileName.slice(0, -ext.length);
+    return `${base}.stale${ext}`;
+}
+function stageIndexMapForTrack(track) {
+    return new Map(trackStages(track).map((stage, index) => [stage, index]));
+}
+function retroArtifactPath(projectRoot) {
+    return path.join(activeArtifactsPath(projectRoot), "09-retro.md");
+}
+async function evaluateRetroGate(projectRoot, state) {
+    const required = state.completedStages.includes("ship");
+    const artifactFile = retroArtifactPath(projectRoot);
+    let hasRetroArtifact = false;
+    if (await exists(artifactFile)) {
+        try {
+            const raw = await fs.readFile(artifactFile, "utf8");
+            hasRetroArtifact = raw.trim().length > 0;
+        }
+        catch {
+            hasRetroArtifact = false;
+        }
+    }
+    const knowledgeFile = path.join(projectRoot, RUNTIME_ROOT, "knowledge.jsonl");
+    let compoundEntries = 0;
+    if (await exists(knowledgeFile)) {
+        try {
+            const raw = await fs.readFile(knowledgeFile, "utf8");
+            for (const line of raw.split(/\r?\n/)) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                try {
+                    const parsed = JSON.parse(trimmed);
+                    if (parsed.type === "compound") {
+                        compoundEntries += 1;
+                    }
+                }
+                catch {
+                    // ignore malformed lines for retro gate calculation
+                }
+            }
+        }
+        catch {
+            compoundEntries = 0;
+        }
+    }
+    const completed = required ? (hasRetroArtifact && compoundEntries > 0) : true;
+    return {
+        required,
+        completed,
+        compoundEntries,
+        hasRetroArtifact
+    };
+}
 export class CorruptFlowStateError extends Error {
     statePath;
     quarantinedPath;
@@ -293,6 +451,7 @@ async function quarantineCorruptState(statePath, cause) {
     throw new CorruptFlowStateError(statePath, quarantinedPath, cause);
 }
 export async function readFlowState(projectRoot) {
+    await ensureFeatureSystem(projectRoot);
     const statePath = flowStatePath(projectRoot);
     if (!(await exists(statePath))) {
         return createInitialFlowState();
@@ -317,6 +476,7 @@ export async function readFlowState(projectRoot) {
     return coerceFlowState(parsed);
 }
 export async function writeFlowState(projectRoot, state, options = {}) {
+    await ensureFeatureSystem(projectRoot);
     await withDirectoryLock(flowStateLockPath(projectRoot), async () => {
         const statePath = flowStatePath(projectRoot);
         if (!options.allowReset && (await exists(statePath))) {
@@ -339,8 +499,10 @@ export async function writeFlowState(projectRoot, state, options = {}) {
         const safe = coerceFlowState({ ...state });
         await writeFileSafe(statePath, `${JSON.stringify(safe, null, 2)}\n`);
     });
+    await syncActiveFeatureSnapshot(projectRoot);
 }
 export async function ensureRunSystem(projectRoot, _options = {}) {
+    await ensureFeatureSystem(projectRoot);
     await ensureDir(runsRoot(projectRoot));
     await ensureDir(activeArtifactsPath(projectRoot));
     const statePath = flowStatePath(projectRoot);
@@ -348,6 +510,7 @@ export async function ensureRunSystem(projectRoot, _options = {}) {
     if (!(await exists(statePath))) {
         await writeFlowState(projectRoot, state, { allowReset: true });
     }
+    await syncActiveFeatureSnapshot(projectRoot);
     return state;
 }
 export async function listRuns(projectRoot) {
@@ -378,8 +541,9 @@ export async function listRuns(projectRoot) {
     }
     return runs.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
 }
-export async function archiveRun(projectRoot, featureName) {
+export async function archiveRun(projectRoot, featureName, options = {}) {
     await ensureRunSystem(projectRoot);
+    const activeFeature = await readActiveFeature(projectRoot);
     const artifactsDir = activeArtifactsPath(projectRoot);
     const runsDir = runsRoot(projectRoot);
     await ensureDir(runsDir);
@@ -391,7 +555,36 @@ export async function archiveRun(projectRoot, featureName) {
     const archiveId = await uniqueArchiveId(projectRoot, archiveBaseId);
     const archivePath = path.join(runsDir, archiveId);
     const archiveArtifactsPath = path.join(archivePath, "artifacts");
-    const sourceState = await readFlowState(projectRoot);
+    let sourceState = await readFlowState(projectRoot);
+    const retroGate = await evaluateRetroGate(projectRoot, sourceState);
+    const skipRetro = options.skipRetro === true;
+    const skipRetroReason = options.skipRetroReason?.trim();
+    if (skipRetro && (!skipRetroReason || skipRetroReason.length === 0)) {
+        throw new Error("archive --skip-retro requires --retro-reason=<text>.");
+    }
+    if (retroGate.required && !retroGate.completed && !skipRetro) {
+        throw new Error("Archive blocked: retro gate is required after ship completion. " +
+            "Run /cc-retro and append at least one compound knowledge entry, or re-run archive with --skip-retro and --retro-reason.");
+    }
+    if (retroGate.completed) {
+        const completedAt = sourceState.retro.completedAt ?? new Date().toISOString();
+        sourceState = {
+            ...sourceState,
+            retro: {
+                required: retroGate.required,
+                completedAt,
+                compoundEntries: retroGate.compoundEntries
+            }
+        };
+        await writeFlowState(projectRoot, sourceState, { allowReset: true });
+    }
+    const retroSummary = {
+        required: retroGate.required,
+        completed: retroGate.completed,
+        skipped: skipRetro,
+        skipReason: skipRetro ? skipRetroReason : undefined,
+        compoundEntries: retroGate.compoundEntries
+    };
     await ensureDir(archivePath);
     await fs.rename(artifactsDir, archiveArtifactsPath);
     await ensureDir(artifactsDir);
@@ -405,21 +598,187 @@ export async function archiveRun(projectRoot, featureName) {
         archiveId,
         archivedAt,
         featureName: feature,
+        activeFeature,
         sourceRunId: sourceState.activeRunId,
         sourceCurrentStage: sourceState.currentStage,
         sourceCompletedStages: sourceState.completedStages,
-        snapshottedStateFiles
+        snapshottedStateFiles,
+        retro: retroSummary
     };
     await writeFileSafe(path.join(archivePath, "archive-manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`);
     const knowledgeStats = await readKnowledgeStats(projectRoot);
+    await syncActiveFeatureSnapshot(projectRoot);
     return {
         archiveId,
         archivePath,
         archivedAt,
         featureName: feature,
+        activeFeature,
         resetState,
         snapshottedStateFiles,
-        knowledge: knowledgeStats
+        knowledge: knowledgeStats,
+        retro: retroSummary
+    };
+}
+export async function rewindRun(projectRoot, options) {
+    await ensureRunSystem(projectRoot);
+    const state = await readFlowState(projectRoot);
+    const track = state.track ?? "standard";
+    const ordered = trackStages(track);
+    const stageToIndex = stageIndexMapForTrack(track);
+    const toIndex = stageToIndex.get(options.to);
+    const currentIndex = stageToIndex.get(state.currentStage);
+    if (toIndex === undefined) {
+        throw new Error(`Cannot rewind to "${options.to}" because it is outside track "${track}".`);
+    }
+    if (currentIndex === undefined) {
+        throw new Error(`Current stage "${state.currentStage}" is not part of track "${track}".`);
+    }
+    if (toIndex > currentIndex) {
+        throw new Error(`Cannot rewind forward from "${state.currentStage}" to "${options.to}".`);
+    }
+    const reason = options.reason?.trim() && options.reason.trim().length > 0
+        ? options.reason.trim()
+        : "manual_rewind";
+    const nowIso = new Date().toISOString();
+    const rewindId = `rewind-${rewindTimestampId()}`;
+    const invalidatedStages = ordered.filter((stage) => {
+        const idx = stageToIndex.get(stage);
+        if (idx === undefined || idx <= toIndex) {
+            return false;
+        }
+        return state.completedStages.includes(stage) || stage === state.currentStage;
+    });
+    const nextCompletedStages = state.completedStages.filter((stage) => {
+        const idx = stageToIndex.get(stage);
+        return typeof idx === "number" && idx < toIndex;
+    });
+    const freshCatalog = createInitialFlowState({ activeRunId: state.activeRunId, track }).stageGateCatalog;
+    const nextCatalog = { ...state.stageGateCatalog };
+    for (const stage of ordered) {
+        const idx = stageToIndex.get(stage);
+        if (idx === undefined)
+            continue;
+        if (idx >= toIndex) {
+            nextCatalog[stage] = {
+                ...freshCatalog[stage],
+                required: [...freshCatalog[stage].required],
+                recommended: [...freshCatalog[stage].recommended],
+                conditional: [...freshCatalog[stage].conditional],
+                triggered: [],
+                passed: [],
+                blocked: []
+            };
+        }
+    }
+    const nextGuardEvidence = { ...state.guardEvidence };
+    for (const stage of ordered) {
+        const idx = stageToIndex.get(stage);
+        if (idx === undefined || idx < toIndex)
+            continue;
+        const catalog = state.stageGateCatalog[stage];
+        const gateIds = new Set([
+            ...catalog.required,
+            ...catalog.recommended,
+            ...catalog.conditional,
+            ...catalog.triggered,
+            ...catalog.passed,
+            ...catalog.blocked
+        ]);
+        for (const gateId of gateIds) {
+            delete nextGuardEvidence[gateId];
+        }
+    }
+    const nextStale = {};
+    for (const [stage, marker] of Object.entries(state.staleStages)) {
+        if (!marker)
+            continue;
+        const idx = stageToIndex.get(stage);
+        if (idx === undefined || idx <= toIndex) {
+            continue;
+        }
+        nextStale[stage] = marker;
+    }
+    for (const stage of invalidatedStages) {
+        nextStale[stage] = {
+            rewindId,
+            reason,
+            markedAt: nowIso
+        };
+    }
+    const archivePath = rewindArchivePath(projectRoot, rewindId);
+    const staleArtifacts = [];
+    for (const stage of invalidatedStages) {
+        const artifactFile = stageSchema(stage).artifactFile;
+        const artifactPath = path.join(activeArtifactsPath(projectRoot), artifactFile);
+        if (!(await exists(artifactPath))) {
+            continue;
+        }
+        await ensureDir(archivePath);
+        await ensureDir(path.join(archivePath, path.dirname(artifactFile)));
+        await fs.copyFile(artifactPath, path.join(archivePath, artifactFile));
+        const staleName = staleArtifactFileName(artifactFile);
+        const stalePath = path.join(activeArtifactsPath(projectRoot), staleName);
+        await fs.rm(stalePath, { force: true });
+        await fs.rename(artifactPath, stalePath);
+        staleArtifacts.push(staleName);
+    }
+    const rewindRecord = {
+        id: rewindId,
+        fromStage: state.currentStage,
+        toStage: options.to,
+        reason,
+        timestamp: nowIso,
+        invalidatedStages
+    };
+    const nextState = {
+        ...state,
+        currentStage: options.to,
+        completedStages: nextCompletedStages,
+        guardEvidence: nextGuardEvidence,
+        stageGateCatalog: nextCatalog,
+        staleStages: nextStale,
+        rewinds: [...state.rewinds, rewindRecord]
+    };
+    await writeFlowState(projectRoot, nextState, { allowReset: true });
+    const rewindLogEntry = {
+        ...rewindRecord,
+        track,
+        runId: state.activeRunId,
+        staleArtifacts
+    };
+    await ensureDir(path.dirname(rewindLogPath(projectRoot)));
+    await fs.appendFile(rewindLogPath(projectRoot), `${JSON.stringify(rewindLogEntry)}\n`, "utf8");
+    return {
+        rewindId,
+        from: state.currentStage,
+        to: options.to,
+        invalidatedStages,
+        staleArtifacts,
+        archivePath,
+        nextState
+    };
+}
+export async function acknowledgeStaleStage(projectRoot, stage) {
+    await ensureRunSystem(projectRoot);
+    const state = await readFlowState(projectRoot);
+    const marker = state.staleStages[stage];
+    if (!marker) {
+        return {
+            acknowledged: false,
+            remaining: Object.keys(state.staleStages).filter((value) => isFlowStage(value))
+        };
+    }
+    const nextStale = { ...state.staleStages };
+    delete nextStale[stage];
+    const nextState = {
+        ...state,
+        staleStages: nextStale
+    };
+    await writeFlowState(projectRoot, nextState, { allowReset: true });
+    return {
+        acknowledged: true,
+        remaining: Object.keys(nextStale).filter((value) => isFlowStage(value))
     };
 }
 const KNOWLEDGE_SOFT_THRESHOLD = 50;

package/dist/tdd-cycle.d.ts

@@ -0,0 +1,22 @@
+export type TddCyclePhase = "red" | "green" | "refactor";
+export interface TddCycleEntry {
+    ts: string;
+    runId: string;
+    stage: string;
+    slice: string;
+    phase: TddCyclePhase;
+    command: string;
+    files?: string[];
+    exitCode?: number;
+    note?: string;
+}
+export interface TddCycleValidation {
+    ok: boolean;
+    issues: string[];
+    openRedSlices: string[];
+    sliceCount: number;
+}
+export declare function parseTddCycleLog(text: string): TddCycleEntry[];
+export declare function validateTddCycleOrder(entries: TddCycleEntry[], options?: {
+    runId?: string;
+}): TddCycleValidation;

package/dist/tdd-cycle.js

@@ -0,0 +1,82 @@
+export function parseTddCycleLog(text) {
+    const out = [];
+    for (const raw of text.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (!line)
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            const phase = parsed.phase;
+            if (phase !== "red" && phase !== "green" && phase !== "refactor") {
+                continue;
+            }
+            const entry = {
+                ts: typeof parsed.ts === "string" ? parsed.ts : "",
+                runId: typeof parsed.runId === "string" ? parsed.runId : "active",
+                stage: typeof parsed.stage === "string" ? parsed.stage : "tdd",
+                slice: typeof parsed.slice === "string" ? parsed.slice : "S-unknown",
+                phase,
+                command: typeof parsed.command === "string" ? parsed.command : "",
+                files: Array.isArray(parsed.files)
+                    ? parsed.files.filter((item) => typeof item === "string")
+                    : undefined,
+                exitCode: typeof parsed.exitCode === "number" ? parsed.exitCode : undefined,
+                note: typeof parsed.note === "string" ? parsed.note : undefined
+            };
+            out.push(entry);
+        }
+        catch {
+            // skip malformed line
+        }
+    }
+    return out;
+}
+export function validateTddCycleOrder(entries, options = {}) {
+    const targetRun = options.runId;
+    const filtered = targetRun
+        ? entries.filter((entry) => entry.runId === targetRun)
+        : entries;
+    const bySlice = new Map();
+    for (const entry of filtered) {
+        const list = bySlice.get(entry.slice) ?? [];
+        list.push(entry);
+        bySlice.set(entry.slice, list);
+    }
+    const issues = [];
+    const openRedSlices = [];
+    for (const [slice, sliceEntries] of bySlice.entries()) {
+        let state = "need_red";
+        for (const entry of sliceEntries) {
+            if (entry.phase === "red") {
+                if (state === "red_open") {
+                    issues.push(`slice ${slice}: duplicate red before green`);
+                    continue;
+                }
+                state = "red_open";
+                continue;
+            }
+            if (entry.phase === "green") {
+                if (state !== "red_open") {
+                    issues.push(`slice ${slice}: green logged before red`);
+                    continue;
+                }
+                state = "green_done";
+                continue;
+            }
+            // refactor
+            if (state !== "green_done") {
+                issues.push(`slice ${slice}: refactor logged before green`);
+            }
+            state = "need_red";
+        }
+        if (state === "red_open") {
+            openRedSlices.push(slice);
+        }
+    }
+    return {
+        ok: issues.length === 0 && openRedSlices.length === 0,
+        issues,
+        openRedSlices,
+        sliceCount: bySlice.size
+    };
+}

package/dist/types.d.ts

@@ -61,6 +61,10 @@ export interface VibyConfig {
     autoAdvance?: boolean;
     /** Prompt guard behavior for runtime write-risk detection hooks. */
     promptGuardMode?: "advisory" | "strict";
+    /** TDD red->green->refactor enforcement mode used by workflow guard hooks. */
+    tddEnforcement?: "advisory" | "strict";
+    /** Optional test file globs used by guard guidance and /cc-tdd-log docs. */
+    tddTestGlobs?: string[];
     /** When true, cclaw installs managed git pre-commit/pre-push wrappers. */
     gitHookGuards?: boolean;
     /** Default flow track for new runs (quick = shortened path, standard = full pipeline). */

package/package.json

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