cclaw-cli 0.51.23 → 0.51.24

package/dist/doctor.js

@@ -24,6 +24,7 @@ import { resolveTrackFromPrompt } from "./track-heuristics.js";
 import { classifyCodexHooksFlag, codexConfigPath, readCodexConfig } from "./codex-feature-flag.js";
 import { LANGUAGE_RULE_PACK_DIR, LANGUAGE_RULE_PACK_FILES, LEGACY_LANGUAGE_RULE_PACK_FOLDERS } from "./content/utility-skills.js";
 import { validateHookDocument } from "./hook-schema.js";
+import { HOOK_EVENTS_BY_HARNESS } from "./content/hook-events.js";
 import { validateKnowledgeEntry } from "./knowledge-store.js";
 import { readSeedShelf } from "./content/seed-shelf.js";
 import { evaluateRetroGate } from "./retro-gate.js";
@@ -295,8 +296,12 @@ function opencodeConfigCandidates(projectRoot) {
     return [
         path.join(projectRoot, "opencode.json"),
         path.join(projectRoot, "opencode.jsonc"),
+        path.join(projectRoot, "oh-my-opencode.jsonc"),
+        path.join(projectRoot, "oh-my-openagent.jsonc"),
         path.join(projectRoot, ".opencode/opencode.json"),
-        path.join(projectRoot, ".opencode/opencode.jsonc")
+        path.join(projectRoot, ".opencode/opencode.jsonc"),
+        path.join(projectRoot, ".opencode/oh-my-opencode.jsonc"),
+        path.join(projectRoot, ".opencode/oh-my-openagent.jsonc")
     ];
 }
 function openCodeConfigRegistersPlugin(parsed) {
@@ -360,6 +365,87 @@ function opencodeQuestionEnvCheck() {
         details: "Set OPENCODE_ENABLE_QUESTION_TOOL=1 for OpenCode ACP clients so permission-gated structured questions can use the question tool."
     };
 }
+function codexFlagInactiveDetail(configPath, state, error) {
+    if (state === "enabled") {
+        return `codex_hooks feature flag is enabled in ${configPath}; Codex hooks are active.`;
+    }
+    if (state === "read-error") {
+        return `Codex hooks are inactive: could not read ${configPath} (${error instanceof Error ? error.message : String(error)}).`;
+    }
+    if (state === "missing-file") {
+        return `Codex hooks are inactive: ${configPath} does not exist; .codex/hooks.json is ignored until [features] codex_hooks = true is configured.`;
+    }
+    if (state === "missing-section") {
+        return `Codex hooks are inactive: ${configPath} has no [features] section; add codex_hooks = true to activate configured hooks.`;
+    }
+    if (state === "missing-key") {
+        return `Codex hooks are inactive: ${configPath} is missing codex_hooks under [features]; add codex_hooks = true to activate configured hooks.`;
+    }
+    return `Codex hooks are inactive: ${configPath} sets codex_hooks to a non-true value; set codex_hooks = true under [features].`;
+}
+function hookCommandsWithMatchers(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const out = [];
+    for (const item of value) {
+        const obj = toObject(item);
+        if (!obj)
+            continue;
+        const matcher = typeof obj.matcher === "string" ? obj.matcher : undefined;
+        if (typeof obj.command === "string") {
+            out.push({ command: obj.command, matcher });
+        }
+        const nested = hookCommandsWithMatchers(obj.hooks);
+        for (const child of nested) {
+            out.push({ ...child, matcher: child.matcher ?? matcher });
+        }
+    }
+    return out;
+}
+function commandHasHandler(entries, handler) {
+    return entries.some((entry) => entry.command.includes(`run-hook.cmd ${handler}`) || entry.command.includes(`run-hook.mjs ${handler}`));
+}
+function codexBashOnly(entries, handler) {
+    const matches = entries.filter((entry) => entry.command.includes(`run-hook.cmd ${handler}`) || entry.command.includes(`run-hook.mjs ${handler}`));
+    return matches.length > 0 && matches.every((entry) => entry.matcher === "Bash|bash");
+}
+function codexStructuralWiringCheck(codexHooks) {
+    const problems = [];
+    const expectedSession = HOOK_EVENTS_BY_HARNESS.codex.session_rehydrate;
+    if (expectedSession !== "SessionStart matcher=startup|resume") {
+        problems.push("semantic session_rehydrate mapping must remain SessionStart matcher=startup|resume");
+    }
+    const session = hookCommandsWithMatchers(codexHooks.SessionStart);
+    if (!commandHasHandler(session, "session-start") || !session.some((entry) => entry.matcher === "startup|resume")) {
+        problems.push("SessionStart must run session-start with matcher startup|resume");
+    }
+    const userPrompt = hookCommandsWithMatchers(codexHooks.UserPromptSubmit);
+    if (!commandHasHandler(userPrompt, "prompt-guard")) {
+        problems.push("UserPromptSubmit must run prompt-guard");
+    }
+    if (!commandHasHandler(userPrompt, "verify-current-state")) {
+        problems.push("UserPromptSubmit must run verify-current-state");
+    }
+    const pre = hookCommandsWithMatchers(codexHooks.PreToolUse);
+    if (!codexBashOnly(pre, "prompt-guard")) {
+        problems.push("PreToolUse prompt-guard must be Bash-only matcher Bash|bash");
+    }
+    if (!codexBashOnly(pre, "workflow-guard")) {
+        problems.push("PreToolUse workflow-guard must be Bash-only matcher Bash|bash");
+    }
+    const post = hookCommandsWithMatchers(codexHooks.PostToolUse);
+    if (!codexBashOnly(post, "context-monitor")) {
+        problems.push("PostToolUse context-monitor must be Bash-only matcher Bash|bash");
+    }
+    const stop = hookCommandsWithMatchers(codexHooks.Stop);
+    if (!commandHasHandler(stop, "stop-handoff")) {
+        problems.push("Stop must run stop-handoff");
+    }
+    return problems.length === 0
+        ? { ok: true, details: "Codex hook events, matchers, and manifest semantic mappings are structurally valid" }
+        : { ok: false, details: problems.join("; ") };
+}
 async function initRecoveryCheck(projectRoot) {
     const sentinelPath = path.join(projectRoot, RUNTIME_ROOT, "state", ".init-in-progress");
     if (!(await exists(sentinelPath))) {
@@ -1003,34 +1089,48 @@ export async function doctorChecks(projectRoot, options = {}) {
             ok: codexWiringOk,
             details: `${codexHooksFile} must wire SessionStart, UserPromptSubmit(prompt/verify-current-state), Bash-only PreToolUse(prompt/workflow), Bash-only PostToolUse(context-monitor), and Stop(stop-handoff). Codex workflow-guard is intentionally strict Bash-only.`
         });
-        // Feature flag warning: Codex ignores `.codex/hooks.json` unless the
-        // user has `[features] codex_hooks = true` in `~/.codex/config.toml`.
-        // Advisory warning — not a hard failure, because the skills still
-        // work without the flag.
+        const codexStructural = codexStructuralWiringCheck(codexHooks);
+        checks.push({
+            name: "hook:wiring:codex:structure",
+            ok: codexStructural.ok,
+            details: codexStructural.details
+        });
+        // Codex ignores `.codex/hooks.json` unless the user has
+        // `[features] codex_hooks = true` in `~/.codex/config.toml`.
         const codexConfig = codexConfigPath();
-        let featureFlagNote = "";
+        let codexFlagState = "read-error";
+        let codexFlagReadError;
         try {
             const content = await readCodexConfig(codexConfig);
-            const state = classifyCodexHooksFlag(content);
-            featureFlagNote =
-                state === "enabled"
-                    ? `codex_hooks feature flag is enabled in ${codexConfig}`
-                    : state === "missing-file"
-                        ? `warning: ${codexConfig} does not exist; .codex/hooks.json will be ignored until you create it with \`[features]\\ncodex_hooks = true\\n\`.`
-                        : state === "missing-section"
-                            ? `warning: ${codexConfig} has no [features] section; add \`[features]\\ncodex_hooks = true\\n\` to enable cclaw hooks.`
-                            : state === "missing-key"
-                                ? `warning: ${codexConfig} is missing the codex_hooks key under [features]. Add \`codex_hooks = true\` to enable cclaw hooks.`
-                                : `warning: ${codexConfig} sets codex_hooks to a non-true value; set \`codex_hooks = true\` under [features] to enable cclaw hooks.`;
+            codexFlagState = classifyCodexHooksFlag(content);
         }
         catch (err) {
-            featureFlagNote = `warning: could not read ${codexConfig}: ${err instanceof Error ? err.message : String(err)}`;
+            codexFlagReadError = err;
         }
+        const featureFlagNote = codexFlagInactiveDetail(codexConfig, codexFlagState, codexFlagReadError);
+        const featureFlagOk = codexFlagState === "enabled";
         checks.push({
             name: "warning:codex:feature_flag",
-            ok: true,
-            details: featureFlagNote
+            ok: featureFlagOk,
+            details: featureFlagNote,
+            summary: featureFlagOk
+                ? "Codex hooks are active."
+                : "Codex hooks are inactive; configured hooks will be ignored.",
+            fix: "Set `[features] codex_hooks = true` in the Codex config or run cclaw init/sync with Codex flag repair.",
+            docRef: "docs/harnesses.md"
         });
+        if (parsedConfig?.strictness === "strict") {
+            checks.push({
+                name: "hook:codex:feature_flag_active",
+                ok: featureFlagOk,
+                details: featureFlagNote,
+                summary: featureFlagOk
+                    ? "Codex hooks are active for strict runtime enforcement."
+                    : "Codex hooks are inactive; strict Codex hook enforcement is not ready.",
+                fix: "Set `[features] codex_hooks = true` in the Codex config so strict Codex hooks can run.",
+                docRef: "docs/harnesses.md"
+            });
+        }
         // Legacy `.codex/commands/*` must not linger from older cclaw installs.
         // (The `.codex/hooks.json` path is now managed and is validated above,
         // so there is no longer a legacy_hooks_json warning.)

package/dist/flow-state.d.ts

@@ -63,6 +63,7 @@ export interface CloseoutState {
     retroSkipReason?: string;
     compoundCompletedAt?: string;
     compoundSkipped?: boolean;
+    compoundSkipReason?: string;
     compoundPromoted: number;
 }
 export declare function createInitialCloseoutState(): CloseoutState;

package/dist/flow-state.js

@@ -42,6 +42,7 @@ export function createInitialCloseoutState() {
         retroSkipReason: undefined,
         compoundCompletedAt: undefined,
         compoundSkipped: undefined,
+        compoundSkipReason: undefined,
         compoundPromoted: 0
     };
 }

package/dist/install.js

@@ -191,15 +191,84 @@ function resolveRepoRoot() {
   return process.cwd();
 }
 
+function isZeroSha(value) {
+  return /^0{40,64}$/u.test(value);
+}
+
+function readStdin() {
+  try {
+    return fs.readFileSync(0, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function uniqueLines(chunks) {
+  return [...new Set(chunks
+    .join("\n")
+    .split(/\r?\n/gu)
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0))].join("\n");
+}
+
+function diffNames(root, range) {
+  const result = runGit(["diff", "--name-only", range], root);
+  return result.status === 0 ? result.stdout : "";
+}
+
+function changedFilesFromUnpushedCommits(root, localSha = "HEAD") {
+  const revList = runGit(["rev-list", "--reverse", localSha, "--not", "--remotes"], root);
+  if (revList.status !== 0 || revList.stdout.trim().length === 0) {
+    return "";
+  }
+  const chunks = [];
+  for (const commit of revList.stdout.split(/\r?\n/gu).map((line) => line.trim()).filter(Boolean)) {
+    const diffTree = runGit(["diff-tree", "--no-commit-id", "--name-only", "-r", "--root", commit], root);
+    if (diffTree.status === 0) chunks.push(diffTree.stdout);
+  }
+  return uniqueLines(chunks);
+}
+
+function changedFilesFromPrePushStdin(root, stdin) {
+  const chunks = [];
+  for (const rawLine of stdin.split(/\r?\n/gu)) {
+    const parts = rawLine.trim().split(/\s+/u);
+    if (parts.length < 4) continue;
+    const [localRef, localSha, remoteRef, remoteSha] = parts;
+    void localRef;
+    void remoteRef;
+    if (!localSha || isZeroSha(localSha)) continue;
+    if (remoteSha && !isZeroSha(remoteSha)) {
+      chunks.push(diffNames(root, remoteSha + ".." + localSha));
+      continue;
+    }
+    const upstream = runGit(["rev-parse", "--verify", "--quiet", "@{upstream}"], root);
+    if (upstream.status === 0 && upstream.stdout.trim().length > 0) {
+      chunks.push(diffNames(root, upstream.stdout.trim() + ".." + localSha));
+      continue;
+    }
+    chunks.push(changedFilesFromUnpushedCommits(root, localSha));
+  }
+  return uniqueLines(chunks);
+}
+
 function resolveChangedFiles(root) {
   if (HOOK_NAME === "pre-commit") {
     const result = runGit(["diff", "--cached", "--name-only"], root);
     return result.status === 0 ? result.stdout : "";
   }
-  const upstreamResult = runGit(["diff", "--name-only", "@{upstream}...HEAD"], root);
+  const stdinChanged = changedFilesFromPrePushStdin(root, readStdin());
+  if (stdinChanged.length > 0) {
+    return stdinChanged;
+  }
+  const upstreamResult = runGit(["diff", "--name-only", "@{upstream}..HEAD"], root);
   if (upstreamResult.status === 0) {
     return upstreamResult.stdout;
   }
+  const unpushed = changedFilesFromUnpushedCommits(root);
+  if (unpushed.length > 0) {
+    return unpushed;
+  }
   const fallback = runGit(["diff", "--name-only", "HEAD~1...HEAD"], root);
   return fallback.status === 0 ? fallback.stdout : "";
 }
@@ -1272,6 +1341,8 @@ export async function uninstallCclaw(projectRoot) {
     await removeIfEmpty(path.join(projectRoot, ".agents"));
     const managedAgentNames = [
         "planner",
+        "product-manager",
+        "critic",
         "reviewer",
         "security-reviewer",
         "test-author",

package/dist/knowledge-store.js

@@ -505,18 +505,40 @@ export async function appendKnowledge(projectRoot, seeds, defaults = {}) {
         appendedEntries
     };
 }
+const SHORT_TECHNICAL_TOKEN_SET = new Set(["ci", "db", "ui", "qa", "ux"]);
 function tokenizeText(value) {
     if (!value)
         return [];
-    return value
-        .toLowerCase()
-        .split(/[^a-z0-9]+/u)
-        .map((token) => token.trim())
-        .filter((token) => token.length >= 3);
+    const tokens = [];
+    const matches = value.matchAll(/[A-Za-z0-9]+/gu);
+    for (const match of matches) {
+        const raw = match[0] ?? "";
+        const normalized = raw.toLowerCase();
+        if (normalized.length >= 3) {
+            tokens.push(normalized);
+            continue;
+        }
+        if (/^[A-Z]{2}$/u.test(raw) || SHORT_TECHNICAL_TOKEN_SET.has(normalized)) {
+            tokens.push(normalized);
+        }
+    }
+    return tokens;
 }
 function uniqueTokens(values) {
     return [...new Set(values)];
 }
+function supersededTriggerSet(entries) {
+    const superseded = new Set();
+    for (const entry of entries) {
+        for (const trigger of entry.supersedes ?? []) {
+            superseded.add(normalizeText(trigger));
+        }
+    }
+    return superseded;
+}
+function isSupersededLearning(entry, supersededTriggers) {
+    return entry.superseded_by !== undefined || supersededTriggers.has(normalizeText(entry.trigger));
+}
 function pathTokens(paths) {
     if (!Array.isArray(paths) || paths.length === 0)
         return [];
@@ -538,7 +560,9 @@ export async function selectRelevantLearnings(projectRoot, options = {}) {
     const limit = typeof options.limit === "number" && Number.isFinite(options.limit) && options.limit > 0
         ? Math.floor(options.limit)
         : 8;
-    const ranked = entries.map((entry, index) => {
+    const staleTriggers = supersededTriggerSet(entries);
+    const activeEntries = entries.filter((entry) => !isSupersededLearning(entry, staleTriggers));
+    const ranked = activeEntries.map((entry, index) => {
         let score = 0;
         let stageScore = 0;
         if (stage) {

package/dist/run-archive.js

@@ -35,6 +35,13 @@ function stateDirPath(projectRoot) {
 function archiveLockPath(projectRoot) {
     return path.join(projectRoot, RUNTIME_ROOT, "state", ".archive.lock");
 }
+function compoundCloseoutComplete(state) {
+    return (state.closeout.compoundCompletedAt !== undefined ||
+        state.closeout.compoundPromoted > 0 ||
+        (state.closeout.compoundSkipped === true &&
+            typeof state.closeout.compoundSkipReason === "string" &&
+            state.closeout.compoundSkipReason.trim().length > 0));
+}
 async function snapshotStateDirectory(projectRoot, destinationRoot) {
     const sourceDir = stateDirPath(projectRoot);
     if (!(await exists(sourceDir))) {
@@ -209,6 +216,10 @@ export async function archiveRun(projectRoot, runName, options = {}) {
                 sourceState.closeout.retroSkipReason.trim().length > 0;
             const readyForArchive = sourceState.closeout.shipSubstate === "ready_to_archive";
             const inShipCloseout = sourceState.currentStage === "ship";
+            if (readyForArchive && !compoundCloseoutComplete(sourceState)) {
+                throw new Error("Archive blocked: compound closeout is incomplete. " +
+                    "Promote compound guidance or skip compound review with an explicit reason before archiving.");
+            }
             if (inShipCloseout && skipRetro) {
                 throw new Error("Archive blocked: --skip-retro is not allowed while current stage is ship. " +
                     "Complete closeout to ready_to_archive via /cc-next.");

package/dist/run-persistence.js

@@ -255,21 +255,27 @@ function sanitizeCloseoutState(value) {
         ? true
         : undefined;
     const compoundCompletedAt = typeof typed.compoundCompletedAt === "string" ? typed.compoundCompletedAt : undefined;
-    const compoundSkipped = typeof typed.compoundSkipped === "boolean" ? typed.compoundSkipped : undefined;
+    const compoundSkipReason = typeof typed.compoundSkipReason === "string"
+        ? typed.compoundSkipReason.trim() || undefined
+        : undefined;
+    const compoundSkipped = typed.compoundSkipped === true && compoundSkipReason !== undefined
+        ? true
+        : undefined;
     const promotedRaw = typed.compoundPromoted;
     const compoundPromoted = typeof promotedRaw === "number" && Number.isFinite(promotedRaw) && promotedRaw >= 0
         ? Math.floor(promotedRaw)
         : 0;
-    // Demote shipSubstate when its retro invariant is violated on disk. A
-    // hand-edited flow-state could claim `ready_to_archive` or `compound_review`
-    // without ever going through the retro step, which would let `archive`
-    // proceed and skip the gate. Compound completion is not independently
-    // tracked in all flows (some runs rely on knowledge.jsonl + the retro
-    // window), so we only demote when the retro leg is missing outright.
+    // Demote shipSubstate when its closeout invariants are violated on disk. A
+    // hand-edited flow-state could claim `ready_to_archive` without completing
+    // the compound leg, which would let `archive` skip durable closeout proof.
     const retroDone = retroAcceptedAt !== undefined || retroSkipped === true;
+    const compoundDone = compoundCompletedAt !== undefined || compoundPromoted > 0 || compoundSkipped === true;
     if (!retroDone && (shipSubstate === "ready_to_archive" || shipSubstate === "compound_review")) {
         shipSubstate = "retro_review";
     }
+    else if (shipSubstate === "ready_to_archive" && !compoundDone) {
+        shipSubstate = "compound_review";
+    }
     return {
         shipSubstate,
         retroDraftedAt,
@@ -278,6 +284,7 @@ function sanitizeCloseoutState(value) {
         retroSkipReason,
         compoundCompletedAt,
         compoundSkipped,
+        compoundSkipReason,
         compoundPromoted
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cclaw-cli",
-  "version": "0.51.23",
+  "version": "0.51.24",
   "description": "Installer-first flow toolkit for coding agents",
   "type": "module",
   "bin": {