wogiflow 2.4.2 → 2.4.4

package/scripts/flow-verify.js

@@ -22,15 +22,12 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const { spawn, execSync } = require('node:child_process');
-const { getProjectRoot, getConfig, colors: c, readJson } = require('./flow-utils');
+const { getProjectRoot, getConfig, colors: c, readJson, PATHS } = require('./flow-utils');
 const { success: printSuccess, error: printError } = require('./flow-output');
 const { recordCommandResult } = require('./flow-metrics');
 const { detectPackageManager, getExecCommand, getRunPrefix } = require('./flow-script-resolver');
 const { CREDENTIAL_SCAN_PATTERNS } = require('./flow-security');
 
-const PROJECT_ROOT = getProjectRoot();
-const WORKFLOW_DIR = path.join(PROJECT_ROOT, '.workflow');
-
 /**
  * Gate result structure
  */
@@ -197,7 +194,7 @@ const ERROR_PARSERS = {
       if (match) {
         const [, file, lineNum, col, message, rule] = match;
         errors.push({
-          file: path.relative(PROJECT_ROOT, file),
+          file: path.relative(PATHS.root, file),
           line: parseInt(lineNum),
           column: parseInt(col),
           message: message.trim(),
@@ -220,7 +217,7 @@ const ERROR_PARSERS = {
       if (match) {
         const [, file, lineNum, col, severity, code, message] = match;
         errors.push({
-          file: path.relative(PROJECT_ROOT, file),
+          file: path.relative(PATHS.root, file),
           line: parseInt(lineNum),
           column: parseInt(col),
           message,
@@ -250,7 +247,7 @@ const ERROR_PARSERS = {
       const [, file, line, col] = match;
       if (!file.includes('node_modules')) {
         errors.push({
-          file: path.relative(PROJECT_ROOT, file),
+          file: path.relative(PATHS.root, file),
           line: parseInt(line),
           column: parseInt(col),
           message: 'Test assertion failed',
@@ -363,12 +360,11 @@ const ERROR_PARSERS = {
   }
 };
 
-
 /**
  * Detect which command to use based on installed packages
  */
 function detectCommand(gate) {
-  const packageJsonPath = path.join(PROJECT_ROOT, 'package.json');
+  const packageJsonPath = path.join(PATHS.root, 'package.json');
   let deps = {};
 
   if (fs.existsSync(packageJsonPath)) {
@@ -405,7 +401,7 @@ function runCommand(cmd, args, timeout = 120000) {
     let stderrTruncated = false;
 
     const proc = spawn(cmd, args, {
-      cwd: PROJECT_ROOT,
+      cwd: PATHS.root,
       timeout,
       stdio: ['pipe', 'pipe', 'pipe']
     });
@@ -687,7 +683,7 @@ function generateFixSuggestions(gateName, errors) {
 function getStagedFiles() {
   try {
     const output = execSync('git diff --cached --name-only', {
-      cwd: PROJECT_ROOT,
+      cwd: PATHS.root,
       encoding: 'utf-8'
     });
     return output.split('\n').filter(f => f.trim() && /\.(ts|tsx|js|jsx|json|env)$/i.test(f));
@@ -720,7 +716,7 @@ function findSourceFiles(dir, extensions, limit) {
         if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
 
         const fullPath = path.join(currentDir, entry.name);
-        const relativePath = path.relative(PROJECT_ROOT, fullPath);
+        const relativePath = path.relative(PATHS.root, fullPath);
 
         if (entry.isDirectory()) {
           walk(fullPath, depth + 1);
@@ -756,7 +752,7 @@ function checkForSecrets(files) {
     });
     if (shouldIgnore) continue;
 
-    const filePath = path.join(PROJECT_ROOT, file);
+    const filePath = path.join(PATHS.root, file);
     if (!fs.existsSync(filePath)) continue;
 
     try {
@@ -809,7 +805,7 @@ function checkForInjection(files) {
     });
     if (shouldIgnore) continue;
 
-    const filePath = path.join(PROJECT_ROOT, file);
+    const filePath = path.join(PATHS.root, file);
     if (!fs.existsSync(filePath)) continue;
 
     try {
@@ -853,7 +849,7 @@ async function runSecurityChecks(gateResult) {
     // Fall back to src directory if no staged files
     // Use fs.readdirSync instead of shell find to prevent command injection
     try {
-      const srcDir = path.join(PROJECT_ROOT, 'src');
+      const srcDir = path.join(PATHS.root, 'src');
       if (fs.existsSync(srcDir)) {
         files = findSourceFiles(srcDir, ['.ts', '.tsx', '.js', '.jsx'], 100);
       }
@@ -1075,7 +1071,7 @@ function formatResults(results, options = {}) {
  * Save results to run artifacts
  */
 function saveResults(runId, results) {
-  const runDir = path.join(WORKFLOW_DIR, 'runs', runId);
+  const runDir = path.join(PATHS.workflow, 'runs', runId);
   if (!fs.existsSync(runDir)) {
     return false;
   }

package/scripts/flow-version-check.js

@@ -16,7 +16,7 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const { execSync } = require('node:child_process');
-const { PATHS, meetsVersion, readJson } = require('./flow-utils');
+const { PATHS, meetsVersion, readJson, safeJsonParse } = require('./flow-utils');
 
 const VERSION_CHECK_PATH = path.join(PATHS.state, '.version-check.json');
 
@@ -46,12 +46,7 @@ function getClaudeCodeVersion() {
  * @returns {{ version: string, checkedAt: string, wogiflowVersion: string } | null}
  */
 function readLastCheck() {
-  try {
-    const content = fs.readFileSync(VERSION_CHECK_PATH, 'utf-8');
-    return JSON.parse(content);
-  } catch (err) {
-    return null;
-  }
+  return safeJsonParse(VERSION_CHECK_PATH, null);
 }
 
 /**
@@ -195,9 +190,8 @@ function checkWogiFlowUpdateOnce() {
   if (localVersion === 'unknown') return null;
 
   // Check cached result
-  try {
-    const cached = fs.readFileSync(UPDATE_CHECK_PATH, 'utf-8');
-    const data = JSON.parse(cached);
+  const data = safeJsonParse(UPDATE_CHECK_PATH, null);
+  if (data) {
     const age = Date.now() - new Date(data.checkedAt).getTime();
     if (age < UPDATE_CHECK_TTL_MS && data.localVersion === localVersion) {
       // Still within TTL and same local version — return cached result
@@ -206,8 +200,6 @@ function checkWogiFlowUpdateOnce() {
       }
       return null;
     }
-  } catch (err) {
-    // No cache or invalid — proceed with fresh check
   }
 
   // Fetch from npm

package/scripts/flow-webmcp-generator.js

@@ -16,15 +16,13 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const crypto = require('node:crypto');
-const { getProjectRoot, getConfig, color, success, warn, error } = require('./flow-utils');
+const { getProjectRoot, getConfig, color, success, warn, error, PATHS } = require('./flow-utils');
 const { readJson, writeJson, ensureDir, fileExists } = require('./flow-utils');
 const { BaseScanner, PROJECT_ROOT } = require('./flow-scanner-base');
 
-const WORKFLOW_DIR = path.join(PROJECT_ROOT, '.workflow');
-const STATE_DIR = path.join(WORKFLOW_DIR, 'state');
-const WEBMCP_DIR = path.join(WORKFLOW_DIR, 'webmcp');
+const WEBMCP_DIR = path.join(PATHS.workflow, 'webmcp');
 const TOOLS_PATH = path.join(WEBMCP_DIR, 'tools.json');
-const APP_MAP_PATH = path.join(STATE_DIR, 'app-map.md');
+const APP_MAP_PATH = PATHS.appMap;
 
 // ============================================================
 // Configuration

package/scripts/flow-workflow-steps.js

@@ -15,8 +15,6 @@ const fs = require('node:fs');
 const path = require('node:path');
 const { getProjectRoot, colors, getConfig, invalidateConfigCache, writeJson, PATHS } = require('./flow-utils');
 
-const PROJECT_ROOT = getProjectRoot();
-
 // ============================================================
 // Step Registry - All available workflow steps
 // ============================================================

package/scripts/flow-workflow.js

@@ -24,18 +24,16 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const { spawn } = require('node:child_process');
-const { getProjectRoot, colors: c, readJson } = require('./flow-utils');
+const { getProjectRoot, colors: c, readJson, PATHS } = require('./flow-utils');
 const { success: printSuccess, error: printError } = require('./flow-output');
 const { detectPackageManager } = require('./flow-script-resolver');
 
-const PROJECT_ROOT = getProjectRoot();
-const WORKFLOW_DIR = path.join(PROJECT_ROOT, '.workflow');
-const WORKFLOWS_DIR = path.join(WORKFLOW_DIR, 'workflows');
+const WORKFLOWS_DIR = path.join(PATHS.workflow, 'workflows');
 
 /**
  * Validate that a path is within the project root (prevent path traversal)
  */
-function validatePathWithinProject(targetPath, baseRoot = PROJECT_ROOT) {
+function validatePathWithinProject(targetPath, baseRoot = PATHS.root) {
   const resolvedPath = path.resolve(baseRoot, targetPath);
   const resolvedRoot = path.resolve(baseRoot);
 
@@ -62,11 +60,11 @@ const STEP_TYPES = {
  * Detect project type (language, package manager)
  * Returns { language, packageManager } with defaults to Node.js/npm
  */
-function detectProjectType(projectRoot = PROJECT_ROOT) {
+function detectProjectType(projectRoot = PATHS.root) {
   // Validate projectRoot to prevent path traversal
-  const safeRoot = projectRoot === PROJECT_ROOT
-    ? PROJECT_ROOT
-    : validatePathWithinProject(projectRoot, PROJECT_ROOT);
+  const safeRoot = projectRoot === PATHS.root
+    ? PATHS.root
+    : validatePathWithinProject(projectRoot, PATHS.root);
 
   // Check for Go
   if (fs.existsSync(path.join(safeRoot, 'go.mod'))) {
@@ -95,7 +93,7 @@ function detectProjectType(projectRoot = PROJECT_ROOT) {
  * Get quality gate command for an action (lint, test, build)
  * Adapts to detected package manager and language
  */
-function getQualityCommand(action, projectRoot = PROJECT_ROOT) {
+function getQualityCommand(action, projectRoot = PATHS.root) {
   const { language, packageManager } = detectProjectType(projectRoot);
 
   const commands = {
@@ -312,7 +310,7 @@ function executeCommand(command, options = {}) {
     const startTime = Date.now();
 
     const proc = spawn('sh', ['-c', command], {
-      cwd: options.cwd || PROJECT_ROOT,
+      cwd: options.cwd || PATHS.root,
       env: { ...process.env, ...options.env },
       timeout: options.timeout || 60000
     });

package/scripts/hooks/adapters/claude-code.js

@@ -32,6 +32,7 @@ const HOOK_TIMEOUTS = {
   STOP: 5,                // Loop enforcement check
   SESSION_END: 10,        // Session cleanup/logging
   TASK_COMPLETED: 10,     // Post-task cleanup (Claude Code 2.1.33+)
+  TASK_CREATED: 5,        // Task creation tracking (Claude Code 2.1.84+)
   TEAMMATE_IDLE: 5,       // Task dispatch for idle agents (Claude Code 2.1.33+)
   CONFIG_CHANGE: 5,       // Mid-session config change detection (Claude Code latest)
   INSTRUCTIONS_LOADED: 5  // Instructions loaded event (Claude Code latest)
@@ -55,6 +56,7 @@ const CLAUDE_CODE_EVENTS = [
   'ConfigChange',         // Claude Code 2.1.63+ — mid-session config change detection
   'InstructionsLoaded',   // Claude Code latest — fires when CLAUDE.md/.claude/rules loaded
   'PostCompact',          // Claude Code 2.1.76+ — fires after context compaction completes
+  'TaskCreated',          // Claude Code 2.1.84+ — fires when a task is created via TaskCreate
 ];
 
 /**
@@ -67,6 +69,9 @@ const CLAUDE_CODE_EVENTS = [
 //   'Notification',       // Supported but not yet used by WogiFlow
 //   'Elicitation',        // Claude Code 2.1.76+ — intercept MCP elicitation requests before dialog
 //   'ElicitationResult',  // Claude Code 2.1.76+ — intercept/override elicitation responses before sending
+//   'CwdChanged',         // Claude Code 2.1.83+ — fires when working directory changes (e.g., direnv)
+//   'FileChanged',        // Claude Code 2.1.83+ — fires when watched files change on disk
+//   'WorktreeCreate (http)', // Claude Code 2.1.84+ — WorktreeCreate now supports type:"http" transport
 // ];
 
 /**
@@ -202,6 +207,8 @@ class ClaudeCodeAdapter extends BaseAdapter {
         return this.transformInstructionsLoaded(coreResult);
       case 'PostCompact':
         return this.transformPostCompact(coreResult);
+      case 'TaskCreated':
+        return this.transformTaskCreated(coreResult);
       default:
         return { continue: true };
     }
@@ -504,6 +511,23 @@ Run: /wogi-start ${coreResult.nextTaskId}`;
     };
   }
 
+  /**
+   * Transform TaskCreated result (Claude Code 2.1.84+)
+   * Fires when a task is created via TaskCreate.
+   * Links native tasks to the active WogiFlow task for tracking.
+   */
+  transformTaskCreated(coreResult) {
+    return {
+      continue: true,
+      ...(coreResult.message && { systemMessage: coreResult.message }),
+      hookSpecificOutput: {
+        hookEventName: 'TaskCreated',
+        linked: coreResult.linked || false,
+        wogiTaskId: coreResult.wogiTaskId || null
+      }
+    };
+  }
+
   /**
    * Transform InstructionsLoaded result
    * Fires when CLAUDE.md or .claude/rules/*.md files are loaded into context.
@@ -639,6 +663,13 @@ Run: /wogi-start ${coreResult.nextTaskId}`;
       }];
     }
 
+    // TaskCreated hook — link native tasks to WogiFlow task (Claude Code 2.1.84+)
+    if (rules.taskCreated?.enabled !== false) {
+      hooks.TaskCreated = [{
+        hooks: [hookEntry('TaskCreated', 'task-created.js', HOOK_TIMEOUTS.TASK_CREATED)]
+      }];
+    }
+
     // WorktreeCreate hook — copy essential state to new worktree (Claude Code 2.1.50+)
     if (rules.worktreeLifecycle?.enabled !== false) {
       hooks.WorktreeCreate = [{

package/scripts/hooks/core/config-change.js

@@ -65,6 +65,7 @@ function handleConfigChange(options = {}) {
     let bridgeState = null;
     try {
       bridgeState = require('../../flow-bridge-state');
+const { PATHS } = require('../../flow-utils');
     } catch (_err) {
       // Bridge state module unavailable
     }

package/scripts/hooks/core/extension-registry.js

@@ -1,5 +1,3 @@
-'use strict';
-
 /**
  * Extension Hook Registry
  *

package/scripts/hooks/core/instructions-loaded.js

@@ -14,7 +14,7 @@
 const fs = require('node:fs');
 const path = require('node:path');
 
-const { safeJsonParse } = require('../../flow-utils');
+const { safeJsonParse, PATHS } = require('../../flow-utils');
 
 /**
  * Check if new packages have been added since last scan.

package/scripts/hooks/core/observation-capture.js

@@ -266,6 +266,11 @@ async function captureObservation(options) {
     return { skipped: true, reason: 'missing_tool_name' };
   }
 
+  // Fast path: skip everything if no memory DB file exists (avoids getConfig() + WASM load)
+  if (!fs.existsSync(MEMORY_DB_PATH)) {
+    return { skipped: true, reason: 'no_memory_db' };
+  }
+
   try {
     // Load settings ONCE and use directly (avoids 4x redundant getConfig() calls)
     const settings = getObservationSettings();
@@ -327,11 +332,6 @@ async function captureObservation(options) {
       fullOutput = '[serialization failed]';
     }
 
-    // Fast path: skip DB init if no database file exists yet (avoids 200-800ms WASM load)
-    if (!fs.existsSync(MEMORY_DB_PATH)) {
-      return { skipped: true, reason: 'no_memory_db' };
-    }
-
     // Store observation
     const db = getMemoryDb();
     const result = await db.storeObservation({

package/scripts/hooks/core/phase-gate.js

@@ -119,6 +119,11 @@ function writePhaseState(state) {
       fs.mkdirSync(dir, { recursive: true });
     }
     fs.writeFileSync(PHASE_FILE, JSON.stringify(state, null, 2) + '\n', 'utf-8');
+    // Update aggregated hook status
+    try {
+      const { setPhase } = require('../../flow-hook-status');
+      setPhase(state.phase);
+    } catch (_err) { /* non-blocking */ }
     return true;
   } catch (err) {
     if (process.env.DEBUG) {

package/scripts/hooks/core/post-compact.js

@@ -22,18 +22,7 @@
 const path = require('node:path');
 const fs = require('node:fs');
 const { PATHS, safeJsonParse, getReadyData } = require('../../flow-utils');
-
-/**
- * Sanitize a string value before injecting into AI context.
- * Strips markdown heading markers and truncates to prevent prompt manipulation.
- *
- * @param {string} value - Raw string from state files
- * @param {number} [maxLen=200] - Maximum length
- * @returns {string} Sanitized string
- */
-function sanitize(value, maxLen = 200) {
-  return String(value).replace(/^#+\s/gm, '').slice(0, maxLen);
-}
+const { sanitizeForContext: sanitize } = require('../../flow-io');
 
 /**
  * Handle PostCompact event.

package/scripts/hooks/core/research-gate.js

@@ -11,7 +11,7 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const { PATHS } = require('../../flow-utils');
+const { PATHS, safeJsonParse } = require('../../flow-utils');
 const {
   checkResearchGate,
   isResearchEnabled: _isResearchEnabled,
@@ -423,17 +423,7 @@ function getCachePath() {
  */
 function readCache() {
   const cachePath = getCachePath();
-  try {
-    if (fs.existsSync(cachePath)) {
-      const raw = fs.readFileSync(cachePath, 'utf-8');
-      return JSON.parse(raw);
-    }
-  } catch (err) {
-    if (process.env.DEBUG) {
-      console.error(`[Research Cache] Read failed: ${err.message}`);
-    }
-  }
-  return { entries: {}, lastCleanup: null };
+  return safeJsonParse(cachePath, { entries: {}, lastCleanup: null });
 }
 
 /**

package/scripts/hooks/core/routing-gate.js

@@ -205,6 +205,12 @@ function clearRoutingPending() {
     }
   }
 
+  // Update aggregated hook status
+  try {
+    const { setRouting } = require('../../flow-hook-status');
+    setRouting({ pending: false, cleared: true, clearedAt: new Date().toISOString() });
+  } catch (_err) { /* non-blocking */ }
+
   return { cleared: flagDeleted, reason: flagDeleted ? 'flag_cleared' : 'unlink_error' };
 }
 

package/scripts/hooks/core/task-completed.js

@@ -20,6 +20,7 @@ const fs = require('node:fs');
 // Import from parent scripts directory
 const { getConfig, PATHS, safeJsonParse, writeJson, withLock, validateTaskId, archiveCompletedTasksToLog } = require('../../flow-utils');
 const { resetPhase, isPhaseGateEnabled } = require('./phase-gate');
+const { clearOnTaskComplete } = require('../../flow-hook-status');
 
 /**
  * Check if task completed handling is enabled
@@ -146,6 +147,17 @@ async function handleTaskCompleted(input) {
       }
     }
 
+    // Clear hook status on task completion (single aggregated state file)
+    if (result.completed) {
+      try {
+        clearOnTaskComplete();
+      } catch (err) {
+        if (process.env.DEBUG) {
+          console.error(`[Task Completed] Hook status clear failed: ${err.message}`);
+        }
+      }
+    }
+
     // Clear progress tracker state on task completion
     if (result.completed) {
       try {

package/scripts/hooks/core/task-created.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow - Task Created (Core Module)
+ *
+ * CLI-agnostic task creation tracking logic.
+ * Called when a native task is created via TaskCreate (Claude Code 2.1.84+).
+ *
+ * Handles:
+ * - Linking native Claude Code tasks to the active WogiFlow task
+ * - Tracking subtask creation for progress visibility
+ * - Logging task creation events to session state
+ *
+ * Returns a standardized result that adapters transform for specific CLIs.
+ */
+
+const path = require('node:path');
+const { getConfig, PATHS, safeJsonParse } = require('../../flow-utils');
+
+/**
+ * Check if task created handling is enabled
+ * @returns {boolean}
+ */
+function isTaskCreatedEnabled() {
+  const config = getConfig();
+  return config.hooks?.rules?.taskCreated?.enabled !== false;
+}
+
+/**
+ * Handle task creation event
+ * @param {Object} input - Parsed hook input from Claude Code
+ * @returns {Object} Core result
+ */
+async function handleTaskCreated(input) {
+  if (!isTaskCreatedEnabled()) {
+    return { enabled: false, message: null };
+  }
+
+  const result = {
+    enabled: true,
+    linked: false,
+    wogiTaskId: null,
+    message: null
+  };
+
+  try {
+    // Find the active WogiFlow task to link against
+    const readyPath = path.join(PATHS.state, 'ready.json');
+    const ready = safeJsonParse(readyPath, { inProgress: [] });
+
+    if (Array.isArray(ready.inProgress) && ready.inProgress.length > 0) {
+      const activeTask = ready.inProgress[0];
+      const wogiTaskId = typeof activeTask === 'string' ? activeTask : activeTask?.id;
+
+      if (wogiTaskId) {
+        result.linked = true;
+        result.wogiTaskId = wogiTaskId;
+      }
+    }
+
+    // Track creation in session state (fire-and-forget)
+    try {
+      const sessionStatePath = path.join(PATHS.state, 'session-state.json');
+      const sessionState = safeJsonParse(sessionStatePath, {});
+      if (!sessionState.nativeTasksCreated) {
+        sessionState.nativeTasksCreated = 0;
+      }
+      sessionState.nativeTasksCreated += 1;
+      sessionState.lastNativeTaskAt = new Date().toISOString();
+
+      const fs = require('node:fs');
+      fs.writeFileSync(sessionStatePath, JSON.stringify(sessionState, null, 2));
+    } catch (_err) {
+      // Non-critical — session state tracking is best-effort
+    }
+  } catch (err) {
+    result.message = `Task created handler error: ${err.message}`;
+  }
+
+  return result;
+}
+
+module.exports = { handleTaskCreated, isTaskCreatedEnabled };

package/scripts/hooks/core/worktree-lifecycle.js

@@ -25,7 +25,7 @@ const CORE_STATE_FILES = ['ready.json', 'decisions.md'];
 
 function getEssentialStateFiles() {
   try {
-    const { getRegistryMapFiles } = require('../../flow-utils');
+    const { getRegistryMapFiles, PATHS } = require('../../flow-utils');
     return [...CORE_STATE_FILES, ...getRegistryMapFiles()];
   } catch (_err) {
     return [...CORE_STATE_FILES, 'app-map.md', 'function-map.md', 'api-map.md'];

package/scripts/hooks/entry/claude-code/config-change.js

@@ -11,33 +11,10 @@
  */
 
 const { handleConfigChange } = require('../../core/config-change');
-const { claudeCodeAdapter } = require('../../adapters/claude-code');
-const { readHookInput } = require('../shared/read-stdin');
+const { runHook } = require('../shared/hook-runner');
 
-process.stdin.setEncoding('utf8');
-
-async function main() {
-  try {
-    const { input: parsedStdin } = await readHookInput();
-    const input = parsedStdin || {};
-
-    // Extract the changed file path from the hook input
-    const filePath = input.file_path || input.filePath || '';
-    const projectRoot = input.cwd || process.cwd();
-
-    // Handle the config change
-    const result = handleConfigChange({ filePath, projectRoot });
-
-    // Transform to Claude Code format via adapter (consistent with other hooks)
-    const output = claudeCodeAdapter.transformResult('ConfigChange', result);
-
-    process.stdout.write(JSON.stringify(output));
-    process.exit(0);
-  } catch (err) {
-    // Never block on config change errors
-    process.stdout.write(JSON.stringify({ continue: true }));
-    process.exit(0);
-  }
-}
-
-main();
+runHook('ConfigChange', async ({ input }) => {
+  const filePath = input.file_path || input.filePath || '';
+  const projectRoot = input.cwd || process.cwd();
+  return handleConfigChange({ filePath, projectRoot });
+}, { failMode: 'silent', useStdoutWrite: true });

package/scripts/hooks/entry/claude-code/instructions-loaded.js

@@ -14,34 +14,9 @@
  */
 
 const { handleInstructionsLoaded } = require('../../core/instructions-loaded');
-const { claudeCodeAdapter } = require('../../adapters/claude-code');
-const { readHookInput } = require('../shared/read-stdin');
+const { runHook } = require('../shared/hook-runner');
 
-process.stdin.setEncoding('utf8');
-
-async function main() {
-  try {
-    const { input: parsedStdin } = await readHookInput();
-    const input = parsedStdin || {};
-    const parsedInput = claudeCodeAdapter.parseInput(input);
-    const projectRoot = parsedInput.cwd || process.cwd();
-
-    // Handle the instructions loaded event
-    const result = handleInstructionsLoaded({ projectRoot });
-
-    // Transform to Claude Code format via adapter
-    const output = claudeCodeAdapter.transformResult('InstructionsLoaded', result);
-
-    process.stdout.write(JSON.stringify(output));
-    process.exit(0);
-  } catch (err) {
-    // Never block on errors
-    if (process.env.DEBUG) {
-      console.error(`[instructions-loaded] Error: ${err.message}`);
-    }
-    process.stdout.write(JSON.stringify({ continue: true }));
-    process.exit(0);
-  }
-}
-
-main();
+runHook('InstructionsLoaded', async ({ parsedInput }) => {
+  const projectRoot = parsedInput.cwd || process.cwd();
+  return handleInstructionsLoaded({ projectRoot });
+}, { failMode: 'silent', useStdoutWrite: true });