wogiflow 2.4.1 → 2.4.3

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

@@ -67,6 +67,8 @@ 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
 // ];
 
 /**

package/scripts/hooks/core/commit-log-gate.js

@@ -15,8 +15,10 @@
  * v1.0: Initial implementation — pre-commit blocking gate
  */
 
+const fs = require('node:fs');
+const path = require('node:path');
 const { execFileSync } = require('node:child_process');
-const { getConfig, getReadyData } = require('../../flow-utils');
+const { getConfig, getReadyData, PATHS } = require('../../flow-utils');
 
 /**
  * Check if a Bash command contains a git commit
@@ -120,25 +122,34 @@ function checkCommitLogGate(command, config) {
     return { allowed: true, blocked: false };
   }
 
-  // Check if request-log.md is in staged changes
-  const hasLogEntry = stagedFiles.some(f => f.endsWith('request-log.md'));
+  // Check if request-log.md contains an entry for the active task.
+  // We check file content instead of git staging because .workflow/ may be
+  // in .gitignore (intentional user choice to keep state files out of git).
+  // Checking staged files would silently fail when the directory is gitignored.
+  const task = readyData.inProgress[0];
+  const taskId = (typeof task === 'string' ? task : task.id) || 'unknown';
+
+  const logPath = path.join(PATHS.state, 'request-log.md');
+  let hasLogEntry = false;
+  try {
+    const logContent = fs.readFileSync(logPath, 'utf-8');
+    hasLogEntry = logContent.includes(taskId);
+  } catch (_err) {
+    // File doesn't exist or can't be read — no log entry
+  }
+
   if (hasLogEntry) {
     return { allowed: true, blocked: false };
   }
 
-  // Block: active task + code changes but no log entry
-  const task = readyData.inProgress[0];
-  const taskId = (typeof task === 'string' ? task : task.id) || 'unknown';
-
   return {
     allowed: false,
     blocked: true,
     reason: 'commit_without_log_entry',
     message: [
-      `BLOCKED: Active task ${taskId} but request-log.md is not staged.`,
+      `BLOCKED: Active task ${taskId} but no request-log entry found.`,
       'Add a request-log entry before committing.',
-      'Append a ### R-[N] entry to .workflow/state/request-log.md following the existing format,',
-      'then stage it: git add .workflow/state/request-log.md'
+      `Append a ### R-[N] entry referencing ${taskId} to .workflow/state/request-log.md following the existing format.`
     ].join(' ')
   };
 }

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-gate.js

@@ -296,6 +296,33 @@ function checkTaskGate(options = {}, config) {
     };
   }
 
+  // getActiveTask() returned null — check if a task EXISTS in inProgress
+  // but was rejected for missing routing proof (routedAt + receipt).
+  // This gives the AI an actionable error instead of the misleading "no active task".
+  try {
+    const readyData = getReadyData();
+    if (readyData.inProgress && readyData.inProgress.length > 0) {
+      const task = readyData.inProgress[0];
+      const taskId = typeof task === 'string' ? task : task.id;
+      if (taskId) {
+        trackBypassAttempt({
+          filePath,
+          operation,
+          reason: 'task_missing_routing_proof',
+          taskId
+        });
+        return {
+          allowed: false,
+          blocked: true,
+          message: `Task ${taskId} is in inProgress but has no routing proof (missing routedAt and no routing receipt file).\n\nThis usually means the task was inserted into ready.json manually instead of through /wogi-start.\n\nTo fix:\n1. Use /wogi-start ${taskId} to properly route this task\n2. Or remove it from inProgress and start fresh: /wogi-ready`,
+          reason: 'task_missing_routing_proof'
+        };
+      }
+    }
+  } catch (_err) {
+    // Fall through to normal "no active task" path
+  }
+
   // No active task - should we block?
   const shouldBlock = config.enforcement?.taskGating?.blockWithoutTask !== false;
 

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 });

package/scripts/hooks/entry/claude-code/post-compact.js

@@ -11,35 +11,8 @@
  */
 
 const { handlePostCompact } = require('../../core/post-compact');
-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 {
-    // Consume stdin (required by hook protocol, even if we don't use the input)
-    await readHookInput();
-
-    // Handle post-compaction state recovery
-    const result = handlePostCompact();
-
-    // Transform to Claude Code format via adapter
-    const output = claudeCodeAdapter.transformResult('PostCompact', result);
-
-    process.stdout.write(JSON.stringify(output));
-    process.exit(0);
-  } catch (err) {
-    // Never block on post-compact errors — fail open
-    try {
-      const { logHookError } = require('../../../flow-hook-errors');
-      logHookError('PostCompact', err, { failMode: 'open', operation: 'post-compaction-recovery' });
-    } catch (logErr) {
-      console.error(`[WogiFlow] PostCompact hook error: ${err.message}`);
-    }
-    process.stdout.write(JSON.stringify({ continue: true }));
-    process.exit(0);
-  }
-}
-
-main();
+runHook('PostCompact', async () => {
+  return handlePostCompact();
+}, { failMode: 'warn', useStdoutWrite: true });