cclaw-cli 0.48.30 → 0.48.32

package/dist/content/seed-shelf.d.ts

@@ -0,0 +1,36 @@
+export interface SeedShelfEntry {
+    fileName: string;
+    absPath: string;
+    relPath: string;
+    createdOn: string;
+    title: string;
+    triggerWhen: string[];
+    sourceStage: string | null;
+    sourceArtifact: string | null;
+    hypothesis: string | null;
+    action: string | null;
+    summary: string;
+    raw: string;
+}
+export interface SeedTemplateInput {
+    title: string;
+    triggerWhen: readonly string[];
+    hypothesis: string;
+    action: string;
+    sourceStage?: string;
+    sourceArtifact?: string;
+    createdAt?: Date;
+}
+export interface ResolvedSeedPath {
+    fileName: string;
+    absPath: string;
+    relPath: string;
+}
+export declare function seedShelfDir(projectRoot: string): string;
+export declare function seedSlug(title: string): string;
+export declare function seedFileName(title: string, createdAt?: Date): string;
+export declare function resolveSeedPathForWrite(projectRoot: string, title: string, createdAt?: Date): Promise<ResolvedSeedPath>;
+export declare function readSeedShelf(projectRoot: string): Promise<SeedShelfEntry[]>;
+export declare function seedMatchesPrompt(seed: SeedShelfEntry, prompt: string): boolean;
+export declare function findMatchingSeeds(projectRoot: string, prompt: string, maxMatches?: number): Promise<SeedShelfEntry[]>;
+export declare function renderSeedTemplate(input: SeedTemplateInput): string;

package/dist/content/seed-shelf.js

@@ -0,0 +1,236 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { parse } from "yaml";
+import { RUNTIME_ROOT } from "../constants.js";
+const SEED_FILE_NAME_PATTERN = /^SEED-(\d{4}-\d{2}-\d{2})-([a-z0-9]+(?:-[a-z0-9]+)*)(?:-(\d+))?\.md$/u;
+const DEFAULT_MAX_MATCHES = 3;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeTriggerList(value) {
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => typeof item === "string" || typeof item === "number" ? String(item).trim() : "")
+            .filter((item) => item.length > 0);
+    }
+    if (typeof value === "string") {
+        return value
+            .split(/,\s*/u)
+            .map((item) => item.trim())
+            .filter((item) => item.length > 0);
+    }
+    return [];
+}
+function parseSeedFrontmatter(raw) {
+    if (!raw.startsWith("---")) {
+        return { values: {}, body: raw };
+    }
+    const lines = raw.split(/\r?\n/u);
+    let closingIndex = -1;
+    for (let index = 1; index < lines.length; index += 1) {
+        if (lines[index]?.trim() === "---") {
+            closingIndex = index;
+            break;
+        }
+    }
+    if (closingIndex < 0) {
+        return { values: {}, body: raw };
+    }
+    const frontmatterRaw = lines.slice(1, closingIndex).join("\n");
+    const body = lines.slice(closingIndex + 1).join("\n");
+    try {
+        const parsed = parse(frontmatterRaw);
+        if (isRecord(parsed)) {
+            return { values: parsed, body };
+        }
+        return { values: {}, body };
+    }
+    catch {
+        return { values: {}, body };
+    }
+}
+function firstHeading(body) {
+    const match = /^#\s+(.+)$/mu.exec(body);
+    if (!match)
+        return null;
+    const title = match[1]?.trim() ?? "";
+    return title.length > 0 ? title : null;
+}
+function firstNonEmptyParagraph(body) {
+    const lines = body.split(/\r?\n/u);
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.length === 0)
+            continue;
+        if (/^#\s+/u.test(trimmed))
+            continue;
+        if (/^[-*]\s+/u.test(trimmed))
+            continue;
+        return trimmed;
+    }
+    return "";
+}
+function fromFileNameFallbackTitle(fileName) {
+    const stem = fileName.replace(/\.md$/u, "");
+    const withoutPrefix = stem.replace(/^SEED-\d{4}-\d{2}-\d{2}-/u, "");
+    return withoutPrefix
+        .split("-")
+        .filter((part) => part.length > 0 && !/^\d+$/u.test(part))
+        .map((part) => part[0]?.toUpperCase() + part.slice(1))
+        .join(" ")
+        .trim();
+}
+export function seedShelfDir(projectRoot) {
+    return path.join(projectRoot, RUNTIME_ROOT, "seeds");
+}
+export function seedSlug(title) {
+    const normalized = title
+        .toLowerCase()
+        .trim()
+        .replace(/[`"'“”‘’()[\]{}<>]/gu, " ")
+        .replace(/[^a-z0-9]+/gu, "-")
+        .replace(/^-+/u, "")
+        .replace(/-+$/u, "");
+    if (normalized.length === 0) {
+        return "seed";
+    }
+    return normalized.slice(0, 48);
+}
+function isoDate(value) {
+    return value.toISOString().slice(0, 10);
+}
+export function seedFileName(title, createdAt = new Date()) {
+    return `SEED-${isoDate(createdAt)}-${seedSlug(title)}.md`;
+}
+async function pathExists(absPath) {
+    try {
+        await fs.stat(absPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function resolveSeedPathForWrite(projectRoot, title, createdAt = new Date()) {
+    const seedsDir = seedShelfDir(projectRoot);
+    await fs.mkdir(seedsDir, { recursive: true });
+    const baseFile = seedFileName(title, createdAt);
+    const baseStem = baseFile.replace(/\.md$/u, "");
+    let candidate = baseFile;
+    let index = 2;
+    while (await pathExists(path.join(seedsDir, candidate))) {
+        candidate = `${baseStem}-${index}.md`;
+        index += 1;
+    }
+    return {
+        fileName: candidate,
+        absPath: path.join(seedsDir, candidate),
+        relPath: path.join(RUNTIME_ROOT, "seeds", candidate)
+    };
+}
+export async function readSeedShelf(projectRoot) {
+    const dir = seedShelfDir(projectRoot);
+    let names = [];
+    try {
+        names = await fs.readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    const entries = [];
+    for (const fileName of names) {
+        if (!SEED_FILE_NAME_PATTERN.test(fileName))
+            continue;
+        const absPath = path.join(dir, fileName);
+        let raw = "";
+        try {
+            raw = await fs.readFile(absPath, "utf8");
+        }
+        catch {
+            continue;
+        }
+        const frontmatter = parseSeedFrontmatter(raw);
+        const title = (typeof frontmatter.values.title === "string" && frontmatter.values.title.trim().length > 0
+            ? frontmatter.values.title.trim()
+            : null) ??
+            firstHeading(frontmatter.body) ??
+            fromFileNameFallbackTitle(fileName) ??
+            "Untitled seed";
+        const triggerWhen = normalizeTriggerList(frontmatter.values.trigger_when ?? frontmatter.values.triggerWhen);
+        const sourceStage = typeof frontmatter.values.source_stage === "string"
+            ? frontmatter.values.source_stage
+            : typeof frontmatter.values.sourceStage === "string"
+                ? frontmatter.values.sourceStage
+                : null;
+        const sourceArtifact = typeof frontmatter.values.source_artifact === "string"
+            ? frontmatter.values.source_artifact
+            : typeof frontmatter.values.sourceArtifact === "string"
+                ? frontmatter.values.sourceArtifact
+                : null;
+        const hypothesis = typeof frontmatter.values.hypothesis === "string" ? frontmatter.values.hypothesis : null;
+        const action = typeof frontmatter.values.action === "string" ? frontmatter.values.action : null;
+        const createdOn = SEED_FILE_NAME_PATTERN.exec(fileName)?.[1] ?? "1970-01-01";
+        const summary = firstNonEmptyParagraph(frontmatter.body);
+        entries.push({
+            fileName,
+            absPath,
+            relPath: path.join(RUNTIME_ROOT, "seeds", fileName),
+            createdOn,
+            title,
+            triggerWhen,
+            sourceStage,
+            sourceArtifact,
+            hypothesis,
+            action,
+            summary,
+            raw
+        });
+    }
+    entries.sort((a, b) => b.fileName.localeCompare(a.fileName));
+    return entries;
+}
+export function seedMatchesPrompt(seed, prompt) {
+    const normalizedPrompt = prompt.toLowerCase().trim();
+    if (normalizedPrompt.length === 0)
+        return false;
+    if (seed.triggerWhen.length === 0)
+        return false;
+    return seed.triggerWhen.some((trigger) => normalizedPrompt.includes(trigger.toLowerCase()));
+}
+export async function findMatchingSeeds(projectRoot, prompt, maxMatches = DEFAULT_MAX_MATCHES) {
+    const seeds = await readSeedShelf(projectRoot);
+    const matches = seeds.filter((seed) => seedMatchesPrompt(seed, prompt));
+    return matches.slice(0, Math.max(1, maxMatches));
+}
+export function renderSeedTemplate(input) {
+    const triggerWhen = [...input.triggerWhen].map((item) => item.trim()).filter((item) => item.length > 0);
+    const createdAt = input.createdAt ?? new Date();
+    const sourceStage = input.sourceStage?.trim() || "unknown";
+    const sourceArtifact = input.sourceArtifact?.trim() || "unknown";
+    return `---
+title: ${input.title.trim()}
+created_at: ${createdAt.toISOString()}
+source_stage: ${sourceStage}
+source_artifact: ${sourceArtifact}
+trigger_when:
+${triggerWhen.length > 0 ? triggerWhen.map((trigger) => `  - ${trigger}`).join("\n") : "  - <trigger token>"}
+hypothesis: ${input.hypothesis.trim()}
+action: ${input.action.trim()}
+---
+
+# ${input.title.trim()}
+
+## Why capture this seed
+${input.hypothesis.trim()}
+
+## Trigger when
+${triggerWhen.length > 0 ? triggerWhen.map((trigger) => `- ${trigger}`).join("\n") : "- <trigger token>"}
+
+## Suggested action
+${input.action.trim()}
+
+## Notes
+- Expected payoff:
+- Risks:
+`;
+}

package/dist/content/skills.js

@@ -1,22 +1,20 @@
 import { RUNTIME_ROOT, STAGE_TO_SKILL_FOLDER } from "../constants.js";
-import { STAGE_EXAMPLES_REFERENCE_DIR, stageDomainExamples, stageExamples, stageGoodBadExamples } from "./examples.js";
+import { STAGE_EXAMPLES_REFERENCE_DIR, stageExamples } from "./examples.js";
 import { STAGE_COMMON_GUIDANCE_REL_PATH } from "./stage-common-guidance.js";
 import { stageAutoSubagentDispatch, stageSchema } from "./stage-schema.js";
 const VERIFICATION_STAGES = ["tdd", "review", "ship"];
 const DECISION_PROTOCOL_PATH = `${RUNTIME_ROOT}/references/protocols/decision.md`;
 const COMPLETION_PROTOCOL_PATH = `${RUNTIME_ROOT}/references/protocols/completion.md`;
-function whenNotToUseBlock(stage, track) {
-    const schema = stageSchema(stage, track);
-    if (schema.whenNotToUse.length === 0) {
+function whenNotToUseBlock(items) {
+    if (items.length === 0) {
         return "";
     }
     return `## When Not to Use
-${schema.whenNotToUse.map((item) => `- ${item}`).join("\n")}
+${items.map((item) => `- ${item}`).join("\n")}
 
 `;
 }
-function contextLoadingBlock(stage, track) {
-    const trace = stageSchema(stage, track).crossStageTrace;
+function contextLoadingBlock(trace) {
     const readLines = trace.readsFrom.length > 0
         ? trace.readsFrom.map((value) => `- \`${value}\``).join("\n")
         : "- (first stage — no upstream artifacts)";
@@ -54,8 +52,7 @@ Mandatory delegations for this stage: ${mandatoryList}.
 Record completion/waiver in \`${delegationLogRel}\` before stage completion.
 `;
 }
-function researchPlaybooksBlock(stage, track) {
-    const playbooks = stageSchema(stage, track).researchPlaybooks ?? [];
+function researchPlaybooksBlock(playbooks) {
     if (playbooks.length === 0)
         return "";
     const rows = playbooks
@@ -70,11 +67,10 @@ and record outcomes in the stage artifact when relevant.
 ${rows}
 `;
 }
-function reviewSectionsBlock(stage, track) {
-    const schema = stageSchema(stage, track);
-    if (schema.reviewSections.length === 0)
+function reviewSectionsBlock(sectionsInput) {
+    if (sectionsInput.length === 0)
         return "";
-    const sections = schema.reviewSections
+    const sections = sectionsInput
         .map((sec) => {
         const points = sec.evaluationPoints.map((p) => `- ${p}`).join("\n");
         const title = sec.stopGate ? `${sec.title} (STOP gate)` : sec.title;
@@ -86,6 +82,18 @@ function reviewSectionsBlock(stage, track) {
 ${sections}
 `;
 }
+function reviewLoopBlock(reviewLoop) {
+    if (!reviewLoop)
+        return "";
+    const checklist = reviewLoop.checklist.map((item) => `- \`${item}\``).join("\n");
+    return `## Outside Voice Review Loop
+- Stage: \`${reviewLoop.stage}\`
+- Target score: \`${reviewLoop.targetScore}\`
+- Max iterations: \`${reviewLoop.maxIterations}\`
+- Checklist dimensions:
+${checklist}
+`;
+}
 function verificationBlock(stage) {
     if (!VERIFICATION_STAGES.includes(stage))
         return "";
@@ -116,8 +124,7 @@ Detailed walkthrough:
 \`.cclaw/${STAGE_EXAMPLES_REFERENCE_DIR}/tdd-batch-walkthrough.md\`
 `;
 }
-function crossStageTraceBlock(stage, track) {
-    const trace = stageSchema(stage, track).crossStageTrace;
+function crossStageTraceBlock(trace) {
     const reads = trace.readsFrom.length > 0
         ? trace.readsFrom.map((r) => `- ${r}`).join("\n")
         : "- (first stage — no upstream artifacts)";
@@ -135,8 +142,7 @@ ${writes}
 Rule: ${trace.traceabilityRule}
 `;
 }
-function artifactValidationBlock(stage, track) {
-    const validations = stageSchema(stage, track).artifactValidation;
+function artifactValidationBlock(validations) {
     if (validations.length === 0)
         return "";
     const rows = validations
@@ -152,10 +158,10 @@ function artifactValidationBlock(stage, track) {
 ${rows}
 `;
 }
-function mergedAntiPatterns(schema) {
+function mergedAntiPatterns(philosophy, execution) {
     const merged = [];
     const seen = new Set();
-    for (const item of [...schema.commonRationalizations, ...schema.blockers]) {
+    for (const item of [...philosophy.commonRationalizations, ...execution.blockers]) {
         const key = item.trim().toLowerCase();
         if (seen.has(key))
             continue;
@@ -205,9 +211,9 @@ function stageSpecificSeeAlso(stage) {
     return refs[stage];
 }
 function completionParametersBlock(schema, track) {
-    const gateList = schema.requiredGates.map((g) => `\`${g.id}\``).join(", ");
-    const mandatory = schema.mandatoryDelegations.length > 0
-        ? schema.mandatoryDelegations.map((a) => `\`${a}\``).join(", ")
+    const gateList = schema.executionModel.requiredGates.map((g) => `\`${g.id}\``).join(", ");
+    const mandatory = schema.reviewLens.mandatoryDelegations.length > 0
+        ? schema.reviewLens.mandatoryDelegations.map((a) => `\`${a}\``).join(", ")
         : "none";
     const nextStage = schema.next === "done" ? "done" : schema.next;
     const nextDescription = schema.next === "done"
@@ -218,25 +224,24 @@ function completionParametersBlock(schema, track) {
 - \`stage\`: \`${schema.stage}\`
 - \`next\`: \`${nextStage}\` (${nextDescription})
 - \`gates\`: ${gateList}
-- \`artifact\`: \`${RUNTIME_ROOT}/artifacts/${schema.artifactFile}\`
+- \`artifact\`: \`${RUNTIME_ROOT}/artifacts/${schema.artifactRules.artifactFile}\`
 - \`mandatory delegations\`: ${mandatory}
 - \`completion helper\`: \`node .cclaw/hooks/stage-complete.mjs ${schema.stage}\`
 - Fill \`## Learnings\` before closeout: either \`- None this stage.\` or JSON bullets with required keys \`type\`, \`trigger\`, \`action\`, \`confidence\` (knowledge-schema compatible).
 - Record mandatory delegation completion/waiver in \`${RUNTIME_ROOT}/state/delegation-log.json\` with rationale as needed.
 - Use the completion helper instead of raw \`flow-state.json\` edits (legacy direct edits trigger workflow-guard warnings or strict-mode blocks).
-Apply shared completion logic from:
-\`${COMPLETION_PROTOCOL_PATH}\`
+- Completion protocol reference: \`${COMPLETION_PROTOCOL_PATH}\`
 `;
 }
 function quickStartBlock(stage, track) {
     const schema = stageSchema(stage, track);
-    const gatePreview = schema.requiredGates.slice(0, 3).map((g) => `\`${g.id}\``).join(", ");
+    const gatePreview = schema.executionModel.requiredGates.slice(0, 3).map((g) => `\`${g.id}\``).join(", ");
     return `## Quick Start
 
-1. Announce at start: "Using \`${schema.skillName}\` to ${schema.purpose}".
+1. Announce at start: "Using \`${schema.skillName}\` to ${schema.philosophy.purpose}".
 2. Obey HARD-GATE and Iron Law.
-3. Execute checklist in order and persist \`${RUNTIME_ROOT}/artifacts/${schema.artifactFile}\`.
-4. Satisfy gates (${gatePreview}${schema.requiredGates.length > 3 ? ` +${schema.requiredGates.length - 3}` : ""}).
+3. Execute checklist in order and persist \`${RUNTIME_ROOT}/artifacts/${schema.artifactRules.artifactFile}\`.
+4. Satisfy gates (${gatePreview}${schema.executionModel.requiredGates.length > 3 ? ` +${schema.executionModel.requiredGates.length - 3}` : ""}).
 `;
 }
 /**
@@ -325,21 +330,27 @@ function dedupeGuidance(items, blockedBy) {
 }
 export function stageSkillMarkdown(stage, track = "standard") {
     const schema = stageSchema(stage, track);
-    const gateList = schema.requiredGates
+    const philosophy = schema.philosophy;
+    const executionModel = schema.executionModel;
+    const artifactRules = schema.artifactRules;
+    const reviewLens = schema.reviewLens;
+    const mandatoryDelegations = reviewLens.mandatoryDelegations;
+    const gateList = executionModel.requiredGates
         .map((g) => `- \`${g.id}\` — ${g.description}`)
         .join("\n");
-    const evidenceList = schema.requiredEvidence
+    const evidenceList = executionModel.requiredEvidence
         .map((e) => `- [ ] ${e}`)
         .join("\n");
-    const checklistItems = schema.checklist
+    const checklistItems = executionModel.checklist
         .map((item, i) => `${i + 1}. ${item}`)
         .join("\n");
-    const interactionFocus = dedupeGuidance(schema.interactionProtocol, [...schema.checklist, ...schema.process]).slice(0, 5);
-    const processSummary = dedupeGuidance(schema.process, schema.checklist).slice(0, 5);
-    const processNote = schema.process.length > processSummary.length
-        ? `- Follow the Checklist above for remaining execution detail (+${schema.process.length - processSummary.length} condensed step${schema.process.length - processSummary.length === 1 ? "" : "s"}).`
-        : "";
+    const interactionFocus = dedupeGuidance(executionModel.interactionProtocol, [...executionModel.checklist, ...executionModel.process]).slice(0, 5);
+    const processSummary = dedupeGuidance(executionModel.process, executionModel.checklist).slice(0, 5);
     const stageRefs = stageSpecificSeeAlso(stage);
+    const reviewLoopSection = reviewLoopBlock(reviewLens.reviewLoop);
+    const mandatoryDelegationSummary = mandatoryDelegations.length > 0
+        ? mandatoryDelegations.map((name) => `\`${name}\``).join(", ")
+        : "none";
     return `---
 name: ${schema.skillName}
 description: "${schema.skillDescription}"
@@ -349,7 +360,7 @@ description: "${schema.skillDescription}"
 
 <EXTREMELY-IMPORTANT>
 
-**IRON LAW — ${stage.toUpperCase()}:** ${schema.ironLaw}
+**IRON LAW — ${stage.toUpperCase()}:** ${philosophy.ironLaw}
 
 If you are about to violate the Iron Law, STOP. No amount of urgency, partial progress, or clever reinterpretation overrides it. Escalate via the Decision Protocol or abandon the stage.
 
@@ -357,28 +368,35 @@ If you are about to violate the Iron Law, STOP. No amount of urgency, partial pr
 
 ${quickStartBlock(stage, track)}
 
-## Overview
-${schema.purpose}
+## Philosophy
+${philosophy.purpose}
+
+## Complexity Tier
+- Active tier: \`${schema.complexityTier}\`
+- Mandatory delegations at this tier: ${mandatoryDelegationSummary}
 
 ## When to Use
-${schema.whenToUse.map((item) => `- ${item}`).join("\n")}
+${philosophy.whenToUse.map((item) => `- ${item}`).join("\n")}
+
+${whenNotToUseBlock(philosophy.whenNotToUse)}
+## HARD-GATE
+${philosophy.hardGate}
+
+## Anti-Patterns & Red Flags
+${mergedAntiPatterns(philosophy, executionModel)}
+
+## Process
+${processSummary.length > 0 ? processSummary.map((item, i) => `${i + 1}. ${item}`).join("\n") : "1. Execute the Checklist in order.\n2. Satisfy every required gate.\n3. Complete verification before stage closeout."}
 
-${whenNotToUseBlock(stage, track)}
 ## Inputs
-${schema.inputs.length > 0 ? schema.inputs.map((item) => `- ${item}`).join("\n") : "- (first stage — no required inputs)"}
+${executionModel.inputs.length > 0 ? executionModel.inputs.map((item) => `- ${item}`).join("\n") : "- (first stage — no required inputs)"}
 
 ## Required Context
-${schema.requiredContext.length > 0 ? schema.requiredContext.map((item) => `- ${item}`).join("\n") : "- None beyond this skill"}
+${executionModel.requiredContext.length > 0 ? executionModel.requiredContext.map((item) => `- ${item}`).join("\n") : "- None beyond this skill"}
 
-${contextLoadingBlock(stage, track)}
+${contextLoadingBlock(artifactRules.crossStageTrace)}
 ${autoSubagentDispatchBlock(stage, track)}
-${researchPlaybooksBlock(stage, track)}
-
-## Outputs
-${schema.outputs.map((item) => `- ${item}`).join("\n")}
-
-## HARD-GATE
-${schema.hardGate}
+${researchPlaybooksBlock(executionModel.researchPlaybooks ?? [])}
 
 ## Checklist
 
@@ -386,15 +404,12 @@ You MUST complete these steps in order:
 
 ${checklistItems}
 
-${stageGoodBadExamples(stage)}
-${stageDomainExamples(stage)}
 ${stageExamples(stage)}
 
 ## Interaction Protocol
 ${interactionFocus.length > 0 ? interactionFocus.map((item, i) => `${i + 1}. ${item}`).join("\n") : "- Keep communication concise and decision-focused; rely on the Checklist for execution order."}
 
-Shared decision/ask-user protocol:
-\`${DECISION_PROTOCOL_PATH}\`
+Decision protocol reference: \`${DECISION_PROTOCOL_PATH}\`
 
 ${batchExecutionModeBlock(stage, track)}
 ## Required Gates
@@ -403,22 +418,24 @@ ${gateList}
 ## Required Evidence
 ${evidenceList}
 
-## Process
-${processSummary.length > 0 ? processSummary.map((item, i) => `${i + 1}. ${item}`).join("\n") : "1. Execute the Checklist in order.\n2. Satisfy every required gate.\n3. Complete verification before stage closeout."}
-${processNote.length > 0 ? `\n${processNote}` : ""}
-
-${reviewSectionsBlock(stage, track)}
 ${verificationBlock(stage)}
-${crossStageTraceBlock(stage, track)}
-${artifactValidationBlock(stage, track)}
-
-## Anti-Patterns & Red Flags
-${mergedAntiPatterns(schema)}
 
 ## Verification
-${schema.exitCriteria.map((item) => `- [ ] ${item}`).join("\n")}
+${executionModel.exitCriteria.map((item) => `- [ ] ${item}`).join("\n")}
 
 ${completionParametersBlock(schema, track)}
+## Artifact Rules
+- Artifact target: \`${RUNTIME_ROOT}/artifacts/${artifactRules.artifactFile}\`
+
+${crossStageTraceBlock(artifactRules.crossStageTrace)}
+${artifactValidationBlock(artifactRules.artifactValidation)}
+
+## Review Lens
+${reviewLoopSection ? `${reviewLoopSection}\n` : ""}## Outputs
+${reviewLens.outputs.map((item) => `- ${item}`).join("\n")}
+
+${reviewSectionsBlock(reviewLens.reviewSections)}
+
 ## Shared Stage Guidance
 See:
 - \`${STAGE_COMMON_GUIDANCE_REL_PATH}\`

package/dist/content/stage-schema.d.ts

@@ -1,6 +1,6 @@
 import type { FlowStage, FlowTrack, TransitionRule } from "../types.js";
 import type { StageComplexityTier, StageAutoSubagentDispatch, StageSchema } from "./stages/schema-types.js";
-export type { ArtifactValidation, CrossStageTrace, ReviewSection, StageComplexityTier, StageExecutionModel, StagePhilosophy, StageArtifactRules, StageReviewLens, StageAutoSubagentDispatch, StageGate, StageSchemaLegacyInput, StageSchema, StageSchemaInput, StageSchemaV2Input } from "./stages/schema-types.js";
+export type { ArtifactValidation, CrossStageTrace, ReviewSection, StageComplexityTier, StageExecutionModel, StagePhilosophy, StageArtifactRules, StageReviewLoop, StageReviewLens, StageAutoSubagentDispatch, StageGate, StageSchemaLegacyInput, StageSchema, StageSchemaInput, StageSchemaV2Input } from "./stages/schema-types.js";
 export declare const SKILL_ENVELOPE_KINDS: readonly ["stage-output", "gate-result", "delegation-record"];
 export type SkillEnvelopeKind = (typeof SKILL_ENVELOPE_KINDS)[number];
 export interface SkillEnvelope {

package/dist/content/stage-schema.js

@@ -145,13 +145,23 @@ const REQUIRED_GATE_IDS = {
     ]
 };
 const REQUIRED_ARTIFACT_SECTIONS = {
-    brainstorm: ["Context", "Problem", "Approaches", "Selected Direction"],
+    brainstorm: [
+        "Context",
+        "Problem",
+        "Approach Tier",
+        "Approaches",
+        "Approach Reaction",
+        "Selected Direction"
+    ],
     scope: ["Scope Mode", "In Scope / Out of Scope", "Completion Dashboard", "Scope Summary"],
     design: [
         "Research Fleet Synthesis",
         "Architecture Boundaries",
         "Architecture Diagram",
         "Failure Mode Table",
+        "Security & Threat Model",
+        "Observability & Debuggability",
+        "Deployment & Rollout",
         "Completion Dashboard"
     ],
     spec: ["Acceptance Criteria", "Edge Cases", "Testability Map", "Approval"],
@@ -227,6 +237,7 @@ function normalizeStageSchemaInput(value) {
         next: value.next,
         checklist: value.executionModel.checklist,
         reviewSections: value.reviewLens.reviewSections,
+        reviewLoop: value.reviewLens.reviewLoop,
         completionStatus: value.artifactRules.completionStatus,
         crossStageTrace: value.artifactRules.crossStageTrace,
         artifactValidation: value.artifactRules.artifactValidation,
@@ -453,7 +464,8 @@ export function stageSchema(stage, track = "standard") {
     const reviewLens = {
         outputs: base.outputs,
         reviewSections: base.reviewSections,
-        mandatoryDelegations
+        mandatoryDelegations,
+        reviewLoop: base.reviewLoop
     };
     return {
         ...base,

package/dist/content/stages/brainstorm.js

@@ -44,6 +44,7 @@ export const BRAINSTORM = {
             "**Propose 2-3 architecturally distinct approaches** — with real trade-offs and no recommendation yet. At least one option must be a higher-upside challenger that raises ambition vs the user's initial ask.",
             "**Collect user reaction** — ask which approach feels closest and what concerns remain before stating your recommendation.",
             "**Recommend only after reaction** — present final recommendation with rationale that explicitly references user feedback.",
+            "**Plant-seed shelf (optional)** — when a non-selected approach is still promising, capture it as `.cclaw/seeds/SEED-<YYYY-MM-DD>-<slug>.md` with `trigger_when`, hypothesis, and suggested action instead of losing it.",
             "**Present design by sections** — scale each section to its complexity. Ask after each section whether it looks right so far. Cover: architecture, key components, data flow.",
             "**Optional visual companion** — when architecture/data flow complexity is medium+ offer a compact diagram (ASCII or Mermaid) before artifact write-up.",
             "**Write artifact** to `.cclaw/artifacts/01-brainstorm-<slug>.md`.",
@@ -74,6 +75,7 @@ export const BRAINSTORM = {
             "Propose 2-3 architecturally distinct approaches with trade-offs (one must be higher-upside challenger).",
             "Collect user reaction before giving your recommendation.",
             "Recommend after reaction and explain how feedback changed the recommendation.",
+            "Optionally plant promising non-selected approaches into `.cclaw/seeds/SEED-<YYYY-MM-DD>-<slug>.md` with trigger_when/action notes.",
             "Present design sections incrementally, get approval after each.",
             "Write approved direction to `.cclaw/artifacts/01-brainstorm-<slug>.md`.",
             "Run document-quality pass to close contradictions and weak trade-off reasoning.",
@@ -93,6 +95,7 @@ export const BRAINSTORM = {
             "2-3 approaches with trade-offs are recorded, including one higher-upside challenger option.",
             "User reaction to approaches is captured before final recommendation.",
             "Final recommendation explicitly reflects user reaction.",
+            "When a promising option is parked, a seed file is created under `.cclaw/seeds/` and referenced in the artifact.",
             "Approved direction and approval marker are present.",
             "Assumptions and open questions are captured (or explicitly marked as none)."
         ],
@@ -130,13 +133,21 @@ export const BRAINSTORM = {
             { section: "Context", required: true, validationRule: "Must reference project state and relevant existing code or patterns." },
             { section: "Problem", required: true, validationRule: "Must define what we're solving, success criteria, and constraints." },
             { section: "Clarifying Questions", required: false, validationRule: "Must capture question, answer, and decision impact for each clarifying question." },
-            { section: "Approach Tier", required: false, validationRule: "Must classify depth as Lightweight/Standard/Deep and explain why." },
-            { section: "Approaches", required: true, validationRule: "Must compare 2-3 architecturally distinct options with real trade-offs and include one higher-upside challenger option." },
-            { section: "Approach Reaction", required: false, validationRule: "Must summarize user reaction before recommendation, including concerns that changed direction." },
-            { section: "Selected Direction", required: true, validationRule: "Must include the selected approach, rationale tied to user reaction, and explicit approval marker." },
+            { section: "Approach Tier", required: true, validationRule: "Must classify depth as Lightweight/Standard/Deep and explain why." },
+            { section: "Short-Circuit Decision", required: false, validationRule: "Must include Status/Why/Scope handoff lines when short-circuit is discussed." },
+            { section: "Approaches", required: true, validationRule: "Must compare 2-3 architecturally distinct options with real trade-offs and include one row labeled `challenger: higher-upside`." },
+            { section: "Approach Reaction", required: true, validationRule: "Must summarize user reaction before recommendation, including concerns that changed direction." },
+            { section: "Selected Direction", required: true, validationRule: "Must include the selected approach, rationale tied to user reaction/feedback, and explicit approval marker." },
             { section: "Design", required: false, validationRule: "Must cover architecture, key components, and data flow scaled to complexity." },
             { section: "Visual Companion", required: false, validationRule: "If architecture/data-flow complexity is medium+, include compact ASCII/Mermaid diagram or explicitly justify omission." },
             { section: "Assumptions and Open Questions", required: false, validationRule: "Must capture unresolved assumptions/open questions, or explicitly state none." }
+        ],
+        trivialOverrideSections: [
+            "Context",
+            "Problem",
+            "Approach Tier",
+            "Short-Circuit Decision",
+            "Selected Direction"
         ]
     },
     reviewLens: {