pigpig-agent 1.0.0

package/.skills/code-review/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: code-review
+description: "以高级工程师的视角审查项目代码，检测 SOLID 违规、安全风险、性能隐患"
+whenToUse: "当用户要求审查代码、review 代码、或检查代码质量"
+---
+
+# Code Review
+
+## 审查流程
+
+**1) 确定审查范围**
+
+先问用户要审查哪部分代码。如果用户没指定，用 `list_directory` 看一下 `src/` 的目录结构，让用户选一个模块。不要一次审查整个项目——聚焦到具体的目录或文件。
+
+**2) 逐文件阅读和审查**
+
+用 `read_file` 读取目标模块的源码文件，关注以下问题：
+- **SRP**：一个模块是不是干了太多不相关的事
+- **OCP**：新功能是靠修改已有代码实现的，还是通过扩展点
+- **DIP**：高层逻辑是不是直接依赖了低层实现
+
+如果建议重构，说清楚为什么能改善内聚/耦合，并给出最小改动方案。
+
+**3) 安全扫描**
+
+检查常见风险：
+- 注入漏洞（SQL/命令/XSS）
+- 认证/授权缺口
+- 密钥泄漏（硬编码在代码里的 API Key、Token）
+- 竞态条件
+
+**4) 代码质量**
+
+- 错误处理：有没有吞异常、catch 太宽泛、async 错误没处理
+- 性能：N+1 查询、热路径上的重计算、缺少缓存
+- 边界条件：null/undefined、空集合、数字溢出
+
+## 输出格式
+
+按 P0（必须修复）、P1（建议修复）、P2（可以改进）分级输出。
+每个发现标注文件:行号和具体建议。
+默认只输出审查结果，不直接改代码——除非用户明确要求。

package/dist/agent/loop-detection.js

@@ -0,0 +1,135 @@
+// 死循环检测
+import { createHash } from 'node:crypto';
+// 配置
+const HISTORY_SIZE = 30; // 滑动窗口 最近30轮
+const WARNING_THRESHOLD = 5; // 警告阈值，超过就向大模型注入提示警告
+const CRITICAL_THRESHOLD = 8; // 严重阈值，超过就直接停止工具调用
+const BREAKER_THRESHOLD = 10; // 熔断阈值，超过就直接停止循环
+// 指纹计算
+function stableStringify(value) {
+    if (value === null || typeof value !== 'object') {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map(stableStringify).join(',')}]`; // ['xxx,yyy']
+    }
+    const keys = Object.keys(value).sort();
+    return `{${keys.map(k => `${JSON.stringify(k)}:${stableStringify(value[k])}`).join(',')}}`;
+}
+function hash(input) {
+    return createHash('sha256').update(input).digest('hex').slice(0, 16);
+}
+export function hashToolCall(toolName, params) {
+    return `${toolName}:${hash(stableStringify(params))}`;
+}
+export function hashResult(result) {
+    return hash(stableStringify(result));
+}
+//  滑动窗口
+const history = [];
+export function recordCall(toolName, params) {
+    history.push({
+        toolName,
+        argsHash: hashToolCall(toolName, params),
+        timestamp: Date.now(),
+    });
+    if (history.length > HISTORY_SIZE) {
+        history.shift();
+    }
+}
+export function recordResult(toolName, params, result) {
+    const argsHash = hashToolCall(toolName, params);
+    const resultH = hashResult(result);
+    for (let i = history.length - 1; i >= 0; i--) {
+        if (history[i].toolName === toolName && history[i].argsHash === argsHash && !history[i].resultHash) {
+            history[i].resultHash = resultH;
+            break;
+        }
+    }
+}
+export function resetHistory() {
+    history.length = 0;
+}
+// 检测器
+function getNoProgressStreak(toolName, argsHash) {
+    let streak = 0;
+    let lastResultHash;
+    for (let i = history.length - 1; i >= 0; i--) {
+        const r = history[i];
+        if (r.toolName !== toolName || r.argsHash !== argsHash)
+            continue;
+        if (!r.resultHash)
+            continue;
+        if (!lastResultHash) {
+            lastResultHash = r.resultHash;
+            streak = 1;
+            continue;
+        }
+        if (r.resultHash !== lastResultHash)
+            break;
+        streak++;
+    }
+    return streak;
+}
+function getPingPongCount(currentHash) {
+    if (history.length < 3)
+        return 0;
+    const last = history[history.length - 1];
+    let otherHash;
+    for (let i = history.length - 2; i >= 0; i--) {
+        if (history[i].argsHash !== last.argsHash) {
+            otherHash = history[i].argsHash;
+            break;
+        }
+    }
+    if (!otherHash)
+        return 0;
+    let count = 0;
+    for (let i = history.length - 1; i >= 0; i--) {
+        const expected = count % 2 === 0 ? last.argsHash : otherHash;
+        if (history[i].argsHash !== expected)
+            break;
+        count++;
+    }
+    if (currentHash === otherHash && count >= 2)
+        return count + 1;
+    return 0;
+}
+// --- 主检测函数 ---
+export function detect(toolName, params) {
+    const argsHash = hashToolCall(toolName, params);
+    const noProgress = getNoProgressStreak(toolName, argsHash);
+    if (noProgress >= BREAKER_THRESHOLD) {
+        return {
+            stuck: true, level: 'critical', detector: 'global_circuit_breaker', count: noProgress,
+            message: `[熔断] ${toolName} 已重复 ${noProgress} 次且无进展，强制停止`
+        };
+    }
+    const pingPong = getPingPongCount(argsHash);
+    if (pingPong >= CRITICAL_THRESHOLD) {
+        return {
+            stuck: true, level: 'critical', detector: 'ping_pong', count: pingPong,
+            message: `[熔断] 检测到乒乓循环（${pingPong} 次交替），强制停止`
+        };
+    }
+    if (pingPong >= WARNING_THRESHOLD) {
+        return {
+            stuck: true, level: 'warning', detector: 'ping_pong', count: pingPong,
+            message: `[警告] 检测到乒乓循环（${pingPong} 次交替），建议换个思路`
+        };
+    }
+    const recentCount = history.filter(h => h.toolName === toolName && h.argsHash === argsHash).length;
+    if (recentCount >= CRITICAL_THRESHOLD) {
+        return {
+            stuck: true, level: 'critical', detector: 'generic_repeat', count: recentCount,
+            message: `[熔断] ${toolName} 相同参数已调用 ${recentCount} 次，强制停止`
+        };
+    }
+    if (recentCount >= WARNING_THRESHOLD) {
+        return {
+            stuck: true, level: 'warning', detector: 'generic_repeat', count: recentCount,
+            message: `[警告] ${toolName} 相同参数已调用 ${recentCount} 次，你可能陷入了重复`
+        };
+    }
+    return { stuck: false };
+}

package/dist/agent/loop.js

@@ -0,0 +1,123 @@
+import { streamText } from "ai";
+import { detect, resetHistory, recordCall, recordResult } from './loop-detection.js';
+import { isRetryable, calculateDelay, sleep } from './retry.js';
+import { normalizeUsage } from "../usage/tracker.js";
+const MAX_STEPS = 50; // 最大循环次数
+const MAX_RETRIES = 3; // 最大重试次数
+const TOKEN_BUDGET = 500000; // 最大token用量
+export async function agentLoop(model, registry, messages, system, tracker) {
+    let step = 0; // 当前这轮的循环次数
+    let totalTokens = 0; // 总token用量
+    resetHistory(); // 重置工具执行的历史记录
+    while (step < MAX_STEPS) {
+        step++;
+        console.log(`\n--- Step ${step} ---`);
+        let hasToolCall = false; // 当前这轮是否有工具调用
+        let fullText = ''; // 当前这轮的模型输出
+        let shouldBreak = false; // 是否需要熔断
+        let lastToolCall = null; // 最后一个工具调用记录
+        let stepResponse; // 当前这轮的模型输出
+        let stepUsage; // 当前这轮的token用量
+        // 步骤重试：应该包裹 streamText 和 result 的处理
+        for (let attempt = 1;; attempt++) {
+            try {
+                const result = streamText({
+                    model,
+                    tools: registry.toAISDKFormat(),
+                    messages,
+                    system,
+                    maxRetries: 0, // 不配置重试，就只会跑一次
+                    onError: () => { },
+                    providerOptions: { openai: { parallelCalls: true } } // 开启并行调用，提高效率
+                    // 不配置 stopwhen，就只会跑一次
+                });
+                for await (const part of result.fullStream) { // fullStream 是ai库生成一个水桶，里面装的是模型的输出，并且当工具调用完毕后会自动的将结果添加到水桶中
+                    switch (part.type) {
+                        case 'text-delta':
+                            process.stdout.write(part.text);
+                            fullText += part.text;
+                            break;
+                        case 'tool-call':
+                            hasToolCall = true;
+                            lastToolCall = { name: part.toolName, input: part.input };
+                            console.log(`\n  [调用: ${part.toolName}(${JSON.stringify(part.input)})]`);
+                            // 检测是否需要熔断或警告
+                            const detection = detect(part.toolName, part.input);
+                            if (detection.stuck) { // 至少到了危险警告阶段
+                                console.log(` ${detection.message}`);
+                                if (detection.level === 'critical') { // 直接熔断
+                                    shouldBreak = true;
+                                }
+                                else {
+                                    messages.push({
+                                        role: 'user',
+                                        content: `[系统提醒] ${detection.message}，请换一个思路解决问题，不要重复同样的操作。`,
+                                    });
+                                }
+                            }
+                            recordCall(part.toolName, part.input); // 记录当前这次的工具调用
+                            break;
+                        case 'tool-result':
+                            const output = typeof part.output == 'string' ? part.output : JSON.stringify(part.output);
+                            const preview = output.length > 120 ? output.slice(0, 120) + '...' : output;
+                            console.log(`[结果: ${part.toolName}] ${preview}`);
+                            // 记录工具调用结果指纹
+                            if (lastToolCall) {
+                                recordResult(lastToolCall.name, lastToolCall.input, output);
+                            }
+                            break;
+                    }
+                }
+                stepResponse = await result.response;
+                stepUsage = await result.usage; // 从LLM获取当前这轮的token用量
+                break;
+            }
+            catch (error) {
+                if (attempt > MAX_RETRIES || !isRetryable(error))
+                    throw error;
+                const delay = calculateDelay(attempt);
+                console.log(`[重试]第${attempt}/${MAX_RETRIES}次失败，${delay}ms 后重试`);
+                await sleep(delay);
+                hasToolCall = false;
+                fullText = '';
+                shouldBreak = false;
+                lastToolCall = null;
+            }
+        }
+        // 判断是否需要熔断
+        if (shouldBreak) {
+            console.log('\n [循环检测触发，Agent已停止]');
+            break;
+        }
+        messages.push(...stepResponse.messages);
+        // 把 useage 喂给 tracker，tracker内部会按四类 token 分别累计并计算 cost
+        const norm = normalizeUsage(stepUsage); // 把 从 AI SDK 返回的 usage 对象规范化成四类 token
+        const stepRecord = tracker?.record(model?.modelId || '', norm);
+        totalTokens += norm.inputTokens + norm.outputTokens + norm.cacheReadTokens + norm.cacheWriteTokens;
+        // cache 命中时打印简洁状态
+        if (stepRecord && (norm.cacheReadTokens > 0 || norm.cacheWriteTokens > 0)) {
+            const tag = norm.cacheReadTokens > 0 ? 'cache hit' : 'cache miss';
+            const detail = norm.cacheReadTokens > 0 ? `read ${norm.cacheReadTokens}` : `write ${norm.cacheWriteTokens}`;
+            console.log(`  [${tag}] ${detail} tokens  ~ 本步骤 $ ${stepRecord.cost.toFixed(5)}`);
+        }
+        if (totalTokens > TOKEN_BUDGET * 0.9) {
+            console.log(` [Token 预算] 已使用 ${totalTokens} / ${TOKEN_BUDGET}，(${Math.round((totalTokens / TOKEN_BUDGET) * 100)}%)`);
+        }
+        // 检查是否超过预算
+        if (totalTokens > TOKEN_BUDGET) {
+            console.log(`\n [Token 预算耗尽，强制停止]`);
+            break;
+        }
+        // 退出条件
+        if (!hasToolCall) {
+            if (fullText)
+                console.log();
+            break;
+        }
+        // 还有工具调用，继续循环
+        console.log(' --> 模型还在工作，继续下一步...');
+    }
+    if (step >= MAX_STEPS) {
+        console.log('循环次数超过最大限制，退出循环。');
+    }
+}

package/dist/agent/retry.js

@@ -0,0 +1,39 @@
+// 判断是否值得重试
+export function isRetryable(error) {
+    if (!(error instanceof Error))
+        return false;
+    const message = error.message || '';
+    // http 状态码判断
+    const statusMatch = message.match(/(\d{3})/);
+    if (statusMatch) {
+        const status = parseInt(statusMatch[1]);
+        if ([429, 529, 408].includes(status))
+            return true;
+        if (status >= 500 && status < 600)
+            return true; // 服务器错误 LLM 错误
+        if (status >= 400 && status < 500)
+            return false; // 客户端错误 
+    }
+    // 网络错误
+    if (message.includes('ECONNRESET') || message.includes('EPIPE'))
+        return true;
+    if (message.includes('ETIMEDOUT') || message.includes('timeout'))
+        return true;
+    if (message.includes('fetch failed') || message.includes('network'))
+        return true;
+    // AI SDK 会把流式错误包装成 NoOutputGeneratedError
+    if (message.includes('No output generated'))
+        return true;
+    return false;
+}
+// 指数退避 + 随机抖动
+export function calculateDelay(attempt, baseMs = 500, maxMs = 30000) {
+    const exponential = baseMs * Math.pow(2, attempt - 1);
+    const capped = Math.min(exponential, maxMs);
+    const jitterRange = capped * 0.25;
+    const jittered = capped + (Math.random() * 2 - 1) * jitterRange;
+    return Math.max(0, Math.round(jittered));
+}
+export function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}

package/dist/agents/registry.js

@@ -0,0 +1,59 @@
+/**
+ * 一个简单的注册表
+ * 记录谁在跑
+ * 跑到哪里了
+ * 结果是什么
+ */
+import { DEFAULT_CONFIG } from './types.js';
+export class SubAgentRegistry {
+    runs = new Map();
+    config = DEFAULT_CONFIG;
+    idCounter = 0;
+    constructor(config) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    generateId() {
+        return `sub-${++this.idCounter}-${Date.now().toString(36).slice(-4)}`;
+    }
+    canSpawn(currentDepth) {
+        if (currentDepth >= this.config.maxSpawnDepth) {
+            return { ok: false, reason: `已到达嵌套深度${this.config.maxSpawnDepth}` };
+        }
+        const activeCount = this.getActiveRuns().length;
+        if (activeCount >= this.config.maxConcurrent) {
+            return { ok: false, reason: `已到达最大并行子Agent数${this.config.maxConcurrent}` };
+        }
+        return { ok: true };
+    }
+    register(run) {
+        this.runs.set(run.id, run);
+    }
+    complete(id, result) {
+        const run = this.runs.get(id);
+        if (!run)
+            return;
+        run.status = 'completed';
+        run.finishedAt = new Date().toISOString();
+        run.result = result;
+    }
+    fail(id, error) {
+        const run = this.runs.get(id);
+        if (!run)
+            return;
+        run.status = 'error';
+        run.finishedAt = new Date().toISOString();
+        run.error = error;
+    }
+    get(id) {
+        return this.runs.get(id);
+    }
+    getActiveRuns() {
+        return [...this.runs.values()].filter(run => run.status === 'running');
+    }
+    getAllRuns() {
+        return [...this.runs.values()];
+    }
+    getConfig() {
+        return this.config;
+    }
+}

package/dist/agents/spawn.js

@@ -0,0 +1,124 @@
+import { streamText } from "ai";
+const EXCLUDED_TOOLS = new Set(['spawn_agent']); // 不允许子Agent调用spawn_agent工具
+const AGENT_COLORS = [
+    '\x1b[36m', // cyan
+    '\x1b[33m', // yellow
+    '\x1b[35m', // magenta
+    '\x1b[32m', // green
+    '\x1b[34m', // blue
+];
+const RESET = '\x1b[0m';
+function agentTag(index, runId) {
+    const color = AGENT_COLORS[index % AGENT_COLORS.length];
+    return `${color}[Agent-${index + 1}: ${runId}]${RESET}`;
+}
+export async function spawnAgent(request, ctx, index = 0) {
+    const { ok, reason } = ctx.agentRegistry.canSpawn(ctx.currentDepth);
+    if (!ok)
+        return `[spawn] 拒绝: ${reason}`;
+    const runId = ctx.agentRegistry.generateId();
+    const tag = agentTag(index, runId);
+    const run = {
+        id: runId,
+        task: request.task,
+        status: 'running',
+        depth: ctx.currentDepth + 1,
+        startedAt: new Date().toISOString(),
+    };
+    ctx.agentRegistry.register(run);
+    const timeout = request.timeout || 60000;
+    const maxSteps = 30;
+    const ac = new AbortController(); // 用于取消子Agent运行
+    console.log(` ${tag}启动：${request.task.slice(0, 50)}`);
+    // 关键：独立的messages
+    const messages = [
+        { role: 'user', content: request.task }
+    ];
+    try {
+        const system = ctx.buildSystem() +
+            '\n\n[子 Agent 模式] 你是一个被派出去执行具体任务的子 Agent。直接完成任务并输出结论，保持简洁。' +
+            '\n当你需要同时获取多个独立信息时（比如读多个文件、搜多个关键词），尽可能在一次回复中并行调用多个工具，不要一个个串行调。';
+        // 不能跟父Agent共用一个 Agent Loop 
+        const tools = ctx.registry.toAISDKFormatUnlocked(EXCLUDED_TOOLS);
+        const timer = setTimeout(() => { ac.abort(); }, timeout); // 超时取消子Agent运行
+        try {
+            let step = 0;
+            while (step < maxSteps) {
+                step++;
+                const isLastStep = step === maxSteps;
+                console.log(`  ${tag} Step ${step}/${maxSteps}${isLastStep ? ' (总结)' : ''}`);
+                if (isLastStep) {
+                    messages.push({ role: 'user', content: '你已经收集了足够的信息。请直接输出文字总结，不要再调用任何工具。' });
+                }
+                const result = streamText({
+                    model: ctx.model, system,
+                    tools,
+                    toolChoice: isLastStep ? 'none' : 'auto',
+                    messages,
+                    maxRetries: 0, abortSignal: ac.signal,
+                    providerOptions: { openai: { parallelToolCalls: true } },
+                    onError: () => { },
+                });
+                let hasToolCall = false;
+                for await (const part of result.fullStream) {
+                    if (part.type === 'tool-call') {
+                        hasToolCall = true;
+                        const argsPreview = JSON.stringify(part.input).slice(0, 80);
+                        console.log(`  ${tag} 调用 ${part.toolName}(${argsPreview})`);
+                    }
+                }
+                const response = await result.response;
+                messages.push(...response.messages);
+                if (!hasToolCall)
+                    break;
+            }
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        // 提取最后一条assistant回复
+        const lastAssistant = [...messages].reverse().find(m => m.role === 'assistant');
+        let result = '(无输出)';
+        if (lastAssistant) {
+            if (typeof lastAssistant.content === 'string') {
+                result = lastAssistant.content;
+            }
+            else if (Array.isArray(lastAssistant.content)) {
+                result = lastAssistant.content
+                    .filter((p) => p.type === 'text')
+                    .map((p) => p.text)
+                    .join('');
+            }
+        }
+        ctx.agentRegistry.complete(runId, result);
+        console.log(` ${tag} 完成 √ (${result.length}) 字符`);
+        return result;
+    }
+    catch (err) {
+        const isAbort = err.name === 'AbortError' || ac.signal.aborted;
+        const errorMsg = isAbort ? `执行超时 (${timeout / 1000}s)` : (err.message || String(err));
+        ctx.agentRegistry.fail(runId, errorMsg);
+        console.log(`  ${tag} ${isAbort ? '超时' : '失败'} ✗: ${errorMsg}`);
+        if (isAbort) {
+            const partial = [...messages].reverse().find(m => m.role === 'assistant');
+            if (partial) {
+                const text = typeof partial.content === 'string' ? partial.content
+                    : Array.isArray(partial.content)
+                        ? partial.content.filter((p) => p.type === 'text').map((p) => p.text).join('')
+                        : '';
+                if (text)
+                    return `[部分结果] ${text}`; // 子Agent执行超时，返回部分结果
+            }
+        }
+        return `[sub-agent 执行失败] ${errorMsg}`;
+    }
+}
+export async function spawnParallel(requests, ctx) {
+    console.log(`\n  ┌─ 派发 ${requests.length} 个子 Agent 并行执行 ─┐`);
+    const results = await Promise.all(requests.map(async (req, i) => {
+        const result = await spawnAgent(req, ctx, i); // 并行执行每个子Agent
+        return { task: req.task, result };
+    }));
+    console.log(`  └─ 全部完成 (${results.length}/${requests.length}) ─┘\n`);
+    return results;
+}

package/dist/agents/types.js

@@ -0,0 +1,5 @@
+export const DEFAULT_CONFIG = {
+    maxSpawnDepth: 1,
+    maxConcurrent: 3,
+    defaultTimeout: 600000,
+};

package/dist/commands/agent.js

@@ -0,0 +1,33 @@
+export function createAgentCommands(agentRegistry) {
+    const handler = (cmd) => {
+        if (!cmd.startsWith('/agents'))
+            return false;
+        const runs = agentRegistry.getAllRuns();
+        if (runs.length === 0) {
+            console.log('  暂无子 Agent 记录');
+        }
+        else {
+            const active = runs.filter(r => r.status === 'running');
+            const completed = runs.filter(r => r.status === 'completed');
+            const failed = runs.filter(r => r.status === 'error');
+            console.log(`  子 Agent 记录 (${runs.length}):`);
+            for (const r of runs) {
+                const icon = r.status === 'running' ? '⟳'
+                    : r.status === 'completed' ? '✓'
+                        : '✗';
+                const detail = r.status === 'completed'
+                    ? `${r.result?.slice(0, 60)}...`
+                    : r.status === 'error'
+                        ? r.error
+                        : '执行中...';
+                console.log(`    ${icon} ${r.id} (depth=${r.depth}) — ${r.task.slice(0, 40)}`);
+                console.log(`      ${detail}`);
+            }
+            const config = agentRegistry.getConfig();
+            console.log(`\n  活跃: ${active.length}/${config.maxConcurrent} | 完成: ${completed.length} | 失败: ${failed.length}`);
+            console.log(`  最大深度: ${config.maxSpawnDepth} | 最大并发: ${config.maxConcurrent}`);
+        }
+        return true;
+    };
+    return [handler];
+}

package/dist/commands/context.js

@@ -0,0 +1,27 @@
+import { renderUsageView, buildContextSnapshot, renderContextView } from '../context/view.js';
+export const contextCommands = [
+    (cmd, ctx) => {
+        if (cmd !== '/context' && cmd !== 'context')
+            return false;
+        const SYSTEM = ctx.builder.build(ctx.makePromptCtx());
+        const memoryChars = ctx.memoryStore?.buildPromptSection().length ?? 0;
+        const snapshot = buildContextSnapshot({
+            modelName: process.env.DASHSCOPE_API_KEY ? 'Qwen Plus' : 'Mock Model (开发用)',
+            modelId: process.env.DASHSCOPE_API_KEY ? 'qwen3-6-plus' : 'mock-model',
+            windowTokens: 1_000_000,
+            systemPromptChars: SYSTEM.length,
+            toolDescriptionChars: ctx.registry.getActiveTools().reduce((a, t) => a + t.name.length + (t.description?.length || 0) + JSON.stringify(t.parameters || {}).length, 0),
+            memoryChars,
+            skillsChars: 0,
+            messages: ctx.messages,
+        });
+        console.log(renderContextView(snapshot));
+        return true;
+    },
+    (cmd, ctx) => {
+        if (cmd !== '/usage' && cmd !== 'usage')
+            return false;
+        console.log(renderUsageView(ctx.tracker));
+        return true;
+    },
+];

package/dist/commands/cron.js

@@ -0,0 +1,38 @@
+export function createCronCommands(cronService) {
+    const handler = (cmd) => {
+        if (!cmd.startsWith('/cron'))
+            return false;
+        const sub = cmd.slice(5).trim();
+        if (!sub || sub === 'list') {
+            const jobs = cronService.list();
+            if (jobs.length === 0) {
+                console.log('  暂无定时任务');
+            }
+            else {
+                console.log(`  定时任务 (${jobs.length}):`);
+                for (const j of jobs) {
+                    const icon = j.status === 'running' ? '⟳' : j.status === 'scheduled' ? '◉' : j.status === 'disabled' ? '○' : '·';
+                    console.log(`    ${icon} ${j.config.id} — ${j.config.name} [${j.config.schedule}] (${j.status})`);
+                }
+            }
+            return true;
+        }
+        if (sub === 'logs') {
+            const logs = cronService.getRecentLogs(undefined, 10);
+            if (logs.length === 0) {
+                console.log('  暂无执行记录');
+            }
+            else {
+                console.log('  最近执行记录:');
+                for (const l of logs) {
+                    const icon = l.status === 'success' ? '✓' : '✗';
+                    console.log(`    ${icon} ${l.jobId} @ ${l.startedAt} — ${l.output?.slice(0, 80) || l.error || ''}`);
+                }
+            }
+            return true;
+        }
+        console.log('  用法: /cron [list|logs]');
+        return true;
+    };
+    return [handler];
+}

package/dist/commands/debug.js

@@ -0,0 +1,44 @@
+import { estimateMessageTokens, applyDefense } from '../context/defense.js';
+export const debugCommands = [
+    (cmd, ctx) => {
+        if (cmd !== '模拟长对话' && cmd !== 'sim')
+            return false;
+        const now = Date.now();
+        console.log('\n[模拟] 注入 20 条历史消息（含大量工具结果）...');
+        for (let i = 0; i < 5; i++) {
+            const age = (20 - i * 4) * 60 * 1000;
+            const idx = ctx.messages.length;
+            ctx.messages.push({ role: 'user', content: `第 ${i + 1} 轮：帮我读文件 file-${i}.ts` });
+            ctx.timestamps.set(idx, now - age);
+            ctx.messages.push({ role: 'assistant', content: [{ type: 'tool-call', toolCallId: `sim-${i}`, toolName: 'read_file', input: { path: `file-${i}.ts` } }] });
+            ctx.timestamps.set(idx + 1, now - age);
+            const bigContent = `// file-${i}.ts\n` + 'export function handler() {\n  // ...\n}\n'.repeat(200);
+            ctx.messages.push({ role: 'tool', content: [{ type: 'tool-result', toolCallId: `sim-${i}`, toolName: 'read_file', output: bigContent }] });
+            ctx.timestamps.set(idx + 2, now - age);
+            ctx.messages.push({ role: 'assistant', content: [{ type: 'text', text: `文件 file-${i}.ts 的内容已读取。` }] });
+            ctx.timestamps.set(idx + 3, now - age);
+        }
+        console.log(`[模拟完成] ${ctx.messages.length} 条消息, ~${estimateMessageTokens(ctx.messages)} tokens\n`);
+        return true;
+    },
+    (cmd, ctx) => {
+        if (cmd !== '执行防线' && cmd !== 'defend')
+            return false;
+        console.log('\n--- 执行三层防线 ---');
+        const before = estimateMessageTokens(ctx.messages);
+        const def = applyDefense(ctx.messages, ctx.timestamps);
+        ctx.messages = def.messages;
+        console.log(`  [Layer 2] 截断: ${def.truncated} 条, 预算清理: ${def.compacted} 条`);
+        console.log(`  [Layer 3] 软修剪: ${def.softPruned}, 硬清除: ${def.hardPruned}`);
+        console.log(`  [结果] ~${before} → ~${def.tokenEstimate} tokens (节省 ${before - def.tokenEstimate})\n`);
+        return true;
+    },
+    (cmd, ctx) => {
+        if (cmd !== 'status' && cmd !== '查看状态')
+            return false;
+        const tokens = estimateMessageTokens(ctx.messages);
+        const memCount = ctx.memoryStore?.list().length ?? 0;
+        console.log(`\n[状态] ${ctx.messages.length} 条消息, ~${tokens} tokens, ${memCount} 条记忆\n`);
+        return true;
+    },
+];