@winspan/claude-forge 8.53.2 → 8.54.3

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

@@ -1,112 +0,0 @@
-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/daemon/skill-sync.ts

@@ -1,88 +0,0 @@
-import { existsSync, readFileSync, copyFileSync, mkdirSync, readdirSync } from 'node:fs';
-import { createHash } from 'node:crypto';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { homedir } from 'node:os';
-import { logger } from '../core/utils/logger.js';
-
-const USER_SKILLS_DIR = join(homedir(), '.claude', 'skills');
-
-function sha256(content: Buffer): string {
-  return createHash('sha256').update(content).digest('hex');
-}
-
-function getSourceSkillsDir(): string {
-  // Compiled: dist/daemon/skill-sync.js → dist/skills/official
-  // Dev (vitest): src/daemon/skill-sync.ts → src/skills/official
-  return join(dirname(fileURLToPath(import.meta.url)), '..', 'skills', 'official');
-}
-
-export interface SkillSyncResult {
-  copied: number;
-  checked: number;
-  skipped_userOwned: number; // user skills not in source list — untouched
-}
-
-/**
- * Sync official skills from dist/skills/official to ~/.claude/skills/.
- *
- * Strategy:
- * - Only files present in the source dir (dist/skills/official) are candidates
- * - sha256 identical → skip; different → overwrite
- * - User-only skills (not in source list) are never touched
- * - Target dir is created if absent (first install)
- *
- * Failures are logged as warnings and never thrown — daemon startup must not be blocked.
- */
-export function syncSkills(opts?: { sourceDir?: string; targetDir?: string }): SkillSyncResult {
-  const result: SkillSyncResult = { copied: 0, checked: 0, skipped_userOwned: 0 };
-  const sourceDir = opts?.sourceDir ?? getSourceSkillsDir();
-  const targetDir = opts?.targetDir ?? USER_SKILLS_DIR;
-
-  if (!existsSync(sourceDir)) {
-    logger.warn(`[SkillSync] source dir not found at ${sourceDir}, skipping`);
-    return result;
-  }
-
-  // Ensure target dir exists (first install may not have ~/.claude/skills/)
-  try {
-    mkdirSync(targetDir, { recursive: true });
-  } catch {
-    /* ignore — if it already exists mkdirSync is a no-op */
-  }
-
-  let sourceFiles: string[];
-  try {
-    sourceFiles = readdirSync(sourceDir).filter((f) => f.endsWith('.md'));
-  } catch (err) {
-    logger.warn(`[SkillSync] failed to list ${sourceDir}: ${err}`);
-    return result;
-  }
-
-  for (const file of sourceFiles) {
-    result.checked++;
-    const src = join(sourceDir, file);
-    const dest = join(targetDir, file);
-
-    try {
-      const srcContent = readFileSync(src);
-      if (existsSync(dest)) {
-        const destContent = readFileSync(dest);
-        if (sha256(srcContent) === sha256(destContent)) {
-          continue; // identical — no copy needed
-        }
-      }
-
-      copyFileSync(src, dest);
-      result.copied++;
-      logger.info(`[SkillSync] updated ${file}`);
-    } catch (err) {
-      logger.warn(`[SkillSync] failed to sync ${file}: ${err instanceof Error ? err.message : String(err)}`);
-    }
-  }
-
-  if (result.copied > 0) {
-    logger.info(`[SkillSync] synced ${result.copied}/${result.checked} skill files`);
-  }
-  return result;
-}

package/src/hooks/hook-lib.sh

@@ -1,118 +0,0 @@
-#!/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

@@ -1,35 +0,0 @@
-#!/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 -nc \
-  --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

@@ -1,61 +0,0 @@
-#!/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 -nc \
-  --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

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

@@ -1,63 +0,0 @@
-#!/usr/bin/env bash
-# Claude Forge - PreToolUse 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（Claude Code 传入的 JSON）
-INPUT=$(cat)
-
-# 提取字段（单次 jq 调用，替代 3 个 python3 进程）
-TOOL_NAME="${CLAUDE_TOOL_NAME:-$(echo "$INPUT" | jq -r '.tool_name // ""')}"
-TOOL_INPUT=$(echo "$INPUT" | jq -c '.tool_input // {}')
-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（jq -n 替代 python3 heredoc）
-TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%S.000Z")
-EVENT=$(jq -nc \
-  --arg hook_type "PreToolUse" \
-  --arg timestamp "$TIMESTAMP" \
-  --arg session_id "$SESSION_ID" \
-  --arg project_path "$PROJECT_PATH" \
-  --arg tool_name "$TOOL_NAME" \
-  --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: $tool_name, tool_input: $tool_input,
-    _auth: $auth}')
-
-# 发送事件（5 秒超时；失败时入队）
-send_event_or_enqueue "$EVENT" 5
-RESPONSE="$HOOK_RESPONSE"
-
-if [ -n "$RESPONSE" ]; then
-  ALLOW=$(echo "$RESPONSE" | jq -r '.allow // true')
-
-  if [ "$ALLOW" = "false" ]; then
-    # 优先使用 hookSpecificOutput（Claude Code 官方格式），否则降级到 stderr + exit 2
-    HAS_HOOK_OUTPUT=$(echo "$RESPONSE" | jq -r 'if .hookSpecificOutput then "yes" else "no" end')
-    if [ "$HAS_HOOK_OUTPUT" = "yes" ]; then
-      # 输出 hookSpecificOutput 格式到 stdout，但必须 exit 非0 才能真正阻止工具执行
-      echo "$RESPONSE" | jq '{hookSpecificOutput: .hookSpecificOutput}'
-      exit 1
-    else
-      # 降级：输出原因到 stderr，exit 2 强制阻断
-      REASON=$(echo "$RESPONSE" | jq -r '.reason // "操作被 Forge 阻断"')
-      echo "$REASON" >&2
-      exit 2
-    fi
-  fi
-
-  # 有 additionalContext 时输出
-  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

package/src/hooks/stop.sh

@@ -1,43 +0,0 @@
-#!/usr/bin/env bash
-# Claude Forge - Stop 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 2>/dev/null || echo '{}')
-
-# 提取 cwd，上溯 git root
-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 -nc \
-  --arg hook_type "Stop" \
-  --arg timestamp "$TIMESTAMP" \
-  --arg session_id "$SESSION_ID" \
-  --arg project_path "$PROJECT_PATH" \
-  --arg auth "$AUTH_TOKEN" \
-  '{hook_type: $hook_type, timestamp: $timestamp, session_id: $session_id,
-    project_path: $project_path, tool_name: "stop", tool_input: {}, _auth: $auth}')
-
-# 发送事件并读取响应（失败时入队）
-send_event_or_enqueue "$EVENT" 5
-RESPONSE="$HOOK_RESPONSE"
-
-# 解析响应：allow=false 时输出 reason 并以 exit 2 阻断
-if [ -n "$RESPONSE" ]; then
-  ALLOW=$(echo "$RESPONSE" | jq -r '.allow // true' 2>/dev/null)
-  if [ "$ALLOW" = "false" ]; then
-    REASON=$(echo "$RESPONSE" | jq -r '.reason // "质量门禁阻断"' 2>/dev/null)
-    echo "$REASON"
-    exit 2
-  fi
-fi
-
-exit 0

package/src/hooks/user-prompt-submit.sh

@@ -1,69 +0,0 @@
-#!/usr/bin/env bash
-# Claude Forge - UserPromptSubmit Hook
-# 拦截用户输入，触发意图分析和自动 Pipeline 编排
-
-# shellcheck source=./hook-lib.sh
-source "$(dirname "$0")/hook-lib.sh"
-
-AUTH_TOKEN=$(cat "$HOME/.claude-forge/daemon.token" 2>/dev/null || echo '')
-
-# 读取 stdin（Claude Code 传入的 JSON）
-INPUT=$(cat)
-
-# 提取字段（jq 替代 python3）
-USER_PROMPT=$(echo "$INPUT" | jq -r '.prompt // ""')
-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}}"
-
-# 空 prompt 跳过
-if [ -z "$USER_PROMPT" ]; then
-  exit 0
-fi
-
-# 构造事件 JSON（jq -n 替代 python3 heredoc）
-TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%S.000Z")
-EVENT=$(jq -nc \
-  --arg hook_type "UserPromptSubmit" \
-  --arg timestamp "$TIMESTAMP" \
-  --arg session_id "$SESSION_ID" \
-  --arg project_path "$PROJECT_PATH" \
-  --arg user_prompt "$USER_PROMPT" \
-  --arg auth "$AUTH_TOKEN" \
-  '{hook_type: $hook_type, timestamp: $timestamp, session_id: $session_id,
-    project_path: $project_path, tool_name: "UserPrompt",
-    user_prompt: $user_prompt, tool_input: {user_prompt: $user_prompt}, _auth: $auth}')
-
-if [ -z "$EVENT" ]; then
-  exit 0
-fi
-
-# 发送事件（10 秒超时，AI 分析可能需要更多时间）
-# 失败时自动入队（daemon 停机期间事件不丢失）
-send_event_or_enqueue "$EVENT" 10
-RESPONSE="$HOOK_RESPONSE"
-
-if [ -n "$RESPONSE" ]; then
-  HAS_SYSTEM=$(echo "$RESPONSE" | jq -r 'if .systemMessage and (.systemMessage != "") then "yes" else "no" end')
-  HAS_CONTEXT=$(echo "$RESPONSE" | jq -r 'if .additionalContext and (.additionalContext != "") then "yes" else "no" end')
-
-  if [ "$HAS_SYSTEM" = "yes" ] || [ "$HAS_CONTEXT" = "yes" ]; then
-    # stderr 输出摘要到终端
-    if [ "$HAS_SYSTEM" = "yes" ]; then
-      SM_LEN=$(echo "$RESPONSE" | jq -r '.systemMessage | length')
-      printf '\033[36m💉 [Forge] 注入 systemMessage (%s chars)\033[0m\n' "$SM_LEN" >&2
-    fi
-    if [ "$HAS_CONTEXT" = "yes" ]; then
-      CONTEXT=$(echo "$RESPONSE" | jq -r '.additionalContext // ""')
-      DISPLAY_LINES=$(printf '%s' "$CONTEXT" | head -3)
-      if [ -n "$DISPLAY_LINES" ]; then
-        printf '\033[36m💉 [Forge] %s\033[0m\n' "$DISPLAY_LINES" >&2
-      fi
-    fi
-    # stdout 返回给 Claude Code
-    echo "$RESPONSE"
-  fi
-fi
-
-exit 0