@winspan/claude-forge 8.41.0 → 8.51.0

package/src/daemon/lifecycle.ts

@@ -0,0 +1,128 @@
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import { execSync, execFileSync } from 'child_process';
+import { logger } from '../core/utils/logger.js';
+import { FORGE_PATHS } from '../core/constants.js';
+
+const FORGE_HOME = FORGE_PATHS.home();
+const TOKEN_FILE = FORGE_PATHS.daemonToken();
+const PID_FILE = FORGE_PATHS.daemonPid();
+
+export function writePidFile(): void {
+  if (!fs.existsSync(FORGE_HOME)) {
+    fs.mkdirSync(FORGE_HOME, { recursive: true });
+  }
+  fs.writeFileSync(PID_FILE, String(process.pid));
+}
+
+export function removePidFile(): void {
+  if (fs.existsSync(PID_FILE)) {
+    fs.unlinkSync(PID_FILE);
+  }
+}
+
+export function readPid(): number | null {
+  if (!fs.existsSync(PID_FILE)) {
+    return null;
+  }
+
+  try {
+    const pid = parseInt(fs.readFileSync(PID_FILE, 'utf-8').trim(), 10);
+
+    // 检查进程是否存活
+    try {
+      process.kill(pid, 0);
+      return pid;
+    } catch {
+      // 进程不存在，清理过期 PID 文件
+      removePidFile();
+      return null;
+    }
+  } catch {
+    return null;
+  }
+}
+
+export function isRunning(): boolean {
+  return readPid() !== null;
+}
+
+export function getSocketPath(): string {
+  return FORGE_PATHS.daemonSocket();
+}
+
+export function cleanSocket(): void {
+  const socketPath = getSocketPath();
+  if (fs.existsSync(socketPath)) {
+    fs.unlinkSync(socketPath);
+  }
+}
+
+/** daemon 启动时生成随机 auth token，写入 chmod 600 文件 */
+export function writeAuthToken(): string {
+  const token = crypto.randomBytes(32).toString('hex');
+  if (!fs.existsSync(FORGE_HOME)) {
+    fs.mkdirSync(FORGE_HOME, { recursive: true });
+  }
+  fs.writeFileSync(TOKEN_FILE, token, { mode: 0o600 });
+  return token;
+}
+
+/** 读取当前 auth token */
+export function readAuthToken(): string | null {
+  if (!fs.existsSync(TOKEN_FILE)) return null;
+  try {
+    return fs.readFileSync(TOKEN_FILE, 'utf-8').trim();
+  } catch {
+    return null;
+  }
+}
+
+/** daemon 关闭时清理 token 文件 */
+export function removeAuthToken(): void {
+  if (fs.existsSync(TOKEN_FILE)) {
+    fs.unlinkSync(TOKEN_FILE);
+  }
+}
+
+/**
+ * Sync MCP registration token after daemon restart.
+ *
+ * Problem: Each daemon start generates a new token, but the MCP registration
+ * in Claude Code still has the old token → 401 → "Failed to connect".
+ *
+ * Solution: After writing the new token, re-register the MCP server with
+ * the updated Bearer header. This is a best-effort operation — if Claude CLI
+ * is not installed or registration fails, we log a warning and continue.
+ */
+export function syncMcpToken(token: string, port: number): void {
+  try {
+    execSync('command -v claude', { stdio: 'ignore' });
+  } catch {
+    return; // Claude CLI not installed, skip
+  }
+
+  try {
+    const checkOutput = execSync('claude mcp get claude-forge', {
+      stdio: ['ignore', 'pipe', 'ignore'],
+      encoding: 'utf-8',
+    });
+    if (!checkOutput.includes('claude-forge')) return; // Not registered
+  } catch {
+    return; // Not registered, skip
+  }
+
+  const mcpUrl = `http://127.0.0.1:${port}/mcp`;
+  try {
+    execFileSync('claude', ['mcp', 'remove', 'claude-forge', '-s', 'user'], { stdio: 'ignore' });
+    execFileSync('claude', [
+      'mcp', 'add', '--transport', 'http', '-s', 'user',
+      'claude-forge', mcpUrl,
+      '-H', `Authorization: Bearer ${token}`,
+    ], { stdio: 'ignore' });
+    logger.info('[Lifecycle] MCP token synced successfully');
+  } catch (err) {
+    logger.warn(`[Lifecycle] MCP token sync failed (non-fatal): ${err instanceof Error ? err.message : err}`);
+  }
+}

package/src/daemon/router.ts

@@ -0,0 +1,40 @@
+import type { ForgeEvent, HookResult } from '../core/types.js';
+import { isUserPromptSubmit, isPostToolUse, isStop } from '../core/types.js';
+import type { UserPromptHandler } from './handlers/user-prompt.js';
+import type { PostToolUseHandler } from './handlers/post-tool-use.js';
+import type { StopHandler } from './handlers/stop.js';
+import { logger } from '../core/utils/logger.js';
+import { formatError } from '../core/utils/format.js';
+import { truncateSessionId } from '../core/utils/session.js';
+
+export interface Handlers {
+  UserPromptSubmit: UserPromptHandler;
+  PostToolUse: PostToolUseHandler;
+  Stop: StopHandler;
+}
+
+/**
+ * Dispatch an event to the matching handler with hook-type narrowing.
+ *
+ * The narrow union (PreToolUseEvent / PostToolUseEvent / ...) is enforced at
+ * the handler entry, not at storage / wire level — so handlers can rely on
+ * required fields without `!` assertions.
+ *
+ * Error boundary: catches and logs handler errors to prevent daemon crashes.
+ */
+export async function routeEvent(event: ForgeEvent, handlers: Handlers): Promise<HookResult | void> {
+  try {
+    if (isUserPromptSubmit(event)) return await handlers.UserPromptSubmit.handle(event);
+    if (isPostToolUse(event)) return await handlers.PostToolUse.handle(event);
+    if (isStop(event)) return await handlers.Stop.handle(event);
+    // PreToolUse / Notification: handled inline in daemon/index.ts (no dedicated handler).
+  } catch (err) {
+    logger.error(
+      `[Router] Handler error for ${event.hook_type}: ${formatError(err)} ` +
+      `(session: ${truncateSessionId(event.session_id)})`
+    );
+
+    // Return safe default to prevent daemon crash
+    return { allow: true };
+  }
+}

package/src/daemon/server.ts

@@ -0,0 +1,196 @@
+import net from 'net';
+import fs from 'fs';
+import { EventParser } from './event-parser.js';
+import { logger } from '../core/utils/logger.js';
+import { formatError, truncateString } from '../core/utils/format.js';
+
+export interface HookResponse {
+  allow: boolean;
+  reason?: string;
+  additionalContext?: string;
+  systemMessage?: string;
+  hookSpecificOutput?: {
+    hookEventName: string;
+    permissionDecision: 'allow' | 'deny' | 'ask' | 'defer';
+    permissionDecisionReason?: string;
+  };
+}
+
+export type EventHandler = (
+  event: import('../core/types.js').ForgeEvent
+) => HookResponse | void | Promise<HookResponse | void>;
+
+export class SocketServer {
+  private server: net.Server;
+  private parser: EventParser;
+  private handler: EventHandler;
+  private authToken: string | null;
+  private static readonly MAX_BUFFER_SIZE = 512 * 1024; // 512KB
+
+  constructor(socketPath: string, handler: EventHandler, authToken?: string) {
+    this.parser = new EventParser();
+    this.handler = handler;
+    this.authToken = authToken ?? null;
+
+    this.server = net.createServer(this.handleConnection.bind(this));
+    this.server.listen(socketPath, () => {
+      // 限制 socket 文件仅当前用户可读写，防止同机其他用户注入伪造事件
+      try {
+        fs.chmodSync(socketPath, 0o600);
+      } catch (err) {
+        logger.warn(`[Socket] 设置权限失败：${formatError(err)}`);
+      }
+      logger.info(`Socket 服务器已监听：${socketPath}`);
+    });
+
+    this.server.on('error', (err) => {
+      logger.error(`Socket 服务器错误：${formatError(err)}`);
+    });
+  }
+
+  private handleConnection(socket: net.Socket): void {
+    let buffer = '';
+    let connectionTimeout: NodeJS.Timeout | null = null;
+
+    // 设置 10 秒超时，防止连接挂起
+    connectionTimeout = setTimeout(() => {
+      if (buffer.length > 0) {
+        logger.warn(`连接超时，数据不完整（${buffer.length} 字节）`);
+      }
+      socket.destroy();
+    }, 10000);
+
+    socket.on('data', async (chunk) => {
+      buffer += chunk.toString();
+
+      // 主动检查 buffer 大小，防止内存溢出
+      if (buffer.length > SocketServer.MAX_BUFFER_SIZE) {
+        logger.warn(`事件过大（${buffer.length} 字节），关闭连接`);
+        buffer = '';
+        if (connectionTimeout) clearTimeout(connectionTimeout);
+        socket.destroy();
+        return;
+      }
+
+      // 性能修复（L3）：hook 端用 `echo` 发送 JSON，结尾自带换行符。
+      // 只在 buffer 中遇到换行符时才尝试解析，避免大事件（接近 512KB）
+      // 在分片到达时每个 chunk 都跑一次完整 JSON.parse 造成的 N² 行为。
+      // 兼容：如果数据无换行（旧客户端、其他来源），等到 socket 关闭时
+      // 由 'end' 事件做最后一次解析尝试。
+      const newlineIdx = buffer.indexOf('\n');
+      if (newlineIdx === -1) {
+        // 尚未收到完整消息，继续等待
+        return;
+      }
+
+      // 取换行前的完整消息；忽略行后可能存在的多余数据（hook 单连接一事件）
+      const message = buffer.slice(0, newlineIdx);
+      buffer = '';
+
+      try {
+        await this.processMessage(socket, message);
+      } finally {
+        if (connectionTimeout) clearTimeout(connectionTimeout);
+      }
+    });
+
+    // 兜底：连接关闭时若 buffer 仍有内容（无换行结尾的旧客户端），尝试解析一次
+    socket.on('end', async () => {
+      const remaining = buffer.trim();
+      buffer = '';
+      if (remaining.length === 0) return;
+      try {
+        await this.processMessage(socket, remaining);
+      } catch {
+        // processMessage 内部已记录错误
+      } finally {
+        if (connectionTimeout) clearTimeout(connectionTimeout);
+      }
+    });
+
+    socket.on('error', (err) => {
+      logger.debug(`Socket 连接错误：${formatError(err)}`);
+      if (connectionTimeout) clearTimeout(connectionTimeout);
+    });
+
+    socket.on('close', () => {
+      if (connectionTimeout) clearTimeout(connectionTimeout);
+    });
+  }
+
+  /**
+   * 解析单条完整消息（一次性，无 N² 行为）并执行 handler。
+   *
+   * 注意：调用方需确保 message 是一条完整的 JSON 文本（已根据换行符切分）。
+   */
+  private async processMessage(socket: net.Socket, message: string): Promise<void> {
+    try {
+      // 认证检查：在 EventParser 之前提取 _auth 字段（zod 会剥离未知字段）
+      if (this.authToken) {
+        try {
+          const raw = JSON.parse(message);
+          if (raw._auth !== this.authToken) {
+            logger.warn('[Socket] 认证失败，关闭连接');
+            socket.destroy();
+            return;
+          }
+        } catch {
+          // JSON 解析失败，交给下面的 EventParser 处理
+        }
+      }
+
+      const event = this.parser.parse(message);
+      const result = await this.handler(event);
+
+      // 双向通信：如果 handler 返回了结果，写回给 hook 脚本
+      if (result) {
+        // 清理无意义内容，避免 Claude Code 注入干扰上下文
+        const cleaned = { ...result } as Record<string, unknown>;
+        if (cleaned['additionalContext'] && !this.isValidContent(cleaned['additionalContext'] as string)) {
+          delete cleaned['additionalContext'];
+        }
+        if (cleaned['systemMessage'] && !this.isValidContent(cleaned['systemMessage'] as string)) {
+          delete cleaned['systemMessage'];
+        }
+
+        const payload = JSON.stringify(cleaned);
+        socket.write(payload, () => socket.end());
+      } else {
+        socket.end();
+      }
+    } catch (err) {
+      logger.error(`事件解析失败：${formatError(err)}`);
+      logger.debug(`无效消息内容：${truncateString(message, 500)}`);
+      socket.destroy();
+    }
+  }
+
+  /**
+   * 判断内容是否有意义，过滤空字符串、纯标点/符号等
+   */
+  private isValidContent(content: string): boolean {
+    if (!content) return false;
+    const trimmed = content.trim();
+    if (trimmed.length === 0) return false;
+
+    const stripped = trimmed
+      .split('\n')
+      .map(line => line.replace(/^>\s*/, '').trim())
+      .join('\n')
+      .trim();
+
+    if (stripped.length === 0) return false;
+    if (!/[\p{L}\p{N}]/u.test(stripped)) return false;
+
+    return true;
+  }
+
+  close(): Promise<void> {
+    return new Promise((resolve) => {
+      this.server.close(() => {
+        logger.info('Socket 服务器已关闭');
+        resolve();
+      });
+    });
+  }
+}

package/src/daemon/services/task-segmenter.ts

@@ -0,0 +1,112 @@
+import { randomUUID } from 'node:crypto';
+import type { SQLiteStorage } from '../../core/storage/sqlite.js';
+import { logger } from '../../core/utils/logger.js';
+import { normalizeTimestamp, timestampToMs } from '../../core/utils/time.js';
+import { truncateSessionId } from '../../core/utils/session.js';
+import { truncateString } from '../../core/utils/format.js';
+
+const NEW_TASK_KEYWORDS = [
+  '帮我', '实现', '修复', '添加', '重构', '优化', '创建', '删除',
+  '升级', '迁移', '部署', '配置', '设计', '提交', '推送',
+  'fix', 'add', 'implement', 'refactor', 'create', 'delete', 'deploy',
+];
+
+const CONTINUE_KEYWORDS = [
+  '继续', '然后', '还有', '另外', '这个', '那个', '它',
+  '对', '好的', '可以', '是的', '不是', '不对', '改一下',
+];
+
+const TASK_SWITCH_MINUTES = 10;
+
+export class TaskSegmenter {
+  private currentTasks = new Map<string, { id: string; lastTime: number }>();
+
+  constructor(private storage: SQLiteStorage) {}
+
+  processPrompt(sessionId: string, prompt: string, timestamp: string, eventId?: string): string {
+    const key = sessionId;
+    const current = this.currentTasks.get(key) ?? this.recoverActiveTask(key);
+    const now = timestampToMs(timestamp);
+
+    if (!current || this.shouldStartNewTask(prompt, now, current)) {
+      if (current) {
+        this.storage.updateTask(current.id, { status: 'completed', end_time: timestamp });
+      }
+      const taskId = this.createTask(sessionId, prompt, timestamp);
+      this.currentTasks.set(key, { id: taskId, lastTime: now });
+      if (eventId) this.storage.linkEventToTask(taskId, eventId);
+      return taskId;
+    }
+
+    current.lastTime = now;
+    if (eventId) this.storage.linkEventToTask(current.id, eventId);
+    return current.id;
+  }
+
+  linkEvent(sessionId: string, eventId: string): void {
+    const current = this.currentTasks.get(sessionId) ?? this.recoverActiveTask(sessionId);
+    if (current) {
+      this.storage.linkEventToTask(current.id, eventId);
+    }
+  }
+
+  /**
+   * 从数据库恢复 session 的 active 任务到内存 Map。
+   * 用于 daemon 重启后内存丢失场景的 lazy 恢复。
+   * 找不到 active 任务时返回 null（不报错）。
+   */
+  private recoverActiveTask(sessionId: string): { id: string; lastTime: number } | null {
+    const tasks = this.storage.queryTasks({ session_id: sessionId, limit: 5 });
+    const activeTask = tasks.find(t => t.status === 'active');
+    if (!activeTask) return null;
+
+    const anchor = activeTask.end_time ?? activeTask.start_time;
+    const lastTime = timestampToMs(anchor);
+    const entry = { id: activeTask.id, lastTime };
+    this.currentTasks.set(sessionId, entry);
+    logger.info(
+      `[TaskSegmenter] Recovered active task ${truncateString(activeTask.id, 8)} for session ${truncateSessionId(sessionId)} from DB`,
+    );
+    return entry;
+  }
+
+  getCurrentTaskId(sessionId: string): string | null {
+    return this.currentTasks.get(sessionId)?.id ?? null;
+  }
+
+  completeCurrentTask(sessionId: string, timestamp: string): void {
+    const current = this.currentTasks.get(sessionId) ?? this.recoverActiveTask(sessionId);
+    if (!current) return;
+    this.storage.updateTask(current.id, {
+      status: 'completed',
+      end_time: timestamp,
+    });
+    this.currentTasks.delete(sessionId);
+  }
+
+  private shouldStartNewTask(prompt: string, now: number, current: { lastTime: number }): boolean {
+    const minutesDiff = (now - current.lastTime) / 60000;
+    if (minutesDiff > TASK_SWITCH_MINUTES) return true;
+
+    const hasContinue = CONTINUE_KEYWORDS.some(kw => prompt.includes(kw));
+    if (hasContinue) return false;
+
+    const hasNewTask = NEW_TASK_KEYWORDS.some(kw => prompt.includes(kw));
+    return hasNewTask;
+  }
+
+  private createTask(sessionId: string, prompt: string, timestamp: string): string {
+    const taskId = randomUUID();
+    const title = this.extractTitle(prompt);
+    this.storage.writeTask({ id: taskId, session_id: sessionId, title, start_time: timestamp });
+    logger.info(`[TaskSegmenter] New task: "${title}" (${truncateString(taskId, 8)})`);
+    return taskId;
+  }
+
+  private extractTitle(prompt: string): string {
+    const cleaned = prompt.replace(/\[Image #\d+\]/g, '').trim();
+    const firstLine = cleaned.split('\n')[0].trim();
+    if (firstLine.length <= 60) return firstLine || '(无标题)';
+    return truncateString(firstLine, 60);
+  }
+}

package/src/hooks/hook-lib.sh

@@ -0,0 +1,118 @@
+#!/usr/bin/env bash
+# Claude Forge - Hook shared library
+# Source this file at the top of each hook script:
+#   source "$(dirname "$0")/hook-lib.sh"
+#
+# Provides:
+#   - SOCKET_PATH, QUEUE_DIR shared variables
+#   - send_event_or_enqueue() function
+
+SOCKET_PATH="${CLAUDE_FORGE_SOCKET:-$HOME/.claude-forge/daemon.sock}"
+QUEUE_DIR="$HOME/.claude-forge/queue"
+
+# resolve_project_path <input_cwd>
+#
+# Walk up the directory tree from <input_cwd> to find the nearest ancestor that
+# contains a `.git` entry (directory for normal clones, file for worktrees /
+# submodules). Print the resolved git-root path on stdout.
+#
+# Fallback rules:
+#   - Empty input → start from $PWD
+#   - Relative input → prefixed with $PWD to absolutise
+#   - No .git found within 64 levels → print original input unchanged
+#
+# POSIX-only: uses `dirname` and `case`; does NOT depend on `realpath` or any
+# GNU coreutils extensions, so it works on macOS BSD and Linux alike.
+resolve_project_path() {
+  local input="${1:-}"
+  local dir="${input:-$PWD}"
+
+  # Absolutise: prefix relative paths with $PWD (no realpath dependency)
+  case "$dir" in
+    /*) ;;
+    *)  dir="$PWD/$dir" ;;
+  esac
+
+  local guard=0
+  while [ "$dir" != "/" ] && [ "$dir" != "." ] && [ $guard -lt 64 ]; do
+    if [ -d "$dir/.git" ] || [ -f "$dir/.git" ]; then
+      printf '%s' "$dir"
+      return 0
+    fi
+    dir=$(dirname "$dir")
+    guard=$((guard + 1))
+  done
+
+  # No git ancestor found → fall back to the caller's original cwd
+  printf '%s' "${input:-$PWD}"
+}
+
+# send_event_or_enqueue <event_json> [timeout_seconds]
+#
+# 1. If socket file does not exist → enqueue in background → return empty string
+# 2. If socket exists → send via nc with timeout
+#    - nc exit code != 0 → enqueue in background → return empty string
+#    - nc exit code == 0 → return daemon response on stdout
+#
+# The caller reads REPLY_RESPONSE after calling this function:
+#   send_event_or_enqueue "$EVENT" 10
+#   RESPONSE="$HOOK_RESPONSE"
+#
+# macOS BSD nc notes:
+#   - `nc -U` opens a Unix domain socket connection
+#   - `-w N` sets idle timeout (seconds); on macOS this is the "connection timeout"
+#     for UDP but for TCP/Unix it's inactivity timeout after connection
+#   - Exit code: 0 = success (data sent + connection closed by remote), 1 = error
+#   - An empty response (daemon returns nothing) still exits 0 if the connection
+#     was established and closed cleanly → we check exit code, NOT response content
+
+HOOK_RESPONSE=""
+
+send_event_or_enqueue() {
+  local event_json="$1"
+  local timeout_secs="${2:-10}"
+
+  HOOK_RESPONSE=""
+
+  # Fast path: no socket file → daemon is not running
+  if [ ! -S "$SOCKET_PATH" ]; then
+    _enqueue_event_bg "$event_json"
+    return 0
+  fi
+
+  # Socket exists: try to send; capture exit code separately from stdout
+  local tmp_response
+  tmp_response=$(echo "$event_json" | nc -U -w "$timeout_secs" "$SOCKET_PATH" 2>/dev/null)
+  local nc_exit=$?
+
+  if [ $nc_exit -ne 0 ]; then
+    # nc failed (connection refused, socket disappeared between check and send, etc.)
+    _enqueue_event_bg "$event_json"
+    return 0
+  fi
+
+  # Success: pass response back to caller
+  HOOK_RESPONSE="$tmp_response"
+}
+
+# _enqueue_event_bg <event_json>
+# Forks a background subshell to write the event JSON to the queue directory.
+# The main hook process is never blocked by this operation.
+_enqueue_event_bg() {
+  local event_json="$1"
+  (
+    mkdir -p "$QUEUE_DIR"
+    # Timestamp with second precision (BSD date has no %N nanoseconds)
+    local ts
+    ts=$(date -u +"%Y%m%dT%H%M%S")
+    # UUID: prefer uuidgen (macOS), fall back to /proc on Linux
+    local uuid
+    uuid=$(uuidgen 2>/dev/null \
+      || cat /proc/sys/kernel/random/uuid 2>/dev/null \
+      || printf '%s-%s' "$$" "$RANDOM")
+    local filename="${ts}-${uuid}.json"
+    # Atomic write: write to temp file, then rename
+    local tmp_file="$QUEUE_DIR/.tmp-${filename}"
+    printf '%s' "$event_json" > "$tmp_file" && mv "$tmp_file" "$QUEUE_DIR/${filename}"
+  ) &
+}

package/src/hooks/notification.sh

@@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+# Claude Forge - Notification Hook
+
+# shellcheck source=./hook-lib.sh
+source "$(dirname "$0")/hook-lib.sh"
+
+AUTH_TOKEN=$(cat "$HOME/.claude-forge/daemon.token" 2>/dev/null || echo '')
+
+# 读取 stdin
+INPUT=$(cat)
+
+# 提取 cwd（jq 替代 python3）
+RAW_CWD=$(echo "$INPUT" | jq -r '.cwd // ""')
+PROJECT_PATH=$(resolve_project_path "${RAW_CWD:-$PWD}")
+SESSION_ID=$(echo "$INPUT" | jq -r '.session_id // .sessionId // ""')
+SESSION_ID="${SESSION_ID:-${CLAUDE_CODE_SESSION_ID:-cli}}"
+
+# 构造事件 JSON（原始 INPUT 作为 tool_input，保留完整通知内容）
+TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%S.000Z")
+TOOL_INPUT=$(echo "$INPUT" | jq -c '.')
+EVENT=$(jq -n \
+  --arg hook_type "Notification" \
+  --arg timestamp "$TIMESTAMP" \
+  --arg session_id "$SESSION_ID" \
+  --arg project_path "$PROJECT_PATH" \
+  --argjson tool_input "$TOOL_INPUT" \
+  --arg auth "$AUTH_TOKEN" \
+  '{hook_type: $hook_type, timestamp: $timestamp, session_id: $session_id,
+    project_path: $project_path, tool_name: "notification",
+    tool_input: $tool_input, _auth: $auth}')
+
+# 发送到 daemon（1 秒超时；失败时入队）
+send_event_or_enqueue "$EVENT" 1
+
+exit 0

package/src/hooks/post-tool-use.sh

@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+# Claude Forge - PostToolUse Hook
+
+# shellcheck source=./hook-lib.sh
+source "$(dirname "$0")/hook-lib.sh"
+
+AUTH_TOKEN=$(cat "$HOME/.claude-forge/daemon.token" 2>/dev/null || echo '')
+
+# 读取 stdin
+INPUT=$(cat)
+
+# 提取字段（单次 jq 调用，替代 4 个 python3 进程）
+# tool_response 是 Claude Code 的字段名
+TOOL_NAME="${CLAUDE_TOOL_NAME:-$(echo "$INPUT" | jq -r '.tool_name // ""')}"
+TOOL_INPUT=$(echo "$INPUT" | jq -c '.tool_input // {}')
+TOOL_OUTPUT=$(echo "$INPUT" | jq -c '.tool_response // {}')
+RAW_CWD=$(echo "$INPUT" | jq -r '.cwd // ""')
+PROJECT_PATH=$(resolve_project_path "${RAW_CWD:-$PWD}")
+SESSION_ID=$(echo "$INPUT" | jq -r '.session_id // .sessionId // ""')
+SESSION_ID="${SESSION_ID:-${CLAUDE_CODE_SESSION_ID:-cli}}"
+
+# 构造事件 JSON
+TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%S.000Z")
+EVENT=$(jq -n \
+  --arg hook_type "PostToolUse" \
+  --arg timestamp "$TIMESTAMP" \
+  --arg session_id "$SESSION_ID" \
+  --arg project_path "$PROJECT_PATH" \
+  --arg tool_name "$TOOL_NAME" \
+  --argjson tool_input "$TOOL_INPUT" \
+  --argjson tool_output "$TOOL_OUTPUT" \
+  --arg auth "$AUTH_TOKEN" \
+  '{hook_type: $hook_type, timestamp: $timestamp, session_id: $session_id,
+    project_path: $project_path, tool_name: $tool_name, tool_input: $tool_input,
+    tool_output: $tool_output, _auth: $auth}')
+
+# 发送到 daemon（PostToolUse 也需要等待响应以支持通知注入；失败时入队）
+send_event_or_enqueue "$EVENT" 5
+RESPONSE="$HOOK_RESPONSE"
+
+if [ -n "$RESPONSE" ]; then
+  # 硬阻断：优先使用 hookSpecificOutput（Claude Code 官方格式）
+  ALLOW=$(echo "$RESPONSE" | jq -r '.allow // true')
+  if [ "$ALLOW" = "false" ]; then
+    HAS_HOOK_OUTPUT=$(echo "$RESPONSE" | jq -r 'if .hookSpecificOutput then "yes" else "no" end')
+    if [ "$HAS_HOOK_OUTPUT" = "yes" ]; then
+      echo "$RESPONSE" | jq '{hookSpecificOutput: .hookSpecificOutput}'
+      exit 0
+    else
+      REASON=$(echo "$RESPONSE" | jq -r '.reason // "Pipeline 已阻断"')
+      echo "$REASON" >&2
+      exit 2
+    fi
+  fi
+
+  HAS_CONTEXT=$(echo "$RESPONSE" | jq -r 'if .additionalContext and (.additionalContext != "") then "yes" else "no" end')
+  if [ "$HAS_CONTEXT" = "yes" ]; then
+    echo "$RESPONSE"
+  fi
+fi
+exit 0