cclaw-cli 0.39.1 → 0.41.0

package/README.md

@@ -127,9 +127,12 @@ Plus harness-specific shims:
 - `.claude/commands/cc*.md` + `.claude/hooks/hooks.json`
 - `.cursor/commands/cc*.md` + `.cursor/hooks.json` + `.cursor/rules/cclaw-workflow.mdc`
 - `.opencode/commands/cc*.md` + `.opencode/plugins/cclaw-plugin.mjs`
-- `.agents/skills/cclaw-cc*/SKILL.md` (Codex; activated via `/use cclaw-cc`
-  or description-based auto-matching — Codex no longer reads `.codex/commands/`
-  or `.codex/hooks.json`, and `cclaw sync` cleans those up if present)
+- `.agents/skills/cc*/SKILL.md` + `.codex/hooks.json` (Codex; skills are
+  activated via `/use cc` or description-based auto-matching. Hooks
+  require Codex CLI ≥ v0.114 and `[features] codex_hooks = true` in
+  `~/.codex/config.toml`; `cclaw init --codex` offers to patch that flag
+  for you. `.codex/commands/` and the legacy `.agents/skills/cclaw-cc*/`
+  folders are auto-cleaned on sync.)
 - `AGENTS.md` with a managed routing block (includes a Codex-specific note)
 
 `.cclaw/config.yaml` holds every tunable key (prompt guard strictness,
@@ -356,8 +359,8 @@ closes every real gap with a documented fallback — not a silent waiver.
 |---|---|---|---|---|---|
 | Claude Code | full (named subagents) | `native` | full | `AskUserQuestion` | [`claude-playbook.md`](./src/content/harness-playbooks.ts) |
 | Cursor | generic Task dispatcher | `generic-dispatch` | full | `AskQuestion` | `cursor-playbook.md` |
-| OpenCode | plugin / in-session | `role-switch` | plugin | plain-text | `opencode-playbook.md` |
-| OpenAI Codex | in-session only | `role-switch` (evidenceRefs required) | none (no hooks API) | plain-text | `codex-playbook.md` |
+| OpenCode | plugin / in-session | `role-switch` | plugin | `question` (permission-gated; `permission.question: "allow"`) | `opencode-playbook.md` |
+| OpenAI Codex | in-session only | `role-switch` (evidenceRefs required) | limited (Bash-only `PreToolUse`/`PostToolUse`; requires `codex_hooks` feature flag) | `request_user_input` (experimental; Plan / Collaboration mode) | `codex-playbook.md` |
 
 What the fallbacks mean:
 
@@ -380,16 +383,21 @@ What the fallbacks mean:
   harness declares it. Currently unused — v0.33 removed the old
   Codex-only auto-waiver path.
 
-> **Codex note (v0.39+).** Codex CLI deprecated custom prompts and the
-> `.codex/hooks.json` API, so cclaw installs Codex entry points as
-> native **skills** under `.agents/skills/cclaw-cc*/SKILL.md`. Invoke
-> them with `/use cclaw-cc`, `/use cclaw-cc-next`, `/use cclaw-cc-view`,
-> `/use cclaw-cc-ops`, `/use cclaw-cc-ideate`, or just say something
-> like *"run cc for payments refund fix"* — Codex auto-matches skills
-> from their description. Hook-driven checks (prompt-guard, stop-save,
-> post-tool context monitor) are substituted in the `cclaw-cc*` skill
-> bodies as explicit agent steps; run `cclaw doctor` to see what's
-> missing and how the playbook compensates.
+> **Codex note (v0.40+).** Codex CLI deprecated custom prompts in v0.89
+> (Jan 2026), but Codex ≥ v0.114 (Mar 2026) grew an experimental
+> lifecycle hooks API. cclaw installs Codex entry points as native
+> **skills** under `.agents/skills/cc*/SKILL.md` (invoke with `/use cc`,
+> `/use cc-next`, `/use cc-view`, `/use cc-ops`, `/use cc-ideate`, or
+> by typing `/cc …` in plain text — Codex auto-matches from the skill
+> description) **and** writes `.codex/hooks.json` so session-start
+> rehydration, stop-checkpoint, prompt-guard, workflow-guard, and
+> context-monitor fire automatically — as long as you enable the
+> `codex_hooks` feature flag in `~/.codex/config.toml`. `cclaw init
+> --codex` asks for consent before patching that file. Codex's
+> `PreToolUse`/`PostToolUse` are Bash-only; the stage skills compensate
+> for `Write`/`Edit`/`MCP` tool calls with explicit in-turn checks. Run
+> `cclaw doctor` to see the current state of hooks, the feature flag,
+> and any legacy layout to clean up.
 
 The full capability matrix lives in
 [`docs/harnesses.md`](./docs/harnesses.md). Per-harness playbooks are

package/dist/cli.js

@@ -15,6 +15,7 @@ import { CCLAW_VERSION, RUNTIME_ROOT } from "./constants.js";
 import { createDefaultConfig } from "./config.js";
 import { detectHarnesses } from "./init-detect.js";
 import { HARNESS_ADAPTERS } from "./harness-adapters.js";
+import { classifyCodexHooksFlag, codexConfigPath, patchCodexHooksFlag, readCodexConfig, writeCodexConfig } from "./codex-feature-flag.js";
 import { runEval } from "./eval/runner.js";
 import { createStderrProgressLogger } from "./eval/progress.js";
 import { writeBaselinesFromReport } from "./eval/baseline.js";
@@ -152,7 +153,7 @@ function buildInitSurfacePreview(harnesses) {
     for (const harness of harnesses) {
         const adapter = HARNESS_ADAPTERS[harness];
         if (adapter.shimKind === "skill") {
-            lines.push(`${adapter.commandDir}/cclaw-cc*/SKILL.md`);
+            lines.push(`${adapter.commandDir}/cc*/SKILL.md`);
         }
         else {
             lines.push(`${adapter.commandDir}/cc*.md`);
@@ -164,9 +165,12 @@ function buildInitSurfacePreview(harnesses) {
             lines.push(".cursor/hooks.json");
             lines.push(".cursor/rules/cclaw-workflow.mdc");
         }
-        // Codex has no hooks file — it reads skills from `.agents/skills/` only
-        // (v0.39.0+). Legacy `.codex/commands/*` and `.codex/hooks.json` are
-        // auto-cleaned on sync.
+        if (harness === "codex") {
+            // v0.40.0: .codex/hooks.json is managed again now that Codex CLI
+            // grew a real hooks API (v0.114+, behind the `codex_hooks`
+            // feature flag). Legacy `.codex/commands/*` is still auto-cleaned.
+            lines.push(".codex/hooks.json (requires `codex_hooks = true` in ~/.codex/config.toml)");
+        }
         if (harness === "opencode") {
             lines.push(".opencode/plugins/cclaw-plugin.mjs");
             lines.push("opencode.json(.c) plugin registration");
@@ -207,6 +211,85 @@ async function promptInitConfig(defaults, ctx) {
         rl.close();
     }
 }
+/**
+ * When Codex is one of the installed harnesses, check the Codex CLI
+ * config file for the `codex_hooks` feature flag. If it is missing or
+ * disabled, offer to patch it in with the user's explicit consent.
+ *
+ * The function is deliberately advisory: it never fails init — the worst
+ * case is that Codex runs without the hooks engine, which is exactly
+ * how v0.39.x already shipped. We always print a resolution hint so
+ * the user knows what to do next regardless of which branch was taken.
+ */
+async function maybeEnableCodexHooksFlag(harnesses, parsed, ctx) {
+    if (!harnesses || !harnesses.includes("codex"))
+        return;
+    const configPath = codexConfigPath();
+    let existing;
+    try {
+        existing = await readCodexConfig(configPath);
+    }
+    catch (err) {
+        ctx.stdout.write(`note: Could not read ${configPath} to check the codex_hooks flag: ` +
+            `${err instanceof Error ? err.message : String(err)}\n`);
+        return;
+    }
+    const state = classifyCodexHooksFlag(existing);
+    if (state === "enabled") {
+        return;
+    }
+    const humanState = state === "missing-file"
+        ? "Codex config file does not exist yet"
+        : state === "missing-section"
+            ? "no [features] section"
+            : state === "missing-key"
+                ? "no codex_hooks key"
+                : "codex_hooks is not enabled";
+    const instructions = `To enable Codex hooks manually later, ensure ${configPath} contains:\n` +
+        `  [features]\n  codex_hooks = true\n`;
+    if (parsed.interactive === false) {
+        ctx.stdout.write(`note: codex_hooks feature flag is not enabled (${humanState}).\n` +
+            `      cclaw wrote .codex/hooks.json, but Codex will ignore it until you enable the flag.\n` +
+            `      ${instructions}`);
+        return;
+    }
+    if (!isInitPromptAllowed(ctx)) {
+        ctx.stdout.write(`note: codex_hooks feature flag is not enabled (${humanState}).\n` +
+            `      cclaw wrote .codex/hooks.json, but Codex will ignore it until you enable the flag.\n` +
+            `      ${instructions}`);
+        return;
+    }
+    const rl = createInterface({
+        input: process.stdin,
+        output: ctx.stdout
+    });
+    try {
+        const answer = (await rl.question(`\nCodex CLI hooks are off (${humanState}).\n` +
+            `Enable [features] codex_hooks = true in ${configPath} now? [y/N]: `)).trim().toLowerCase();
+        const yes = answer === "y" || answer === "yes";
+        if (!yes) {
+            ctx.stdout.write(`Leaving ${configPath} untouched. ${instructions}`);
+            return;
+        }
+        const { updated, changed } = patchCodexHooksFlag(existing);
+        if (!changed) {
+            ctx.stdout.write(`codex_hooks is already enabled — no changes written.\n`);
+            return;
+        }
+        try {
+            await writeCodexConfig(configPath, updated);
+            ctx.stdout.write(`Enabled [features] codex_hooks = true in ${configPath}.\n`);
+        }
+        catch (err) {
+            ctx.stdout.write(`Could not write ${configPath}: ` +
+                `${err instanceof Error ? err.message : String(err)}\n` +
+                `${instructions}`);
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
 async function resolveInitInputs(parsed, ctx) {
     const detectedHarnesses = parsed.harnesses ? [] : await detectHarnesses(ctx.cwd);
     const autoHarnesses = parsed.harnesses
@@ -744,6 +827,7 @@ async function runCommand(parsed, ctx) {
         }
         const trackNote = effectiveTrack ? ` (track=${effectiveTrack})` : "";
         info(ctx, `Initialized .cclaw runtime and generated harness shims${trackNote}`);
+        await maybeEnableCodexHooksFlag(effectiveHarnesses, parsed, ctx);
         return 0;
     }
     if (command === "sync") {

package/dist/codex-feature-flag.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Manage the `codex_hooks` feature flag in `~/.codex/config.toml`.
+ *
+ * Codex CLI ≥ v0.114 (Mar 2026) exposes lifecycle hooks via
+ * `.codex/hooks.json`, but the hooks engine is inert unless the user has
+ * opted into it with:
+ *
+ * ```toml
+ * [features]
+ * codex_hooks = true
+ * ```
+ *
+ * in `$CODEX_HOME/config.toml` (default: `~/.codex/config.toml`).
+ * cclaw's `init --codex` prompts the user to flip this flag for them;
+ * this module owns the detection / mutation code so the prompt logic in
+ * `cli.ts` stays small and testable.
+ *
+ * The TOML mutations here are intentionally surgical — we never reparse
+ * or rewrite the whole document. A deliberately narrow regex based
+ * approach lets the function stay dependency-free and preserves the
+ * user's comments, whitespace, and custom key ordering.
+ */
+/**
+ * Absolute path of the Codex config file. Respects `$CODEX_HOME` when
+ * present (the only override Codex CLI documents); falls back to
+ * `~/.codex/config.toml` otherwise.
+ */
+export declare function codexConfigPath(env?: NodeJS.ProcessEnv): string;
+export type CodexHooksFlagState = "enabled" | "disabled" | "missing-key" | "missing-section" | "missing-file";
+/**
+ * Inspect a TOML document and decide which of the five canonical states
+ * it represents. Comments and blank lines are ignored. Only the first
+ * `[features]` section is considered — duplicates are technically invalid
+ * TOML and Codex rejects them, so cclaw does not try to be clever there.
+ */
+export declare function classifyCodexHooksFlag(toml: string | null): CodexHooksFlagState;
+/**
+ * Return a TOML document with `[features] codex_hooks = true` set.
+ * Preserves all other content verbatim:
+ *   - If the document lacks a `[features]` section, we append one at the
+ *     end of the file (separated by a blank line).
+ *   - If `[features]` exists without `codex_hooks`, we insert the key
+ *     immediately after the header.
+ *   - If `codex_hooks` exists with any non-`true` value, we rewrite
+ *     just that line.
+ *   - If the flag is already `true`, the input is returned unchanged.
+ */
+export declare function patchCodexHooksFlag(toml: string | null): {
+    updated: string;
+    changed: boolean;
+};
+/**
+ * Read the Codex config, return `null` when the file does not exist.
+ * All other read errors propagate so callers can surface a useful
+ * message instead of silently degrading.
+ */
+export declare function readCodexConfig(configPath: string): Promise<string | null>;
+export declare function writeCodexConfig(configPath: string, content: string): Promise<void>;

package/dist/codex-feature-flag.js

@@ -0,0 +1,193 @@
+/**
+ * Manage the `codex_hooks` feature flag in `~/.codex/config.toml`.
+ *
+ * Codex CLI ≥ v0.114 (Mar 2026) exposes lifecycle hooks via
+ * `.codex/hooks.json`, but the hooks engine is inert unless the user has
+ * opted into it with:
+ *
+ * ```toml
+ * [features]
+ * codex_hooks = true
+ * ```
+ *
+ * in `$CODEX_HOME/config.toml` (default: `~/.codex/config.toml`).
+ * cclaw's `init --codex` prompts the user to flip this flag for them;
+ * this module owns the detection / mutation code so the prompt logic in
+ * `cli.ts` stays small and testable.
+ *
+ * The TOML mutations here are intentionally surgical — we never reparse
+ * or rewrite the whole document. A deliberately narrow regex based
+ * approach lets the function stay dependency-free and preserves the
+ * user's comments, whitespace, and custom key ordering.
+ */
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+/**
+ * Absolute path of the Codex config file. Respects `$CODEX_HOME` when
+ * present (the only override Codex CLI documents); falls back to
+ * `~/.codex/config.toml` otherwise.
+ */
+export function codexConfigPath(env = process.env) {
+    const codexHome = env.CODEX_HOME && env.CODEX_HOME.trim().length > 0
+        ? env.CODEX_HOME
+        : path.join(os.homedir(), ".codex");
+    return path.join(codexHome, "config.toml");
+}
+/**
+ * Inspect a TOML document and decide which of the five canonical states
+ * it represents. Comments and blank lines are ignored. Only the first
+ * `[features]` section is considered — duplicates are technically invalid
+ * TOML and Codex rejects them, so cclaw does not try to be clever there.
+ */
+export function classifyCodexHooksFlag(toml) {
+    if (toml === null) {
+        return "missing-file";
+    }
+    const lines = toml.split(/\r?\n/);
+    let inFeaturesSection = false;
+    let sawFeaturesHeader = false;
+    for (const rawLine of lines) {
+        const stripped = stripTomlComment(rawLine).trim();
+        if (stripped.length === 0)
+            continue;
+        const headerMatch = /^\[\s*([A-Za-z0-9_.-]+)\s*\]$/u.exec(stripped);
+        if (headerMatch) {
+            const section = headerMatch[1];
+            if (section === "features") {
+                inFeaturesSection = true;
+                sawFeaturesHeader = true;
+            }
+            else {
+                inFeaturesSection = false;
+            }
+            continue;
+        }
+        if (inFeaturesSection) {
+            const keyMatch = /^codex_hooks\s*=\s*(.*)$/u.exec(stripped);
+            if (keyMatch) {
+                const value = keyMatch[1].trim().toLowerCase();
+                return value === "true" ? "enabled" : "disabled";
+            }
+        }
+    }
+    if (sawFeaturesHeader)
+        return "missing-key";
+    return "missing-section";
+}
+function stripTomlComment(line) {
+    // Naive but sufficient for our narrow use case: we only read cclaw's
+    // own writes back, and cclaw never emits `=` after a `#` inside a
+    // string literal in config.toml. If a user has complex string values
+    // with `#` inside them, worst case we trip `classifyCodexHooksFlag`
+    // and prompt them again — non-destructive.
+    const hashIndex = line.indexOf("#");
+    return hashIndex === -1 ? line : line.slice(0, hashIndex);
+}
+/**
+ * Return a TOML document with `[features] codex_hooks = true` set.
+ * Preserves all other content verbatim:
+ *   - If the document lacks a `[features]` section, we append one at the
+ *     end of the file (separated by a blank line).
+ *   - If `[features]` exists without `codex_hooks`, we insert the key
+ *     immediately after the header.
+ *   - If `codex_hooks` exists with any non-`true` value, we rewrite
+ *     just that line.
+ *   - If the flag is already `true`, the input is returned unchanged.
+ */
+export function patchCodexHooksFlag(toml) {
+    const initial = toml ?? "";
+    const state = classifyCodexHooksFlag(toml);
+    if (state === "enabled") {
+        return { updated: initial, changed: false };
+    }
+    if (state === "missing-file" || state === "missing-section") {
+        const prefix = initial.length === 0
+            ? ""
+            : initial.endsWith("\n") ? initial : `${initial}\n`;
+        const separator = initial.trim().length === 0 ? "" : "\n";
+        const block = `${separator}[features]\ncodex_hooks = true\n`;
+        return { updated: `${prefix}${block}`, changed: true };
+    }
+    if (state === "missing-key") {
+        const updated = insertKeyInFeaturesSection(initial);
+        return { updated, changed: true };
+    }
+    const updated = replaceCodexHooksLineInFeaturesSection(initial);
+    return { updated, changed: true };
+}
+function insertKeyInFeaturesSection(toml) {
+    // Walk into `[features]`, remember the index of the last key / non-blank
+    // line inside that section, and splice `codex_hooks = true` immediately
+    // after it. This keeps the inserted key adjacent to existing features,
+    // never stranded after a blank line or pushed down past a later section
+    // header. If `[features]` is empty, we insert right after its header.
+    const lines = toml.split(/\r?\n/);
+    let inFeaturesSection = false;
+    let featuresHeaderIndex = -1;
+    let lastFeatureKeyIndex = -1;
+    for (let index = 0; index < lines.length; index += 1) {
+        const rawLine = lines[index];
+        const stripped = stripTomlComment(rawLine).trim();
+        const headerMatch = /^\[\s*([A-Za-z0-9_.-]+)\s*\]$/u.exec(stripped);
+        if (headerMatch) {
+            if (inFeaturesSection)
+                break;
+            if (headerMatch[1] === "features") {
+                inFeaturesSection = true;
+                featuresHeaderIndex = index;
+                lastFeatureKeyIndex = index;
+            }
+            continue;
+        }
+        if (inFeaturesSection && stripped.length > 0) {
+            lastFeatureKeyIndex = index;
+        }
+    }
+    if (featuresHeaderIndex === -1) {
+        // caller should have short-circuited before getting here; defensive
+        return toml;
+    }
+    lines.splice(lastFeatureKeyIndex + 1, 0, "codex_hooks = true");
+    const joined = lines.join("\n");
+    return joined.endsWith("\n") ? joined : `${joined}\n`;
+}
+function replaceCodexHooksLineInFeaturesSection(toml) {
+    const lines = toml.split(/\r?\n/);
+    let inFeaturesSection = false;
+    for (let index = 0; index < lines.length; index += 1) {
+        const rawLine = lines[index];
+        const stripped = stripTomlComment(rawLine).trim();
+        const headerMatch = /^\[\s*([A-Za-z0-9_.-]+)\s*\]$/u.exec(stripped);
+        if (headerMatch) {
+            inFeaturesSection = headerMatch[1] === "features";
+            continue;
+        }
+        if (inFeaturesSection && /^codex_hooks\s*=/u.test(stripped)) {
+            const indent = /^\s*/u.exec(rawLine)?.[0] ?? "";
+            lines[index] = `${indent}codex_hooks = true`;
+        }
+    }
+    const joined = lines.join("\n");
+    return joined.endsWith("\n") ? joined : `${joined}\n`;
+}
+/**
+ * Read the Codex config, return `null` when the file does not exist.
+ * All other read errors propagate so callers can surface a useful
+ * message instead of silently degrading.
+ */
+export async function readCodexConfig(configPath) {
+    try {
+        return await fs.readFile(configPath, "utf8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            return null;
+        }
+        throw err;
+    }
+}
+export async function writeCodexConfig(configPath, content) {
+    await fs.mkdir(path.dirname(configPath), { recursive: true });
+    await fs.writeFile(configPath, content, "utf8");
+}

package/dist/constants.d.ts

@@ -14,7 +14,7 @@ export declare const EVALS_ROOT = ".cclaw/evals";
 export declare const EVALS_CONFIG_PATH = ".cclaw/evals/config.yaml";
 export declare const EVALS_DIRS: readonly [".cclaw/evals", ".cclaw/evals/corpus", ".cclaw/evals/rubrics", ".cclaw/evals/baselines", ".cclaw/evals/reports"];
 export declare const REQUIRED_DIRS: readonly [".cclaw", ".cclaw/commands", ".cclaw/skills", ".cclaw/contexts", ".cclaw/templates", ".cclaw/artifacts", ".cclaw/worktrees", ".cclaw/state", ".cclaw/runs", ".cclaw/rules", ".cclaw/adapters", ".cclaw/agents", ".cclaw/hooks", ".cclaw/custom-skills", ".cclaw/evals", ".cclaw/evals/corpus", ".cclaw/evals/rubrics", ".cclaw/evals/baselines", ".cclaw/evals/reports"];
-export declare const REQUIRED_GITIGNORE_PATTERNS: readonly ["# cclaw generated artifacts", ".cclaw/", "# cclaw evals: user-owned, track in git", "!.cclaw/evals/", "!.cclaw/evals/config.yaml", "!.cclaw/evals/corpus/", "!.cclaw/evals/corpus/**", "!.cclaw/evals/rubrics/", "!.cclaw/evals/rubrics/**", "!.cclaw/evals/baselines/", "!.cclaw/evals/baselines/**", ".claude/commands/cc-*.md", ".claude/commands/cc.md", ".cursor/commands/cc-*.md", ".cursor/commands/cc.md", ".opencode/commands/cc-*.md", ".opencode/commands/cc.md", ".agents/skills/cclaw-cc/SKILL.md", ".agents/skills/cclaw-cc-*/SKILL.md", ".claude/hooks/hooks.json", ".cursor/hooks.json", ".opencode/plugins/cclaw-plugin.mjs", ".cursor/rules/cclaw-workflow.mdc"];
+export declare const REQUIRED_GITIGNORE_PATTERNS: readonly ["# cclaw generated artifacts", ".cclaw/", "# cclaw evals: user-owned, track in git", "!.cclaw/evals/", "!.cclaw/evals/config.yaml", "!.cclaw/evals/corpus/", "!.cclaw/evals/corpus/**", "!.cclaw/evals/rubrics/", "!.cclaw/evals/rubrics/**", "!.cclaw/evals/baselines/", "!.cclaw/evals/baselines/**", ".claude/commands/cc-*.md", ".claude/commands/cc.md", ".cursor/commands/cc-*.md", ".cursor/commands/cc.md", ".opencode/commands/cc-*.md", ".opencode/commands/cc.md", ".agents/skills/cc/SKILL.md", ".agents/skills/cc-*/SKILL.md", ".claude/hooks/hooks.json", ".cursor/hooks.json", ".codex/hooks.json", ".opencode/plugins/cclaw-plugin.mjs", ".cursor/rules/cclaw-workflow.mdc"];
 export declare const COMMAND_FILE_ORDER: FlowStage[];
 export declare const UTILITY_COMMANDS: readonly ["learn", "next", "ideate", "view", "status", "tree", "diff", "ops", "feature", "tdd-log", "retro", "compound", "archive", "rewind"];
 export declare const SUBAGENT_SKILL_FOLDERS: readonly ["subagent-dev", "parallel-dispatch"];

package/dist/constants.js

@@ -91,12 +91,15 @@ export const REQUIRED_GITIGNORE_PATTERNS = [
     ".cursor/commands/cc.md",
     ".opencode/commands/cc-*.md",
     ".opencode/commands/cc.md",
-    // Codex uses skill-kind shims under `.agents/skills/cclaw-cc*/` since
-    // v0.39.0; legacy `.codex/commands/*` is auto-cleaned on sync.
-    ".agents/skills/cclaw-cc/SKILL.md",
-    ".agents/skills/cclaw-cc-*/SKILL.md",
+    // Codex uses skill-kind shims under `.agents/skills/cc*/` since
+    // v0.40.0 (renamed from the `cclaw-cc*` layout in v0.39.0/v0.39.1).
+    // `cclaw sync` and `cclaw uninstall` both auto-remove the legacy
+    // `cclaw-cc*` directories.
+    ".agents/skills/cc/SKILL.md",
+    ".agents/skills/cc-*/SKILL.md",
     ".claude/hooks/hooks.json",
     ".cursor/hooks.json",
+    ".codex/hooks.json",
     ".opencode/plugins/cclaw-plugin.mjs",
     ".cursor/rules/cclaw-workflow.mdc"
 ];

package/dist/content/compound-command.js

@@ -39,8 +39,10 @@ the user can approve individual lifts, accept-all, or skip.
    "Drift check" section in the skill): confirm the lift target file is
    current, spot-check the repo for contradictions, demote stale clusters
    into a new superseding entry instead of a lift.
-6. Otherwise, present **one** structured ask (AskUserQuestion / AskQuestion /
-   plain text) summarising all candidates at once:
+6. Otherwise, present **one** structured ask via the harness's native ask
+   tool (\`AskUserQuestion\` / \`AskQuestion\` / \`question\` /
+   \`request_user_input\`; plain-text lettered list as fallback) summarising
+   all candidates at once:
    - \`apply-all\` (default) — apply every listed lift,
    - \`apply-selected\` — prompt per-candidate,
    - \`skip\` — record a skip reason and advance without changes.