@miphamai/cli 0.69.0 → 0.70.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.69.0",
+  "version": "0.70.0",
   "description": "Mipham Code — Multi-model open-core intelligent coding terminal by MiphamAI",
   "keywords": [
     "ai",

package/src/commands/loop-scaffold.ts

@@ -64,10 +64,6 @@ function writeTemplate(
  * ├── .mipham/
  * │   ├── CLAUDE.md
  * │   ├── settings.json
- * │   ├── hooks/
- * │   │   ├── pre-tool-use.sh
- * │   │   ├── post-tool-use.sh
- * │   │   └── stop.sh
  * │   ├── agents/
  * │   │   └── verifier.md
  * │   └── skills/
@@ -103,13 +99,6 @@ export function scaffoldLoopKit(basePath: string): ScaffoldResult {
   // ── .mipham/settings.json ──
   writeTemplate(join(miphamDir, 'settings.json'), TEMPLATES.settingsJson, false, created, skipped)
 
-  // ── .mipham/hooks/ ──
-  const hooksDir = join(miphamDir, 'hooks')
-  ensureDir(hooksDir, created, skipped)
-  writeTemplate(join(hooksDir, 'pre-tool-use.sh'), TEMPLATES.preToolUse, true, created, skipped)
-  writeTemplate(join(hooksDir, 'post-tool-use.sh'), TEMPLATES.postToolUse, true, created, skipped)
-  writeTemplate(join(hooksDir, 'stop.sh'), TEMPLATES.stopHook, true, created, skipped)
-
   // ── .mipham/agents/ ──
   const agentsDir = join(miphamDir, 'agents')
   ensureDir(agentsDir, created, skipped)
@@ -180,7 +169,20 @@ const TEMPLATES = {
           deny: [],
         },
         hooks: {
-          PreToolUse: [],
+          // 示例：PreToolUse 拦截 Bash。脚本从 stdin 读 JSON（tool_name/tool_input），
+          // 输出 hookSpecificOutput JSON 决定 allow/deny；exit 2 = 拦截（stderr 作理由）。
+          PreToolUse: [
+            {
+              matcher: 'Bash',
+              hooks: [
+                {
+                  type: 'command',
+                  command: 'your-hook-script.sh',
+                  timeout: 60,
+                },
+              ],
+            },
+          ],
           PostToolUse: [],
           Stop: [],
           SessionStart: [],
@@ -192,37 +194,6 @@ const TEMPLATES = {
       2,
     ) + '\n',
 
-  preToolUse: `#!/bin/bash
-# PreToolUse hook — runs before each tool execution.
-# Tool name passed as \$1, input JSON as \$2.
-# Exit non-zero to block the tool.
-# Write JSON to stdout to modify the tool input.
-
-TOOL_NAME="\$1"
-TOOL_INPUT="\$2"
-
-echo "{\\"decision\\": \\"allow\\"}" >&2
-exit 0
-`,
-
-  postToolUse: `#!/bin/bash
-# PostToolUse hook — runs after each tool execution.
-# Tool name passed as \$1, result JSON as \$2.
-
-TOOL_NAME="\$1"
-TOOL_RESULT="\$2"
-
-exit 0
-`,
-
-  stopHook: `#!/bin/bash
-# Stop hook — runs when the AI session ends.
-# Use for cleanup, notifications, or saving state.
-
-echo "Session ended at \$(date)" >&2
-exit 0
-`,
-
   verifierAgent: `# Verifier Agent
 
 > Pre-commit audit specialist. Dispatched BEFORE committing to verify changes.
@@ -290,7 +261,7 @@ Verify staged changes against coding standards, security rules, and best practic
 
 ## Structure
 
-- \`.mipham/\` — Mipham Code configuration (CLAUDE.md, settings, hooks, agents, skills)
+- \`.mipham/\` — Mipham Code configuration (CLAUDE.md, settings.json, agents, skills)
 - \`.mcp.json\` — MCP server configuration
 - \`MEMORY.md\` — AI persistent memory
 - \`run.sh\` — Project launcher

package/src/config/loader.ts

@@ -28,6 +28,7 @@ import {
   DEFAULT_CROSS_SESSION_CONFIG,
 } from './defaults'
 import { getCredentialKey, encryptApiKey, decryptApiKey, ENC_PREFIX } from './credential-crypto'
+import type { SettingsHooks } from '../core/hooks-config'
 
 const MIPHAM_HOME = join(homedir(), '.mipham')
 const BACKUP_PREFIX = 'config.backup-'
@@ -139,7 +140,7 @@ function backupConfig(configPath: string): void {
  * Try to restore config from the most recent backup.
  * Returns true if restored successfully.
  */
-function tryRestoreFromBackup(configPath: string): boolean {
+export function tryRestoreFromBackup(configPath: string): boolean {
   try {
     if (!existsSync(MIPHAM_HOME)) return false
     const files = readdirSync(MIPHAM_HOME)
@@ -216,6 +217,60 @@ function loadMcpJson(cwd: string): McpServerConfig[] {
   return servers
 }
 
+/**
+ * Parsed `settings.json` (Claude Code convention): hooks + permissions.
+ * Hooks are additive across levels; permissions allow/deny are deduped unions.
+ */
+export interface SettingsJson {
+  hooks: SettingsHooks
+  permissions: { allow: string[]; deny: string[] }
+}
+
+/**
+ * Load `settings.json` — project-level `.mipham/settings.json` then user-level
+ * `~/.mipham/settings.json`. Mirrors the Claude Code convention (hooks additive,
+ * permissions merged), so users can migrate their Claude settings unchanged.
+ */
+export function loadSettingsJson(cwd: string = process.cwd()): SettingsJson {
+  const hooks: SettingsHooks = {}
+  const permissions = { allow: [] as string[], deny: [] as string[] }
+
+  const searchPaths = [join(cwd, '.mipham', 'settings.json'), join(MIPHAM_HOME, 'settings.json')]
+
+  for (const path of searchPaths) {
+    try {
+      if (!existsSync(path)) continue
+      const raw = readFileSync(path, 'utf-8')
+      const parsed = JSON.parse(raw) as {
+        hooks?: Record<string, unknown>
+        permissions?: { allow?: unknown; deny?: unknown }
+      }
+
+      if (parsed.hooks && typeof parsed.hooks === 'object') {
+        for (const [eventName, entries] of Object.entries(parsed.hooks)) {
+          if (!Array.isArray(entries)) continue
+          const bucket = (hooks as Record<string, unknown[]>)[eventName]
+          ;(hooks as Record<string, unknown[]>)[eventName] = [...(bucket ?? []), ...entries]
+        }
+      }
+
+      if (parsed.permissions) {
+        for (const key of ['allow', 'deny'] as const) {
+          const list = parsed.permissions[key]
+          if (!Array.isArray(list)) continue
+          for (const p of list) {
+            if (typeof p === 'string' && !permissions[key].includes(p)) permissions[key].push(p)
+          }
+        }
+      }
+    } catch {
+      // Silently skip malformed or missing settings.json files
+    }
+  }
+
+  return { hooks, permissions }
+}
+
 export function loadConfig(cwd: string = process.cwd()): MiphamConfig {
   const configPath = join(cwd, '.mipham', 'config.yml')
   const userConfigPath = join(MIPHAM_HOME, 'config.yml')

package/src/core/claude-md-fix.ts

@@ -0,0 +1,28 @@
+/**
+ * CLAUDE.md fix — write the derivable-section headings that `findDerivableSections`
+ * flags into the document's `prompt-exclude` frontmatter, so `stripSections` stops
+ * injecting them into the system prompt every session.
+ */
+import { stringify as stringifyYaml } from 'yaml'
+import { parseFrontmatter, parsePromptExclude } from './instructions'
+
+export interface ApplyPromptExcludeResult {
+  content: string
+  added: string[]
+}
+
+/**
+ * Merge `headings` into the document's `prompt-exclude` frontmatter (creating the
+ * frontmatter block if absent). Preserves existing exclusions and other frontmatter
+ * fields; reports only the headings that were actually new.
+ */
+export function applyPromptExclude(content: string, headings: string[]): ApplyPromptExcludeResult {
+  const { data, content: body } = parseFrontmatter(content)
+  const existing = parsePromptExclude(data['prompt-exclude'])
+  const added = [...new Set(headings)].filter((h) => !existing.includes(h))
+  if (added.length === 0) return { content, added: [] }
+
+  data['prompt-exclude'] = [...existing, ...added]
+  const frontmatter = stringifyYaml(data)
+  return { content: `---\n${frontmatter}---\n${body}`, added }
+}

package/src/core/fix-code.ts

@@ -0,0 +1,167 @@
+/**
+ * `/fix test` — LLM-driven repair of failing tests in the real repo.
+ *
+ * Reuses the `/crsi bench` closed loop (LLM generates → a frozen test judges the
+ * result) but applied to the caller's own codebase: the failing test is the frozen
+ * ground truth, and the LLM may only fix the *source*, never the test.
+ */
+
+/**
+ * Extract failing test-file paths from a `vitest run` output stream. Matches the
+ * ` FAIL  test/xxx.test.ts > describe > it` lines (vitest 4 default reporter).
+ */
+export function parseVitestFailures(output: string): string[] {
+  const files = new Set<string>()
+  const re = /^\s*FAIL\s+(\S+)/gm
+  let m
+  while ((m = re.exec(output))) {
+    files.add(m[1]!)
+  }
+  return [...files]
+}
+
+/**
+ * Extract relative import specifiers (`./foo`, `../bar`) from a test file — these
+ * are the candidate source files the failing test depends on. Package imports
+ * (`vitest`, `lodash`) and node builtins (`node:fs`) are ignored.
+ */
+export function collectLocalImports(testContent: string): string[] {
+  const imports: string[] = []
+  const re = /from\s+['"](\.[^'"]*)['"]/g
+  let m
+  while ((m = re.exec(testContent))) {
+    imports.push(m[1]!)
+  }
+  return imports
+}
+
+/**
+ * Build the LLM prompt that asks for a source-only fix. The test is declared
+ * frozen ground truth; the model must return the corrected source file contents.
+ */
+export function buildFixPrompt(opts: {
+  testPath: string
+  testContent: string
+  sourcePath: string
+  sourceContent: string
+  failure: string
+}): string {
+  const { testPath, testContent, sourcePath, sourceContent, failure } = opts
+  return [
+    'You are fixing a failing test in a real codebase.',
+    '',
+    'RULES:',
+    '- The test file is FROZEN ground truth. Do NOT modify the test.',
+    '- Only fix the SOURCE file so the test passes.',
+    '- Output ONLY the corrected source file contents — no markdown fences, no explanation.',
+    '',
+    `Failing test: ${testPath}`,
+    '```',
+    testContent,
+    '```',
+    '',
+    `Source to fix: ${sourcePath}`,
+    '```',
+    sourceContent,
+    '```',
+    '',
+    'Failure:',
+    failure,
+  ].join('\n')
+}
+
+export interface FixCodeDeps {
+  runVitest: (testFile: string) => { exitCode: number; output: string }
+  readFile: (path: string) => string | null
+  writeFile: (path: string, content: string) => void
+  generateFix: (prompt: string) => Promise<string>
+  resolveSourceFile: (testFile: string, specifier: string) => string
+}
+
+export interface FixTargetResult {
+  testFile: string
+  sourceFile: string | null
+  fixed: boolean
+  attempts: number
+  detail?: string
+}
+
+/**
+ * Repair one failing test: locate the first local source the test imports, ask
+ * the LLM for a source-only fix, verify it against the frozen test, and apply it
+ * (or restore the original in dry-run). Retries up to `maxRetries`, feeding each
+ * failure back into the next prompt.
+ */
+export async function fixCodeTarget(
+  deps: FixCodeDeps,
+  testFile: string,
+  opts?: { apply?: boolean; maxRetries?: number },
+): Promise<FixTargetResult> {
+  const apply = opts?.apply ?? false
+  const maxRetries = opts?.maxRetries ?? 3
+
+  const initial = deps.runVitest(testFile)
+  if (initial.exitCode === 0) {
+    return { testFile, sourceFile: null, fixed: true, attempts: 0, detail: 'test already passes' }
+  }
+
+  const testContent = deps.readFile(testFile)
+  if (testContent === null) {
+    return {
+      testFile,
+      sourceFile: null,
+      fixed: false,
+      attempts: 0,
+      detail: 'cannot read test file',
+    }
+  }
+
+  const specifiers = collectLocalImports(testContent)
+  if (specifiers.length === 0) {
+    return {
+      testFile,
+      sourceFile: null,
+      fixed: false,
+      attempts: 0,
+      detail: 'no local imports to locate a source file',
+    }
+  }
+
+  const sourceFile = deps.resolveSourceFile(testFile, specifiers[0]!)
+  const sourceContent = deps.readFile(sourceFile)
+  if (sourceContent === null) {
+    return { testFile, sourceFile, fixed: false, attempts: 0, detail: 'cannot read source file' }
+  }
+
+  let failure = initial.output
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    const prompt = buildFixPrompt({
+      testPath: testFile,
+      testContent,
+      sourcePath: sourceFile,
+      sourceContent,
+      failure,
+    })
+    const fixedContent = await deps.generateFix(prompt)
+    if (!fixedContent) continue
+
+    deps.writeFile(sourceFile, fixedContent)
+    const result = deps.runVitest(testFile)
+
+    if (result.exitCode === 0) {
+      if (!apply) deps.writeFile(sourceFile, sourceContent)
+      return { testFile, sourceFile, fixed: true, attempts: attempt }
+    }
+
+    deps.writeFile(sourceFile, sourceContent)
+    failure = result.output
+  }
+
+  return {
+    testFile,
+    sourceFile,
+    fixed: false,
+    attempts: maxRetries,
+    detail: 'fix never passed the frozen test',
+  }
+}

package/src/core/fix.ts

@@ -0,0 +1,176 @@
+/**
+ * `/fix` — deterministic self-repair (no LLM). Orchestrates three repair targets:
+ *   - doctor: write derivable CLAUDE.md sections into `prompt-exclude` frontmatter
+ *   - config: restore a corrupted config.yml from backup, re-enable disabled hooks
+ *   - cache:  detect corrupt JSONL state lines under ~/.mipham (dry-run by default)
+ *
+ * The pure decision functions live here for testability; file I/O and engine calls
+ * are injected so each target is testable without touching the real filesystem.
+ */
+import { findDerivableSections } from './claude-md-audit'
+import { applyPromptExclude } from './claude-md-fix'
+
+export interface DoctorFix {
+  content: string
+  added: string[]
+}
+
+/**
+ * Compute the repaired content for one CLAUDE.md document, or null when there is
+ * nothing to change (no derivable sections, or all of them already excluded).
+ */
+export function computeDoctorFix(content: string): DoctorFix | null {
+  const sections = findDerivableSections(content)
+  if (sections.length === 0) return null
+  const { content: fixed, added } = applyPromptExclude(
+    content,
+    sections.map((s) => s.heading),
+  )
+  return added.length > 0 ? { content: fixed, added } : null
+}
+
+/**
+ * Return the 0-based line numbers of a JSONL document whose non-blank lines are not
+ * valid JSON. Blank/whitespace-only lines are ignored.
+ */
+export function findCorruptJsonlLines(content: string): number[] {
+  const corrupt: number[] = []
+  content.split('\n').forEach((line, i) => {
+    const trimmed = line.trim()
+    if (trimmed === '') return
+    try {
+      JSON.parse(trimmed)
+    } catch {
+      corrupt.push(i)
+    }
+  })
+  return corrupt
+}
+
+/** Drop the given line numbers from a document, keeping everything else verbatim. */
+export function removeCorruptLines(content: string, corrupt: number[]): string {
+  const corruptSet = new Set(corrupt)
+  return content
+    .split('\n')
+    .filter((_, i) => !corruptSet.has(i))
+    .join('\n')
+}
+
+/**
+ * Select the CLAUDE.md files that live inside the current repository (project and
+ * directory levels), excluding group/company/user policy files outside the repo.
+ */
+export function selectRepoClaudeFiles(
+  files: Array<{ path: string; level: string }>,
+): Array<{ path: string }> {
+  return files
+    .filter(
+      (f) => f.path.endsWith('CLAUDE.md') && (f.level === 'project' || f.level === 'directory'),
+    )
+    .map((f) => ({ path: f.path }))
+}
+
+export interface DoctorReport {
+  fixed: Array<{ path: string; added: string[] }>
+}
+
+/** Read each CLAUDE.md, apply the derivable-section fix, and write it back. */
+export function fixDoctor(
+  files: Array<{ path: string }>,
+  io: { read: (path: string) => string | null; write: (path: string, content: string) => void },
+): DoctorReport {
+  const fixed: DoctorReport['fixed'] = []
+  for (const f of files) {
+    const raw = io.read(f.path)
+    if (raw === null) continue
+    const result = computeDoctorFix(raw)
+    if (result) {
+      io.write(f.path, result.content)
+      fixed.push({ path: f.path, added: result.added })
+    }
+  }
+  return { fixed }
+}
+
+export interface ConfigFixReport {
+  /** Config files whose YAML failed to parse (detected). */
+  corruptConfigs: string[]
+  /** Corrupt config files actually restored from backup. */
+  restoredConfigs: string[]
+  /** Hooks currently disabled (detected). */
+  disabledHooks: string[]
+  /** Disabled hooks actually re-enabled. */
+  reenabledHooks: string[]
+}
+
+/**
+ * Detect corrupt config.yml files and disabled hooks. Repairs (restore from
+ * backup / re-enable) only happen when `dryRun` is false; in dry-run the report
+ * still lists what was detected without mutating anything.
+ */
+export function fixConfig(deps: {
+  configPaths: string[]
+  read: (path: string) => string | null
+  parseYaml: (raw: string) => unknown
+  restore: (path: string) => boolean
+  hookHealth: () => Array<{ key: string; disabled: boolean }>
+  reEnableHook: (key: string) => boolean
+  dryRun?: boolean
+}): ConfigFixReport {
+  const report: ConfigFixReport = {
+    corruptConfigs: [],
+    restoredConfigs: [],
+    disabledHooks: [],
+    reenabledHooks: [],
+  }
+
+  for (const p of deps.configPaths) {
+    const raw = deps.read(p)
+    if (raw === null) continue
+    let corrupt = false
+    try {
+      deps.parseYaml(raw)
+    } catch {
+      corrupt = true
+    }
+    if (!corrupt) continue
+    report.corruptConfigs.push(p)
+    if (!deps.dryRun && deps.restore(p)) report.restoredConfigs.push(p)
+  }
+
+  for (const h of deps.hookHealth()) {
+    if (!h.disabled) continue
+    report.disabledHooks.push(h.key)
+    if (!deps.dryRun && deps.reEnableHook(h.key)) report.reenabledHooks.push(h.key)
+  }
+  return report
+}
+
+export interface CacheFixReport {
+  files: Array<{ path: string; corruptLines: number[] }>
+  cleaned: Array<{ path: string; removed: number }>
+}
+
+/**
+ * Scan JSONL state files for corrupt lines. Reports them always; only rewrites the
+ * file (dropping corrupt lines) when `apply` is true.
+ */
+export function fixCache(
+  files: string[],
+  io: { read: (path: string) => string | null; write: (path: string, content: string) => void },
+  apply: boolean,
+): CacheFixReport {
+  const report: CacheFixReport = { files: [], cleaned: [] }
+  for (const path of files) {
+    const raw = io.read(path)
+    if (raw === null) continue
+    const corrupt = findCorruptJsonlLines(raw)
+    if (corrupt.length === 0) continue
+    report.files.push({ path, corruptLines: corrupt })
+    if (apply) {
+      io.write(path, removeCorruptLines(raw, corrupt))
+      report.cleaned.push({ path, removed: corrupt.length })
+    }
+  }
+  return report
+}

package/src/core/hooks-config.ts

@@ -1,22 +1,27 @@
 import type { HookConfig, HookEvent, HookDefinition, HookContext } from '../shared/index.ts'
 import { executeHook } from './hooks-executor'
 
-interface HookConfigEntry {
+export interface HookConfigEntry {
   matcher: string
   hooks: HookConfig[]
 }
 
-interface SettingsHooks {
+/** `settings.json` `hooks` section — one matcher-group list per event. */
+export interface SettingsHooks {
   PreToolUse?: HookConfigEntry[]
   PostToolUse?: HookConfigEntry[]
+  PostToolUseFailure?: HookConfigEntry[]
+  SessionStart?: HookConfigEntry[]
+  SessionEnd?: HookConfigEntry[]
+  Notification?: HookConfigEntry[]
   Stop?: HookConfigEntry[]
   UserPromptSubmit?: HookConfigEntry[]
   PreCompact?: HookConfigEntry[]
   PostCompact?: HookConfigEntry[]
-  SessionStart?: HookConfigEntry[]
-  SessionEnd?: HookConfigEntry[]
-  Notification?: HookConfigEntry[]
   ConfigChange?: HookConfigEntry[]
+  SubagentStart?: HookConfigEntry[]
+  SubagentStop?: HookConfigEntry[]
+  PreInference?: HookConfigEntry[]
 }
 
 /**

package/src/core/hooks-executor.ts

@@ -30,22 +30,101 @@ function substituteVars(template: string, ctx: HookContext): string {
     .replace(/\$SESSION_ID/g, ctx.sessionId)
 }
 
+/**
+ * Build the Claude Code protocol stdin JSON for a hook script. Mirrors the
+ * fields Claude Code passes (session_id / hook_event_name / cwd / tool_name /
+ * tool_input / tool_response) so hand-written Claude hooks can migrate
+ * unchanged.
+ */
+export function buildHookStdin(ctx: HookContext, cwd: string): Record<string, unknown> {
+  const payload: Record<string, unknown> = {
+    session_id: ctx.sessionId,
+    hook_event_name: ctx.event,
+    cwd,
+  }
+  if (ctx.toolName) payload.tool_name = ctx.toolName
+  if (ctx.toolInput) payload.tool_input = ctx.toolInput
+  if (ctx.toolResult) payload.tool_response = ctx.toolResult
+  return payload
+}
+
+/**
+ * Parse a hook script's stdout JSON into a HookResult, following the Claude
+ * Code output contract. Supports the modern `hookSpecificOutput` carrier
+ * (permissionDecision / updatedInput / additionalContext) plus the legacy
+ * root-level `decision` and `continue` fields. Non-JSON or empty stdout = allow.
+ */
+export function parseHookStdout(stdout: string | null | undefined, _ctx: HookContext): HookResult {
+  if (!stdout) return { allowed: true }
+
+  let parsed: Record<string, unknown>
+  try {
+    parsed = JSON.parse(stdout) as Record<string, unknown>
+  } catch {
+    return { allowed: true }
+  }
+
+  const hso = parsed.hookSpecificOutput as Record<string, unknown> | undefined
+  if (hso) {
+    const decision = hso.permissionDecision as string | undefined
+    const reason = hso.permissionDecisionReason as string | undefined
+    const additionalContext = hso.additionalContext as string | undefined
+    const updatedInput = hso.updatedInput as Record<string, unknown> | undefined
+
+    if (decision === 'deny') {
+      return { allowed: false, reason: reason ?? 'Denied by hook', additionalContext }
+    }
+    if (decision === 'allow') {
+      return {
+        allowed: true,
+        permissionDecision: 'allow',
+        modifiedInput: updatedInput,
+        additionalContext,
+      }
+    }
+    if (decision === 'ask') {
+      return { allowed: true, permissionDecision: 'ask', additionalContext }
+    }
+    if (decision === 'defer') {
+      return { allowed: true, permissionDecision: 'defer', additionalContext }
+    }
+    if (additionalContext) {
+      return { allowed: true, additionalContext }
+    }
+  }
+
+  // Legacy root-level decision: block / approve
+  if (parsed.decision === 'block') {
+    return { allowed: false, reason: (parsed.reason as string) ?? 'Blocked by hook' }
+  }
+
+  // Stop-style events: continue:false
+  if (parsed.continue === false) {
+    return { allowed: false, reason: (parsed.stopReason as string) ?? 'Stopped by hook' }
+  }
+
+  return { allowed: true }
+}
+
 function executeCommand(cfg: HookConfig, ctx: HookContext): HookResult {
   if (!cfg.command) return { allowed: true }
 
   try {
     const args = cfg.args ? cfg.args.map((a) => substituteVars(a, ctx)) : []
 
-    // Use spawnSync with array args — no shell, no command injection
+    // Use spawnSync with array args — no shell, no command injection.
+    // Pass the Claude-protocol stdin JSON so scripts can read structured context.
+    const input = JSON.stringify(buildHookStdin(ctx, process.cwd()))
     const result = spawnSync(cfg.command, args, {
-      timeout: 30_000,
+      timeout: (cfg.timeout ?? 60) * 1000,
       encoding: 'utf-8',
-      stdio: ['ignore', 'pipe', 'pipe'],
+      stdio: ['pipe', 'pipe', 'pipe'],
+      input,
     })
 
-    // Exit code 0 = success, allow
+    // Exit code 0 = success — parse the stdout JSON for structured decisions.
     if (result.status === 0) {
-      return { allowed: true }
+      return parseHookStdout(result.stdout, ctx)
     }
 
     // Non-zero exit: check for block signal (exit code 2)