nine-hundred 0.0.1

package/README.md

@@ -0,0 +1,43 @@
+# 900
+
+A personal AI Agent like OpenClaw, run in the terminal.
+
+## Requirements
+
+- Node.js
+- pnpm 11.5.2
+
+## Install
+
+```bash
+pnpm install
+```
+
+## Scripts
+
+```bash
+pnpm typecheck
+```
+
+Run TypeScript checks with `tsc`.
+
+```bash
+pnpm test
+```
+
+Run unit tests once with Vitest.
+
+```bash
+pnpm test:watch
+```
+
+Run Vitest in watch mode.
+
+## Project structure
+
+```text
+src/              Source files
+test/             Unit tests
+tsconfig.json     TypeScript configuration
+vitest.config.ts  Vitest configuration
+```

package/dist/agent/config/index.js

@@ -0,0 +1,85 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+export const CONFIG_DIR = path.join(os.homedir(), '.900');
+export const CONFIG_FILE = path.join(CONFIG_DIR, '900.json');
+let cachedConfig;
+export function readConfig() {
+    if (cachedConfig)
+        return cachedConfig;
+    try {
+        const raw = fs.readFileSync(CONFIG_FILE, 'utf-8');
+        cachedConfig = JSON.parse(raw);
+        return cachedConfig;
+    }
+    catch {
+        cachedConfig = {};
+        return cachedConfig;
+    }
+}
+export function getModelConfig() {
+    const config = readConfig();
+    const model = config.model;
+    if (!model) {
+        throw new Error(`找不到 LLM 配置。请在 ${CONFIG_FILE} 中添加 model 配置，例如：\n` +
+            JSON.stringify({
+                model: {
+                    model: 'kimi-k2.6',
+                    apiKey: 'your-api-key',
+                    baseURL: 'https://api.moonshot.cn/v1',
+                },
+            }, null, 2));
+    }
+    if (!model.model || !model.apiKey || !model.baseURL) {
+        throw new Error(`LLM 配置不完整。${CONFIG_FILE} 中的 model 必须包含 model、apiKey 和 baseURL 字段。`);
+    }
+    return model;
+}
+async function validateApiKey(config) {
+    const url = `${config.baseURL.replace(/\/$/, '')}/chat/completions`;
+    try {
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${config.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                model: config.model,
+                messages: [{ role: 'user', content: 'hi' }],
+                max_tokens: 1,
+            }),
+        });
+        if (!response.ok) {
+            const body = await response.text().catch(() => '');
+            throw new Error(`API Key 验证失败 (${response.status})。\n` +
+                `请检查 ${CONFIG_FILE} 中的 apiKey 是否正确。\n` +
+                (body ? `服务器返回: ${body.slice(0, 200)}` : ''));
+        }
+    }
+    catch (err) {
+        if (err instanceof Error && err.message.includes('API Key 验证失败')) {
+            throw err;
+        }
+        throw new Error(`无法连接到 LLM 服务 (${url})。\n` +
+            `请检查网络或 ${CONFIG_FILE} 中的 baseURL 配置。\n` +
+            `原始错误: ${err.message}`);
+    }
+}
+export async function ensureModelConfig() {
+    const config = getModelConfig();
+    if (!config.apiKey || config.apiKey.length === 0) {
+        throw new Error(`apiKey 为空。请在 ${CONFIG_FILE} 中填写有效的 apiKey。`);
+    }
+    if (config.apiKey.length < 20) {
+        await validateApiKey(config);
+    }
+}
+export function getEnvValue(key) {
+    const config = readConfig();
+    return config.env?.[key] ?? process.env[key];
+}
+export function getMCPServerConfig() {
+    const config = readConfig();
+    return { mcpServers: config.mcpServers ?? {} };
+}

package/dist/agent/context/compress.js

@@ -0,0 +1,145 @@
+import { AIMessage, HumanMessage, SystemMessage, ToolMessage, } from '@langchain/core/messages';
+import { getCompressModel } from '../llm/index.js';
+/**
+ * 每轮对话保留的最近消息条数，这些消息不会被压缩，
+ * 始终原样进入模型输入，保证短期上下文连贯。
+ */
+export const KEEP_RECENT = 6;
+/**
+ * 将单条消息格式化为纯文本，用于拼接成给 AI 总结的长文本。
+ * 不同类型消息加上角色前缀，方便摘要模型理解对话结构。
+ * @param m 任意 BaseMessage
+ * @returns 格式化后的字符串
+ */
+function formatMessage(m) {
+    if (m instanceof HumanMessage)
+        return `User: ${m.content}`;
+    if (m instanceof AIMessage)
+        return `AI: ${m.content}`;
+    if (m instanceof ToolMessage)
+        return `Tool (${m.name}): ${m.content}`;
+    if (m instanceof SystemMessage)
+        return `System: ${m.content}`;
+    return `Unknown: ${m.content}`;
+}
+/**
+ * 将一组消息拼接为供 AI 摘要的长文本。
+ * @param messages 需要格式化的消息数组
+ * @returns 以双换行分隔的格式化字符串
+ */
+export function formatMessagesForSummary(messages) {
+    return messages.map(formatMessage).join('\n\n');
+}
+/**
+ * 调用 AI 接口对一批历史消息生成摘要。
+ * 提示词要求保留关键决策、结论、待办事项和重要上下文，并使用中文输出。
+ * @param messages 需要被摘要的消息数组
+ * @returns 摘要文本；若数组为空返回空字符串
+ */
+export async function summarizeMessages(messages) {
+    if (messages.length === 0)
+        return '';
+    const text = formatMessagesForSummary(messages);
+    const prompt = `请用中文总结以下对话历史，保留关键决策、结论、待办事项和重要上下文信息。尽量简洁：\n\n${text}`;
+    const response = await getCompressModel().invoke([new HumanMessage(prompt)]);
+    const content = typeof response.content === 'string' ? response.content : JSON.stringify(response.content);
+    return content.trim();
+}
+/**
+ * 判断当前 token 使用量是否已达到压缩阈值（≥ 80%）。
+ * 若上下文窗口未知或非法，直接返回 false，避免误触发。
+ * @param usage 当前 token 使用量
+ * @param contextWindow 模型上下文窗口大小，可能为 null
+ * @returns true 表示需要触发压缩
+ */
+export function shouldCompress(usage, contextWindow) {
+    if (contextWindow == null || contextWindow <= 0)
+        return false;
+    return (usage.total_tokens / contextWindow) * 100 >= 80;
+}
+/**
+ * 简化历史消息中的 ToolMessage：将旧的 tool 结果替换为占位符，
+ * 减少上下文臃肿，同时保留最近 3 条和 read_file_tool 的完整内容。
+ *
+ * 规则：
+ * - 只处理 ToolMessage，其他类型原样返回；
+ * - 保留数组中最近 3 条 ToolMessage（按索引）；
+ * - read_file_tool 无论新旧都保留原内容；
+ * - 通过 map 返回新数组，不修改原始 messages。
+ */
+function simplifyToolMessages(messages) {
+    const toolIndices = [];
+    for (let i = 0; i < messages.length; i++) {
+        if (messages[i] instanceof ToolMessage) {
+            toolIndices.push(i);
+        }
+    }
+    const keepIndices = new Set(toolIndices.slice(-3));
+    return messages.map((m, i) => {
+        if (!(m instanceof ToolMessage))
+            return m;
+        if (keepIndices.has(i))
+            return m;
+        if (m.name === 'read_file_tool')
+            return m;
+        return new ToolMessage({
+            content: `[Previous: used ${m.name}]`,
+            tool_call_id: m.tool_call_id,
+            name: m.name,
+        });
+    });
+}
+/**
+ * 构建本轮模型实际看到的输入消息列表。
+ *
+ * 策略：
+ * - 先对 ToolMessage 做简化，减少上下文冗余；
+ * - 若存在历史摘要，将其包装为 SystemMessage 放在最前面，
+ *   后面紧跟最近 `KEEP_RECENT` 条原始消息；
+ * - 若不存在摘要，直接返回全部简化后的消息。
+ *
+ * 这样既能压缩远历史，又保留近期上下文。
+ * @param options.messages 当前会话的完整消息列表
+ * @param options.summary 已生成的历史摘要，null 表示无摘要
+ * @returns 本轮应输入给模型的消息数组
+ */
+export function buildLlmInputMessages(options) {
+    const { messages, summary } = options;
+    // compress tool messages
+    let simplified = simplifyToolMessages(messages);
+    // compact context
+    const recent = simplified.slice(-KEEP_RECENT);
+    if (summary) {
+        const summaryMessage = new SystemMessage(`以下是对话历史摘要（由历史消息压缩生成）：\n\n${summary}`);
+        return [summaryMessage, ...recent];
+    }
+    // 暴力保留最近 300 条记录
+    simplified = simplified.slice(0, 300);
+    // 一共 4 层压缩机制，保障 context 不会膨胀不会爆炸。
+    // 1. 压缩 tool 输出， persist tool output
+    // 2. 压缩 tool message
+    // 3. 超过 80% 压缩整个 messages
+    // 4. 超过 300 messages 自动裁剪
+    return simplified;
+}
+/**
+ * 计算本次需要被压缩的消息范围。
+ *
+ * 规则：
+ * 1. 始终保留最后 `KEEP_RECENT` 条消息不压缩；
+ * 2. 从 `summarizedIndex` 位置开始向后取，跳过已压缩过的消息；
+ * 3. 若消息总数不足 `KEEP_RECENT`，或已全部压缩完，返回空数组。
+ *
+ * @param options.messages 当前会话的完整消息列表
+ * @param options.summarizedIndex 已摘要覆盖到的索引（从数组开头算起）
+ * @returns 本次应被送入 summarizeMessages 的消息子数组
+ */
+export function getMessagesToCompress(options) {
+    const { messages, summarizedIndex } = options;
+    // 计算「可压缩区域」的结束索引（即保留区起点）
+    const endIndex = Math.max(0, messages.length - KEEP_RECENT);
+    // 已压缩的部分已经覆盖到保留区，无需再压缩
+    if (summarizedIndex >= endIndex)
+        return [];
+    return messages.slice(summarizedIndex, endIndex);
+}

package/dist/agent/context/index.js

@@ -0,0 +1,68 @@
+// 模型 → context window 大小映射。
+// 没有 SDK API 能动态查 context window，只能维护静态表 + 环境变量覆盖。
+// 用户切换 baseURL 到自托管模型时可设 MODEL_CONTEXT_WINDOW 手动指定。
+// DeepSeek: https://api-docs.deepseek.com/zh-cn/
+//  - deepseek-chat (DeepSeek-V3): 64K
+//  - deepseek-reasoner (DeepSeek-R1): 64K
+// Minimax: https://platform.minimaxi.com/
+//  - MiniMax-Text-01 / M1: 1M
+//  - abab6.5s: 245K
+//  - abab6: 8K
+// GLM (智谱): https://docs.bigmodel.cn/
+//  - GLM-4 / GLM-4-Plus / GLM-4-Flash / GLM-4-9B: 128K
+//  - GLM-4V: 8K (多模态)
+//  - GLM-Z1: 32K
+//  - ChatGLM 系列: 32K
+// Qwen (阿里云): https://bailian.console.aliyun.com/
+//  - qwen-long: 10M
+//  - qwen-max 新版 / qwen-plus / qwen-turbo / qwen-coder-plus / qwen2.5 系列: 128K
+//  - qwen-max 旧版 / qwen1.5 系列: 32K
+// 小米 mimo: https://mimo.mi.com/
+//  - mimo 系列: 128K
+const KNOWN = [
+    // --- Anthropic ---
+    [/^claude-/, 200_000],
+    // --- OpenAI ---
+    [/^gpt-4o/, 128_000],
+    [/^gpt-4-turbo/, 128_000],
+    [/^o1/, 200_000],
+    [/^gpt-3\.5-turbo/, 16_000],
+    // --- DeepSeek ---
+    [/^deepseek-/, 64_000],
+    // --- Minimax ---
+    [/^minimax-text-01/i, 1_000_000],
+    [/^minimax-m1/i, 1_000_000],
+    [/^abab6\.5/i, 245_000],
+    [/^abab6/i, 8_000],
+    [/^minimax-/i, 1_000_000], // fallback
+    // --- GLM (智谱) ---
+    [/^glm-4v/i, 8_000],
+    [/^glm-z1/i, 32_000],
+    [/^chatglm/i, 32_000],
+    [/^glm-/i, 128_000],
+    // --- Qwen (阿里云) ---
+    [/^qwen-long/i, 10_000_000],
+    [/^qwen2\.5/i, 128_000],
+    [/^qwen-coder-plus/i, 128_000],
+    [/^qwen-plus/i, 128_000],
+    [/^qwen-turbo/i, 128_000],
+    [/^qwen-max/i, 32_000],
+    [/^qwen1\.5/i, 32_000],
+    [/^qwen/i, 128_000], // fallback
+    // --- 小米 mimo ---
+    [/^mimo/i, 128_000],
+    // --- Moonshot (Kimi) ---
+    [/^kimi-/i, 256_000], // Kimi K2 系列
+    [/^moonshot-/i, 128_000], // moonshot-v1-{8k,32k,128k}
+];
+export function getModelContextWindow(modelName) {
+    const override = process.env.MODEL_CONTEXT_WINDOW;
+    if (override && /^\d+$/.test(override))
+        return Number(override);
+    if (!modelName)
+        return null;
+    for (const [re, n] of KNOWN)
+        if (re.test(modelName))
+            return n;
+    return null;
+}

package/dist/agent/context/token.js

@@ -0,0 +1,30 @@
+import chalk from 'chalk';
+const WARN_THRESHOLD = 80;
+const DANGER_THRESHOLD = 90;
+function ratioOf(usage, contextWindow) {
+    if (contextWindow == null || contextWindow <= 0)
+        return null;
+    return (usage.total_tokens / contextWindow) * 100;
+}
+// 渲染一行 footer：[tokens: <total> / <max> · <ratio>%]
+// ratio: < 70% dim，70~90% yellow，> 90% red；window 未知时整体 dim 且占比/上限均显示 ?
+export function formatTokenFooter(usage, contextWindow) {
+    const used = usage.total_tokens;
+    const max = contextWindow != null ? contextWindow.toLocaleString() : '?';
+    const ratio = ratioOf(usage, contextWindow);
+    const ratioStr = ratio != null ? `${ratio.toFixed(1)}%` : '?';
+    const color = ratio == null ? chalk.dim : ratio > 90 ? chalk.red : ratio > 70 ? chalk.yellow : chalk.dim;
+    return color(`[tokens: ${used.toLocaleString()} / ${max} · ${ratioStr}]`);
+}
+// 占比超过 80% 时返回两行警告，否则返回 null。
+// > 90% 用红色加粗加重，80~90% 用黄色加粗。
+export function formatTokenWarning(usage, contextWindow) {
+    const ratio = ratioOf(usage, contextWindow);
+    if (ratio == null || ratio <= WARN_THRESHOLD)
+        return null;
+    const color = ratio > DANGER_THRESHOLD ? chalk.red.bold : chalk.yellow.bold;
+    return [
+        color('[警告] Context window 接近大模型接口上限，即将压缩 Context，可能会丢失信息'),
+        color('       建议输入 /new 命令开启新会话'),
+    ].join('\n');
+}

package/dist/agent/hooks/config.js

@@ -0,0 +1,41 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { HookConfigSchema } from './types.js';
+export const HOOKS_CONFIG_PATH = path.join(os.homedir(), '.900', '900.json');
+// 从 ~/.900/900.json 读取 hooks 配置。永不抛错：
+//   - 文件不存在 → 返回零配置（首次启动/无 hooks 时静默）；
+//   - JSON 解析失败 → warn-log + 返回零配置；
+//   - 缺少 hooks 字段 → 返回零配置；
+//   - Zod 校验失败 → warn-log + 返回零配置。
+// 配置每次调用都重读一遍，换"编辑即生效"。
+export function loadHooksConfig() {
+    let raw;
+    try {
+        raw = fs.readFileSync(HOOKS_CONFIG_PATH, 'utf8');
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 'ENOENT')
+            return { hooks: {} };
+        console.warn(`[hooks] failed to read ${HOOKS_CONFIG_PATH}: ${err.message}; treating as no hooks`);
+        return { hooks: {} };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        console.warn(`[hooks] invalid JSON in ${HOOKS_CONFIG_PATH}: ${err.message}; treating as no hooks`);
+        return { hooks: {} };
+    }
+    const hooks = parsed?.hooks;
+    if (!hooks)
+        return { hooks: {} };
+    const result = HookConfigSchema.safeParse({ hooks });
+    if (!result.success) {
+        console.warn(`[hooks] ${HOOKS_CONFIG_PATH} hooks field does not match the expected schema: ${result.error.message}; treating as no hooks`);
+        return { hooks: {} };
+    }
+    return result.data;
+}

package/dist/agent/hooks/core.js

@@ -0,0 +1,177 @@
+// core.ts — 5 个 hook event 共用的 fork / 缓冲 / exit code 映射 / 调度逻辑。
+// 各 event 的语义包装见 pre-tool-use.ts / post-tool-use.ts / session-start.ts /
+// user-prompt-submit.ts / stop.ts；公共 API 全部从 index.ts 桶导出。
+import { spawn } from 'node:child_process';
+import chalk from 'chalk';
+import { loadHooksConfig } from './config.js';
+let DEFAULT_TIMEOUT_MS = 30_000;
+const MAX_BUFFER = 1024 * 1024;
+const ENV_EVENT = 'ARGOS_HOOK_EVENT';
+const ENV_THREAD_ID = 'ARGOS_HOOK_THREAD_ID';
+export function __setDefaultTimeoutMsForTesting(ms) {
+    DEFAULT_TIMEOUT_MS = ms;
+}
+function matches(matcher, name) {
+    if (!matcher || matcher === '*')
+        return true;
+    return name.includes(matcher);
+}
+function resolveEntries(config, event, toolName) {
+    const entries = config.hooks[event] ?? [];
+    if (event === 'PreToolUse' || event === 'PostToolUse') {
+        return entries.filter((e) => matches(e.matcher, toolName ?? ''));
+    }
+    return entries;
+}
+function runOneCommand(command, stdinPayload, timeoutMs, event, threadId) {
+    return new Promise((resolve) => {
+        const child = spawn('/bin/sh', ['-c', command], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: {
+                ...process.env,
+                [ENV_EVENT]: event,
+                [ENV_THREAD_ID]: threadId,
+            },
+        });
+        let stdout = '';
+        let stdoutTruncated = false;
+        let stderr = '';
+        let stderrTruncated = false;
+        // stdout / stderr 同样缓冲。block 语义只用 stderr，但 verbose hook 要看两者。
+        child.stdout.on('data', (chunk) => {
+            if (stdoutTruncated)
+                return;
+            const s = chunk.toString();
+            const remaining = MAX_BUFFER - stdout.length;
+            if (remaining <= 0) {
+                stdoutTruncated = true;
+                return;
+            }
+            if (s.length > remaining) {
+                stdout += s.slice(0, remaining) + '…';
+                stdoutTruncated = true;
+            }
+            else {
+                stdout += s;
+            }
+        });
+        child.stderr.on('data', (chunk) => {
+            if (stderrTruncated)
+                return;
+            const s = chunk.toString();
+            const remaining = MAX_BUFFER - stderr.length;
+            if (remaining <= 0) {
+                stderrTruncated = true;
+                return;
+            }
+            if (s.length > remaining) {
+                stderr += s.slice(0, remaining) + '…';
+                stderrTruncated = true;
+            }
+            else {
+                stderr += s;
+            }
+        });
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill('SIGKILL');
+        }, timeoutMs);
+        child.on('error', (err) => {
+            clearTimeout(timer);
+            resolve({ exitCode: null, stdout, stderr: stderr + err.message, signal: null, timedOut: false });
+        });
+        child.on('close', (code, signal) => {
+            clearTimeout(timer);
+            if (timedOut) {
+                resolve({
+                    exitCode: null,
+                    stdout,
+                    stderr: (stderr ? stderr + '\n' : '') + 'hook timed out after ' + timeoutMs + 'ms',
+                    signal: 'SIGKILL',
+                    timedOut: true,
+                });
+                return;
+            }
+            resolve({ exitCode: code, stdout, stderr, signal, timedOut: false });
+        });
+        try {
+            child.stdin.write(stdinPayload);
+            child.stdin.end();
+        }
+        catch {
+            // EPIPE / closed stream
+        }
+    });
+}
+function mapExitCode(result, command) {
+    // mapExitCode 只用 stderr；stdout 留给 verbose 路径自己打印。
+    const code = result.exitCode;
+    const trimmedStderr = result.stderr.trim();
+    if (result.timedOut) {
+        return { error: { message: 'hook timed out: ' + command } };
+    }
+    if (code === 0)
+        return {};
+    if (code === 1) {
+        return { block: { message: trimmedStderr || 'Blocked by hook' } };
+    }
+    if (code === 2) {
+        return { additionalContext: trimmedStderr };
+    }
+    if (code === null) {
+        return { error: { message: 'hook failed to spawn: ' + command } };
+    }
+    return { error: { message: 'hook exited with code ' + code + ': ' + command } };
+}
+// 公共入口：跑一个 event 的所有匹配 hook，合并结果。
+//   - 第一个 exit 1 → block 短路，后面的 hook 不再跑
+//   - exit 2 的 additionalContext 累加（多 hook 都能注入）
+//   - error 不短路，但聚合到结果里（runner 自己 warn-log）
+export async function runHook(event, input) {
+    const config = loadHooksConfig();
+    const toolName = input.event === 'PreToolUse' || input.event === 'PostToolUse' ? input.tool.name : undefined;
+    const entries = resolveEntries(config, event, toolName);
+    if (entries.length === 0)
+        return {};
+    const stdinPayload = JSON.stringify(input);
+    let blockMessage;
+    const contexts = [];
+    const errors = [];
+    for (const entry of entries) {
+        if (blockMessage)
+            break;
+        const raw = await runOneCommand(entry.command, stdinPayload, entry.timeoutMs ?? DEFAULT_TIMEOUT_MS, event, input.threadId);
+        // 每次 hook 跑完都把捕获的 stdout/stderr 打到主进程 console，
+        // 让用户能在终端直接看到 hook 在跑。command 自身不重复打（hooks.json 里已写明）。
+        // 格式对齐 tool_logger：`\n[Hook] <event> output: <content>`，独立成行。
+        // 颜色用 magenta 与 tool 的 cyan 区分——hook 是用户配置的扩展点，
+        // 同 cyan tool/blue AI 视觉上属于"系统元动作"一类，不抢眼也不警示。
+        const combined = (raw.stdout + raw.stderr).trim();
+        if (combined) {
+            console.log(`\n${chalk.dim.magenta('[Hook]')} ${chalk.magenta(event)} ${chalk.dim('output:')} ${chalk.yellow(combined)}`);
+        }
+        const mapped = mapExitCode(raw, entry.command);
+        if (mapped.error) {
+            console.warn('[hooks] ' + event + ' hook error: ' + mapped.error.message);
+            errors.push(mapped.error.message);
+            continue;
+        }
+        if (mapped.block) {
+            blockMessage = mapped.block.message;
+            break;
+        }
+        if (mapped.additionalContext) {
+            contexts.push(mapped.additionalContext);
+        }
+    }
+    const out = {};
+    if (blockMessage)
+        out.block = { message: blockMessage };
+    if (contexts.length > 0)
+        out.additionalContext = contexts.join('\n\n');
+    if (errors.length > 0 && !blockMessage) {
+        out.error = { message: errors.join('; ') };
+    }
+    return out;
+}

package/dist/agent/hooks/events/index.js

@@ -0,0 +1,9 @@
+// 5 个 per-event hook wrapper 的公共 API 桶。
+// 每个 event 的语义说明见各自的文件：
+//   pre-tool-use-hook.ts / post-tool-use-hook.ts / session-start-hook.ts /
+//   user-prompt-submit-hook.ts / stop-hook.ts
+export { runPreToolUseHooks } from './pre-tool-use-hook.js';
+export { runPostToolUseHooks } from './post-tool-use-hook.js';
+export { runSessionStartHook } from './session-start-hook.js';
+export { runUserPromptSubmitHook } from './user-prompt-submit-hook.js';
+export { runStopHook } from './stop-hook.js';

package/dist/agent/hooks/events/post-tool-use-hook.js

@@ -0,0 +1,7 @@
+// PostToolUse hook — 跑在 tool 成功返回之后、ToolMessage 写入之前。
+// 退出码：
+//   0 继续；1 此时无意义（tool 已跑，runner 内部 warn-log，不写入）；2 把 stderr 注入到 ToolMessage 之后。
+import { runHook } from '../core.js';
+export async function runPostToolUseHooks(input) {
+    return runHook('PostToolUse', input);
+}

package/dist/agent/hooks/events/pre-tool-use-hook.js

@@ -0,0 +1,8 @@
+// PreToolUse hook — 跑在工具调用通过硬编码 permission 之后、真正 invoke 之前。
+// 退出码：
+//   0 继续；1 拦下当前 tool（stderr 作为 block message，并停止当前 agent turn）；2 把 stderr 注入到 ToolMessage 之后。
+// 位置：硬编码 permission 之后，hook 永远不能解除硬编码 block——这是安全设计。
+import { runHook } from '../core.js';
+export async function runPreToolUseHooks(input) {
+    return runHook('PreToolUse', input);
+}

package/dist/agent/hooks/events/session-start-hook.js

@@ -0,0 +1,8 @@
+// SessionStart hook — 会话开始时跑一次（仅在 runAgentStream 非 resume 路径）。
+// 退出码：
+//   0 继续；2 把 stderr 作为 additionalContext 拼到 userMessage 顶部。
+// 1 拦下当前 session 启动——目前未用，留作未来。
+import { runHook } from '../core.js';
+export async function runSessionStartHook(input) {
+    return runHook('SessionStart', input);
+}

package/dist/agent/hooks/events/stop-hook.js

@@ -0,0 +1,10 @@
+// Stop hook — 会话结束时跑一次。触发时机：
+//   - runAgentStream 的 finally 块（reason: 'completed' | 'aborted'，由 ESC 中断切换）
+//   - CLI 的 exit 分支（reason: 'exit'）
+//   - CLI 的 /new 或 /rewind 切到新 session 之前（reason: 'new-session'，用旧 threadId）
+// 退出码：
+//   0 继续（其它值 runner 会 warn-log，不影响主流程）。
+import { runHook } from '../core.js';
+export async function runStopHook(input) {
+    return runHook('Stop', input);
+}

package/dist/agent/hooks/events/user-prompt-submit-hook.js

@@ -0,0 +1,7 @@
+// UserPromptSubmit hook — 跑在 readline 收到用户输入之后、slash dispatch / agent 之前。
+// 退出码：
+//   0 继续；1 拦下当前 prompt（stderr 打印到 stdout 给用户看，不进 agent）；2 注入上下文。
+import { runHook } from '../core.js';
+export async function runUserPromptSubmitHook(input) {
+    return runHook('UserPromptSubmit', input);
+}

package/dist/agent/hooks/index.js

@@ -0,0 +1,7 @@
+// 公共 API 桶。caller 应从这里 import：
+//   import { runPreToolUseHooks, type PreToolUseInput } from '../../agent/hooks/index.js';
+// 5 个 event 的 wrapper 在 events/ 子目录里，公共 API 转发自那里；
+// 每个 wrapper 的语义说明见 events/<name>-hook.ts。
+export { runPreToolUseHooks, runPostToolUseHooks, runSessionStartHook, runUserPromptSubmitHook, runStopHook, } from './events/index.js';
+export { runHook, __setDefaultTimeoutMsForTesting } from './core.js';
+export { loadHooksConfig, HOOKS_CONFIG_PATH } from './config.js';