@qlingzzy/qling 1.0.0

package/dist/pipeline/hooks.js

@@ -0,0 +1,377 @@
+// ============================================================
+// 轻灵 - Pipeline Hook 系统（参考 Claude Code 5.x Hook 架构）
+// ============================================================
+import { PermissionMatrix } from "../guard/permissions.js";
+import { RateLimiter } from "../guard/rate-limit.js";
+import { appendGuardAudit } from "../guard.js";
+// --- 0. 动态工具选择器（<30 工具限制 + 场景路由）---
+const MAX_TOOLS_DEFAULT = 30;
+export class DynamicToolSelector {
+    allTools;
+    maxTools;
+    constructor(allTools, maxTools = MAX_TOOLS_DEFAULT) {
+        this.allTools = allTools;
+        this.maxTools = maxTools;
+    }
+    /**
+     * 根据场景选择工具子集。
+     * 策略：
+     * 1. activeScene 中声明的工具优先
+     * 2. 未声明场景的工具（通用工具如 read/write）始终保留
+     * 3. 按 priority 排序后截断到 maxTools
+     */
+    selectForScene(activeScene) {
+        if (this.allTools.length <= this.maxTools) {
+            return this.allTools;
+        }
+        const scored = this.allTools.map((tool) => {
+            let score = tool.priority ?? 5;
+            // 场景匹配加 20 分
+            if (tool.scenes?.includes(activeScene)) {
+                score += 20;
+            }
+            // 核心工具（read/write/bash）不受场景限制
+            const coreTools = ["read", "write", "bash"];
+            if (coreTools.includes(tool.name)) {
+                score += 50;
+            }
+            return { tool, score };
+        });
+        scored.sort((a, b) => b.score - a.score);
+        return scored.slice(0, this.maxTools).map((s) => s.tool);
+    }
+    /**
+     * 根据任务类型关键词选择工具。
+     * 关键词匹配 scenes 或 name。
+     */
+    selectByKeywords(keywords) {
+        if (this.allTools.length <= this.maxTools) {
+            return this.allTools;
+        }
+        const scored = this.allTools.map((tool) => {
+            let score = tool.priority ?? 5;
+            for (const kw of keywords) {
+                if (tool.name.includes(kw))
+                    score += 10;
+                if (tool.scenes?.some((s) => s.includes(kw)))
+                    score += 5;
+                if (tool.description.toLowerCase().includes(kw.toLowerCase()))
+                    score += 2;
+            }
+            return { tool, score };
+        });
+        scored.sort((a, b) => b.score - a.score);
+        return scored.slice(0, this.maxTools).map((s) => s.tool);
+    }
+    getAll() {
+        return this.allTools;
+    }
+    getCount() {
+        return this.allTools.length;
+    }
+}
+// --- 1. Dangerous Pattern Registry ---
+const BUILT_IN_DANGEROUS_PATTERNS = [
+    // 文件删除
+    /\brm\s+-rf\s+\//,
+    /\bdel\s+\/[sfq]\b/i,
+    /rmdir\s+\/[efqs]/i,
+    // 格式化
+    /\bformat\b.*\b[a-z]:/i,
+    /\bnewfs\b/,
+    // 权限修改
+    /\bchmod\s+777\b/,
+    /\bchmod\s+-R\s+777\b/,
+    // 网络相关
+    /\bwget\b.*\s--no-check-certificate/,
+    /\bcurl\b.*\s-k\b/,
+    // 提权
+    /\bsudo\s+su\b/,
+    /\bsu\s+-\b/,
+    // 危险管道
+    /\|.*\s*sh\b/,
+    /\|.*\s*bash\b/,
+    // 进程终止
+    /\bkill\s+-9\b/,
+    /\bpkill\s+-9\b/,
+    // 敏感文件
+    /\/etc\/passwd/,
+    /\/etc\/shadow/,
+    /\.ssh\/authorized_keys/,
+    // 内存修改
+    /\bdd\b.*\sif=.*\bof=\/dev/,
+];
+function matchDangerousPatterns(cmd, patterns) {
+    const allPatterns = [
+        ...BUILT_IN_DANGEROUS_PATTERNS,
+        ...patterns,
+    ];
+    const matched = [];
+    for (const p of allPatterns) {
+        const re = typeof p === "string" ? new RegExp(p) : p;
+        if (re.test(cmd)) {
+            matched.push(typeof p === "string" ? p : String(p));
+        }
+    }
+    return matched;
+}
+// --- 2. Speculative Classifier（3.2 节）---
+export class SpeculativeClassifier {
+    toolDefs;
+    constructor(toolDefs) {
+        this.toolDefs = toolDefs;
+    }
+    classify(toolCall) {
+        const def = this.toolDefs.find((t) => t.name === toolCall.name);
+        // bash 类工具才需要分类
+        if (toolCall.name !== "bash") {
+            return { label: "safe" };
+        }
+        const cmd = String(toolCall.arguments.command ?? "");
+        if (!cmd)
+            return { label: "safe" };
+        const matched = matchDangerousPatterns(cmd, def?.dangerousPatterns ?? []);
+        if (matched.length > 0) {
+            return {
+                label: "dangerous",
+                reason: `匹配危险模式: ${matched.join(", ")}`,
+                patterns: matched,
+            };
+        }
+        // 读操作风险低
+        if (def?.readOnly ||
+            /^\s*(ls|git\s+(status|log|diff)|cat|head|tail|grep|find|wc|echo|pwd)\s/.test(cmd)) {
+            return { label: "safe" };
+        }
+        // 写/删除操作需要询问（仅明确危险的操作才拦截）
+        // curl/wget GET 请求是只读的，不拦截
+        // tee / 追加写入属于中等风险，放宽判断
+        if (def?.destructive ||
+            /\b(del|rmdir|rm\s+-rf|mkfs|truncate\s+-s\s+0)\b/.test(cmd)) {
+            return { label: "ask" };
+        }
+        return { label: "safe" };
+    }
+}
+// --- 3. Hook Manager ---
+/** Plan 模式下禁止的写/执行类工具（OpenCode plan agent 语义） */
+export const PLAN_MODE_DENY_TOOLS = [
+    "write",
+    "patch",
+    "bash",
+    "subtask",
+    "browser_fetch",
+];
+export class HookManager {
+    preHooks = [];
+    postHooks = [];
+    failureHooks = [];
+    classifier;
+    permissionMatrix = null;
+    rateLimiter = null;
+    guardConfig = null;
+    planMode = false;
+    constructor(toolDefs, guardConfig) {
+        this.classifier = new SpeculativeClassifier(toolDefs);
+        if (guardConfig) {
+            this.guardConfig = guardConfig;
+            if (guardConfig.permissions) {
+                this.permissionMatrix = new PermissionMatrix(guardConfig.permissions.default, this.mergePermissionRules(guardConfig.permissions.rules));
+            }
+            if (guardConfig.rate_limit?.enabled) {
+                this.rateLimiter = new RateLimiter(guardConfig.rate_limit.max_per_minute);
+            }
+        }
+    }
+    planModeRules() {
+        return PLAN_MODE_DENY_TOOLS.map((tool) => ({
+            tool_pattern: tool,
+            decision: "deny",
+            reason: `Plan Mode: 工具 ${tool} 已禁用（只读规划）。使用 /plan off 退出。`,
+        }));
+    }
+    mergePermissionRules(baseRules = []) {
+        // plan 规则优先（放前面）
+        return this.planMode ? [...this.planModeRules(), ...baseRules] : baseRules;
+    }
+    rebuildPermissionMatrix() {
+        const defaultDecision = this.guardConfig?.permissions?.default ?? "allow";
+        const rules = this.mergePermissionRules(this.guardConfig?.permissions?.rules ?? []);
+        this.permissionMatrix = new PermissionMatrix(defaultDecision, rules);
+    }
+    isPlanMode() {
+        return this.planMode;
+    }
+    setPlanMode(enabled) {
+        this.planMode = Boolean(enabled);
+        this.rebuildPermissionMatrix();
+    }
+    getPermissionDefaultDecision() {
+        return this.guardConfig?.permissions?.default ?? "allow";
+    }
+    setPermissionDefaultDecision(decision) {
+        const currentRules = this.guardConfig?.permissions?.rules ?? [];
+        if (this.guardConfig) {
+            this.guardConfig.permissions = {
+                ...(this.guardConfig.permissions ?? { rules: [] }),
+                default: decision,
+                rules: currentRules,
+            };
+        }
+        this.rebuildPermissionMatrix();
+    }
+    register(name, handler) {
+        if (name === "PreToolUse")
+            this.preHooks.push(handler);
+        else if (name === "PostToolUse")
+            this.postHooks.push(handler);
+        else if (name === "PostToolUseFailure")
+            this.failureHooks.push(handler);
+    }
+    async runPreHook(ctx, sessionId) {
+        // 1. Permission matrix check (highest priority)
+        if (this.permissionMatrix && this.guardConfig) {
+            const permResult = this.permissionMatrix.evaluate(ctx.toolName);
+            if (permResult.decision === "deny") {
+                await appendGuardAudit(this.guardConfig, {
+                    tool: ctx.toolName,
+                    action: "deny",
+                    category: "permission",
+                    reason: permResult.reason ?? "denied by permission rule: " + (permResult.matched_rule ?? "default"),
+                });
+                return {
+                    decision: "deny",
+                    blockingError: permResult.reason ?? "工具权限拒绝: " + ctx.toolName,
+                    preventContinuation: true,
+                };
+            }
+            if (permResult.decision === "ask") {
+                await appendGuardAudit(this.guardConfig, {
+                    tool: ctx.toolName,
+                    action: "allow",
+                    category: "permission",
+                    reason: "ask triggered by rule: " + (permResult.matched_rule ?? "default"),
+                });
+                return {
+                    decision: "ask",
+                    additionalContexts: [permResult.reason ?? "工具需要确认: " + ctx.toolName],
+                };
+            }
+        }
+        // 2. Rate limit check
+        if (this.rateLimiter && sessionId) {
+            const rlResult = this.rateLimiter.check(ctx.toolName, sessionId);
+            if (!rlResult.allowed) {
+                if (this.guardConfig) {
+                    await appendGuardAudit(this.guardConfig, {
+                        tool: ctx.toolName,
+                        action: "deny",
+                        category: "rate_limit",
+                        reason: `rate limit exceeded, retry after ${rlResult.retryAfterMs}ms`,
+                    });
+                }
+                return {
+                    decision: "deny",
+                    blockingError: `速率限制: 工具 ${ctx.toolName} 调用过于频繁，请 ${Math.ceil((rlResult.retryAfterMs ?? 0) / 1000)}s 后重试`,
+                    preventContinuation: false,
+                };
+            }
+        }
+        // 3. Speculative classifier
+        const fakeCall = {
+            id: "speculative",
+            name: ctx.toolName,
+            arguments: ctx.arguments,
+        };
+        const classification = this.classifier.classify(fakeCall);
+        if (classification.label === "dangerous") {
+            return {
+                decision: "deny",
+                blockingError: classification.reason ?? "危险命令",
+                preventContinuation: true,
+            };
+        }
+        if (classification.label === "ask") {
+            return {
+                decision: "ask",
+                additionalContexts: classification.patterns
+                    ? [`⚠️ 匹配危险模式: ${classification.patterns.join(", ")}`]
+                    : ["⚠️ 这个操作可能具有破坏性"],
+            };
+        }
+        // 4. Custom pre-hooks
+        for (const handler of this.preHooks) {
+            const result = await handler(ctx);
+            if (result.decision === "deny")
+                return result;
+            if (result.decision === "ask")
+                return result;
+        }
+        return { decision: "allow" };
+    }
+    async runPostHook(ctx, result) {
+        for (const handler of this.postHooks) {
+            await handler(ctx, result);
+        }
+    }
+    async runFailureHook(ctx, error) {
+        for (const handler of this.failureHooks) {
+            await handler(ctx, error);
+        }
+    }
+}
+export class ToolPipeline {
+    toolDefs;
+    hookManager;
+    sessionId = null;
+    constructor(toolDefs, hookManager) {
+        this.toolDefs = toolDefs;
+        this.hookManager = hookManager;
+    }
+    setSessionId(id) {
+        this.sessionId = id;
+    }
+    async execute(toolCall, runner) {
+        const def = this.toolDefs.find((t) => t.name === toolCall.name);
+        const hookCtx = this.buildHookContext(toolCall, def);
+        // 1. PreHook（含 Permission Matrix + Rate Limiter + Speculative Classifier）
+        const preResult = await this.hookManager.runPreHook(hookCtx, this.sessionId ?? undefined);
+        if (preResult.decision === "deny") {
+            console.error(`🚫 [Pipeline] 工具 ${toolCall.name} 被 Hook 拦截: ${preResult.blockingError}`);
+            return {
+                tool_call_id: toolCall.id,
+                output: `【权限拒绝】${preResult.blockingError ?? "Hook denied"}`,
+                is_error: true,
+            };
+        }
+        if (preResult.decision === "ask") {
+            const { ApprovalRequiredError } = await import("../guard/approval.js");
+            throw new ApprovalRequiredError(toolCall.id, toolCall.name, preResult.additionalContexts ?? ["需要确认"]);
+        }
+        // 2. 执行工具
+        try {
+            const result = await runner(toolCall);
+            // 3. PostHook
+            await this.hookManager.runPostHook(hookCtx, result);
+            return result;
+        }
+        catch (err) {
+            // 4. Failure Hook
+            await this.hookManager.runFailureHook(hookCtx, err);
+            throw err;
+        }
+    }
+    buildHookContext(toolCall, def) {
+        const cmd = String(toolCall.arguments.command ?? "");
+        const matched = matchDangerousPatterns(cmd, def?.dangerousPatterns ?? []);
+        return {
+            toolName: toolCall.name,
+            arguments: toolCall.arguments,
+            inputSchema: def?.parameters ?? {},
+            isReadOnly: def?.readOnly ?? toolCall.name !== "bash",
+            isDestructive: def?.destructive ?? /\b(rm|del|rmdir)\b/.test(cmd),
+            isConcurrencySafe: def?.concurrencySafe ?? false,
+            dangerousPatterns: matched,
+        };
+    }
+}

package/dist/pipeline/sections.d.ts

@@ -0,0 +1,41 @@
+import { PromptSection, PromptSectionRegistry, AgentConfig } from "../types.js";
+import type { SkillMeta } from "../skills/types.js";
+export declare const SECTION_IDS: {
+    readonly INTRO: "intro";
+    readonly TOOLS: "tools";
+    readonly WORKFLOW: "workflow";
+    readonly RESTRICTIONS: "restrictions";
+    readonly TONE: "tone";
+    readonly REPOMAP: "repomap";
+    readonly TOKEN_BUDGET: "token_budget";
+    readonly SESSION: "session";
+    readonly MCP: "mcp";
+    readonly MEMORY: "memory";
+    readonly SKILLS: "skills";
+    readonly DYNAMIC: "dynamic";
+    readonly REFLECTION: "reflection";
+};
+export declare function buildReflectionPrompt(toolName: string, args: any): string;
+export declare function buildIntroSection(name: string, version: string): PromptSection;
+export declare function buildToolsSection(tools: AgentConfig["tools"]): PromptSection;
+export declare function buildWorkflowSection(): PromptSection;
+export declare function buildRestrictionsSection(): PromptSection;
+export declare function buildToneSection(): PromptSection;
+export declare function buildSessionSection(): PromptSection;
+export declare function buildMemorySection(): PromptSection;
+export declare function buildTokenBudgetSection(usedTokens: number, maxTokens: number): PromptSection;
+export declare function buildSkillsSection(skills: SkillMeta[]): PromptSection;
+export declare function buildMCPSection(serverInfo?: string): PromptSection;
+export declare function buildRepoMapSection(symbols: {
+    file: string;
+    name: string;
+    type: string;
+    line: number;
+    signature: string;
+}[]): PromptSection;
+export declare function buildDefaultRegistry(tools: AgentConfig["tools"], usedTokens?: number, maxTokens?: number): PromptSectionRegistry;
+export declare function buildSystemPrompt(registry: PromptSectionRegistry, dynamicSections?: {
+    memory?: string;
+    session?: string;
+}): string;
+//# sourceMappingURL=sections.d.ts.map

package/dist/pipeline/sections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sections.d.ts","sourceRoot":"","sources":["../../src/pipeline/sections.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,qBAAqB,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAChF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAKpD,eAAO,MAAM,WAAW;;;;;;;;;;;;;;CAcd,CAAC;AAEX,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,GAAG,MAAM,CAgBzE;AAID,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,aAAa,CAS9E;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,WAAW,CAAC,OAAO,CAAC,GAAG,aAAa,CAwB5E;AAED,wBAAgB,oBAAoB,IAAI,aAAa,CAYpD;AAED,wBAAgB,wBAAwB,IAAI,aAAa,CAkBxD;AAED,wBAAgB,gBAAgB,IAAI,aAAa,CAYhD;AAED,wBAAgB,mBAAmB,IAAI,aAAa,CAYnD;AAED,wBAAgB,kBAAkB,IAAI,aAAa,CAUlD;AAED,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,aAAa,CAe5F;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,GAAG,aAAa,CAoBrE;AAED,wBAAgB,eAAe,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,aAAa,CAWlE;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,EAAE,GACvF,aAAa,CA+Bf;AAID,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,WAAW,CAAC,OAAO,CAAC,EAC3B,UAAU,GAAE,MAAU,EACtB,SAAS,GAAE,MAAgB,GAC1B,qBAAqB,CAcvB;AAID,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,qBAAqB,EAC/B,eAAe,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GACtD,MAAM,CAgBR"}

package/dist/pipeline/sections.js

@@ -0,0 +1,244 @@
+// ============================================================
+// 轻灵 - Section-based System Prompt（参考 Claude Code 2.4/2.5 节）
+// ============================================================
+import { PromptSectionRegistry } from "../types.js";
+import { buildToolSpecBoostPrompt } from "./example-generator.js";
+import { getPackageVersion } from "../package-version.js";
+// --- 默认 Section IDs ---
+export const SECTION_IDS = {
+    INTRO: "intro",
+    TOOLS: "tools",
+    WORKFLOW: "workflow",
+    RESTRICTIONS: "restrictions",
+    TONE: "tone",
+    REPOMAP: "repomap",
+    TOKEN_BUDGET: "token_budget",
+    SESSION: "session",
+    MCP: "mcp",
+    MEMORY: "memory",
+    SKILLS: "skills",
+    DYNAMIC: "dynamic",
+    REFLECTION: "reflection",
+};
+export function buildReflectionPrompt(toolName, args) {
+    return `【内心独白 / 风险评估】
+你正准备执行一项具有潜在风险的操作：调用工具 "${toolName}"。
+参数为: ${JSON.stringify(args)}
+
+请在内心进行预演评估（无需输出到最终回复，仅作为逻辑判定依据）：
+1. 该操作是否具有破坏性？（如删除文件、强制重启、网络请求敏感地址）
+2. 该操作是否与之前的用户指令冲突？
+3. 如果执行失败，是否有恢复预案？
+
+请输出 JSON 格式判定：
+{
+  "risk_level": "low" | "medium" | "high",
+  "decision": "proceed" | "ask" | "block",
+  "reason": "简短理由"
+}`;
+}
+// --- 内置 Section Builders ---
+export function buildIntroSection(name, version) {
+    return {
+        id: SECTION_IDS.INTRO,
+        title: "身份",
+        content: `你是一个通用的命令行 Agent，名为"${name}" v${version}。你轻量、敏捷、专注。
+当处理艺术、设计、图片分析等创意任务时，你应当展现出细腻的描述能力，完整传达视觉意象，而不仅仅是数据提取。`,
+        cacheable: true,
+        cached: false,
+    };
+}
+export function buildToolsSection(tools) {
+    const toolList = (tools ?? [])
+        .map((t) => `• ${t.name}: ${t.description}${t.effortHint ? ` [effort: ${t.effortHint}]` : ""}`)
+        .join("\n");
+    let content = `你可用的工具：\n\n${toolList}`;
+    // v0.3 Tool Spec Boost
+    if (process.env.QLING_FEATURES_TOOL_SPEC_BOOST === "true") {
+        content += "\n\n" + buildToolSpecBoostPrompt(tools);
+    }
+    return {
+        id: SECTION_IDS.TOOLS,
+        title: "工具列表",
+        content,
+        cacheable: true,
+        cached: false,
+    };
+}
+export function buildWorkflowSection() {
+    return {
+        id: SECTION_IDS.WORKFLOW,
+        title: "工作流程",
+        content: `【重要工作流程】收到任务时：
+1. 先思考：这个任务需要几步？是否需要规划？
+2. 如果任务复杂（超过2步），先用 todo add 依次列出执行步骤
+3. 然后逐个执行：每完成一步用 todo done 标记
+4. 所有步骤完成后返回清晰总结`,
+        cacheable: true,
+        cached: false,
+    };
+}
+export function buildRestrictionsSection() {
+    return {
+        id: SECTION_IDS.RESTRICTIONS,
+        title: "限制",
+        content: `【工具使用原则】
+- bash：执行命令、安装、构建、运行
+- read：查看文件内容后再决定怎么写
+- write：创建或覆盖文件
+- todo：规划步骤、跟踪进度
+- skill：遇到不熟悉的工具/API/框架时，用 skill 加载对应知识文件
+
+【安全限制】
+- 危险命令（rm -rf /、格式化磁盘等）会被自动拒绝
+- 删除/覆盖操作前必须先读取确认
+- 不确定的操作先问用户`,
+        cacheable: true,
+        cached: false,
+    };
+}
+export function buildToneSection() {
+    return {
+        id: SECTION_IDS.TONE,
+        title: "风格",
+        content: `始终用中文回复，除非用户用英文。
+回答应当平衡“简洁”与“丰富”：
+- 对于纯技术、文件或系统操作：保持极致简洁，给出完成报告。
+- 对于图片分析、创意设计或意境咨询：**禁止使用表格 (Table)**。你应当使用分段的叙述性文字、文学化的词汇和排比句，完整转述视觉意象和氛围。**绝对不要将感性描述提取为结构化数据列。**
+工具执行结果用 ✅（成功）或 ❌（失败）标记。`,
+        cacheable: true,
+        cached: false,
+    };
+}
+export function buildSessionSection() {
+    return {
+        id: SECTION_IDS.SESSION,
+        title: "会话",
+        content: `当前会话可以用来：
+- 记住项目上下文（当前工作目录、使用的技术栈）
+- 记住用户的偏好设置
+- 跨任务保持状态`,
+        cacheable: false, // 动态，每次都重新生成
+        dynamic: true,
+        cached: false,
+    };
+}
+export function buildMemorySection() {
+    return {
+        id: SECTION_IDS.MEMORY,
+        title: "记忆",
+        content: `【长期记忆】（从 ~/.qling/memory/ 加载）
+如无记忆则忽略此节。`,
+        cacheable: false,
+        dynamic: true,
+        cached: false,
+    };
+}
+export function buildTokenBudgetSection(usedTokens, maxTokens) {
+    const remaining = maxTokens - usedTokens;
+    const pct = Math.round((remaining / maxTokens) * 100);
+    return {
+        id: SECTION_IDS.TOKEN_BUDGET,
+        title: "Token 预算",
+        content: `【Token 预算】
+已使用: ~${usedTokens.toLocaleString()} tokens
+剩余: ~${remaining.toLocaleString()} tokens (${pct}%)
+当剩余低于 20% 时，主动精简回复，减少工具调用频率。`,
+        cacheable: false,
+        dynamic: true,
+        cached: false,
+    };
+}
+export function buildSkillsSection(skills) {
+    if (skills.length === 0) {
+        return {
+            id: SECTION_IDS.SKILLS,
+            title: "可用技能",
+            content: "当前无可用技能。在 skills/ 目录下创建 .md 文件即可添加。",
+            cacheable: false,
+            dynamic: true,
+            cached: false,
+        };
+    }
+    const lines = skills.map((s) => `- ${s.name}: ${s.description || "(无描述)"}`);
+    return {
+        id: SECTION_IDS.SKILLS,
+        title: "可用技能",
+        content: `【可用技能】（用 skill name="xxx" 加载）\n${lines.join("\n")}`,
+        cacheable: false,
+        dynamic: true,
+        cached: false,
+    };
+}
+export function buildMCPSection(serverInfo) {
+    return {
+        id: SECTION_IDS.MCP,
+        title: "MCP 服务器",
+        content: serverInfo
+            ? `【MCP 服务器】\n${serverInfo}`
+            : `【MCP 服务器】\n当前无可用 MCP 服务器。如有配置将在此处显示。`,
+        cacheable: false,
+        dynamic: true,
+        cached: false,
+    };
+}
+export function buildRepoMapSection(symbols) {
+    const fileGroups = new Map();
+    for (const sym of symbols) {
+        if (!fileGroups.has(sym.file)) {
+            fileGroups.set(sym.file, []);
+        }
+        fileGroups.get(sym.file).push(sym);
+    }
+    const lines = [];
+    const sortedFiles = Array.from(fileGroups.keys()).sort();
+    for (const file of sortedFiles) {
+        lines.push(`📄 ${file}`);
+        const fileSymbols = fileGroups.get(file);
+        fileSymbols.sort((a, b) => a.line - b.line);
+        for (const sym of fileSymbols) {
+            lines.push(`  - [${sym.type}] L${sym.line}: ${sym.name} (${sym.signature})`);
+        }
+    }
+    const content = lines.length > 0
+        ? `已编制项目符号索引，供全局参考：\n\n${lines.join("\n")}`
+        : "当前没有索引到项目符号。运行 /repomap 命令来索引符号。";
+    return {
+        id: SECTION_IDS.REPOMAP,
+        title: "代码地图",
+        content,
+        cacheable: true,
+        cached: false,
+    };
+}
+// --- 默认 Registry Builder ---
+export function buildDefaultRegistry(tools, usedTokens = 0, maxTokens = 120_000) {
+    const registry = new PromptSectionRegistry();
+    registry.register(buildIntroSection("轻灵", getPackageVersion()));
+    registry.register(buildToolsSection(tools));
+    registry.register(buildWorkflowSection());
+    registry.register(buildRestrictionsSection());
+    registry.register(buildToneSection());
+    registry.register(buildRepoMapSection([]));
+    registry.register(buildSessionSection());
+    registry.register(buildMemorySection());
+    registry.register(buildTokenBudgetSection(usedTokens, maxTokens));
+    return registry;
+}
+// --- Prompt Builder Utility ---
+export function buildSystemPrompt(registry, dynamicSections) {
+    // 更新动态 section
+    const sessionSec = registry.get(SECTION_IDS.SESSION);
+    if (sessionSec && dynamicSections?.session) {
+        sessionSec.content = `【会话上下文】\n${dynamicSections.session}`;
+    }
+    const memorySec = registry.get(SECTION_IDS.MEMORY);
+    if (memorySec && dynamicSections?.memory) {
+        memorySec.content = `【长期记忆】（从 ~/.qling/memory/ 加载）\n${dynamicSections.memory}`;
+    }
+    else if (memorySec) {
+        memorySec.content = `【长期记忆】（从 ~/.qling/memory/ 加载）\n如无记忆则忽略此节。`;
+    }
+    // 按顺序拼装
+    return registry.buildPrompt();
+}

package/dist/pipeline/verification.d.ts

@@ -0,0 +1,12 @@
+import { VerificationResult } from "../types.js";
+export declare class VerificationAgent {
+    private apiKey;
+    private model;
+    constructor(apiKey: string, model?: string);
+    verify(operation: string, expectedOutcome: string, actualOutput: string, context?: string): Promise<VerificationResult>;
+    private verifyWithLLM;
+    private callLLM;
+    private parseResponse;
+    private ruleBasedVerify;
+}
+//# sourceMappingURL=verification.d.ts.map

package/dist/pipeline/verification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verification.d.ts","sourceRoot":"","sources":["../../src/pipeline/verification.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,kBAAkB,EAGnB,MAAM,aAAa,CAAC;AAmBrB,qBAAa,iBAAiB;IAE1B,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,KAAK;gBADL,MAAM,EAAE,MAAM,EACd,KAAK,GAAE,MAAwB;IAGnC,MAAM,CACV,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,MAAM,EACvB,YAAY,EAAE,MAAM,EACpB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,kBAAkB,CAAC;YAiBhB,aAAa;YAkBb,OAAO;IAoBrB,OAAO,CAAC,aAAa;IA0BrB,OAAO,CAAC,eAAe;CAyCxB"}