cclaw-cli 1.0.0 → 3.0.0

package/dist/content/templates.js

@@ -76,6 +76,13 @@ export const ARTIFACT_TEMPLATES = {
 |---|---|---|---|
 | 1 |  |  |  |
 
+## Q&A Log
+| Turn | Question | User answer (1-line) | Decision impact |
+|---|---|---|---|
+| 1 |  |  |  |
+
+> Append-only by turn. Add one row after each user answer; do not rewrite prior rows.
+
 ## Approach Tier
 - Tier: lite | standard | deep
 - Why this tier:
@@ -192,6 +199,13 @@ ${MARKDOWN_CODE_FENCE}
 - Open questions:
 - Drift from upstream (or \`None\`):
 
+## Q&A Log
+| Turn | Question | User answer (1-line) | Decision impact |
+|---|---|---|---|
+| 1 |  |  |  |
+
+> Append-only by turn. Add one row after each user answer; do not rewrite prior rows.
+
 ## Pre-Scope System Audit
 | Check | Command | Findings |
 |---|---|---|
@@ -427,6 +441,13 @@ ${MARKDOWN_CODE_FENCE}
 - Open questions:
 - Drift from upstream (or \`None\`):
 
+## Q&A Log
+| Turn | Question | User answer (1-line) | Decision impact |
+|---|---|---|---|
+| 1 |  |  |  |
+
+> Append-only by turn. Add one row after each user answer; do not rewrite prior rows.
+
 ## Codebase Investigation
 | File | Current responsibility | Patterns discovered | Existing fit / reuse candidate |
 |---|---|---|---|

package/dist/flow-state.d.ts

@@ -82,11 +82,18 @@ export interface FlowState {
     staleStages: Partial<Record<FlowStage, StaleStageMarker>>;
     /** Chronological rewind operations for the active run. */
     rewinds: RewindRecord[];
+    /** Optional per-stage interaction hints carried from prior stage transitions. */
+    interactionHints?: Partial<Record<FlowStage, StageInteractionHint>>;
     /** Mandatory retrospective gate status before archive. */
     retro: RetroState;
     /** Ship → post_ship_review → archive substate for resumable closeout. */
     closeout: CloseoutState;
 }
+export interface StageInteractionHint {
+    skipQuestions?: boolean;
+    sourceStage?: FlowStage;
+    recordedAt?: string;
+}
 export interface InitialFlowStateOptions {
     activeRunId?: string;
     track?: FlowTrack;

package/dist/flow-state.js

@@ -90,6 +90,7 @@ export function createInitialFlowState(activeRunIdOrOptions = {}, maybeTrack) {
         skippedStages,
         staleStages: {},
         rewinds: [],
+        interactionHints: {},
         retro: {
             required: false,
             completedAt: undefined,

package/dist/gate-evidence.js

@@ -2,7 +2,6 @@ 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";
@@ -179,10 +178,7 @@ async function readEarlyLoopGateSnapshot(projectRoot, flowState) {
         return { snapshot: onDisk };
     }
     try {
-        const config = await readConfig(projectRoot);
-        const computed = await computeEarlyLoopStatus(flowState.currentStage, flowState.activeRunId, path.join(stateDir, "early-loop-log.jsonl"), {
-            maxIterations: config.earlyLoop?.maxIterations
-        });
+        const computed = await computeEarlyLoopStatus(flowState.currentStage, flowState.activeRunId, path.join(stateDir, "early-loop-log.jsonl"));
         return {
             snapshot: {
                 stage: computed.stage,

package/dist/hook-schema.js

@@ -68,6 +68,9 @@ function validateClaudeLikeEvent(eventName, eventEntries, errors) {
             if (hook.timeout !== undefined && !isPositiveNumber(hook.timeout)) {
                 errors.push(`hooks.${eventName}[${index}].hooks[${hookIndex}].timeout must be a positive number when present`);
             }
+            if (hook.statusMessage !== undefined && !isNonEmptyString(hook.statusMessage)) {
+                errors.push(`hooks.${eventName}[${index}].hooks[${hookIndex}].statusMessage must be a non-empty string when present`);
+            }
         }
     }
 }

package/dist/hook-schemas/claude-hooks.v1.json

@@ -2,12 +2,9 @@
     "$schema": "https://json-schema.org/draft/2020-12/schema",
     "$id": "cclaw://hooks/claude/v1",
     "harness": "claude",
-    "schemaVersion": 1,
+    "schemaVersion": 2,
     "requiredEvents": [
         "SessionStart",
-        "PreToolUse",
-        "PostToolUse",
-        "Stop",
-        "PreCompact"
+        "Stop"
     ]
 }

package/dist/hook-schemas/codex-hooks.v1.json

@@ -2,12 +2,9 @@
     "$schema": "https://json-schema.org/draft/2020-12/schema",
     "$id": "cclaw://hooks/codex/v1",
     "harness": "codex",
-    "schemaVersion": 1,
+    "schemaVersion": 2,
     "requiredEvents": [
         "SessionStart",
-        "UserPromptSubmit",
-        "PreToolUse",
-        "PostToolUse",
         "Stop"
     ]
 }

package/dist/hook-schemas/cursor-hooks.v1.json

@@ -2,14 +2,12 @@
     "$schema": "https://json-schema.org/draft/2020-12/schema",
     "$id": "cclaw://hooks/cursor/v1",
     "harness": "cursor",
-    "schemaVersion": 1,
+    "schemaVersion": 2,
     "requiredEvents": [
         "sessionStart",
         "sessionResume",
         "sessionClear",
         "sessionCompact",
-        "preToolUse",
-        "postToolUse",
         "stop"
     ]
 }

package/dist/install.d.ts

@@ -11,13 +11,8 @@ export declare function initCclaw(options: InitOptions): Promise<void>;
 export declare function syncCclaw(projectRoot: string, options?: SyncOptions): Promise<void>;
 /**
  * Refresh generated files in `.cclaw/` without touching user-authored
- * artifacts, state, or custom config keys. Only the `version` + `flowVersion`
- * stamps are rewritten so the on-disk config reflects the installed CLI.
- *
- * Shape preservation: if the user previously hand-authored advanced keys
- * (e.g. `tdd`, `compound`, `trackHeuristics`, `sliceReview`), those stay in
- * the yaml. If their existing config is minimal, the upgrade keeps it
- * minimal — advanced knobs are never silently added.
+ * artifacts or state. Config remains harness-only with managed version
+ * stamps.
  */
 export declare function upgradeCclaw(projectRoot: string): Promise<void>;
 export declare function uninstallCclaw(projectRoot: string): Promise<void>;

package/dist/install.js

@@ -3,7 +3,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { promisify } from "node:util";
 import { CCLAW_VERSION, FLOW_VERSION, REQUIRED_DIRS, RUNTIME_ROOT } from "./constants.js";
-import { writeConfig, createDefaultConfig, readConfig, configPath, detectLanguageRulePacks, detectAdvancedKeys } from "./config.js";
+import { writeConfig, createDefaultConfig, readConfig, configPath, detectAdvancedKeys } from "./config.js";
 import { learnSkillMarkdown } from "./content/learnings.js";
 import { stageCommandShimMarkdown } from "./content/stage-command.js";
 import { ideaCommandContract, ideaCommandSkillMarkdown } from "./content/idea.js";
@@ -12,7 +12,7 @@ import { viewCommandContract, viewCommandSkillMarkdown } from "./content/view-co
 import { cancelCommandContract, cancelCommandSkillMarkdown } from "./content/cancel-command.js";
 import { subagentDrivenDevSkill, parallelAgentsSkill } from "./content/subagents.js";
 import { sessionHooksSkillMarkdown } from "./content/session-hooks.js";
-import { ironLawRuntimeDocument, ironLawsSkillMarkdown } from "./content/iron-laws.js";
+import { ironLawsSkillMarkdown } from "./content/iron-laws.js";
 import { stageCompleteScript, startFlowScript, cancelRunScript, runHookCmdScript, delegationRecordScript, opencodePluginJs, claudeHooksJson, codexHooksJson, cursorHooksJson } from "./content/hooks.js";
 import { nodeHookRuntimeScript } from "./content/node-hooks.js";
 import { META_SKILL_NAME, usingCclawSkillMarkdown } from "./content/meta-skill.js";
@@ -20,7 +20,8 @@ import { ARTIFACT_TEMPLATES, CURSOR_WORKFLOW_RULE_MDC, RULEBOOK_MARKDOWN, buildR
 import { STATE_CONTRACTS } from "./content/state-contracts.js";
 import { REVIEW_PROMPTS } from "./content/review-prompts.js";
 import { stageSkillFolder, stageSkillMarkdown, executingWavesSkillMarkdown } from "./content/skills.js";
-import { LANGUAGE_RULE_PACK_DIR, LANGUAGE_RULE_PACK_FILES, LANGUAGE_RULE_PACK_GENERATORS, LEGACY_LANGUAGE_RULE_PACK_FOLDERS } from "./content/utility-skills.js";
+import { adaptiveElicitationSkillMarkdown } from "./content/skills-elicitation.js";
+import { LANGUAGE_RULE_PACK_DIR, LEGACY_LANGUAGE_RULE_PACK_FOLDERS } from "./content/utility-skills.js";
 import { RESEARCH_PLAYBOOKS } from "./content/research-playbooks.js";
 import { SUBAGENT_CONTEXT_SKILLS } from "./content/subagent-context-skills.js";
 import { CCLAW_AGENTS } from "./content/core-agents.js";
@@ -406,55 +407,13 @@ async function removeManagedGitHookRelays(projectRoot) {
     }
 }
 async function syncManagedGitHooks(projectRoot, config) {
-    const hooksDir = await resolveGitHooksDir(projectRoot);
-    if (!hooksDir) {
-        return;
-    }
-    if (config.gitHookGuards !== true) {
-        await removeManagedGitHookRelays(projectRoot);
-        try {
-            await fs.rm(path.join(projectRoot, GIT_HOOK_RUNTIME_REL_DIR), { recursive: true, force: true });
-        }
-        catch {
-            // best-effort cleanup
-        }
-        return;
-    }
-    const runtimeGitHooksDir = path.join(projectRoot, GIT_HOOK_RUNTIME_REL_DIR);
-    await ensureDir(runtimeGitHooksDir);
-    for (const hookName of ["pre-commit", "pre-push"]) {
-        const runtimePathForHook = path.join(runtimeGitHooksDir, `${hookName}.mjs`);
-        await writeFileSafe(runtimePathForHook, managedGitRuntimeScript(hookName));
-        try {
-            await fs.chmod(runtimePathForHook, 0o755);
-        }
-        catch {
-            // best effort on constrained filesystems
-        }
+    void config;
+    await removeManagedGitHookRelays(projectRoot);
+    try {
+        await fs.rm(path.join(projectRoot, GIT_HOOK_RUNTIME_REL_DIR), { recursive: true, force: true });
     }
-    await ensureDir(hooksDir);
-    for (const hookName of ["pre-commit", "pre-push"]) {
-        const hookPath = path.join(hooksDir, hookName);
-        let canWriteRelay = true;
-        if (await exists(hookPath)) {
-            try {
-                const existing = await fs.readFile(hookPath, "utf8");
-                canWriteRelay = existing.includes(GIT_HOOK_MANAGED_MARKER);
-            }
-            catch {
-                canWriteRelay = false;
-            }
-        }
-        if (!canWriteRelay) {
-            continue;
-        }
-        await writeFileSafe(hookPath, managedGitRelayHook(hookName));
-        try {
-            await fs.chmod(hookPath, 0o755);
-        }
-        catch {
-            // best effort on constrained filesystems
-        }
+    catch {
+        // best-effort cleanup
     }
 }
 async function ensureStructure(projectRoot) {
@@ -474,7 +433,8 @@ async function writeWavePlansScaffold(projectRoot) {
     await writeFileSafe(runtimePath(projectRoot, "wave-plans", ".gitkeep"), "");
 }
 async function writeSkills(projectRoot, config) {
-    const skillTrack = config?.defaultTrack ?? "standard";
+    void config;
+    const skillTrack = "standard";
     for (const stage of FLOW_STAGES) {
         const folder = stageSkillFolder(stage);
         await writeFileSafe(runtimePath(projectRoot, "skills", folder, "SKILL.md"), stageSkillMarkdown(stage, skillTrack));
@@ -490,6 +450,7 @@ async function writeSkills(projectRoot, config) {
     await writeFileSafe(runtimePath(projectRoot, "skills", "session", "SKILL.md"), sessionHooksSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", "iron-laws", "SKILL.md"), ironLawsSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", "executing-waves", "SKILL.md"), executingWavesSkillMarkdown());
+    await writeFileSafe(runtimePath(projectRoot, "skills", "adaptive-elicitation", "SKILL.md"), adaptiveElicitationSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", META_SKILL_NAME, "SKILL.md"), usingCclawSkillMarkdown());
     // In-thread research procedures (no YAML frontmatter, not delegated personas).
     for (const [fileName, markdown] of Object.entries(RESEARCH_PLAYBOOKS)) {
@@ -501,42 +462,8 @@ async function writeSkills(projectRoot, config) {
     for (const [folderName, markdown] of Object.entries(SUBAGENT_CONTEXT_SKILLS)) {
         await writeFileSafe(runtimePath(projectRoot, "skills", folderName, "SKILL.md"), markdown);
     }
-    // Language rule packs live under .cclaw/rules/lang/<pack>.md. They are opt-in:
-    // only the packs listed in config.languageRulePacks are materialised. Any
-    // legacy per-language skill folders from v0.7.0 (.cclaw/skills/language-*)
-    // are cleaned up below so the new rules/lang layout is the only truth.
-    const enabledPacks = config?.languageRulePacks ?? [];
-    const enabledPackFileNames = new Set();
-    for (const pack of enabledPacks) {
-        const fileName = LANGUAGE_RULE_PACK_FILES[pack];
-        const generator = LANGUAGE_RULE_PACK_GENERATORS[pack];
-        if (!fileName || !generator)
-            continue;
-        enabledPackFileNames.add(fileName);
-        await writeFileSafe(runtimePath(projectRoot, ...LANGUAGE_RULE_PACK_DIR, fileName), generator());
-    }
-    // Strict idempotence: once a pack is removed from config, its generated
-    // file under .cclaw/rules/lang/ must disappear on the next sync. Without
-    // this loop the directory accumulates a superset of every pack ever
-    // enabled, which silently keeps stale guidance alive.
-    const langDir = runtimePath(projectRoot, ...LANGUAGE_RULE_PACK_DIR);
-    if (await exists(langDir)) {
-        const knownPackFileNames = new Set(Object.values(LANGUAGE_RULE_PACK_FILES));
-        let entries = [];
-        try {
-            entries = await fs.readdir(langDir);
-        }
-        catch {
-            entries = [];
-        }
-        for (const entry of entries) {
-            if (!knownPackFileNames.has(entry))
-                continue;
-            if (enabledPackFileNames.has(entry))
-                continue;
-            await fs.rm(path.join(langDir, entry), { force: true });
-        }
-    }
+    // Wave 21: language packs are no longer materialized from config.
+    await fs.rm(runtimePath(projectRoot, ...LANGUAGE_RULE_PACK_DIR), { recursive: true, force: true });
     for (const legacyFolder of LEGACY_LANGUAGE_RULE_PACK_FOLDERS) {
         const legacyPath = runtimePath(projectRoot, "skills", legacyFolder);
         if (await exists(legacyPath)) {
@@ -934,22 +861,10 @@ async function writeHooks(projectRoot, config) {
     const stateDir = runtimePath(projectRoot, "state");
     await ensureDir(hooksDir);
     await ensureDir(stateDir);
-    const effectiveStrictness = config.strictness ?? "advisory";
-    await writeFileSafe(runtimePath(projectRoot, "state", "iron-laws.json"), `${JSON.stringify(ironLawRuntimeDocument({
-        mode: effectiveStrictness,
-        strictLaws: config.ironLaws?.strictLaws
-    }), null, 2)}\n`);
     await writeFileSafe(path.join(hooksDir, "stage-complete.mjs"), stageCompleteScript());
     await writeFileSafe(path.join(hooksDir, "start-flow.mjs"), startFlowScript());
     await writeFileSafe(path.join(hooksDir, "cancel-run.mjs"), cancelRunScript());
-    const hookRuntimeOptions = {
-        strictness: effectiveStrictness,
-        tddTestPathPatterns: config.tdd?.testPathPatterns ?? config.tddTestGlobs,
-        tddProductionPathPatterns: config.tdd?.productionPathPatterns,
-        compoundRecurrenceThreshold: config.compound?.recurrenceThreshold,
-        earlyLoopEnabled: config.earlyLoop?.enabled,
-        earlyLoopMaxIterations: config.earlyLoop?.maxIterations
-    };
+    const hookRuntimeOptions = {};
     const bundledHookRuntime = await readBundledRunHookRuntimeScript(hookRuntimeOptions);
     await writeFileSafe(path.join(hooksDir, "run-hook.mjs"), bundledHookRuntime ?? nodeHookRuntimeScript(hookRuntimeOptions));
     await writeFileSafe(path.join(hooksDir, "run-hook.cmd"), runHookCmdScript());
@@ -1080,11 +995,17 @@ async function syncDisabledHarnessArtifacts(projectRoot, harnesses) {
     }
 }
 async function writeState(projectRoot, config, forceReset = false) {
+    void config;
+    // Fresh init no longer materializes flow-state.json. The first managed
+    // `/cc <idea>` start-flow call creates the state file.
+    if (!forceReset) {
+        return;
+    }
     const statePath = runtimePath(projectRoot, "state", "flow-state.json");
-    if (!forceReset && (await exists(statePath))) {
+    if (await exists(statePath)) {
         return;
     }
-    const state = createInitialFlowState({ track: config.defaultTrack ?? "standard" });
+    const state = createInitialFlowState({ track: "standard" });
     await writeFileSafe(statePath, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
 }
 async function cleanLegacyArtifacts(projectRoot) {
@@ -1282,19 +1203,12 @@ export async function initCclaw(options) {
     if (options.harnesses !== undefined && options.harnesses.length === 0) {
         throw new Error("Select at least one harness.");
     }
-    const baseConfig = createDefaultConfig(options.harnesses, options.track);
-    // Best-effort auto-detect: a Node project gets `typescript`, a Go module
-    // gets `go`, etc. Skipped entirely when the project root has no manifests.
-    const detectedPacks = await detectLanguageRulePacks(options.projectRoot);
-    const config = {
-        ...baseConfig,
-        languageRulePacks: detectedPacks
-    };
-    // Write a minimal `config.yaml` — advanced knobs live in docs/config.md
-    // and only appear in the on-disk file when the user sets them explicitly
-    // or a non-default value was detected (e.g. languageRulePacks).
+    const config = createDefaultConfig(options.harnesses, options.track);
+    // Wave 21: config is always minimal and harness-only.
     await writeConfig(options.projectRoot, config, { mode: "minimal" });
-    await materializeRuntime(options.projectRoot, config, true, "init");
+    // Init should scaffold runtime surfaces but leave flow-state creation to the
+    // first managed start-flow invocation.
+    await materializeRuntime(options.projectRoot, config, false, "init");
 }
 export async function syncCclaw(projectRoot, options = {}) {
     if (options.harnesses !== undefined && options.harnesses.length === 0) {
@@ -1330,13 +1244,8 @@ export async function syncCclaw(projectRoot, options = {}) {
 }
 /**
  * Refresh generated files in `.cclaw/` without touching user-authored
- * artifacts, state, or custom config keys. Only the `version` + `flowVersion`
- * stamps are rewritten so the on-disk config reflects the installed CLI.
- *
- * Shape preservation: if the user previously hand-authored advanced keys
- * (e.g. `tdd`, `compound`, `trackHeuristics`, `sliceReview`), those stay in
- * the yaml. If their existing config is minimal, the upgrade keeps it
- * minimal — advanced knobs are never silently added.
+ * artifacts or state. Config remains harness-only with managed version
+ * stamps.
  */
 export async function upgradeCclaw(projectRoot) {
     const configExists = await exists(configPath(projectRoot));
@@ -1418,7 +1327,7 @@ function isManagedRuntimeHookCommand(command) {
     // (e.g. `node .cclaw\hooks\run-hook.mjs ...`) still round-trip through
     // sync without being duplicated alongside freshly generated entries.
     const normalized = command.trim().replace(/\s+/gu, " ").replace(/\\/gu, "/");
-    if (/(^|\s)(?:node\s+)?(?:"|')?(?:\.\/)?\.cclaw\/hooks\/run-hook\.(?:mjs|cmd)(?:"|')?\s+(?:session-start|stop-handoff|stop-checkpoint|pre-compact|prompt-guard|workflow-guard|context-monitor|verify-current-state)(?:\s|$)/u.test(normalized)) {
+    if (/(^|\s)(?:node\s+)?(?:"|')?(?:\.\/)?\.cclaw\/hooks\/run-hook\.(?:mjs|cmd)(?:"|')?\s+(?:session-start|stop-handoff|stop-checkpoint|pre-compact|prompt-guard|workflow-guard|pre-tool-pipeline|prompt-pipeline|context-monitor|verify-current-state)(?:\s|$)/u.test(normalized)) {
         return true;
     }
     // Codex UserPromptSubmit non-blocking state nudge.

package/dist/internal/advance-stage/advance.js

@@ -40,6 +40,23 @@ function resolveSuccessorTransition(stage, track, transitionTargets, satisfiedGu
     }
     return natural;
 }
+function nextInteractionHints(flowState, args, successor) {
+    const hints = { ...(flowState.interactionHints ?? {}) };
+    delete hints[args.stage];
+    if (successor) {
+        if (args.skipQuestions) {
+            hints[successor] = {
+                skipQuestions: true,
+                sourceStage: args.stage,
+                recordedAt: new Date().toISOString()
+            };
+        }
+        else {
+            delete hints[successor];
+        }
+    }
+    return hints;
+}
 export async function hydrateReviewLoopEvidenceFromArtifact(projectRoot, stage, track, selectedGateIds, evidenceByGate) {
     const gateId = AUTO_REVIEW_LOOP_GATE_BY_STAGE[stage];
     if (!gateId)
@@ -243,6 +260,7 @@ export async function runAdvanceStage(projectRoot, args, io) {
                 mode: "mandatory",
                 status: "waived",
                 waiverReason,
+                runId: flowState.activeRunId,
                 fulfillmentMode: "role-switch",
                 ts: new Date().toISOString()
             });
@@ -452,10 +470,12 @@ export async function runAdvanceStage(projectRoot, args, io) {
         : flowState.completedStages.includes(args.stage)
             ? [...flowState.completedStages]
             : [...flowState.completedStages, args.stage];
+    const interactionHints = nextInteractionHints(flowState, args, successor);
     const finalState = {
         ...candidateState,
         completedStages,
-        currentStage: successor ?? args.stage
+        currentStage: successor ?? args.stage,
+        interactionHints
     };
     await writeFlowState(projectRoot, finalState);
     if (!args.quiet) {
@@ -466,6 +486,7 @@ export async function runAdvanceStage(projectRoot, args, io) {
             nextStage: successor,
             currentStage: finalState.currentStage,
             completedStages: finalState.completedStages,
+            skipQuestionsHint: args.skipQuestions,
             learnings: {
                 parsed: learningsHarvest.parsedEntries,
                 appended: learningsHarvest.appendedEntries,

package/dist/internal/advance-stage/parsers.d.ts

@@ -8,6 +8,7 @@ export interface AdvanceStageArgs {
     waiverReason?: string;
     acceptProactiveWaiver: boolean;
     acceptProactiveWaiverReason?: string;
+    skipQuestions: boolean;
     quiet: boolean;
     json: boolean;
 }

package/dist/internal/advance-stage/parsers.js

@@ -12,6 +12,7 @@ export function parseAdvanceStageArgs(tokens) {
     let waiverReason;
     let acceptProactiveWaiver = false;
     let acceptProactiveWaiverReason;
+    let skipQuestions = false;
     let quiet = false;
     let json = false;
     for (let i = 0; i < flagTokens.length; i += 1) {
@@ -80,6 +81,10 @@ export function parseAdvanceStageArgs(tokens) {
             acceptProactiveWaiver = true;
             continue;
         }
+        if (token === "--skip-questions") {
+            skipQuestions = true;
+            continue;
+        }
         if (token === "--accept-proactive-waiver-reason") {
             if (!nextToken || nextToken.startsWith("--")) {
                 throw new Error("--accept-proactive-waiver-reason requires a text value.");
@@ -102,6 +107,7 @@ export function parseAdvanceStageArgs(tokens) {
         waiverReason,
         acceptProactiveWaiver,
         acceptProactiveWaiverReason,
+        skipQuestions,
         quiet,
         json
     };

package/dist/internal/compound-readiness.js

@@ -1,7 +1,6 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { RUNTIME_ROOT } from "../constants.js";
-import { readConfig } from "../config.js";
 import { writeFileSafe } from "../fs-utils.js";
 import { computeCompoundReadiness, readKnowledgeSafely } from "../knowledge-store.js";
 function parseArgs(tokens) {
@@ -80,21 +79,7 @@ export function formatCompoundReadinessLine(status) {
 }
 export async function runCompoundReadinessCommand(projectRoot, argv, io) {
     const args = parseArgs(argv);
-    // Reading config is best-effort — but DO surface a stderr warning so
-    // mis-wired / malformed config shows up in hook-errors / CI logs
-    // instead of silently degrading to default threshold.
-    let config = null;
-    try {
-        config = await readConfig(projectRoot);
-    }
-    catch (error) {
-        const detail = error instanceof Error ? error.message : String(error);
-        io.stderr.write(`[cclaw] compound-readiness: failed to read config (${detail}); falling back to default threshold\n`);
-    }
-    const threshold = args.threshold ??
-        (typeof config?.compound?.recurrenceThreshold === "number"
-            ? config.compound.recurrenceThreshold
-            : undefined);
+    const threshold = args.threshold;
     const archivedRunsCount = await countArchivedRunsSafely(projectRoot);
     const { entries } = await readKnowledgeSafely(projectRoot, { lockAware: true });
     const status = computeCompoundReadiness(entries, {

package/dist/internal/early-loop-status.js

@@ -1,5 +1,4 @@
 import path from "node:path";
-import { readConfig } from "../config.js";
 import { RUNTIME_ROOT } from "../constants.js";
 import { computeEarlyLoopStatus, formatEarlyLoopStatusLine, isEarlyLoopStage } from "../early-loop.js";
 import { writeFileSafe } from "../fs-utils.js";
@@ -66,14 +65,13 @@ function stateDir(projectRoot) {
 export async function runEarlyLoopStatusCommand(projectRoot, argv, io) {
     const args = parseArgs(argv);
     const flow = await readFlowState(projectRoot).catch(() => null);
-    const config = await readConfig(projectRoot).catch(() => null);
     const stage = args.stage ?? flow?.currentStage;
     if (!isEarlyLoopStage(stage)) {
         io.stderr.write("cclaw internal early-loop-status: current stage is not an early-loop stage. Pass --stage=brainstorm|scope|design.\n");
         return 1;
     }
     const runId = (args.runId ?? flow?.activeRunId ?? "active").trim() || "active";
-    const status = await computeEarlyLoopStatus(stage, runId, path.join(stateDir(projectRoot), "early-loop-log.jsonl"), { maxIterations: config?.earlyLoop?.maxIterations });
+    const status = await computeEarlyLoopStatus(stage, runId, path.join(stateDir(projectRoot), "early-loop-log.jsonl"));
     if (args.write) {
         const target = path.join(stateDir(projectRoot), "early-loop.json");
         await writeFileSafe(target, `${JSON.stringify(status, null, 2)}\n`);

package/dist/internal/runtime-integrity.js

@@ -2,7 +2,6 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { readConfig } from "../config.js";
 import { RUNTIME_ROOT } from "../constants.js";
-import { classifyCodexHooksFlag, codexConfigPath, readCodexConfig } from "../codex-feature-flag.js";
 import { exists } from "../fs-utils.js";
 import { HARNESS_ADAPTERS, harnessShimFileNames, harnessShimSkillNames } from "../harness-adapters.js";
 import { validateHookDocument } from "../hook-schema.js";
@@ -220,24 +219,6 @@ async function checkHarnessShims(projectRoot, harnesses) {
     }
     return findings;
 }
-async function checkCodexHooksFlag(harnesses) {
-    if (!harnesses.includes("codex")) {
-        return warningFinding("codex_hooks_flag", true, "Codex harness is not enabled.");
-    }
-    const configTomlPath = codexConfigPath();
-    let existing;
-    try {
-        existing = await readCodexConfig(configTomlPath);
-    }
-    catch (error) {
-        return warningFinding("codex_hooks_flag", false, "Could not read Codex config.toml to validate codex_hooks.", [error instanceof Error ? error.message : String(error)]);
-    }
-    const state = classifyCodexHooksFlag(existing);
-    if (state === "enabled") {
-        return warningFinding("codex_hooks_flag", true, "Codex hooks feature flag is enabled.");
-    }
-    return warningFinding("codex_hooks_flag", false, "Codex hooks file is present, but [features] codex_hooks is not true in Codex config.", [`configPath: ${configTomlPath}`, `state: ${state}`]);
-}
 function buildReport(findings) {
     const errors = findings.filter((finding) => !finding.ok && finding.severity === "error").length;
     const warnings = findings.filter((finding) => !finding.ok && finding.severity === "warning").length;
@@ -274,7 +255,6 @@ export async function runRuntimeIntegrityCommand(projectRoot, argv, io) {
             findings.push(await checkHookDocument(projectRoot, harness));
         }
     }
-    findings.push(await checkCodexHooksFlag(harnesses));
     const report = buildReport(findings);
     if (!args.quiet) {
         if (args.json) {

package/dist/policy.js

@@ -96,11 +96,8 @@ export async function policyChecks(projectRoot, options = {}) {
         { file: runtimeFile("skills/session/SKILL.md"), needle: "## Session Resume Protocol", name: "utility_skill:session:resume" },
         { file: runtimeFile("skills/brainstorm/SKILL.md"), needle: "## Shared Stage Guidance", name: "stage_skill:shared_guidance_inline" },
         { file: runtimeFile("hooks/run-hook.mjs"), needle: "activeRunId", name: "hooks:session_start:active_run" },
-        { file: runtimeFile("hooks/run-hook.mjs"), needle: "write_to_cclaw_runtime", name: "hooks:guard:risky_write_advisory" },
-        { file: runtimeFile("hooks/run-hook.mjs"), needle: "stage_invocation_without_recent_flow_read", name: "hooks:workflow_guard:flow_read_reason" },
-        { file: runtimeFile("hooks/run-hook.mjs"), needle: "stage_jump_", name: "hooks:workflow_guard:stage_jump_reason" },
-        { file: runtimeFile("hooks/run-hook.mjs"), needle: "tdd_write_without_open_red", name: "hooks:workflow_guard:tdd_red_first" },
-        { file: runtimeFile("hooks/run-hook.mjs"), needle: "context remaining is", name: "hooks:context:threshold_warning" },
+        { file: runtimeFile("hooks/run-hook.mjs"), needle: "session-start", name: "hooks:session_start:wired" },
+        { file: runtimeFile("hooks/run-hook.mjs"), needle: "stop-handoff", name: "hooks:stop_handoff:wired" },
         { file: runtimeFile("hooks/opencode-plugin.mjs"), needle: "activeRunId", name: "hooks:opencode:active_run" },
         { file: runtimeFile("hooks/run-hook.mjs"), needle: "Knowledge digest", name: "hooks:session_start:knowledge_digest" },
         { file: runtimeFile("hooks/opencode-plugin.mjs"), needle: "Knowledge digest", name: "hooks:opencode:knowledge_digest" }
@@ -108,13 +105,13 @@ export async function policyChecks(projectRoot, options = {}) {
     if (activeHarnesses.has("opencode")) {
         utilitySkillChecks.push({
             file: ".opencode/plugins/cclaw-plugin.mjs",
-            needle: "\"tool.execute.before\"",
-            name: "hooks:opencode:deployed_tool_hook"
+            needle: "session-start",
+            name: "hooks:opencode:deployed_session_start_hook"
         });
         utilitySkillChecks.push({
             file: ".opencode/plugins/cclaw-plugin.mjs",
-            needle: "workflow-guard",
-            name: "hooks:opencode:deployed_workflow_guard"
+            needle: "stop-handoff",
+            name: "hooks:opencode:deployed_stop_handoff_hook"
         });
     }
     if (activeHarnesses.has("cursor")) {

package/dist/run-persistence.d.ts

@@ -42,5 +42,5 @@ export declare function flowStateLockPathFor(projectRoot: string): string;
 interface EnsureRunSystemOptions {
     createIfMissing?: boolean;
 }
-export declare function ensureRunSystem(projectRoot: string, _options?: EnsureRunSystemOptions): Promise<FlowState>;
+export declare function ensureRunSystem(projectRoot: string, options?: EnsureRunSystemOptions): Promise<FlowState>;
 export {};