@winspan/claude-forge 8.39.0 → 8.50.6

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);
+    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/services/weekly-report.ts

@@ -0,0 +1,454 @@
+/**
+ * WeeklyReportGenerator — 周报生成引擎
+ *
+ * 基于现有 events / sessions / routing_events / skill_invocations / tasks 表
+ * 聚合上一周（ISO week，周一 00:00 — 周日 23:59）的关键指标，并提供
+ * Markdown 渲染输出。
+ *
+ * 不修改任何 schema：完全基于现有表。
+ */
+
+import type { SQLiteStorage } from '../../core/storage/sqlite.js';
+
+export interface WeeklyReport {
+  generatedAt: string;
+  week: { start: string; end: string; isoWeekNumber: number };
+  overview: {
+    totalSessions: number;
+    totalEvents: number;
+    totalTasks: number;
+    activeProjects: string[];
+    activeDays: number;
+  };
+  agentDelegation: {
+    totalPrompts: number;
+    delegations: number;
+    rate: string;
+    weekOverWeek: string;
+    topAgents: Array<{ agent: string; count: number }>;
+  };
+  skills: {
+    invocations: number;
+    distinct: number;
+    topSkills: Array<{ skill_id: string; count: number }>;
+    neverUsed: string[];
+  };
+  tools: {
+    totalCalls: number;
+    topTools: Array<{ name: string; count: number }>;
+    failureRate: string;
+  };
+  files: {
+    topEdited: Array<{ path: string; editCount: number }>;
+    totalEdits: number;
+  };
+  anomalies: Array<{ type: string; description: string }>;
+}
+
+interface WeekRange {
+  startMs: number;
+  endMs: number;
+  startISO: string;
+  endISO: string;
+  isoWeekNumber: number;
+}
+
+const FILE_EDIT_TOOLS = new Set(['Edit', 'Write', 'MultiEdit', 'NotebookEdit']);
+
+export class WeeklyReportGenerator {
+  constructor(
+    private storage: SQLiteStorage,
+    private skillRegistry?: { getAll(): Array<{ id: string }> },
+  ) {}
+
+  /**
+   * 生成周报
+   * @param weekOffset 周偏移：0 = 本周, -1 = 上周, -2 = 上上周
+   */
+  generate(weekOffset: number = 0): WeeklyReport {
+    const week = this.computeWeekRange(weekOffset);
+    const previousWeek = this.computeWeekRange(weekOffset - 1);
+
+    const overview = this.aggregateOverview(week);
+    const agentDelegation = this.aggregateAgentDelegation(week, previousWeek);
+    const skills = this.aggregateSkills(week);
+    const tools = this.aggregateTools(week);
+    const files = this.aggregateFiles(week);
+    const anomalies = this.aggregateAnomalies(week);
+
+    return {
+      generatedAt: new Date().toISOString(),
+      week: {
+        start: week.startISO,
+        end: week.endISO,
+        isoWeekNumber: week.isoWeekNumber,
+      },
+      overview,
+      agentDelegation,
+      skills,
+      tools,
+      files,
+      anomalies,
+    };
+  }
+
+  // ── Aggregation methods ──────────────────────────────────────────────
+
+  private aggregateOverview(week: WeekRange): WeeklyReport['overview'] {
+    const db = this.storage.getDatabase();
+
+    const eventsRow = db.prepare(
+      `SELECT COUNT(*) as cnt, COUNT(DISTINCT session_id) as sessionCount,
+              COUNT(DISTINCT date(timestamp)) as dayCount
+         FROM events
+        WHERE timestamp >= ? AND timestamp < ?`,
+    ).get(week.startISO, week.endISO) as {
+      cnt: number;
+      sessionCount: number;
+      dayCount: number;
+    };
+
+    const projectRows = db.prepare(
+      `SELECT DISTINCT project_path
+         FROM events
+        WHERE timestamp >= ? AND timestamp < ?
+              AND project_path IS NOT NULL AND project_path != ''`,
+    ).all(week.startISO, week.endISO) as Array<{ project_path: string }>;
+
+    const tasksRow = db.prepare(
+      `SELECT COUNT(*) as cnt
+         FROM tasks
+        WHERE start_time >= ? AND start_time < ?`,
+    ).get(week.startISO, week.endISO) as { cnt: number };
+
+    return {
+      totalSessions: eventsRow.sessionCount || 0,
+      totalEvents: eventsRow.cnt || 0,
+      totalTasks: tasksRow.cnt || 0,
+      activeProjects: projectRows.map(r => r.project_path),
+      activeDays: eventsRow.dayCount || 0,
+    };
+  }
+
+  private aggregateAgentDelegation(
+    week: WeekRange,
+    previousWeek: WeekRange,
+  ): WeeklyReport['agentDelegation'] {
+    const current = this.computeAgentRate(week);
+    const previous = this.computeAgentRate(previousWeek);
+
+    const diff = current.rateNum - previous.rateNum;
+    const weekOverWeek = `${diff >= 0 ? '+' : ''}${diff.toFixed(1)}pp`;
+
+    return {
+      totalPrompts: current.totalPrompts,
+      delegations: current.delegations,
+      rate: `${current.rateNum.toFixed(1)}%`,
+      weekOverWeek,
+      topAgents: current.topAgents,
+    };
+  }
+
+  private computeAgentRate(week: WeekRange): {
+    totalPrompts: number;
+    delegations: number;
+    rateNum: number;
+    topAgents: Array<{ agent: string; count: number }>;
+  } {
+    const events = this.storage.queryRoutingEvents({
+      since_ts: week.startMs,
+      limit: 100000,
+    }).filter(e => e.ts < week.endMs);
+
+    const totalPrompts = events.length;
+    const delegations = events.filter(e => e.obeyed === 1).length;
+    const rateNum = totalPrompts > 0 ? (delegations / totalPrompts) * 100 : 0;
+
+    const agentMap = new Map<string, number>();
+    for (const e of events) {
+      if (e.obeyed === 1 && e.routed_to_name) {
+        agentMap.set(e.routed_to_name, (agentMap.get(e.routed_to_name) || 0) + 1);
+      }
+    }
+    const topAgents = Array.from(agentMap.entries())
+      .map(([agent, count]) => ({ agent, count }))
+      .sort((a, b) => b.count - a.count)
+      .slice(0, 5);
+
+    return { totalPrompts, delegations, rateNum, topAgents };
+  }
+
+  private aggregateSkills(week: WeekRange): WeeklyReport['skills'] {
+    const invocations = this.storage.querySkillInvocations({
+      since: week.startMs,
+      limit: 100000,
+    }).filter(inv => inv.timestamp < week.endMs);
+
+    const skillMap = new Map<string, number>();
+    for (const inv of invocations) {
+      skillMap.set(inv.skill_id, (skillMap.get(inv.skill_id) || 0) + 1);
+    }
+
+    const topSkills = Array.from(skillMap.entries())
+      .map(([skill_id, count]) => ({ skill_id, count }))
+      .sort((a, b) => b.count - a.count)
+      .slice(0, 5);
+
+    const allSkillIds = this.skillRegistry
+      ? this.skillRegistry.getAll().map(s => s.id)
+      : [];
+    const usedSet = new Set(skillMap.keys());
+    const neverUsed = allSkillIds.filter(id => !usedSet.has(id));
+
+    return {
+      invocations: invocations.length,
+      distinct: skillMap.size,
+      topSkills,
+      neverUsed,
+    };
+  }
+
+  private aggregateTools(week: WeekRange): WeeklyReport['tools'] {
+    const db = this.storage.getDatabase();
+
+    const toolRows = db.prepare(
+      `SELECT tool_name, COUNT(*) as cnt
+         FROM events
+        WHERE timestamp >= ? AND timestamp < ?
+              AND tool_name IS NOT NULL AND tool_name != ''
+              AND hook_type = 'PreToolUse'
+        GROUP BY tool_name
+        ORDER BY cnt DESC`,
+    ).all(week.startISO, week.endISO) as Array<{ tool_name: string; cnt: number }>;
+
+    const totalCalls = toolRows.reduce((sum, r) => sum + r.cnt, 0);
+    const topTools = toolRows.slice(0, 5).map(r => ({ name: r.tool_name, count: r.cnt }));
+
+    // Failure detection: PostToolUse with error keyword in tool_output
+    const failureRow = db.prepare(
+      `SELECT COUNT(*) as failed
+         FROM events
+        WHERE timestamp >= ? AND timestamp < ?
+              AND hook_type = 'PostToolUse'
+              AND tool_output IS NOT NULL
+              AND (tool_output LIKE '%"error"%'
+                OR tool_output LIKE '%"is_error":true%'
+                OR tool_output LIKE '%"isError":true%')`,
+    ).get(week.startISO, week.endISO) as { failed: number };
+
+    const postCallRow = db.prepare(
+      `SELECT COUNT(*) as total
+         FROM events
+        WHERE timestamp >= ? AND timestamp < ?
+              AND hook_type = 'PostToolUse'`,
+    ).get(week.startISO, week.endISO) as { total: number };
+
+    const failureRate = postCallRow.total > 0
+      ? `${((failureRow.failed / postCallRow.total) * 100).toFixed(1)}%`
+      : '0.0%';
+
+    return {
+      totalCalls,
+      topTools,
+      failureRate,
+    };
+  }
+
+  private aggregateFiles(week: WeekRange): WeeklyReport['files'] {
+    const db = this.storage.getDatabase();
+
+    const placeholders = Array.from(FILE_EDIT_TOOLS).map(() => '?').join(',');
+    const rows = db.prepare(
+      `SELECT tool_input
+         FROM events
+        WHERE timestamp >= ? AND timestamp < ?
+              AND hook_type = 'PreToolUse'
+              AND tool_name IN (${placeholders})
+              AND tool_input IS NOT NULL`,
+    ).all(week.startISO, week.endISO, ...Array.from(FILE_EDIT_TOOLS)) as Array<{ tool_input: string }>;
+
+    const fileMap = new Map<string, number>();
+    let totalEdits = 0;
+    for (const row of rows) {
+      try {
+        const input = JSON.parse(row.tool_input) as { file_path?: string; notebook_path?: string };
+        const path = input.file_path || input.notebook_path;
+        if (typeof path === 'string' && path.length > 0) {
+          fileMap.set(path, (fileMap.get(path) || 0) + 1);
+          totalEdits++;
+        }
+      } catch {
+        // skip malformed JSON
+      }
+    }
+
+    const topEdited = Array.from(fileMap.entries())
+      .map(([path, editCount]) => ({ path, editCount }))
+      .sort((a, b) => b.editCount - a.editCount)
+      .slice(0, 5);
+
+    return { topEdited, totalEdits };
+  }
+
+  private aggregateAnomalies(_week: WeekRange): WeeklyReport['anomalies'] {
+    // anti-pattern-detector.ts is being implemented by another agent.
+    // Return empty array until it's available.
+    return [];
+  }
+
+
+  // ── Helper methods ──────────────────────────────────────────────────
+
+  /**
+   * 计算 ISO 周的起止时间（周一 00:00:00 — 下周一 00:00:00）。
+   * weekOffset: 0 = 本周, -1 = 上周, -2 = 上上周
+   */
+  private computeWeekRange(weekOffset: number): WeekRange {
+    const now = new Date();
+    // 计算本周一（ISO week 起点）
+    const dayOfWeek = now.getDay(); // 0=Sun, 1=Mon, ...
+    const daysFromMonday = (dayOfWeek + 6) % 7; // Mon=0, Tue=1, ..., Sun=6
+
+    const monday = new Date(
+      now.getFullYear(),
+      now.getMonth(),
+      now.getDate() - daysFromMonday + weekOffset * 7,
+      0, 0, 0, 0,
+    );
+    const nextMonday = new Date(monday);
+    nextMonday.setDate(monday.getDate() + 7);
+
+    return {
+      startMs: monday.getTime(),
+      endMs: nextMonday.getTime(),
+      startISO: monday.toISOString(),
+      endISO: nextMonday.toISOString(),
+      isoWeekNumber: getISOWeekNumber(monday),
+    };
+  }
+
+
+  // ── Markdown rendering ──────────────────────────────────────────────
+
+  toMarkdown(report: WeeklyReport): string {
+    const { week, overview, agentDelegation, skills, tools, files, anomalies } = report;
+
+    const lines: string[] = [];
+    lines.push(`# 周报 — 第 ${week.isoWeekNumber} 周`);
+    lines.push('');
+    lines.push(`**周期**: ${week.start.slice(0, 10)} ~ ${week.end.slice(0, 10)}`);
+    lines.push(`**生成时间**: ${report.generatedAt}`);
+    lines.push('');
+
+    lines.push('## 概览');
+    lines.push('');
+    lines.push(`- 总会话数: **${overview.totalSessions}**`);
+    lines.push(`- 总事件数: **${overview.totalEvents}**`);
+    lines.push(`- 总任务数: **${overview.totalTasks}**`);
+    lines.push(`- 活跃天数: **${overview.activeDays}** 天`);
+    lines.push(`- 活跃项目: ${overview.activeProjects.length} 个`);
+    if (overview.activeProjects.length > 0) {
+      for (const p of overview.activeProjects) {
+        lines.push(`  - \`${p}\``);
+      }
+    }
+    lines.push('');
+
+    lines.push('## Agent 委托');
+    lines.push('');
+    lines.push(`- 总路由数: **${agentDelegation.totalPrompts}**`);
+    lines.push(`- 委托数: **${agentDelegation.delegations}**`);
+    lines.push(`- 委托率: **${agentDelegation.rate}** (环比 ${agentDelegation.weekOverWeek})`);
+    if (agentDelegation.topAgents.length > 0) {
+      lines.push('');
+      lines.push('**Top Agents**:');
+      lines.push('');
+      lines.push('| Agent | 调用次数 |');
+      lines.push('| --- | ---: |');
+      for (const a of agentDelegation.topAgents) {
+        lines.push(`| ${a.agent} | ${a.count} |`);
+      }
+    }
+    lines.push('');
+
+    lines.push('## Skills');
+    lines.push('');
+    lines.push(`- 调用总数: **${skills.invocations}**`);
+    lines.push(`- 不同 Skill: **${skills.distinct}**`);
+    if (skills.topSkills.length > 0) {
+      lines.push('');
+      lines.push('**Top Skills**:');
+      lines.push('');
+      lines.push('| Skill | 调用次数 |');
+      lines.push('| --- | ---: |');
+      for (const s of skills.topSkills) {
+        lines.push(`| ${s.skill_id} | ${s.count} |`);
+      }
+    }
+    if (skills.neverUsed.length > 0) {
+      lines.push('');
+      lines.push(`**从未使用** (${skills.neverUsed.length}): ${skills.neverUsed.map(s => `\`${s}\``).join(', ')}`);
+    }
+    lines.push('');
+
+    lines.push('## Tools');
+    lines.push('');
+    lines.push(`- 调用总数: **${tools.totalCalls}**`);
+    lines.push(`- 失败率: **${tools.failureRate}**`);
+    if (tools.topTools.length > 0) {
+      lines.push('');
+      lines.push('**Top Tools**:');
+      lines.push('');
+      lines.push('| Tool | 调用次数 |');
+      lines.push('| --- | ---: |');
+      for (const t of tools.topTools) {
+        lines.push(`| ${t.name} | ${t.count} |`);
+      }
+    }
+    lines.push('');
+
+    lines.push('## Files');
+    lines.push('');
+    lines.push(`- 编辑总数: **${files.totalEdits}**`);
+    if (files.topEdited.length > 0) {
+      lines.push('');
+      lines.push('**Top Edited**:');
+      lines.push('');
+      lines.push('| 文件 | 编辑次数 |');
+      lines.push('| --- | ---: |');
+      for (const f of files.topEdited) {
+        lines.push(`| \`${f.path}\` | ${f.editCount} |`);
+      }
+    }
+    lines.push('');
+
+    lines.push('## 异常');
+    lines.push('');
+    if (anomalies.length === 0) {
+      lines.push('本周无异常。');
+    } else {
+      for (const a of anomalies) {
+        lines.push(`- **${a.type}**: ${a.description}`);
+      }
+    }
+    lines.push('');
+
+    return lines.join('\n');
+  }
+}
+
+/**
+ * 计算 ISO 8601 周数。
+ */
+function getISOWeekNumber(date: Date): number {
+  const target = new Date(date.getTime());
+  // ISO 周以周四为锚点
+  target.setHours(0, 0, 0, 0);
+  target.setDate(target.getDate() + 3 - ((target.getDay() + 6) % 7));
+  const week1 = new Date(target.getFullYear(), 0, 4);
+  return 1 + Math.round(
+    ((target.getTime() - week1.getTime()) / 86400000
+      - 3 + ((week1.getDay() + 6) % 7)) / 7,
+  );
+}
+

package/src/hooks/hook-lib.sh

@@ -0,0 +1,81 @@
+#!/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"
+
+# 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）
+PROJECT_PATH=$(echo "$INPUT" | jq -r '.cwd // ""')
+PROJECT_PATH="${PROJECT_PATH:-${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