selftune 0.2.15 → 0.2.16

package/bin/run-hook.cjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+/**
+ * Hook runner — executes a TypeScript hook script via Bun.
+ *
+ * Usage: node run-hook.cjs <path-to-hook.ts>
+ *
+ * Stdin is piped through to the hook script (Claude Code sends JSON on stdin).
+ * Exit code is propagated from the hook. If bun is not found, exits 0
+ * (fail-open: hooks must never block Claude).
+ *
+ * Note: selftune hooks depend on Bun-specific APIs (Bun.stdin.text(),
+ * Bun.spawn()) and cannot run under tsx/node. The runner exists so that
+ * hook commands use `node run-hook.cjs` (universally available) as the
+ * entry point, avoiding a hard dependency on bun being in PATH for the
+ * shell that Claude Code invokes.
+ */
+
+const { execFileSync } = require("child_process");
+const hookScript = process.argv[2];
+
+if (!hookScript) {
+  // No script specified — fail-open
+  process.exit(0);
+}
+
+try {
+  execFileSync("bun", ["run", hookScript], { stdio: "inherit" });
+  process.exit(0);
+} catch (e) {
+  // Hook exited non-zero → propagate (e.g. exit 2 = block in PreToolUse)
+  if (e.status != null) {
+    process.exit(e.status);
+  }
+  // bun not found (ENOENT) — fail-open
+  process.exit(0);
+}

package/cli/selftune/evolution/evolve.ts

@@ -51,6 +51,7 @@ import {
   selectFromFrontier,
 } from "./pareto.js";
 import { generateMultipleProposals, generateProposal } from "./propose-description.js";
+import { buildUnblockSuggestions } from "./unblock-suggestions.js";
 import type { ValidationResult } from "./validate-proposal.js";
 import {
   TRIGGER_CHECK_BATCH_SIZE,
@@ -1272,11 +1273,16 @@ Options:
       ...(result.descriptionQualityAfter != null
         ? { description_quality_after: result.descriptionQualityAfter }
         : {}),
+      ...(!result.deployed
+        ? {
+            suggestions: buildUnblockSuggestions(result, values.skill),
+          }
+        : {}),
     };
     console.log(JSON.stringify(summary, null, 2));
   }
 
-  // Print human-readable status to stderr so users always see outcome
+  // Print human-readable status to stderr so agents always see outcome + next steps
   if (!result.deployed) {
     console.error(`\n[NOT DEPLOYED] ${result.reason}`);
     if (result.validation && !result.validation.improved) {
@@ -1295,9 +1301,25 @@ Options:
         `  Confidence ${result.proposal.confidence.toFixed(2)} below threshold ${values.confidence ?? "0.6"}`,
       );
     }
-    console.error("  Re-run with --verbose for full diagnostic output.");
+    // Targeted suggestions based on specific failure reason
+    const suggestions = buildUnblockSuggestions(result, values.skill);
+    if (suggestions.length > 0) {
+      console.error("\n  Next steps:");
+      for (const s of suggestions) {
+        console.error(`    → ${s}`);
+      }
+    }
   } else {
     console.error(`\n[DEPLOYED] ${result.reason}`);
+    // Show quality improvement if available
+    if (result.descriptionQualityBefore != null && result.descriptionQualityAfter != null) {
+      const delta = result.descriptionQualityAfter - result.descriptionQualityBefore;
+      if (delta !== 0) {
+        console.error(
+          `  Description quality: ${Math.round(result.descriptionQualityBefore * 100)}% → ${Math.round(result.descriptionQualityAfter * 100)}% (${delta >= 0 ? "+" : ""}${Math.round(delta * 100)}%)`,
+        );
+      }
+    }
   }
 
   process.exit(result.deployed ? 0 : 1);

package/cli/selftune/evolution/unblock-suggestions.ts

@@ -0,0 +1,159 @@
+/**
+ * unblock-suggestions.ts
+ *
+ * Generates targeted, per-failure-reason suggestions when evolve doesn't deploy.
+ * Each suggestion is a concrete next CLI command or manual action that helps the
+ * agent (or user) unblock the evolution pipeline.
+ *
+ * Pure function — no I/O, no LLM calls. Depends only on EvolveResult fields and
+ * the scoreDescription heuristic.
+ */
+
+import { scoreDescription } from "./description-quality.js";
+import type { EvolveResult } from "./evolve.js";
+
+// ---------------------------------------------------------------------------
+// Quality hint helper
+// ---------------------------------------------------------------------------
+
+/**
+ * Append description quality improvement hints if the score reveals weak criteria.
+ * Only fires when composite < 0.7 to avoid noise on already-good descriptions.
+ * Skips when descriptionText is empty (no proposal was generated).
+ */
+function appendQualityHints(
+  suggestions: string[],
+  descriptionText: string,
+  skillName: string,
+): void {
+  if (!descriptionText) return;
+  const score = scoreDescription(descriptionText, skillName);
+  if (score.composite >= 0.7) return;
+
+  const weak: string[] = [];
+  if (score.criteria.trigger_context < 0.5) weak.push("add when/if/after trigger context");
+  if (score.criteria.vagueness < 0.7) weak.push("remove vague words (various, general, etc)");
+  if (score.criteria.specificity < 0.5) weak.push("add concrete action verbs");
+  if (score.criteria.length < 0.7) weak.push("adjust length (ideal: 80-300 chars)");
+  if (score.criteria.not_just_name < 0.5) weak.push("differentiate from skill name");
+
+  if (weak.length > 0) {
+    suggestions.push(
+      `Description quality: ${Math.round(score.composite * 100)}% — improve by: ${weak.join(", ")}`,
+    );
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Main suggestion builder
+// ---------------------------------------------------------------------------
+
+/**
+ * Generate targeted suggestions based on the specific failure reason.
+ * Each suggestion is a concrete next CLI command or manual action.
+ */
+export function buildUnblockSuggestions(result: EvolveResult, skillName: string): string[] {
+  const reason = result.reason;
+  const suggestions: string[] = [];
+  const descText = result.proposal?.original_description ?? "";
+
+  // --- Path/config failures ---
+  if (reason.includes("SKILL.md not found")) {
+    suggestions.push("Verify the --skill-path flag points to a valid SKILL.md file");
+    suggestions.push("Run: selftune init (to re-bootstrap config if paths changed)");
+    return suggestions;
+  }
+
+  if (reason.includes("Failed to load eval set") || reason.includes("not a JSON array")) {
+    suggestions.push("Run: selftune sync (to rebuild source-truth telemetry)");
+    suggestions.push(`Then: selftune evolve --skill ${skillName} (to retry with fresh evals)`);
+    return suggestions;
+  }
+
+  // --- No signal failures ---
+  if (reason.includes("No failure patterns found")) {
+    suggestions.push("This skill may already be routing well — check: selftune status");
+    suggestions.push("If undertriggering, add more sessions so evolve has signal to work with");
+    if (result.descriptionQualityBefore != null && result.descriptionQualityBefore < 0.5) {
+      suggestions.push(
+        `Description quality is ${Math.round(result.descriptionQualityBefore * 100)}% — manually improving the description may help generate patterns`,
+      );
+      appendQualityHints(suggestions, descText, skillName);
+    }
+    return suggestions;
+  }
+
+  // --- Confidence failures (specific before general) ---
+  if (reason.includes("No candidates met confidence")) {
+    suggestions.push(`Lower the threshold: selftune evolve --skill ${skillName} --confidence 0.4`);
+    suggestions.push(
+      `Or increase candidates: selftune evolve --skill ${skillName} --pareto --candidates 5`,
+    );
+    appendQualityHints(suggestions, descText, skillName);
+    return suggestions;
+  }
+  if (reason.toLowerCase().includes("confidence") && reason.includes("threshold")) {
+    suggestions.push(`Lower the threshold: selftune evolve --skill ${skillName} --confidence 0.4`);
+    suggestions.push("Or add more eval entries so the LLM has more context for proposals");
+    appendQualityHints(suggestions, descText, skillName);
+    return suggestions;
+  }
+
+  // --- Validation failures (proposals regressed) ---
+  if (reason.includes("Validation failed after")) {
+    suggestions.push(
+      `The eval set may be contradictory — review with: selftune evolve --skill ${skillName} --verbose`,
+    );
+    suggestions.push(
+      `Try: selftune evolve --skill ${skillName} --pareto --candidates 5 (more diverse proposals)`,
+    );
+    if (result.validation && result.validation.regressions.length > 0) {
+      suggestions.push(
+        `${result.validation.regressions.length} regressions detected — check if negative eval entries are too broad`,
+      );
+    }
+    appendQualityHints(suggestions, descText, skillName);
+    return suggestions;
+  }
+  if (reason.includes("No Pareto candidates improved")) {
+    suggestions.push("All candidates regressed — the eval set may need rebalancing");
+    suggestions.push(`Try: selftune sync --force && selftune evolve --skill ${skillName}`);
+    return suggestions;
+  }
+
+  // --- Gate failures ---
+  if (reason.includes("Baseline gate failed")) {
+    suggestions.push("Improvement was too marginal to justify deployment");
+    suggestions.push("Collect more session data, then retry — small gains compound over time");
+    return suggestions;
+  }
+  if (reason.includes("Gate validation failed")) {
+    suggestions.push("The gate model rejected the proposal — it may be too aggressive");
+    suggestions.push(
+      `Try: selftune evolve --skill ${skillName} --full-model (disables cheap-loop gate)`,
+    );
+    return suggestions;
+  }
+
+  // --- Constitutional rejection ---
+  if (reason.includes("Constitutional")) {
+    suggestions.push("The proposed description violated safety constraints");
+    suggestions.push("Review constitutional rules and manually adjust the description if needed");
+    return suggestions;
+  }
+
+  // --- Dry run (not really a failure) ---
+  if (reason.includes("Dry run")) {
+    suggestions.push(`Deploy: selftune evolve --skill ${skillName} (remove --dry-run to deploy)`);
+    return suggestions;
+  }
+
+  // --- Catch-all for unexpected errors ---
+  if (reason.includes("Error during evolution")) {
+    suggestions.push("Re-run with --verbose for full stack trace");
+    suggestions.push("Run: selftune doctor (to check system health)");
+    return suggestions;
+  }
+
+  return suggestions;
+}

package/cli/selftune/init.ts

@@ -45,7 +45,7 @@ import { installAgentFiles } from "./claude-agents.js";
 import { CLAUDE_CODE_HOOK_KEYS, SELFTUNE_CONFIG_DIR, SELFTUNE_CONFIG_PATH } from "./constants.js";
 import type { AgentCommandGuidance, AlphaIdentity, SelftuneConfig } from "./types.js";
 import { CLIError, handleCLIError } from "./utils/cli-error.js";
-import { hookKeyHasSelftuneEntry } from "./utils/hooks.js";
+import { hookKeyHasSelftuneEntry, isSelftuneCommand } from "./utils/hooks.js";
 import { detectAgent } from "./utils/llm-call.js";
 
 export { installAgentFiles } from "./claude-agents.js";
@@ -229,10 +229,13 @@ const SETTINGS_SNIPPET_PATH = resolve(
  *
  * - Creates settings.json if it does not exist
  * - Creates the hooks section if it does not exist
- * - Only adds hook entries for keys that don't already have a selftune entry
- * - Never overwrites existing user hooks
+ * - Adds hook entries for keys that don't already have a selftune entry
+ * - Updates existing selftune entries with new attributes from the snippet
+ *   (e.g. `if`, `statusMessage`, `async`, `timeout`) while preserving
+ *   the resolved `command` path from the existing entry
+ * - Never overwrites existing non-selftune hooks
  *
- * Returns the list of hook keys that were added.
+ * Returns the list of hook keys that were added or updated.
  */
 export function installClaudeCodeHooks(options?: {
   settingsPath?: string;
@@ -279,43 +282,211 @@ export function installClaudeCodeHooks(options?: {
   }
   const existingHooks = settings.hooks as Record<string, unknown[]>;
 
-  // Resolve the CLI hooks directory for path substitution
+  // Resolve the package root for path substitution
+  // cliPath points to cli/selftune/index.ts → package root is two levels up
   const cliPath = options?.cliPath;
-  const hooksDir = cliPath ? `${dirname(cliPath)}/hooks` : null;
+  const packageRoot = cliPath ? resolve(dirname(cliPath), "..", "..").replace(/\\/g, "/") : null;
 
-  const addedKeys: string[] = [];
+  const changedKeys: string[] = [];
 
   for (const key of Object.keys(snippetHooks)) {
-    // Skip if this key already has a selftune entry
-    if (hookKeyHasSelftuneEntry(existingHooks, key)) {
-      continue;
-    }
-
-    // Get the snippet entries for this key, replacing /PATH/TO/ with actual path
+    // Get the snippet entries for this key, replacing /PATH/TO/ with actual package root
     let entries = snippetHooks[key];
-    if (hooksDir) {
-      // Deep clone and substitute paths
-      const raw = JSON.stringify(entries).replace(/\/PATH\/TO\/cli\/selftune\/hooks/g, hooksDir);
+    if (packageRoot) {
+      // Deep clone and substitute all /PATH/TO/ references with the resolved package root
+      const raw = JSON.stringify(entries).replace(/\/PATH\/TO\//g, `${packageRoot}/`);
       entries = JSON.parse(raw);
     }
 
-    // Merge: append to existing array or create new one
-    if (Array.isArray(existingHooks[key])) {
-      existingHooks[key] = [...existingHooks[key], ...entries];
+    if (hookKeyHasSelftuneEntry(existingHooks, key)) {
+      // Key already has selftune hooks — update them in-place with new attributes
+      // while preserving non-selftune entries and the resolved command paths
+      if (updateExistingSelftuneHooks(existingHooks, key, entries)) {
+        changedKeys.push(key);
+      }
     } else {
-      existingHooks[key] = entries;
+      // No selftune entry yet — add the snippet entries
+      if (Array.isArray(existingHooks[key])) {
+        existingHooks[key] = [...existingHooks[key], ...entries];
+      } else {
+        existingHooks[key] = entries;
+      }
+      changedKeys.push(key);
     }
-
-    addedKeys.push(key);
   }
 
-  if (addedKeys.length > 0) {
+  if (changedKeys.length > 0) {
     // Ensure ~/.claude/ directory exists
     mkdirSync(dirname(settingsPath), { recursive: true });
     writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
   }
 
-  return addedKeys;
+  return changedKeys;
+}
+
+/**
+ * Update existing selftune hook entries in-place with new attributes from the snippet.
+ *
+ * For each matcher group that contains selftune hooks, replaces ALL selftune
+ * hook entries with the full set of snippet entries while:
+ *   - Resolving snippet commands using the package root from existing entries
+ *   - Preserving non-selftune hooks in the same matcher group
+ *   - Handling N→M changes (e.g. 2 hooks expanding to 4 with Write/Edit splits)
+ *
+ * Returns true if any entries were actually modified.
+ */
+export function updateExistingSelftuneHooks(
+  existingHooks: Record<string, unknown[]>,
+  key: string,
+  snippetEntries: unknown[],
+): boolean {
+  const existingArray = existingHooks[key];
+  if (!Array.isArray(existingArray)) return false;
+
+  // Collect all snippet hooks (flattened from matcher groups)
+  const allSnippetHooks: Array<Record<string, unknown>> = [];
+  for (const group of snippetEntries) {
+    if (typeof group !== "object" || group === null) continue;
+    const g = group as Record<string, unknown>;
+    const hooks = g.hooks as Array<Record<string, unknown>> | undefined;
+    if (!Array.isArray(hooks)) continue;
+    allSnippetHooks.push(...hooks);
+  }
+
+  if (allSnippetHooks.length === 0) return false;
+
+  let modified = false;
+
+  for (let i = 0; i < existingArray.length; i++) {
+    const group = existingArray[i];
+    if (typeof group !== "object" || group === null) continue;
+    const g = group as Record<string, unknown>;
+    const hooks = g.hooks as Array<Record<string, unknown>> | undefined;
+
+    // Handle flat entries (direct { command: "..." } without nested hooks array).
+    // These are a legacy format from older selftune versions or manual installs.
+    if (!Array.isArray(hooks)) {
+      if (!isHookSelftune(g)) continue;
+      const pkgRoot = derivePackageRootFromCommand(typeof g.command === "string" ? g.command : "");
+
+      // Replace the flat entry with the full snippet group structure.
+      // If we can derive a package root, resolve /PATH/TO/ in the snippet.
+      // If not (e.g. "npx selftune hook ..."), use snippet entries as-is
+      // (they were already resolved by the caller if a cliPath was provided).
+      const resolvedEntries = snippetEntries.map((se) => {
+        if (!pkgRoot) return se;
+        const raw = JSON.stringify(se).replace(/\/PATH\/TO\//g, `${pkgRoot}/`);
+        return JSON.parse(raw);
+      });
+      existingArray.splice(i, 1, ...resolvedEntries);
+      modified = true;
+      continue;
+    }
+
+    // Derive package root from the first selftune hook in this group
+    let packageRoot: string | null = null;
+    for (const hook of hooks) {
+      if (isHookSelftune(hook)) {
+        packageRoot = derivePackageRootFromCommand(
+          typeof hook.command === "string" ? hook.command : "",
+        );
+        if (packageRoot) break;
+      }
+    }
+
+    // Check if this group has any selftune hooks at all
+    const hasSelftuneHooks = hooks.some(isHookSelftune);
+    if (!hasSelftuneHooks) continue;
+
+    // Build resolved snippet hooks using the derived package root.
+    // If no package root was derivable (e.g. "npx selftune hook ..."),
+    // use snippet hooks as-is (already resolved by caller if cliPath was provided).
+    const resolvedSnippetHooks = allSnippetHooks.map((snippetHook) => {
+      const cmd = typeof snippetHook.command === "string" ? snippetHook.command : "";
+      const resolvedCmd = packageRoot ? cmd.replace(/\/PATH\/TO\//g, `${packageRoot}/`) : cmd;
+      return { ...snippetHook, command: resolvedCmd };
+    });
+
+    // Check if anything actually changed (compare sorted JSON for order independence)
+    const oldSelftune = hooks.filter(isHookSelftune);
+    const oldSorted = JSON.stringify(sortKeys(oldSelftune));
+    const newSorted = JSON.stringify(sortKeys(resolvedSnippetHooks));
+    if (oldSorted !== newSorted) {
+      modified = true;
+    }
+
+    // Rebuild hooks preserving original ordering of non-selftune entries:
+    // replace the first selftune hook with all resolved snippet hooks,
+    // remove remaining old selftune hooks, keep non-selftune hooks in place
+    const updatedHooks: Array<Record<string, unknown>> = [];
+    let selftuneInserted = false;
+    for (const hook of hooks) {
+      if (isHookSelftune(hook)) {
+        if (!selftuneInserted) {
+          // Insert all resolved snippet hooks at the position of the first selftune hook
+          updatedHooks.push(...resolvedSnippetHooks);
+          selftuneInserted = true;
+        }
+        // Skip remaining old selftune hooks (replaced by snippet set above)
+      } else {
+        updatedHooks.push(hook);
+      }
+    }
+    g.hooks = updatedHooks;
+  }
+
+  return modified;
+}
+
+/** Check if a hook entry is a selftune-managed hook. Delegates to shared isSelftuneCommand. */
+function isHookSelftune(hook: Record<string, unknown>): boolean {
+  return typeof hook.command === "string" && isSelftuneCommand(hook.command);
+}
+
+/** Sort object keys recursively for order-independent JSON comparison. */
+function sortKeys(obj: unknown): unknown {
+  if (Array.isArray(obj)) return obj.map(sortKeys);
+  if (obj !== null && typeof obj === "object") {
+    const sorted: Record<string, unknown> = {};
+    for (const key of Object.keys(obj as Record<string, unknown>).sort()) {
+      sorted[key] = sortKeys((obj as Record<string, unknown>)[key]);
+    }
+    return sorted;
+  }
+  return obj;
+}
+
+/**
+ * Derive the selftune package root from an existing hook command.
+ * Supports both old format ("bun run .../cli/selftune/hooks/X.ts")
+ * and new format ("node .../bin/run-hook.cjs .../cli/selftune/hooks/X.ts").
+ *
+ * Handles paths with spaces (e.g. "/Users/Alice Smith/...") and
+ * optional surrounding quotes in the command string.
+ */
+export function derivePackageRootFromCommand(command: string): string | null {
+  // Normalize: strip quotes, collapse backslashes (for Windows-style paths)
+  const normalized = command.replace(/["']/g, "").replace(/\\/g, "/");
+  // Split on the known directory marker and take the prefix.
+  // The command may contain the package root multiple times (e.g.
+  // "node /root/bin/run-hook.cjs /root/cli/selftune/hooks/script.ts")
+  // so we split on the LAST occurrence of the marker.
+  for (const marker of ["/cli/selftune/hooks/", "/bin/run-hook.cjs"]) {
+    const idx = normalized.lastIndexOf(marker);
+    if (idx === -1) continue;
+    // Everything before the marker is "<prefix> <package-root>" or just "<package-root>"
+    const beforeMarker = normalized.slice(0, idx);
+    // Find the start of the path: scan backwards from end for the path start.
+    // Paths start with / (Unix) or a drive letter like C:/ (Windows).
+    // The command prefix (e.g. "node " or "bun run ") precedes the path.
+    const pathMatch = beforeMarker.match(/.*\s(\/.*|[A-Za-z]:\/.*)/);
+    if (pathMatch) return pathMatch[1];
+    // No space prefix — the entire string is the path (e.g. no "node " prefix)
+    if (beforeMarker.startsWith("/") || /^[A-Za-z]:\//.test(beforeMarker)) {
+      return beforeMarker;
+    }
+  }
+  return null;
 }
 
 // ---------------------------------------------------------------------------
@@ -615,16 +786,16 @@ export async function runInit(opts: InitOptions): Promise<SelftuneConfig> {
       );
     }
 
-    const addedHookKeys = installClaudeCodeHooks({
+    const changedHookKeys = installClaudeCodeHooks({
       settingsPath,
       cliPath,
     });
-    if (addedHookKeys.length > 0) {
+    if (changedHookKeys.length > 0) {
       config.hooks_installed = true;
       // Re-write config with updated hooks_installed flag
       writeSelftuneConfig(configPath, config);
       console.error(
-        `[INFO] Installed ${addedHookKeys.length} selftune hook(s) into ${settingsPath}: ${addedHookKeys.join(", ")}`,
+        `[INFO] Installed/updated ${changedHookKeys.length} selftune hook(s) in ${settingsPath}: ${changedHookKeys.join(", ")}`,
       );
     } else if (!config.hooks_installed) {
       // Re-check in case hooks were already present

package/cli/selftune/types.ts

@@ -446,6 +446,7 @@ export interface EvolveResultSummary {
   dashboard_url: string;
   description_quality_before?: number;
   description_quality_after?: number;
+  suggestions?: string[];
 }
 
 export interface ValidationResultBase {

package/cli/selftune/utils/hooks.ts

@@ -13,14 +13,24 @@ function isHookEntry(value: unknown): value is ClaudeCodeHookEntry {
   return typeof value === "object" && value !== null;
 }
 
+/** Check if a command string references a selftune-managed hook. */
+export function isSelftuneCommand(command: string): boolean {
+  const normalized = command.replace(/\\/g, "/");
+  return (
+    normalized.includes("/cli/selftune/hooks/") ||
+    normalized.includes("/bin/run-hook.cjs") ||
+    normalized.startsWith("npx selftune hook ")
+  );
+}
+
 export function entryReferencesSelftune(entry: ClaudeCodeHookEntry): boolean {
-  if (typeof entry.command === "string" && entry.command.includes("selftune")) {
+  if (typeof entry.command === "string" && isSelftuneCommand(entry.command)) {
     return true;
   }
 
   if (Array.isArray(entry.hooks)) {
     return entry.hooks.some(
-      (hook) => typeof hook.command === "string" && hook.command.includes("selftune"),
+      (hook) => typeof hook.command === "string" && isSelftuneCommand(hook.command),
     );
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "selftune",
-  "version": "0.2.15",
+  "version": "0.2.16",
   "description": "Self-improving skills CLI for AI agents",
   "keywords": [
     "agent",

package/skill/SKILL.md

@@ -12,7 +12,7 @@ description: >
   even if they don't say "selftune" explicitly.
 metadata:
   author: selftune-dev
-  version: 0.2.15
+  version: 0.2.16
   category: developer-tools
 ---
 

package/skill/Workflows/AutoActivation.md

@@ -110,7 +110,7 @@ The hook is registered under `UserPromptSubmit`:
   "hooks": {
     "UserPromptSubmit": [
       {
-        "command": "bun run /path/to/cli/selftune/hooks/auto-activate.ts"
+        "command": "node /path/to/bin/run-hook.cjs /path/to/cli/selftune/hooks/auto-activate.ts"
       }
     ]
   }

package/skill/settings_snippet.json

@@ -9,13 +9,13 @@
         "hooks": [
           {
             "type": "command",
-            "command": "bun run /PATH/TO/cli/selftune/hooks/prompt-log.ts",
+            "command": "node /PATH/TO/bin/run-hook.cjs /PATH/TO/cli/selftune/hooks/prompt-log.ts",
             "timeout": 5,
             "statusMessage": "selftune: logging prompt"
           },
           {
             "type": "command",
-            "command": "bun run /PATH/TO/cli/selftune/hooks/auto-activate.ts",
+            "command": "node /PATH/TO/bin/run-hook.cjs /PATH/TO/cli/selftune/hooks/auto-activate.ts",
             "timeout": 5,
             "statusMessage": "selftune: checking activation rules"
           }
@@ -29,28 +29,28 @@
           {
             "type": "command",
             "if": "Write(*SKILL.md)",
-            "command": "bun run /PATH/TO/cli/selftune/hooks/skill-change-guard.ts",
+            "command": "node /PATH/TO/bin/run-hook.cjs /PATH/TO/cli/selftune/hooks/skill-change-guard.ts",
             "timeout": 5,
             "statusMessage": "selftune: checking skill change guard"
           },
           {
             "type": "command",
             "if": "Edit(*SKILL.md)",
-            "command": "bun run /PATH/TO/cli/selftune/hooks/skill-change-guard.ts",
+            "command": "node /PATH/TO/bin/run-hook.cjs /PATH/TO/cli/selftune/hooks/skill-change-guard.ts",
             "timeout": 5,
             "statusMessage": "selftune: checking skill change guard"
           },
           {
             "type": "command",
             "if": "Write(*SKILL.md)",
-            "command": "bun run /PATH/TO/cli/selftune/hooks/evolution-guard.ts",
+            "command": "node /PATH/TO/bin/run-hook.cjs /PATH/TO/cli/selftune/hooks/evolution-guard.ts",
             "timeout": 5,
             "statusMessage": "selftune: checking evolution guard"
           },
           {
             "type": "command",
             "if": "Edit(*SKILL.md)",
-            "command": "bun run /PATH/TO/cli/selftune/hooks/evolution-guard.ts",
+            "command": "node /PATH/TO/bin/run-hook.cjs /PATH/TO/cli/selftune/hooks/evolution-guard.ts",
             "timeout": 5,
             "statusMessage": "selftune: checking evolution guard"
           }
@@ -63,7 +63,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "bun run /PATH/TO/cli/selftune/hooks/skill-eval.ts",
+            "command": "node /PATH/TO/bin/run-hook.cjs /PATH/TO/cli/selftune/hooks/skill-eval.ts",
             "timeout": 5,
             "statusMessage": "selftune: evaluating skill usage"
           }
@@ -75,7 +75,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "bun run /PATH/TO/cli/selftune/hooks/session-stop.ts",
+            "command": "node /PATH/TO/bin/run-hook.cjs /PATH/TO/cli/selftune/hooks/session-stop.ts",
             "timeout": 60,
             "async": true,
             "statusMessage": "selftune: capturing session telemetry"