cclaw-cli 0.51.30 → 1.0.0

package/dist/gate-evidence.js

@@ -2,16 +2,16 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { checkReviewSecurityNoChangeAttestation, checkReviewVerdictConsistency, extractMarkdownSectionBody, lintArtifact, validateReviewArmy } from "./artifact-linter.js";
 import { resolveArtifactPath } from "./artifact-paths.js";
+import { readConfig } from "./config.js";
 import { RUNTIME_ROOT } from "./constants.js";
 import { stageSchema } from "./content/stage-schema.js";
 import { readDelegationLedger } from "./delegation.js";
-import { ensureDir, exists, writeFileSafe } from "./fs-utils.js";
+import { exists } from "./fs-utils.js";
+import { computeEarlyLoopStatus, isEarlyLoopStage, normalizeEarlyLoopMaxIterations } from "./early-loop.js";
 import { detectPublicApiChanges } from "./internal/detect-public-api-changes.js";
 import { readFlowState, writeFlowState } from "./runs.js";
 import { parseTddCycleLog, validateTddCycleOrder } from "./tdd-cycle.js";
 import { validateTddVerificationEvidence } from "./tdd-verification-evidence.js";
-import { buildTraceMatrix } from "./trace-matrix.js";
-import { FLOW_STAGES } from "./types.js";
 async function currentStageArtifactExists(projectRoot, stage, track) {
     const resolved = await resolveArtifactPath(stage, {
         projectRoot,
@@ -105,8 +105,7 @@ async function discoverRealTestCommands(projectRoot) {
     return unique(commands);
 }
 async function verifyDiscoveredCommandEvidence(projectRoot, stage, gateId, flowState) {
-    if (!(stage === "tdd" && gateId === "tdd_verified_before_complete") &&
-        !(stage === "review" && gateId === "review_trace_matrix_clean")) {
+    if (!(stage === "tdd" && gateId === "tdd_verified_before_complete")) {
         return null;
     }
     const commands = await discoverRealTestCommands(projectRoot);
@@ -119,111 +118,99 @@ async function verifyDiscoveredCommandEvidence(projectRoot, stage, gateId, flowS
         return null;
     return `${stage} verification gate blocked (${gateId}): guard evidence must cite one discovered real test command: ${commands.join(", ")}.`;
 }
-const RECONCILIATION_NOTICES_FILE = "reconciliation-notices.json";
-const RECONCILIATION_NOTICES_SCHEMA_VERSION = 1;
-const DESIGN_RESEARCH_REQUIRED_SECTIONS = [
-    "Stack Analysis",
-    "Features & Patterns",
-    "Architecture Options",
-    "Pitfalls & Risks",
-    "Synthesis"
-];
-export const RECONCILIATION_NOTICES_REL_PATH = `${RUNTIME_ROOT}/state/${RECONCILIATION_NOTICES_FILE}`;
-function isFlowStageValue(value) {
-    return typeof value === "string" && FLOW_STAGES.includes(value);
-}
-function reconciliationNoticesPath(projectRoot) {
-    return path.join(projectRoot, RUNTIME_ROOT, "state", RECONCILIATION_NOTICES_FILE);
-}
-function defaultReconciliationNoticesPayload() {
-    return {
-        schemaVersion: RECONCILIATION_NOTICES_SCHEMA_VERSION,
-        notices: [],
-        parseOk: true,
-        schemaOk: true
-    };
-}
-function sanitizeReconciliationNotice(raw) {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+function toEarlyLoopGateSnapshot(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
         return null;
-    }
-    const typed = raw;
-    if (typeof typed.id !== "string" ||
-        typeof typed.runId !== "string" ||
-        !isFlowStageValue(typed.stage) ||
-        typeof typed.gateId !== "string" ||
-        typeof typed.reason !== "string" ||
-        typeof typed.demotedAt !== "string") {
+    const typed = value;
+    const stage = typeof typed.stage === "string" ? typed.stage : "";
+    const runId = typeof typed.runId === "string" ? typed.runId : "active";
+    const iteration = typeof typed.iteration === "number" && Number.isInteger(typed.iteration) && typed.iteration >= 0
+        ? typed.iteration
+        : 0;
+    const maxIterations = normalizeEarlyLoopMaxIterations(typeof typed.maxIterations === "number" ? typed.maxIterations : undefined);
+    const openConcernIds = Array.isArray(typed.openConcerns)
+        ? typed.openConcerns
+            .flatMap((concern) => {
+            if (!concern || typeof concern !== "object" || Array.isArray(concern))
+                return [];
+            const id = concern.id;
+            return typeof id === "string" && id.trim().length > 0 ? [id.trim()] : [];
+        })
+            .sort((a, b) => a.localeCompare(b, "en"))
+        : [];
+    if (stage.length === 0)
         return null;
-    }
     return {
-        id: typed.id,
-        runId: typed.runId,
-        stage: typed.stage,
-        gateId: typed.gateId,
-        reason: typed.reason,
-        demotedAt: typed.demotedAt
+        stage,
+        runId,
+        iteration,
+        maxIterations,
+        openConcernIds,
+        openConcernCount: openConcernIds.length,
+        convergenceTripped: typed.convergenceTripped === true,
+        escalationReason: typeof typed.escalationReason === "string" && typed.escalationReason.trim().length > 0
+            ? typed.escalationReason.trim()
+            : undefined
     };
 }
-export async function readReconciliationNotices(projectRoot) {
-    const filePath = reconciliationNoticesPath(projectRoot);
-    if (!(await exists(filePath))) {
-        return defaultReconciliationNoticesPayload();
+async function readEarlyLoopGateSnapshot(projectRoot, flowState) {
+    if (!isEarlyLoopStage(flowState.currentStage)) {
+        return { snapshot: null };
+    }
+    const stateDir = path.join(projectRoot, RUNTIME_ROOT, "state");
+    const statusPath = path.join(stateDir, "early-loop.json");
+    let onDisk = null;
+    if (await exists(statusPath)) {
+        try {
+            onDisk = toEarlyLoopGateSnapshot(JSON.parse(await fs.readFile(statusPath, "utf8")));
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            return {
+                snapshot: null,
+                issue: `early loop gate blocked (early_loop_open_concerns): unable to parse ${statusPath} (${reason}). ` +
+                    "Rebuild status with `cclaw internal early-loop-status --write`."
+            };
+        }
+    }
+    if (onDisk &&
+        onDisk.stage === flowState.currentStage &&
+        onDisk.runId === flowState.activeRunId) {
+        return { snapshot: onDisk };
     }
     try {
-        const raw = JSON.parse(await fs.readFile(filePath, "utf8"));
-        const schemaOk = raw.schemaVersion === RECONCILIATION_NOTICES_SCHEMA_VERSION;
-        const notices = Array.isArray(raw.notices)
-            ? raw.notices
-                .map((value) => sanitizeReconciliationNotice(value))
-                .filter((value) => value !== null)
-            : [];
+        const config = await readConfig(projectRoot);
+        const computed = await computeEarlyLoopStatus(flowState.currentStage, flowState.activeRunId, path.join(stateDir, "early-loop-log.jsonl"), {
+            maxIterations: config.earlyLoop?.maxIterations
+        });
         return {
-            schemaVersion: RECONCILIATION_NOTICES_SCHEMA_VERSION,
-            notices,
-            parseOk: true,
-            schemaOk
+            snapshot: {
+                stage: computed.stage,
+                runId: computed.runId,
+                iteration: computed.iteration,
+                maxIterations: computed.maxIterations,
+                openConcernIds: computed.openConcerns.map((concern) => concern.id),
+                openConcernCount: computed.openConcerns.length,
+                convergenceTripped: computed.convergenceTripped,
+                escalationReason: computed.escalationReason
+            }
         };
     }
-    catch {
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
         return {
-            ...defaultReconciliationNoticesPayload(),
-            parseOk: false,
-            schemaOk: false
+            snapshot: null,
+            issue: `early loop gate blocked (early_loop_open_concerns): unable to compute status from early-loop-log.jsonl (${reason}).`
         };
     }
 }
-async function writeReconciliationNotices(projectRoot, payload) {
-    const filePath = reconciliationNoticesPath(projectRoot);
-    await ensureDir(path.dirname(filePath));
-    await writeFileSafe(filePath, `${JSON.stringify({
-        schemaVersion: RECONCILIATION_NOTICES_SCHEMA_VERSION,
-        notices: payload.notices
-    }, null, 2)}\n`, { mode: 0o600 });
-}
-export function classifyReconciliationNotices(flowState, notices) {
-    const activeBlocked = [];
-    const currentStageBlocked = [];
-    const unsynced = [];
-    const staleRun = [];
-    for (const notice of notices) {
-        if (notice.runId !== flowState.activeRunId) {
-            staleRun.push(notice);
-            continue;
-        }
-        const stageCatalog = flowState.stageGateCatalog[notice.stage];
-        const blocked = stageCatalog.blocked.includes(notice.gateId);
-        if (!blocked) {
-            unsynced.push(notice);
-            continue;
-        }
-        activeBlocked.push(notice);
-        if (notice.stage === flowState.currentStage) {
-            currentStageBlocked.push(notice);
-        }
-    }
-    return { activeBlocked, currentStageBlocked, unsynced, staleRun };
-}
+const DESIGN_RESEARCH_REQUIRED_SECTIONS = [
+    "Stack Analysis",
+    "Features & Patterns",
+    "Architecture Options",
+    "Pitfalls & Risks",
+    "Synthesis"
+];
 export async function verifyCurrentStageGateEvidence(projectRoot, flowState) {
     const stage = flowState.currentStage;
     const schema = stageSchema(stage, flowState.track);
@@ -239,6 +226,7 @@ export async function verifyCurrentStageGateEvidence(projectRoot, flowState) {
     const recommendedSet = new Set(recommended);
     const allowedSet = new Set([...required, ...recommended]);
     const issues = [];
+    const softNotices = [];
     const catalogRequired = unique(catalog.required);
     const catalogRecommended = unique(catalog.recommended ?? []);
     const catalogConditional = unique(catalog.conditional ?? []);
@@ -338,23 +326,6 @@ export async function verifyCurrentStageGateEvidence(projectRoot, flowState) {
             if (!securityAttestation.ok) {
                 issues.push(`review security attestation failed: ${securityAttestation.errors.join("; ")}`);
             }
-            const traceGateRequired = schema.requiredGates.some((gate) => gate.id === "review_trace_matrix_clean" && gate.tier === "required");
-            if (traceGateRequired) {
-                const trace = await buildTraceMatrix(projectRoot);
-                const traceIssues = [];
-                if (trace.orphanedCriteria.length > 0) {
-                    traceIssues.push(`orphaned criteria: ${trace.orphanedCriteria.join(", ")}`);
-                }
-                if (trace.orphanedTasks.length > 0) {
-                    traceIssues.push(`orphaned tasks: ${trace.orphanedTasks.join(", ")}`);
-                }
-                if (trace.orphanedTests.length > 0) {
-                    traceIssues.push(`orphaned tests: ${trace.orphanedTests.join(", ")}`);
-                }
-                if (traceIssues.length > 0) {
-                    issues.push(`review trace-matrix gate blocked (review_trace_matrix_clean): ${traceIssues.join("; ")}.`);
-                }
-            }
         }
         if (stage === "design") {
             const researchGateRequired = schema.requiredGates.some((gate) => gate.id === "design_research_complete" && gate.tier === "required");
@@ -439,8 +410,33 @@ export async function verifyCurrentStageGateEvidence(projectRoot, flowState) {
             }
         }
     }
+    if (isEarlyLoopStage(stage)) {
+        const { snapshot, issue } = await readEarlyLoopGateSnapshot(projectRoot, flowState);
+        if (issue) {
+            issues.push(issue);
+        }
+        else if (snapshot && snapshot.openConcernCount > 0) {
+            const concernTail = snapshot.openConcernIds.length > 3
+                ? `, +${snapshot.openConcernIds.length - 3} more`
+                : "";
+            const concernSample = snapshot.openConcernIds.slice(0, 3).join(", ");
+            if (snapshot.convergenceTripped) {
+                const reason = snapshot.escalationReason ?? "convergence guard tripped";
+                softNotices.push(`early loop escalation notice (early_loop_open_concerns): ${reason}; ` +
+                    `open concerns remain (${concernSample}${concernTail}). Request explicit human override before advancing.`);
+            }
+            else {
+                issues.push(`early loop gate blocked (early_loop_open_concerns): ` +
+                    `${snapshot.openConcernCount} open concern(s) remain after iteration ` +
+                    `${snapshot.iteration}/${snapshot.maxIterations} (${concernSample}${concernTail}).`);
+            }
+        }
+    }
     const missingRequired = required.filter((gateId) => !passedSet.has(gateId));
-    const missingRecommended = recommended.filter((gateId) => !passedSet.has(gateId));
+    const missingRecommended = [
+        ...recommended.filter((gateId) => !passedSet.has(gateId)),
+        ...softNotices
+    ];
     const missingTriggeredConditional = [];
     const blockingBlocked = catalog.blocked.filter((gateId) => requiredSet.has(gateId));
     const complete = missingRequired.length === 0 && blockingBlocked.length === 0;
@@ -604,46 +600,8 @@ export function reconcileCurrentStageGateCatalog(flowState) {
 export async function reconcileAndWriteCurrentStageGateCatalog(projectRoot) {
     const state = await readFlowState(projectRoot);
     const { nextState, reconciliation } = reconcileCurrentStageGateCatalog(state);
-    const effectiveState = reconciliation.changed ? nextState : state;
     if (reconciliation.changed) {
-        await writeFlowState(projectRoot, effectiveState);
-    }
-    const noticesPayload = await readReconciliationNotices(projectRoot);
-    let noticesChanged = false;
-    const noticeBuckets = classifyReconciliationNotices(effectiveState, noticesPayload.notices);
-    if (noticeBuckets.unsynced.length > 0 || noticeBuckets.staleRun.length > 0) {
-        const dropIds = new Set([...noticeBuckets.unsynced, ...noticeBuckets.staleRun].map((notice) => notice.id));
-        noticesPayload.notices = noticesPayload.notices.filter((notice) => !dropIds.has(notice.id));
-        noticesChanged = true;
-    }
-    if (reconciliation.demotedGateIds.length > 0) {
-        const existing = new Set(noticesPayload.notices.map((notice) => `${notice.runId}:${notice.stage}:${notice.gateId}`));
-        for (const gateId of reconciliation.demotedGateIds) {
-            const dedupeKey = `${effectiveState.activeRunId}:${reconciliation.stage}:${gateId}`;
-            if (existing.has(dedupeKey)) {
-                continue;
-            }
-            const ts = new Date().toISOString();
-            noticesPayload.notices.push({
-                id: `${dedupeKey}:${ts}`,
-                runId: effectiveState.activeRunId,
-                stage: reconciliation.stage,
-                gateId,
-                reason: "demoted from passed to blocked during gate reconciliation (missing evidence)",
-                demotedAt: ts
-            });
-            existing.add(dedupeKey);
-            noticesChanged = true;
-        }
-    }
-    if (noticesChanged) {
-        noticesPayload.notices.sort((a, b) => {
-            if (a.demotedAt === b.demotedAt) {
-                return a.id.localeCompare(b.id);
-            }
-            return a.demotedAt.localeCompare(b.demotedAt);
-        });
-        await writeReconciliationNotices(projectRoot, noticesPayload);
+        await writeFlowState(projectRoot, nextState);
     }
     return {
         ...reconciliation,

package/dist/harness-adapters.d.ts

@@ -32,7 +32,7 @@ export type SubagentFallback =
  *   directories under a skills root (Codex CLI ≥0.89, Jan 2026). cclaw
  *   writes `<commandDir>/<skillName>/SKILL.md` and the agent invokes it
  *   either via `/use <skillName>` or via automatic description matching
- *   when the user's text mentions `/cc`, `/cc-ideate`, or `/cc-cancel`.
+ *   when the user's text mentions `/cc`, `/cc-idea`, or `/cc-cancel`.
  */
 export type ShimKind = "command" | "skill";
 export interface HarnessAdapter {
@@ -47,7 +47,7 @@ export interface HarnessAdapter {
      * Root directory where cclaw writes `/cc*` entry points.
      *
      * - For `shimKind: "command"` this is the directory containing flat
-     *   markdown files (`<commandDir>/cc.md`, `<commandDir>/cc-ideate.md`, …).
+     *   markdown files (`<commandDir>/cc.md`, `<commandDir>/cc-idea.md`, …).
      * - For `shimKind: "skill"` this is the skills root that contains
      *   per-skill subdirectories (`<commandDir>/<skillName>/SKILL.md`).
      */

package/dist/harness-adapters.js

@@ -3,7 +3,7 @@ import path from "node:path";
 import { RUNTIME_ROOT } from "./constants.js";
 import { conversationLanguagePolicyMarkdown } from "./content/language-policy.js";
 import { CCLAW_AGENTS, agentMarkdown } from "./content/core-agents.js";
-import { ironLawsAgentsMdBlock } from "./content/iron-laws.js";
+import { IRON_LAWS } from "./content/iron-laws.js";
 import { ensureDir, exists, writeFileSafe } from "./fs-utils.js";
 export const CCLAW_MARKER_START = "<!-- cclaw-start -->";
 export const CCLAW_MARKER_END = "<!-- cclaw-end -->";
@@ -15,11 +15,11 @@ 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");
 const UTILITY_SHIMS = [
     {
-        fileName: "cc-ideate.md",
-        skillName: "cc-ideate",
-        command: "ideate",
-        skillFolder: "flow-ideate",
-        commandFile: "ideate.md"
+        fileName: "cc-idea.md",
+        skillName: "cc-idea",
+        command: "idea",
+        skillFolder: "flow-idea",
+        commandFile: "idea.md"
     },
     {
         fileName: "cc-cancel.md",
@@ -163,9 +163,9 @@ export function harnessDispatchSurface(harnessId) {
         case "cursor":
             return "Use Cursor Subagent/Task with a generic subagent_type (explore for read-only mapping, generalPurpose for broader work, shell/browser-use when specifically needed) and paste the cclaw role prompt; record fulfillmentMode: \"generic-dispatch\" with evidenceRefs.";
         case "opencode":
-            return "Use OpenCode subagents: invoke the generated .opencode/agents/<agent>.md agent via Task or @<agent>; if agents or plugin registration are missing, run `cclaw sync` and check opencode.json(.c) plugin registration with `cclaw doctor --explain`; record scheduled/launched/acknowledged/completed events with spanId+dispatchId before claiming fulfillmentMode: \"isolated\".";
+            return "Use OpenCode subagents: invoke the generated .opencode/agents/<agent>.md agent via Task or @<agent>; if agents or plugin registration are missing, run `cclaw sync` and check opencode.json(.c) plugin registration with `npx cclaw-cli sync`; record scheduled/launched/acknowledged/completed events with spanId+dispatchId before claiming fulfillmentMode: \"isolated\".";
         case "codex":
-            return "Use Codex native subagents: ask Codex to spawn the generated .codex/agents/<agent>.toml agent(s) by name; if hooks are inert, set `[features] codex_hooks = true` in ~/.codex/config.toml or rerun init/sync repair, then `cclaw doctor --explain`; record scheduled/launched/acknowledged/completed events with spanId+dispatchId before claiming fulfillmentMode: \"isolated\".";
+            return "Use Codex native subagents: ask Codex to spawn the generated .codex/agents/<agent>.toml agent(s) by name; if hooks are inert, set `[features] codex_hooks = true` in ~/.codex/config.toml or rerun init/sync repair, then `npx cclaw-cli sync`; record scheduled/launched/acknowledged/completed events with spanId+dispatchId before claiming fulfillmentMode: \"isolated\".";
     }
 }
 /**
@@ -292,6 +292,35 @@ export function harnessesByTier() {
         return tierOrder[harnessTier(a)] - tierOrder[harnessTier(b)];
     });
 }
+function ironLawsAgentsMdBlock() {
+    const enforcedLawIds = new Set([
+        "stop-clean-or-handoff",
+        "review-coverage-complete-before-ship"
+    ]);
+    const enforcedRows = IRON_LAWS
+        .filter((law) => enforcedLawIds.has(law.id))
+        .map((law) => `| \`${law.id}\` | ${law.rule} | ${law.enforcement} |`)
+        .join("\n");
+    const advisoryRows = IRON_LAWS
+        .filter((law) => !enforcedLawIds.has(law.id))
+        .map((law) => {
+        const appliesTo = law.appliesTo === "all" ? "all stages" : law.appliesTo.join(", ");
+        return `- \`${law.id}\` (applies to: ${appliesTo})`;
+    })
+        .join("\n");
+    return `### Iron Laws
+
+These rules are always-on. The hook-enforced runtime laws are:
+
+| ID | Rule | Enforced by |
+|---|---|---|
+${enforcedRows}
+
+Advisory laws are stage-owned through each stage's HARD-GATE block:
+
+${advisoryRows}
+`;
+}
 function agentsMdBlock() {
     return `${CCLAW_MARKER_START}
 ## Cclaw — Workflow Adapter
@@ -343,13 +372,13 @@ When in doubt, prefer **non-trivial** — the quick track is opt-in and only saf
 | Command | Purpose |
 |---|---|
 | \`/cc\` | **Entry point.** No args = resume or progress current flow. With prompt = classify task and start the right flow. |
-| \`/cc-ideate\` | **Ideate mode.** Generates a ranked repo-improvement backlog before implementation. |
+| \`/cc-idea\` | **Idea mode.** Generates a ranked repo-improvement backlog before implementation. |
 | \`/cc-cancel\` | **Non-completion closeout.** Archives a cancelled/abandoned run with a required reason. |
 
 Knowledge capture and curation run automatically as part of stage completion
 protocols via the internal \`learnings\` skill — no user-facing command.
 Reusable entries land in \`.cclaw/knowledge.jsonl\` as strict JSONL with
-\`type\`, \`trigger\`, \`action\`, and \`origin_run\` metadata.
+\`type\`, \`trigger\`, \`action\`, \`confidence\`, \`stage\`, and \`origin_stage\` metadata.
 
 **Stage order:** brainstorm > scope > design > spec > plan > tdd > review > ship, then closeout: retro > compound > archive. Use \`/cc\` to keep moving through normal work and post-ship closeout; use \`/cc-cancel\` for cancelled/abandoned runs. Gates must pass before handoff.
 
@@ -372,11 +401,11 @@ If the same approach fails three times in a row (same command, same finding, sam
 ### Codex users
 
 OpenAI Codex CLI has **no native \`/cc\` slash command** (custom prompts
-were deprecated in v0.89, Jan 2026). The \`/cc\`, \`/cc-ideate\`, and
+were deprecated in v0.89, Jan 2026). The \`/cc\`, \`/cc-idea\`, and
 \`/cc-cancel\` tokens above describe intent — in Codex they map onto skills cclaw installs at
 \`.agents/skills/cc*/SKILL.md\`. Activate one of two ways:
 
-- Type \`/use cc\` (or \`cc-ideate\` / \`cc-cancel\`) at Codex's prompt.
+- Type \`/use cc\` (or \`cc-idea\` / \`cc-cancel\`) at Codex's prompt.
 - Type \`/cc …\` as plain text — Codex matches the skill \`description\`
   frontmatter (which spells out the token verbatim) and loads the right
   skill body automatically.
@@ -385,9 +414,9 @@ Codex CLI v0.114+ (Mar 2026) **does** expose lifecycle hooks via
 \`.codex/hooks.json\`, gated by the \`[features] codex_hooks = true\` flag
 in \`~/.codex/config.toml\`. cclaw generates \`.codex/hooks.json\` on
 sync; if the feature flag is off, hooks are inert and cclaw's
-session-start rehydration simply does not fire. Run \`cclaw doctor\` to
+session-start rehydration simply does not fire. Run \`npx cclaw-cli sync\` to
 see if the flag is missing. \`.codex/commands/*\` is still unused by
-Codex CLI and is removed on every sync. Run \`cclaw doctor --explain\` for
+Codex CLI and is removed on every sync. Run \`npx cclaw-cli sync\` for
 hook coverage details (Bash-only \`PreToolUse\`/\`PostToolUse\`; other events are full).
 ${CCLAW_MARKER_END}`;
 }
@@ -449,7 +478,7 @@ function utilityShimBehavior(command) {
     switch (command) {
         case "cc":
             return "This is the entry command, not a flow stage. It may initialize or resume flow state after confirmation.";
-        case "ideate":
+        case "idea":
             return "This is an ideation command, not a flow stage. It may write ideation artifacts/seeds but does not advance flow state.";
         case "cancel":
             return "This is a non-completion closeout utility, not a flow stage. It requires a reason and archives cancelled or abandoned work without presenting it as completed.";
@@ -484,8 +513,8 @@ function codexSkillDescription(command) {
     switch (command) {
         case "cc":
             return `Entry point for the cclaw track-aware workflow ending in ship plus auto-closeout (retro → compound → archive). Use whenever the user types \`/cc\`, \`/cclaw\`, or asks to "start the flow", "begin cclaw", "kick off the workflow", "classify this task", or wants to start/resume a non-trivial software change. No args = resume the active stage from \`.cclaw/state/flow-state.json\`. With a prompt = classify and pick a track (quick/medium/standard).`;
-        case "ideate":
-            return `Read-only repo-improvement ideate mode for cclaw. Use when the user types \`/cc-ideate\` or asks to "ideate", "scan the repo for TODOs/tech debt", "generate a backlog", or wants a ranked list of candidate ideas before committing to a single flow. Does not mutate \`.cclaw/state/flow-state.json\`.`;
+        case "idea":
+            return `Read-only repo-improvement idea mode for cclaw. Use when the user types \`/cc-idea\` or asks to "scan the repo for TODOs/tech debt", "generate a backlog", "brainstorm improvement ideas", or wants a ranked list of candidate ideas before committing to a single flow. Does not mutate \`.cclaw/state/flow-state.json\`.`;
         case "cancel":
             return `Cancel or abandon the active cclaw run. Use when the user types \`/cc-cancel\` or asks to cancel, abandon, stop, discard, or reset an unfinished run. Requires a reason and archives with cancelled/abandoned disposition.`;
         default:
@@ -518,7 +547,7 @@ under \`.agents/skills/${skillSlug}/\` so the user can either:
 
 Lifecycle hooks **are** available in Codex CLI v0.114+ (behind the
 \`[features] codex_hooks = true\` flag in \`~/.codex/config.toml\`) and
-cclaw installs a matching \`.codex/hooks.json\`; run \`cclaw doctor --explain\`
+cclaw installs a matching \`.codex/hooks.json\`; run \`npx cclaw-cli sync\`
 for the current hook surface and limitations.
 
 ## Protocol
@@ -542,7 +571,7 @@ for the current hook surface and limitations.
   unavailable or disabled, and then include non-empty \`evidenceRefs\`.
 - Codex's \`PreToolUse\` / \`PostToolUse\` hooks currently only intercept
   the \`Bash\` tool. \`Write\`, \`Edit\`, \`WebSearch\`, and MCP tool calls
-  are **not** gated by hooks — use \`cclaw doctor --explain\` for what cclaw
+  are **not** gated by hooks — use \`npx cclaw-cli sync\` for what cclaw
   substitutes with in-turn agent steps for those call classes.
 - Codex's \`SessionStart\` matcher only supports \`startup|resume\`. Claude
   and Cursor also fire on \`clear\` and \`compact\`, so mid-session