cclaw-cli 0.51.29 → 0.55.2

package/dist/content/{ideate-command.js → idea-command.js}

@@ -1,43 +1,43 @@
 import { RUNTIME_ROOT } from "../constants.js";
-import { resolveIdeateFrames } from "./ideate-frames.js";
-import { ideateStructuredAskToolsWithFallback } from "./decision-protocol.js";
+import { resolveIdeaFrames } from "./idea-frames.js";
+import { ideaStructuredAskToolsWithFallback } from "./decision-protocol.js";
 import { conversationLanguagePolicyMarkdown } from "./language-policy.js";
-const IDEATE_SKILL_FOLDER = "flow-ideate";
-const IDEATE_SKILL_NAME = "flow-ideate";
+const IDEA_SKILL_FOLDER = "flow-idea";
+const IDEA_SKILL_NAME = "flow-idea";
 /**
- * Directory + filename convention for ideate artifacts. These are separate
- * from stage artifacts (00-..08-*.md) because `/cc-ideate` runs outside the
+ * Directory + filename convention for idea artifacts. These are separate
+ * from stage artifacts (00-..08-*.md) because `/cc-idea` runs outside the
  * critical-path flow state machine and must not collide with stage numbering.
  */
-const IDEATE_ARTIFACT_GLOB = ".cclaw/artifacts/ideate-*.md";
-const IDEATE_ARTIFACT_PATTERN = ".cclaw/artifacts/ideate-<YYYY-MM-DD-slug>.md";
-const IDEATE_RESUME_WINDOW_DAYS = 30;
-const STRUCTURED_ASK_TOOLS = ideateStructuredAskToolsWithFallback();
-export function minimumDistinctIdeateFrames(frameCount, mode = "repo-grounded") {
+const IDEA_ARTIFACT_GLOB = ".cclaw/artifacts/idea-*.md";
+const IDEA_ARTIFACT_PATTERN = ".cclaw/artifacts/idea-<YYYY-MM-DD-slug>.md";
+const IDEA_RESUME_WINDOW_DAYS = 30;
+const STRUCTURED_ASK_TOOLS = ideaStructuredAskToolsWithFallback();
+export function minimumDistinctIdeaFrames(frameCount, mode = "repo-grounded") {
     if (frameCount <= 0)
         return 0;
     const cap = mode === "repo-grounded" ? 4 : 2;
     return Math.min(cap, frameCount);
 }
 function renderFrameBullets(frameIds) {
-    return resolveIdeateFrames(frameIds)
+    return resolveIdeaFrames(frameIds)
         .map((frame) => `   - ${frame.label} (\`${frame.id}\`)`)
         .join("\n");
 }
 function renderFrameNames(frameIds) {
-    return resolveIdeateFrames(frameIds)
+    return resolveIdeaFrames(frameIds)
         .map((frame) => frame.label)
         .join(", ");
 }
-export function ideateCommandContract(options = {}) {
-    const frames = resolveIdeateFrames(options.frameIds);
+export function ideaCommandContract(options = {}) {
+    const frames = resolveIdeaFrames(options.frameIds);
     const frameBullets = renderFrameBullets(options.frameIds);
-    const minimumDistinctFrames = minimumDistinctIdeateFrames(frames.length, options.mode);
-    return `# /cc-ideate
+    const minimumDistinctFrames = minimumDistinctIdeaFrames(frames.length, options.mode);
+    return `# /cc-idea
 
 ## Purpose
 
-Repository-improvement ideate mode. Generate a ranked backlog of
+Repository-improvement idea mode. Generate a ranked backlog of
 high-value improvements, persist it as an artifact on disk, and end with
 an explicit handoff — either launch \`/cc\` on a chosen candidate in the
 same session, or save/discard the backlog.
@@ -45,18 +45,20 @@ same session, or save/discard the backlog.
 ## HARD-GATE
 
 ${conversationLanguagePolicyMarkdown()}
-- Ideate mode only. Never mutate \`.cclaw/state/flow-state.json\`.
+- Idea mode only. Never mutate \`.cclaw/state/flow-state.json\`.
 - Every recommendation cites evidence from the current repository
   (file path, command output, or knowledge-store entry id).
-- Always write a persisted artifact to
-  \`${IDEATE_ARTIFACT_PATTERN}\`. Chat-only output is not acceptable —
-  the next session must be able to resume.
-- Always end with a structured handoff prompt, not an open question.
+- Whenever you produce ideation output, persist it to
+  \`${IDEA_ARTIFACT_PATTERN}\`. Chat-only output is not acceptable.
+  The only exception is an explicit user-cancel from the resume prompt —
+  in that case, write nothing and exit silently.
+- Always end with a structured handoff prompt, not an open question
+  (skipped on explicit cancel).
 
 ## Algorithm
 
-1. **Resume check.** Glob \`${IDEATE_ARTIFACT_GLOB}\`. If any artifact
-   has been modified within the last ${IDEATE_RESUME_WINDOW_DAYS} days,
+1. **Resume check.** Glob \`${IDEA_ARTIFACT_GLOB}\`. If any artifact
+   has been modified within the last ${IDEA_RESUME_WINDOW_DAYS} days,
    offer the user: continue that backlog, start fresh, or cancel.
 2. **Mode classification.** Explicitly classify subject:
    \`repo-grounded\` / \`elsewhere-software\` / \`elsewhere-non-software\` / \`narrow\`.
@@ -83,7 +85,7 @@ ${frameBullets}
    \`(impact points / effort cost) * confidence multiplier\` and recommend
    the top survivor.
 8. **Write the artifact** at
-   \`${IDEATE_ARTIFACT_PATTERN}\` using the schema in the skill.
+   \`${IDEA_ARTIFACT_PATTERN}\` using the schema in the skill.
 8.5 **Seed shelf (optional).** For critiqued-out or deferred ideas that still
    show upside, write seed notes to
    \`${RUNTIME_ROOT}/seeds/SEED-<YYYY-MM-DD>-<slug>.md\` with
@@ -91,61 +93,66 @@ ${frameBullets}
 9. **Present the handoff prompt** with four concrete options — not A/B/C
    letters. Default = "Start /cc on the top recommendation".
 
-## Headless mode
+## Headless mode (CI/automation only)
 
+Headless envelopes are a machine-mode exception for CI/automation orchestration.
+In normal interactive ideation, respond with natural language plus the artifact path.
 For skill-to-skill invocation, emit exactly one JSON envelope:
 
 \`\`\`json
-{"version":"1","kind":"stage-output","stage":"non-flow","payload":{"command":"/cc-ideate","artifact":".cclaw/artifacts/ideate-<date>-<slug>.md","recommendation":"I-1"},"emittedAt":"<ISO-8601>"}
+{"version":"1","kind":"stage-output","stage":"non-flow","payload":{"command":"/cc-idea","artifact":".cclaw/artifacts/idea-<date>-<slug>.md","recommendation":"I-1"},"emittedAt":"<ISO-8601>"}
 \`\`\`
 
 Validate envelopes with:
-\`cclaw internal envelope-validate --stdin\`
+\`npx cclaw-cli internal envelope-validate --stdin\`
 
 ## Primary skill
 
-   **${RUNTIME_ROOT}/skills/${IDEATE_SKILL_FOLDER}/SKILL.md**
+   **${RUNTIME_ROOT}/skills/${IDEA_SKILL_FOLDER}/SKILL.md**
 `;
 }
-export function ideateCommandSkillMarkdown(options = {}) {
-    const frames = resolveIdeateFrames(options.frameIds);
+export function ideaCommandSkillMarkdown(options = {}) {
+    const frames = resolveIdeaFrames(options.frameIds);
     const frameBullets = renderFrameBullets(options.frameIds);
-    const minimumDistinctFrames = minimumDistinctIdeateFrames(frames.length, options.mode);
+    const minimumDistinctFrames = minimumDistinctIdeaFrames(frames.length, options.mode);
     const frameNames = renderFrameNames(options.frameIds);
     return `---
-name: ${IDEATE_SKILL_NAME}
-description: "Repository ideate mode: detect and rank high-leverage improvements, persist a backlog artifact, and hand off to /cc or save/discard."
+name: ${IDEA_SKILL_NAME}
+description: "Repository idea mode: detect and rank high-leverage improvements, persist a backlog artifact, and hand off to /cc or save/discard."
 ---
 
-# /cc-ideate
+# /cc-idea
 
 ## Announce at start
 
-"Using flow-ideate to identify highest-leverage improvements in this
+"Using flow-idea to identify highest-leverage improvements in this
 repository. Will persist a ranked backlog to
-\`${IDEATE_ARTIFACT_PATTERN}\` and end with an explicit handoff."
+\`${IDEA_ARTIFACT_PATTERN}\` and end with an explicit handoff."
 
 ## HARD-GATE
 
 ${conversationLanguagePolicyMarkdown()}
-- Do not start coding in ideate mode.
-- Do not mutate \`.cclaw/state/flow-state.json\` — ideate mode sits outside
+- Do not start coding in idea mode.
+- Do not mutate \`.cclaw/state/flow-state.json\` — idea mode sits outside
   the critical-path flow.
-- Always produce the artifact file on disk before presenting the handoff.
+- Whenever ideation output is produced, persist the artifact file on disk
+  before presenting the handoff. The only exception is an explicit user-cancel
+  from the resume prompt — in that case, write nothing and exit silently.
 - Always end with a structured handoff that names the concrete follow-up
-  command for each option. No A/B/C letters without command context.
+  command for each option (skipped on explicit cancel). No A/B/C letters
+  without command context.
 
 ## Protocol
 
 ### Phase 0 — Resume and classify
 
 1. Use the harness's file-glob tool (\`Glob\` pattern
-   \`${IDEATE_ARTIFACT_GLOB}\` or equivalent \`ls\`/\`find\`).
-2. Filter to files modified within the last ${IDEATE_RESUME_WINDOW_DAYS} days.
+   \`${IDEA_ARTIFACT_GLOB}\` or equivalent \`ls\`/\`find\`).
+2. Filter to files modified within the last ${IDEA_RESUME_WINDOW_DAYS} days.
 3. If one or more match, present **one** structured ask using the
    harness's native tool (${STRUCTURED_ASK_TOOLS}) with options:
    - **Continue the existing backlog** — read the most-recent
-     ideate-*.md and work from its candidate list; skip re-scanning.
+     idea-*.md and work from its candidate list; skip re-scanning.
    - **Start a fresh scan** — proceed to Phase 1; the old artifact stays
      on disk for history.
    - **Cancel** — stop; do not scan or write anything.
@@ -218,10 +225,10 @@ Only survivors advance to ranking.
    and break ties with rationale strength.
 4. Compute the artifact filename:
    - \`slug\` = first 3–5 words of the top recommendation, lowercase,
-     non-alphanumeric collapsed to \`-\`, trimmed. When ideate mode is
+     non-alphanumeric collapsed to \`-\`, trimmed. When idea mode is
      focus-hinted (user passed an argument), use the focus hint instead.
    - \`date\` = today in \`YYYY-MM-DD\` (local time).
-   - Path = \`.cclaw/artifacts/ideate-<date>-<slug>.md\`.
+   - Path = \`.cclaw/artifacts/idea-<date>-<slug>.md\`.
 5. Use the harness's write-file tool (\`Write\`, \`apply_patch\`, or shell
    \`cat <<EOF > path\`) to create the artifact with this schema:
 
@@ -269,7 +276,7 @@ Only survivors advance to ranking.
 6. Optional: for promising non-selected ideas, write
    \`${RUNTIME_ROOT}/seeds/SEED-<YYYY-MM-DD>-<slug>.md\` entries with:
    \`title\`, \`trigger_when\`, \`hypothesis\`, \`action\`, and
-   \`source_artifact\` = ideate artifact path.
+   \`source_artifact\` = idea artifact path.
 7. Confirm in chat: "Wrote <path>."
 
 ### Phase 5 — Handoff prompt
@@ -286,7 +293,7 @@ Required options, in this order:
 2. **Pick a different candidate** — the agent asks which ID (I-2, I-3, …)
    and then invokes \`/cc <that candidate's handoff phrase>\`.
 3. **Save and close** — leave the artifact on disk, do nothing else.
-   Next session: \`/cc-ideate\` will offer to resume it.
+   Next session: \`/cc-idea\` will offer to resume it.
 4. **Discard** — delete the just-written artifact. Use only when the
    scan produced nothing actionable.
 
@@ -298,7 +305,7 @@ lettered list with the same four labels. Do not invent extra options.
 - **Start /cc on I-1** or **different candidate:** announce
   "Handing off to /cc <phrase>" and load the \`using-cclaw\` router
   skill. From there, the normal \`/cc\` classification and stage flow
-  takes over. Do not produce a second artifact; the ideate file is
+  takes over. Do not produce a second artifact; the idea file is
   preserved as the origin document for this run.
 - **Save and close:** reply with the artifact path and stop.
 - **Discard:** delete the artifact file, confirm deletion, stop.

package/dist/content/idea-frames.d.ts

@@ -0,0 +1,31 @@
+export type IdeaFrameId = "pain-friction" | "inversion" | "assumption-break" | "leverage" | "cross-domain-analogy" | "constraint-flip";
+export interface IdeaFrame {
+    id: IdeaFrameId;
+    label: string;
+    prompt: string;
+    examplePatterns: string[];
+}
+export interface IdeaFrameDispatchInput {
+    focus: string;
+    mode: "repo-grounded" | "elsewhere-software" | "elsewhere-non-software";
+    signalSummary: string[];
+}
+export interface IdeaFrameDispatchPlanEntry {
+    frameId: IdeaFrameId;
+    label: string;
+    prompt: string;
+}
+export interface IdeaCandidateDraft {
+    title: string;
+    evidencePath: string;
+    summary: string;
+    frameId: IdeaFrameId;
+}
+export interface IdeaCandidateMerged extends Omit<IdeaCandidateDraft, "frameId"> {
+    frameIds: IdeaFrameId[];
+}
+export declare const DEFAULT_IDEA_FRAME_IDS: readonly IdeaFrameId[];
+export declare const IDEA_FRAMES: readonly IdeaFrame[];
+export declare function resolveIdeaFrames(frameIds?: readonly IdeaFrameId[]): IdeaFrame[];
+export declare function buildIdeaFrameDispatchPlan(input: IdeaFrameDispatchInput, frameIds?: readonly IdeaFrameId[]): IdeaFrameDispatchPlanEntry[];
+export declare function dedupeIdeaCandidates(drafts: readonly IdeaCandidateDraft[]): IdeaCandidateMerged[];

package/dist/content/{ideate-frames.js → idea-frames.js}

@@ -60,7 +60,7 @@ const FRAME_REGISTRY = {
         ]
     }
 };
-export const DEFAULT_IDEATE_FRAME_IDS = Object.freeze([
+export const DEFAULT_IDEA_FRAME_IDS = Object.freeze([
     "pain-friction",
     "inversion",
     "assumption-break",
@@ -68,16 +68,16 @@ export const DEFAULT_IDEATE_FRAME_IDS = Object.freeze([
     "cross-domain-analogy",
     "constraint-flip"
 ]);
-export const IDEATE_FRAMES = Object.freeze(DEFAULT_IDEATE_FRAME_IDS.map((id) => FRAME_REGISTRY[id]));
-export function resolveIdeateFrames(frameIds) {
+export const IDEA_FRAMES = Object.freeze(DEFAULT_IDEA_FRAME_IDS.map((id) => FRAME_REGISTRY[id]));
+export function resolveIdeaFrames(frameIds) {
     if (!frameIds || frameIds.length === 0) {
-        return [...IDEATE_FRAMES];
+        return [...IDEA_FRAMES];
     }
     const seen = new Set();
     const resolved = [];
     for (const rawId of frameIds) {
-        if (!DEFAULT_IDEATE_FRAME_IDS.includes(rawId)) {
-            throw new Error(`Unknown ideate frame id: ${rawId}`);
+        if (!DEFAULT_IDEA_FRAME_IDS.includes(rawId)) {
+            throw new Error(`Unknown idea frame id: ${rawId}`);
         }
         if (seen.has(rawId))
             continue;
@@ -86,11 +86,11 @@ export function resolveIdeateFrames(frameIds) {
     }
     return resolved;
 }
-export function buildIdeateFrameDispatchPlan(input, frameIds) {
+export function buildIdeaFrameDispatchPlan(input, frameIds) {
     const signalBlock = input.signalSummary.length > 0
         ? input.signalSummary.map((line) => `- ${line}`).join("\n")
         : "- no pre-scan signals captured yet";
-    return resolveIdeateFrames(frameIds).map((frame) => ({
+    return resolveIdeaFrames(frameIds).map((frame) => ({
         frameId: frame.id,
         label: frame.label,
         prompt: [
@@ -115,7 +115,7 @@ function normalizeCandidateKey(title, evidencePath) {
         .replace(/\\/gu, "/");
     return `${normalizedTitle}::${normalizedEvidence}`;
 }
-export function dedupeIdeateCandidates(drafts) {
+export function dedupeIdeaCandidates(drafts) {
     const merged = new Map();
     for (const draft of drafts) {
         const key = normalizeCandidateKey(draft.title, draft.evidencePath);

package/dist/content/idea-ranking.d.ts

@@ -0,0 +1,25 @@
+export type IdeaImpact = "high" | "medium" | "low";
+export type IdeaEffort = "s" | "m" | "l";
+export type IdeaConfidence = "high" | "medium" | "low";
+export interface IdeaCandidateEvaluationInput {
+    id: string;
+    title: string;
+    impact: IdeaImpact;
+    effort: IdeaEffort;
+    confidence: IdeaConfidence;
+    rationaleStrength: number;
+    counterArgumentStrength: number;
+}
+export interface IdeaCandidateEvaluation extends IdeaCandidateEvaluationInput {
+    disposition: "survivor" | "critiqued-out";
+    rankingScore: number;
+}
+export interface IdeaRankingResult {
+    survivors: IdeaCandidateEvaluation[];
+    critiquedOut: IdeaCandidateEvaluation[];
+    recommendationId: string | null;
+}
+export declare function isCritiquedOut(rationaleStrength: number, counterArgumentStrength: number): boolean;
+export declare function scoreIdeaCandidate(impact: IdeaImpact, effort: IdeaEffort, confidence: IdeaConfidence): number;
+export declare function evaluateIdeaCandidate(input: IdeaCandidateEvaluationInput): IdeaCandidateEvaluation;
+export declare function rankIdeaCandidates(inputs: readonly IdeaCandidateEvaluationInput[], maxSurvivors?: number): IdeaRankingResult;

package/dist/content/{ideate-ranking.js → idea-ranking.js}

@@ -25,22 +25,22 @@ function clampStrength(value) {
 export function isCritiquedOut(rationaleStrength, counterArgumentStrength) {
     return clampStrength(counterArgumentStrength) > clampStrength(rationaleStrength);
 }
-export function scoreIdeateCandidate(impact, effort, confidence) {
+export function scoreIdeaCandidate(impact, effort, confidence) {
     const raw = (IMPACT_POINTS[impact] / EFFORT_COST[effort]) * CONFIDENCE_MULTIPLIER[confidence];
     return Number(raw.toFixed(3));
 }
-export function evaluateIdeateCandidate(input) {
+export function evaluateIdeaCandidate(input) {
     const disposition = isCritiquedOut(input.rationaleStrength, input.counterArgumentStrength)
         ? "critiqued-out"
         : "survivor";
     return {
         ...input,
         disposition,
-        rankingScore: scoreIdeateCandidate(input.impact, input.effort, input.confidence)
+        rankingScore: scoreIdeaCandidate(input.impact, input.effort, input.confidence)
     };
 }
-export function rankIdeateCandidates(inputs, maxSurvivors = 10) {
-    const evaluated = inputs.map(evaluateIdeateCandidate);
+export function rankIdeaCandidates(inputs, maxSurvivors = 10) {
+    const evaluated = inputs.map(evaluateIdeaCandidate);
     const survivors = evaluated
         .filter((candidate) => candidate.disposition === "survivor")
         .sort((left, right) => {

package/dist/content/iron-laws.d.ts

@@ -138,5 +138,4 @@ export declare function ironLawRuntimeDocument(options?: {
     strictLaws?: string[];
     nowIso?: string;
 }): IronLawRuntimeDocument;
-export declare function ironLawsAgentsMdBlock(): string;
 export declare function ironLawsSkillMarkdown(): string;

package/dist/content/iron-laws.js

@@ -146,31 +146,37 @@ export function ironLawRuntimeDocument(options = {}) {
         laws
     };
 }
-export function ironLawsAgentsMdBlock() {
-    const rows = IRON_LAWS.map((law) => {
-        return `| \`${law.id}\` | ${law.rule} | ${law.enforcement} | ${law.severity} |`;
-    }).join("\n");
-    return `### Iron Laws
-
-These rules are always-on. Hook-enforced laws can block actions in strict mode.
-
-| ID | Rule | Enforced by | Level |
-|---|---|---|---|
-${rows}
-`;
+function appliesToLabel(law) {
+    return law.appliesTo === "all" ? "all stages" : law.appliesTo.join(", ");
+}
+function hardGateReference(law) {
+    if (law.appliesTo === "all") {
+        return "the active stage `HARD-GATE` block in `.cclaw/skills/<stage>/SKILL.md`";
+    }
+    return law.appliesTo
+        .map((stage) => `\`${RUNTIME_ROOT}/skills/${stage}/SKILL.md\` (${stage} HARD-GATE)`)
+        .join(", ");
 }
 export function ironLawsSkillMarkdown() {
-    const list = IRON_LAWS.map((law, index) => {
-        const applies = law.appliesTo === "all" ? "all stages" : law.appliesTo.join(", ");
+    const enforcedLawIds = new Set([
+        "stop-clean-or-handoff",
+        "review-coverage-complete-before-ship"
+    ]);
+    const enforced = IRON_LAWS.filter((law) => enforcedLawIds.has(law.id));
+    const advisory = IRON_LAWS.filter((law) => !enforcedLawIds.has(law.id));
+    const enforcedSections = enforced.map((law, index) => {
         return `### ${index + 1}. ${law.title}
 
 - **ID:** \`${law.id}\`
 - **Rule:** ${law.rule}
 - **Why:** ${law.rationale}
-- **Applies to:** ${applies}
+- **Applies to:** ${appliesToLabel(law)}
 - **Enforced by:** ${law.enforcement} (${law.severity})
 `;
     }).join("\n");
+    const advisoryList = advisory
+        .map((law) => `- \`${law.id}\` — applies to ${appliesToLabel(law)}; see ${hardGateReference(law)}.`)
+        .join("\n");
     return `---
 name: iron-laws
 description: "Non-negotiable workflow constraints enforced by cclaw hooks and routing."
@@ -181,7 +187,16 @@ description: "Non-negotiable workflow constraints enforced by cclaw hooks and ro
 These are cclaw's non-negotiable constraints for harness sessions.  
 Use them as the final arbitration layer when local instructions conflict.
 
-${list}
+## Hook-Enforced Runtime Laws
+
+${enforcedSections}
+
+## Advisory Laws (Stage-Owned)
+
+The following laws remain active guidance, but their canonical enforcement surface
+is each stage's \`HARD-GATE\` contract:
+
+${advisoryList}
 
 ## Practical rule
 

package/dist/content/learnings.js

@@ -101,7 +101,7 @@ Optional fields \`source\`, \`severity\`, \`supersedes\`, and \`superseded_by\`
 | \`first_seen_ts\` | ISO 8601 UTC string | yes | First observed timestamp (usually equals \`created\`). |
 | \`last_seen_ts\` | ISO 8601 UTC string | yes | Last re-confirmed timestamp. |
 | \`project\` | string \\| null | yes | Repo or scope name. Use \`null\` when the entry crosses projects. |
-| \`source\` | \`"stage" \\| "retro" \\| "compound" \\| "ideate" \\| "manual" \\| null\` | no | Origin channel for the entry when known. |
+| \`source\` | \`"stage" \\| "retro" \\| "compound" \\| "idea" \\| "manual" \\| null\` | no | Origin channel for the entry when known. |
 | \`severity\` | \`"critical" \\| "important" \\| "suggestion"\` | no | Priority signal for compound lifts; \`critical\` enables single-hit override in compound readiness analysis. |
 | \`supersedes\` | string[] | no | Non-empty IDs/slugs of older entries this entry refreshes. Use only for clear replacements discovered during compound closeout or curation. |
 | \`superseded_by\` | string | no | Non-empty ID/slug of the newer entry that refreshes this one. Use only when marking stale guidance as replaced. |

package/dist/content/meta-skill.js

@@ -13,7 +13,7 @@ function generatedHelperSkillList() {
 export function usingCclawSkillMarkdown() {
     return `---
 name: using-cclaw
-description: "Routing brain for cclaw. Decide whether to start/resume a stage, answer directly, or use visible commands like /cc, /cc-next, /cc-ideate, and /cc-view."
+description: "Routing brain for cclaw. Decide whether to start/resume a stage, answer directly, or use visible commands like /cc, /cc-idea, and /cc-cancel."
 ---
 
 # Using Cclaw
@@ -64,12 +64,11 @@ Task arrives
   ├─ Running as spawned subagent? -> obey parent prompt only; do not run cclaw routing
   ├─ Pure question / non-software ask? -> answer directly (no stage)
   ├─ New software work? -> /cc <idea>
-  ├─ Repo-improvement discovery? -> /cc-ideate
-  ├─ Resume existing flow? -> /cc or /cc-next
+  ├─ Repo-improvement discovery? -> /cc-idea
+  ├─ Resume existing flow? -> /cc
   ├─ Knowledge operation? -> load the learnings skill
-  ├─ Read-only workspace view? -> /cc-view [status|tree|diff]
-  ├─ Normal post-ship closeout? -> /cc-next drives ${closeoutChainInline()}
-  └─ Explicit early archival/reset? -> npx cclaw-cli archive [--name=<slug>]
+  ├─ Normal post-ship closeout? -> /cc drives ${closeoutChainInline()}
+  └─ Explicit early cancellation/abandonment? -> /cc-cancel
 \`\`\`
 
 ## Task classification
@@ -87,25 +86,24 @@ Task arrives
 Before stage work:
 
 1. Read \`.cclaw/state/flow-state.json\`.
-2. If active stage exists, continue with \`/cc\` or \`/cc-next\`.
+2. If active stage exists, continue with \`/cc\`.
 3. Do not jump directly to stage-specific commands.
 
 ## Platform reliability notes
 
 - Managed hook dispatch uses \`.cclaw/hooks/run-hook.cmd\` (cross-platform wrapper).
-- If hooks fail due missing runtime deps (for example \`node\` not on \`PATH\`), run \`npx cclaw-cli doctor\` before continuing.
+- If hooks fail due missing runtime deps (for example \`node\` not on \`PATH\`), run \`npx cclaw-cli sync\` before continuing.
 - Prefer cross-platform commands in artifacts/examples (\`npm test\`, \`pnpm test\`, \`python -m pytest\`, etc.) over shell-specific aliases whenever possible.
 
 ## Stage quick map
 
-Use \`/cc <idea>\` for new work, \`/cc-next\` for progression and closeout, \`/cc-view\` for read-only state, and \`/cc-ideate\` for backlog discovery.
+Use \`/cc <idea>\` for new work, \`/cc\` for progression and closeout, \`/cc-idea\` for backlog discovery, and \`/cc-cancel\` for cancellation/abandonment.
 
 ## Main vs Operator Surfaces
 
-- **Main workflow:** \`/cc\`, \`/cc-next\`, \`/cc-ideate\`, \`/cc-view status\`, and \`node .cclaw/hooks/stage-complete.mjs <stage>\` inside the installed harness runtime.
-- **Installer/support surface:** \`npx cclaw-cli init\`, \`npx cclaw-cli sync\`, \`npx cclaw-cli upgrade\`, \`npx cclaw-cli doctor\`, and explicit support/archive actions. Do not ask users to install or run a \`cclaw\` binary during normal stage flow.
-- **Read-only support:** \`/cc-view tree\` and \`/cc-view diff\`.
-- Use operator/support surfaces only for install/runtime diagnosis, explicit archival, or deeper inspection. Do not make them part of the happy path.
+- **Main workflow:** \`/cc\`, \`/cc-idea\`, and \`/cc-cancel\` inside the installed harness runtime.
+- **Installer/support surface:** \`npx cclaw-cli init\`, \`npx cclaw-cli sync\`, \`npx cclaw-cli upgrade\`, \`npx cclaw-cli sync\`, and \`npx cclaw-cli uninstall\`.
+- Use operator/support surfaces only for install/runtime diagnosis or lifecycle maintenance. Do not make them part of the happy path.
 
 ## Whole flow map
 

package/dist/content/node-hooks.d.ts

@@ -15,6 +15,16 @@ export interface NodeHookRuntimeOptions {
      * `cclaw sync` after changing the config value so hook and CLI agree.
      */
     compoundRecurrenceThreshold?: number;
+    /**
+     * Enables early-stage producer/critic loop diagnostics in session-start.
+     * Defaults to true.
+     */
+    earlyLoopEnabled?: boolean;
+    /**
+     * Baked-in max iterations for brainstorm/scope/design early-loop status.
+     * Derived from `config.earlyLoop.maxIterations`.
+     */
+    earlyLoopMaxIterations?: number;
 }
 /**
  * Node-only hook runtime (single entrypoint).