cclaw-cli 2.0.0 → 4.0.0

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,16 +12,16 @@ 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";
-import { ARTIFACT_TEMPLATES, CURSOR_WORKFLOW_RULE_MDC, RULEBOOK_MARKDOWN, buildRulesJson } from "./content/templates.js";
+import { ARTIFACT_TEMPLATES, CURSOR_GUIDELINES_RULE_MDC, CURSOR_WORKFLOW_RULE_MDC, RULEBOOK_MARKDOWN, buildRulesJson } from "./content/templates.js";
 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 { adaptiveElicitationSkillMarkdown } from "./content/skills-elicitation.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 { 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";
@@ -37,6 +37,7 @@ import { CorruptFlowStateError, ensureRunSystem } from "./runs.js";
 import { FLOW_STAGES } from "./types.js";
 const OPENCODE_PLUGIN_REL_PATH = ".opencode/plugins/cclaw-plugin.mjs";
 const CURSOR_RULE_REL_PATH = ".cursor/rules/cclaw-workflow.mdc";
+const CURSOR_GUIDELINES_REL_PATH = ".cursor/rules/cclaw-guidelines.mdc";
 const GIT_HOOK_MANAGED_MARKER = "cclaw-managed-git-hook";
 const GIT_HOOK_RUNTIME_REL_DIR = `${RUNTIME_ROOT}/hooks/git`;
 const INIT_SENTINEL_FILE = ".init-in-progress";
@@ -407,55 +408,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) {
@@ -475,7 +434,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));
@@ -503,42 +463,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)) {
@@ -936,22 +862,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());
@@ -1029,17 +943,22 @@ async function writeRulebook(projectRoot) {
 }
 async function writeCursorWorkflowRule(projectRoot, harnesses) {
     const rulePath = path.join(projectRoot, CURSOR_RULE_REL_PATH);
+    const guidelinesPath = path.join(projectRoot, CURSOR_GUIDELINES_REL_PATH);
     if (!harnesses.includes("cursor")) {
-        try {
-            await fs.rm(rulePath, { force: true });
-        }
-        catch {
-            // best-effort cleanup
+        for (const target of [rulePath, guidelinesPath]) {
+            try {
+                await fs.rm(target, { force: true });
+            }
+            catch {
+                // best-effort cleanup
+            }
         }
         return;
     }
     await ensureDir(path.dirname(rulePath));
     await writeFileSafe(rulePath, CURSOR_WORKFLOW_RULE_MDC);
+    await ensureDir(path.dirname(guidelinesPath));
+    await writeFileSafe(guidelinesPath, CURSOR_GUIDELINES_RULE_MDC);
 }
 async function syncDisabledHarnessArtifacts(projectRoot, harnesses) {
     const enabled = new Set(harnesses);
@@ -1082,6 +1001,7 @@ 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) {
@@ -1091,7 +1011,7 @@ async function writeState(projectRoot, config, forceReset = false) {
     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) {
@@ -1289,17 +1209,8 @@ 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" });
     // Init should scaffold runtime surfaces but leave flow-state creation to the
     // first managed start-flow invocation.
@@ -1339,13 +1250,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));
@@ -1564,11 +1470,16 @@ export async function uninstallCclaw(projectRoot) {
         }
     }
     await removeManagedOpenCodePluginConfig(projectRoot, OPENCODE_PLUGIN_REL_PATH);
-    try {
-        await fs.rm(path.join(projectRoot, CURSOR_RULE_REL_PATH), { force: true });
-    }
-    catch {
-        // best-effort cleanup
+    for (const target of [
+        path.join(projectRoot, CURSOR_RULE_REL_PATH),
+        path.join(projectRoot, CURSOR_GUIDELINES_REL_PATH)
+    ]) {
+        try {
+            await fs.rm(target, { force: true });
+        }
+        catch {
+            // best-effort cleanup
+        }
     }
     const managedDirs = [
         ".claude/hooks",

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

@@ -35,6 +35,7 @@ interface InternalValidationReport {
 export declare function hydrateReviewLoopEvidenceFromArtifact(projectRoot: string, stage: FlowStage, track: FlowState["track"], selectedGateIds: string[], evidenceByGate: Record<string, string>): Promise<void>;
 export declare function buildValidationReport(projectRoot: string, flowState: FlowState, options?: {
     allowBlockedReviewRoute?: boolean;
+    extraStageFlags?: string[];
 }): Promise<InternalValidationReport>;
 interface HarvestLearningsResult {
     ok: boolean;

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

@@ -89,7 +89,9 @@ export async function hydrateReviewLoopEvidenceFromArtifact(projectRoot, stage,
 }
 export async function buildValidationReport(projectRoot, flowState, options = {}) {
     const delegation = await checkMandatoryDelegations(projectRoot, flowState.currentStage);
-    const gates = await verifyCurrentStageGateEvidence(projectRoot, flowState);
+    const gates = await verifyCurrentStageGateEvidence(projectRoot, flowState, {
+        extraStageFlags: options.extraStageFlags
+    });
     const completedStages = verifyCompletedStagesGateClosure(flowState);
     const blockedReviewRouteComplete = options.allowBlockedReviewRoute === true
         && flowState.currentStage === "review"
@@ -332,7 +334,8 @@ export async function runAdvanceStage(projectRoot, args, io) {
         }
     };
     const validation = await buildValidationReport(projectRoot, candidateState, {
-        allowBlockedReviewRoute: blockedReviewRoute
+        allowBlockedReviewRoute: blockedReviewRoute,
+        extraStageFlags: args.skipQuestions ? ["--skip-questions"] : undefined
     });
     if (!validation.ok) {
         const ledgerForDiag = await readDelegationLedger(projectRoot).catch(() => ({ entries: [] }));

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")) {