cclaw-cli 0.48.7 → 0.48.9

package/dist/content/observe.js

@@ -1660,7 +1660,7 @@ exit 0
  * Updated hooks.json generators with PreToolUse/PostToolUse observation.
  */
 function hookDispatcherCommand(scriptName) {
-    return `bash ${RUNTIME_ROOT}/hooks/run-hook.cmd ${scriptName}`;
+    return `node ${RUNTIME_ROOT}/hooks/run-hook.mjs ${scriptName}`;
 }
 export function claudeHooksJsonWithObservation() {
     return JSON.stringify({
@@ -1799,7 +1799,7 @@ export function codexHooksJsonWithObservation() {
                             command: hookDispatcherCommand("workflow-guard.sh")
                         }, {
                             type: "command",
-                            command: "bash -lc 'if ! command -v cclaw >/dev/null 2>&1; then echo \"[cclaw] codex hook: cclaw binary is required for verify-current-state\" >&2; exit 1; fi; MODE=\"${CCLAW_WORKFLOW_GUARD_MODE:-advisory}\"; if [ \"$MODE\" = \"strict\" ]; then cclaw internal verify-current-state --quiet >/dev/null; else cclaw internal verify-current-state --quiet >/dev/null || true; fi'"
+                            command: hookDispatcherCommand("verify-current-state")
                         }]
                 }],
             PreToolUse: [{

package/dist/content/opencode-plugin.js

@@ -272,9 +272,9 @@ export default function cclawPlugin(ctx) {
     });
   }
 
-  async function runHookScript(scriptFileName, payload = {}) {
+  async function runHookScript(hookName, payload = {}) {
     const { spawn } = await import("node:child_process");
-    const scriptPath = join(root, "${RUNTIME_ROOT}/hooks/" + scriptFileName);
+    const hookRuntimePath = join(root, "${RUNTIME_ROOT}/hooks/run-hook.mjs");
     const input = typeof payload === "string" ? payload : JSON.stringify(payload ?? {});
     return scheduleHookTask(() => new Promise((resolve) => {
       let stderr = "";
@@ -287,7 +287,7 @@ export default function cclawPlugin(ctx) {
 
       let child;
       try {
-        child = spawn("bash", [scriptPath], {
+        child = spawn(process.execPath, [hookRuntimePath, hookName], {
           cwd: root,
           stdio: ["pipe", "ignore", "pipe"]
         });
@@ -299,7 +299,7 @@ export default function cclawPlugin(ctx) {
       const timer = setTimeout(() => {
         child.kill("SIGKILL");
         if (stderr.length > 0) {
-          console.error("[cclaw] opencode hook timeout: " + scriptFileName + " stderr=" + stderr.slice(-1200));
+          console.error("[cclaw] opencode hook timeout: " + hookName + " stderr=" + stderr.slice(-1200));
         }
         finish(false);
       }, 20_000);
@@ -318,7 +318,7 @@ export default function cclawPlugin(ctx) {
         clearTimeout(timer);
         const ok = code === 0;
         if (!ok && stderr.length > 0) {
-          console.error("[cclaw] opencode hook failed: " + scriptFileName + " stderr=" + stderr.slice(-1200));
+          console.error("[cclaw] opencode hook failed: " + hookName + " stderr=" + stderr.slice(-1200));
         }
         finish(ok);
       });

package/dist/doctor.js

@@ -879,7 +879,7 @@ export async function doctorChecks(projectRoot, options = {}) {
         const codexWiringOk = codexSessionCmds.some((cmd) => cmd.includes("session-start.sh")) &&
             codexUserPromptCmds.some((cmd) => cmd.includes("prompt-guard.sh")) &&
             codexUserPromptCmds.some((cmd) => cmd.includes("workflow-guard.sh")) &&
-            codexUserPromptCmds.some((cmd) => cmd.includes("verify-current-state --quiet")) &&
+            codexUserPromptCmds.some((cmd) => cmd.includes("verify-current-state")) &&
             codexPreCmds.some((cmd) => cmd.includes("prompt-guard.sh")) &&
             codexPreCmds.some((cmd) => cmd.includes("workflow-guard.sh")) &&
             codexPostCmds.some((cmd) => cmd.includes("context-monitor.sh")) &&

package/dist/install.js

@@ -26,6 +26,7 @@ import { sessionHooksSkillMarkdown } from "./content/session-hooks.js";
 import { ironLawRuntimeDocument, ironLawsSkillMarkdown } from "./content/iron-laws.js";
 import { hookLibScript, sessionStartScript, stopCheckpointScript, runHookDispatcherScript, stageCompleteScript, preCompactScript, opencodePluginJs, claudeHooksJson, codexHooksJson, cursorHooksJson } from "./content/hooks.js";
 import { contextMonitorScript, promptGuardScript, workflowGuardScript } from "./content/observe.js";
+import { nodeHookRuntimeScript } from "./content/node-hooks.js";
 import { META_SKILL_NAME, usingCclawSkillMarkdown } from "./content/meta-skill.js";
 import { decisionProtocolMarkdown, completionProtocolMarkdown, ethosProtocolMarkdown } from "./content/protocols.js";
 import { ARTIFACT_TEMPLATES, CURSOR_WORKFLOW_RULE_MDC, RULEBOOK_MARKDOWN, buildRulesJson } from "./content/templates.js";
@@ -646,6 +647,13 @@ async function writeHooks(projectRoot, config) {
         tddProductionPathPatterns: config.tdd?.productionPathPatterns
     }));
     await writeFileSafe(path.join(hooksDir, "context-monitor.sh"), contextMonitorScript());
+    await writeFileSafe(path.join(hooksDir, "run-hook.mjs"), nodeHookRuntimeScript({
+        promptGuardMode: config.promptGuardMode ?? config.strictness ?? "advisory",
+        workflowGuardMode: config.strictness ?? "advisory",
+        tddEnforcementMode: config.tddEnforcement ?? config.strictness ?? "advisory",
+        tddTestPathPatterns: config.tdd?.testPathPatterns ?? config.tddTestGlobs,
+        tddProductionPathPatterns: config.tdd?.productionPathPatterns
+    }));
     const opencodePluginSource = opencodePluginJs();
     await writeFileSafe(path.join(hooksDir, "opencode-plugin.mjs"), opencodePluginSource);
     try {
@@ -659,6 +667,7 @@ async function writeHooks(projectRoot, config) {
             "prompt-guard.sh",
             "workflow-guard.sh",
             "context-monitor.sh",
+            "run-hook.mjs",
             "opencode-plugin.mjs"
         ]) {
             await fs.chmod(path.join(hooksDir, script), 0o755);
@@ -1347,12 +1356,13 @@ function stripManagedHookCommands(value) {
 function isManagedRuntimeHookCommand(command) {
     const normalized = command.trim().replace(/\s+/gu, " ");
     if (/(^|\s)(?:bash\s+)?(?:\.\/)?\.cclaw\/hooks\/(?:session-start|stop-checkpoint|pre-compact|prompt-guard|workflow-guard|context-monitor)\.sh(?:\s|$)/u.test(normalized) ||
-        /(^|\s)(?:bash\s+)?(?:\.\/)?\.cclaw\/hooks\/run-hook\.cmd\s+(?:session-start|stop-checkpoint|pre-compact|prompt-guard|workflow-guard|context-monitor)(?:\.sh)?(?:\s|$)/u.test(normalized)) {
+        /(^|\s)(?:bash\s+)?(?:\.\/)?\.cclaw\/hooks\/run-hook\.cmd\s+(?:session-start|stop-checkpoint|pre-compact|prompt-guard|workflow-guard|context-monitor)(?:\.sh)?(?:\s|$)/u.test(normalized) ||
+        /(^|\s)(?:node\s+)?(?:"|')?(?:\.\/)?\.cclaw\/hooks\/run-hook\.mjs(?:"|')?\s+(?:session-start|stop-checkpoint|pre-compact|prompt-guard|workflow-guard|context-monitor|verify-current-state)(?:\.sh)?(?:\s|$)/u.test(normalized)) {
         return true;
     }
     // Codex UserPromptSubmit non-blocking state nudge:
-    // bash -lc '... cclaw internal verify-current-state --quiet ...'
-    return /internal verify-current-state --quiet/u.test(normalized);
+    // legacy shell and newer Node wrappers call this internal command.
+    return /internal verify-current-state(?:\s|$)/u.test(normalized);
 }
 async function removeManagedHookEntries(hookFilePath) {
     if (!(await exists(hookFilePath)))

package/dist/internal/advance-stage.js

@@ -1,5 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+import { spawn } from "node:child_process";
+import process from "node:process";
 import { RUNTIME_ROOT, SHIP_FINALIZATION_MODES } from "../constants.js";
 import { stageSchema } from "../content/stage-schema.js";
 import { appendDelegation, checkMandatoryDelegations } from "../delegation.js";
@@ -306,6 +308,17 @@ function parseVerifyCurrentStateArgs(tokens) {
     }
     return { quiet };
 }
+function parseHookArgs(tokens) {
+    const [hookName, ...rest] = tokens;
+    const normalizedHook = typeof hookName === "string" ? hookName.trim() : "";
+    if (normalizedHook.length === 0) {
+        throw new Error("internal hook requires a hook name: cclaw internal hook <name>.");
+    }
+    if (rest.length > 0) {
+        throw new Error(`Unknown arguments for internal hook: ${rest.join(" ")}`);
+    }
+    return { hookName: normalizedHook };
+}
 async function buildValidationReport(projectRoot, flowState) {
     const delegation = await checkMandatoryDelegations(projectRoot, flowState.currentStage);
     const gates = await verifyCurrentStageGateEvidence(projectRoot, flowState);
@@ -621,10 +634,45 @@ async function runVerifyCurrentState(projectRoot, args, io) {
     }
     return validation.ok ? 0 : 1;
 }
+async function runHookCommand(projectRoot, args, io) {
+    const runHookPath = path.join(projectRoot, RUNTIME_ROOT, "hooks", "run-hook.mjs");
+    try {
+        await fs.access(runHookPath);
+    }
+    catch {
+        io.stderr.write(`cclaw internal hook: missing hook runtime at ${runHookPath}. Run \`cclaw sync\` first.\n`);
+        return 1;
+    }
+    return await new Promise((resolve) => {
+        const child = spawn(process.execPath, [runHookPath, args.hookName], {
+            cwd: projectRoot,
+            env: process.env,
+            stdio: ["inherit", "pipe", "pipe"]
+        });
+        child.stdout.on("data", (chunk) => {
+            io.stdout.write(chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+            io.stderr.write(chunk);
+        });
+        child.on("error", (err) => {
+            io.stderr.write(`cclaw internal hook: failed to launch runtime (${err instanceof Error ? err.message : String(err)}).\n`);
+            resolve(1);
+        });
+        child.on("close", (code, signal) => {
+            if (signal) {
+                io.stderr.write(`cclaw internal hook: runtime terminated by signal ${signal}.\n`);
+                resolve(1);
+                return;
+            }
+            resolve(typeof code === "number" ? code : 1);
+        });
+    });
+}
 export async function runInternalCommand(projectRoot, argv, io) {
     const [subcommand, ...tokens] = argv;
     if (!subcommand) {
-        io.stderr.write("cclaw internal requires a subcommand: advance-stage | verify-flow-state-diff | verify-current-state | knowledge-digest | envelope-validate | tdd-red-evidence\n");
+        io.stderr.write("cclaw internal requires a subcommand: advance-stage | verify-flow-state-diff | verify-current-state | knowledge-digest | envelope-validate | tdd-red-evidence | hook\n");
         return 1;
     }
     try {
@@ -646,7 +694,10 @@ export async function runInternalCommand(projectRoot, argv, io) {
         if (subcommand === "tdd-red-evidence") {
             return await runTddRedEvidenceCommand(projectRoot, tokens, io);
         }
-        io.stderr.write(`Unknown internal subcommand: ${subcommand}. Expected advance-stage | verify-flow-state-diff | verify-current-state | knowledge-digest | envelope-validate | tdd-red-evidence\n`);
+        if (subcommand === "hook") {
+            return await runHookCommand(projectRoot, parseHookArgs(tokens), io);
+        }
+        io.stderr.write(`Unknown internal subcommand: ${subcommand}. Expected advance-stage | verify-flow-state-diff | verify-current-state | knowledge-digest | envelope-validate | tdd-red-evidence | hook\n`);
         return 1;
     }
     catch (err) {

package/package.json

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