@bolloon/bolloon-agent 0.1.34 → 0.1.35

package/src/agents/pi-sdk.ts

@@ -41,6 +41,16 @@ import {
 import { Session, SkillRegistry, saveSession, loadSession, type Skill, type StoredSession } from '@bolloon/constraint-runtime';
 import { loadSkillsFromPaths, defaultSkillPaths, describeSkill } from './skill-loader.js';
 
+// Judgment 注入门 (P0): 在主对话 LLM 调起前自动拼入 Top 3 判断力
+// 失败静默, 不阻塞主对话
+import { injectJudgmentGate, recordJudgmentUsage } from '../pi-ecosystem-judgment/injection-gate.js';
+// 持续监控门 (P3): AI 回复后审计是否违反原则
+import { monitorAfterReply } from '../pi-ecosystem-judgment/monitor-gate.js';
+// Bootstrap 生命周期 hook (SessionStart / Stop / PreToolUse)
+import { onSessionStart, onStop, onPreToolUse } from '../pi-ecosystem-judgment/human-value-pipeline.js';
+// React Harness: 8-gate + 4-guard (防越权 / 防 prompt 注入)
+import { ReactHarness } from '../security/react-harness.js';
+
 // Pi Ecosystem Integration (lazy imports - initialized on demand)
 // Functions from: createGoal, getCurrentGoal, completeCurrentGoal, failCurrentGoal, getGoalStats, getQueueSummary
 
@@ -499,9 +509,9 @@ export interface HeartbeatConfig {
 }
 
 export interface AgentSession {
-  prompt(input: string): Promise<string>;
-  promptStream(input: string, onStream: StreamCallback): Promise<string>;
-  promptWithPivotLoop(input: string, config?: PivotLoopConfig): Promise<LoopResult>;
+  prompt(input: string, options?: { onStream?: StreamCallback; signal?: AbortSignal; channelId?: string }): Promise<string>;
+  promptStream(input: string, onStream: StreamCallback, signal?: AbortSignal, channelId?: string): Promise<string>;
+  promptWithPivotLoop(input: string, config?: PivotLoopConfig, channelId?: string): Promise<LoopResult>;
   suggestRename(messages: { type: string; content: string }[]): Promise<string | null>;
   readDocument(filePath: string): Promise<string>;
   summarizeDocument(filePath: string, context?: string): Promise<{
@@ -520,6 +530,7 @@ export interface AgentSession {
   broadcast(message: string): Promise<void>;
   getIdentity(): IdentityDoc;
   updateIdentity(updates: Partial<IdentityDoc>): void;
+  setCurrentChannelId(channelId: string): void;
   getSessionState(): PiSessionState;
   getMemory(): PiMemory;
   getPersona(): PersonaDoc | null;
@@ -568,9 +579,65 @@ class PiAgentSession implements AgentSession {
   private coordinator = new AgentCoordinator(3);
   private harness: any = null;
   private harnessEnabled = false;
+  /** 8-gate + 4-guard 集中调度 (防越权 / 防 prompt 注入) */
+  private reactHarness: ReactHarness = new ReactHarness();
   private usePivotLoop: boolean = false;
   private pivotLoopConfig?: PivotLoopConfig;
 
+  /**
+   * Judgment 注入门临时结果: 在 prompt / promptStream / promptWithPivotLoop 入口算一次, 拼到本轮 systemPrompt 末尾
+   * 每次调用都会重置 (避免上一轮遗留)
+   */
+  private judgmentGateAddition: string = '';
+  private judgmentGateUsedIds: string[] = [];
+
+  /**
+   * 当前 onStream 引用 + abort signal (computeJudgmentGate 需要 onStream 广播 phase)
+   * 每次 prompt / promptStream / promptWithPivotLoop 入口设置, 用完即清
+   */
+  private currentOnStream: StreamCallback | null = null;
+  private currentSignal: AbortSignal | null = null;
+  /** Bootstrap SessionStart 拼的 system prompt 片段 (用完即清) */
+  private bootstrapAddition: string = '';
+  /** 当前 prompt 开始时间 (供 Stop hook 计算 durationMs) */
+  private promptStartTime: number = 0;
+  /** 当前 channel id (由 getAgentForChannel / prompt 4 参注入, 供 hook / log 使用) */
+  private currentChannelId: string = '';
+
+  /**
+   * 算 judgment 注入门: 失败静默, 不阻塞主对话
+   * 期间通过 currentOnStream 广播 phase 事件, 前端可显示 "正在检索判断力..." 状态
+   * 调用方负责用完即清 (judgmentGateAddition='')
+   */
+  private async computeJudgmentGate(input: string): Promise<void> {
+    const safePhase = (phase: string, extra: Record<string, unknown> = {}) => {
+      try {
+        if (this.currentOnStream) {
+          this.currentOnStream({ type: 'phase', phase, ...extra, content: '' } as any);
+        }
+      } catch { /* 静默 */ }
+    };
+
+    safePhase('gate_compute', { detail: '正在检索相关判断力...' });
+    try {
+      const gate = await injectJudgmentGate(input);
+      this.judgmentGateAddition = gate.systemAddition;
+      this.judgmentGateUsedIds = gate.usedIds;
+      if (gate.usedIds.length > 0) {
+        safePhase('gate_done', { usedCount: gate.usedIds.length });
+      }
+    } catch (err) {
+      console.warn('[PiAgent] judgment gate failed (non-fatal):', err);
+      this.judgmentGateAddition = '';
+      this.judgmentGateUsedIds = [];
+    }
+  }
+
+  private clearJudgmentGate(): void {
+    this.judgmentGateAddition = '';
+    this.judgmentGateUsedIds = [];
+  }
+
   constructor(config: AgentSessionConfig) {
     this.cwd = config.cwd;
     this.peerId = config.peerId || 'local';
@@ -656,9 +723,13 @@ class PiAgentSession implements AgentSession {
       const { createBollharnessIntegration } = await import('../bollharness-integration/index.js');
       this.harness = createBollharnessIntegration();
       this.harnessEnabled = true;
+      // ReactHarness 已用 bollharness, 这里也记一份以供 archive 调用
+      this.reactHarness = new ReactHarness({ harnessEnabled: true, gateEnabled: true });
     } catch (e) {
       console.warn('[PiAgentSession] Harness initialization failed:', e);
       this.harnessEnabled = false;
+      // 失败 fallback: 走纯 8-gate (不带 bollharness 的 8-gate 工作流)
+      this.reactHarness = new ReactHarness({ harnessEnabled: false, gateEnabled: true });
     }
   }
 
@@ -1004,8 +1075,9 @@ class PiAgentSession implements AgentSession {
     }
   }
 
-  async prompt(input: string): Promise<string> {
+  async prompt(input: string, options?: { onStream?: StreamCallback; signal?: AbortSignal; channelId?: string }): Promise<string> {
     this.minimaxAvailable = this.checkMinimax();
+    this.currentChannelId = options?.channelId ?? this.currentChannelId;
 
     this.messageHistory.push({
       role: 'user',
@@ -1018,11 +1090,27 @@ class PiAgentSession implements AgentSession {
       return response;
     }
 
-    return this.runReActLoop();
+    // P0 注入门
+    this.currentSignal = options?.signal ?? null;
+    this.currentOnStream = options?.onStream ?? null;
+    await this.computeJudgmentGate(input);
+    try {
+      return await this.runReActLoop(undefined, options?.signal);
+    } finally {
+      if (this.judgmentGateUsedIds.length > 0) {
+        recordJudgmentUsage(this.judgmentGateUsedIds, { userInput: input }).catch((err) =>
+          console.warn('[PiAgent] recordJudgmentUsage failed:', err)
+        );
+      }
+      this.clearJudgmentGate();
+      this.currentSignal = null;
+      this.currentOnStream = null;
+    }
   }
 
-  async promptStream(input: string, onStream: StreamCallback): Promise<string> {
+  async promptStream(input: string, onStream: StreamCallback, signal?: AbortSignal, channelId?: string): Promise<string> {
     this.minimaxAvailable = this.checkMinimax();
+    this.currentChannelId = channelId ?? this.currentChannelId;
 
     this.messageHistory.push({
       role: 'user',
@@ -1038,12 +1126,66 @@ class PiAgentSession implements AgentSession {
       return response;
     }
 
-    const result = await this.runReActLoop(onStream);
+    // P0 注入门: 缓存 onStream + signal, computeJudgmentGate 用 currentOnStream 广播 phase
+    this.currentOnStream = onStream;
+    this.currentSignal = signal ?? null;
+    await this.computeJudgmentGate(input);
+
+    // Bootstrap SessionStart: 收集项目 Context, 拼到 systemAddition 头部
+    // (失败静默, 5s 限流防止循环)
+    let bootstrapAddition = '';
+    try {
+      const ss = await onSessionStart({ channelId: this.currentChannelId || undefined });
+      bootstrapAddition = ss.systemAddition || '';
+    } catch (err) {
+      console.warn('[PiAgent] onSessionStart failed (non-fatal):', err);
+    }
+    this.bootstrapAddition = bootstrapAddition;
+    this.promptStartTime = Date.now();
+
+    let result: string;
+    try {
+      result = await this.runReActLoop(onStream, signal);
+    } catch (err: any) {
+      // abort 失败: 视作"已中断", 抛错让上层用 partial 兜底
+      this.currentOnStream = null;
+      this.currentSignal = null;
+      throw err;
+    }
     onStream({ type: 'done', content: '' });
+
+    // 回溯: 异步记录 usage (不等)
+    if (this.judgmentGateUsedIds.length > 0) {
+      recordJudgmentUsage(this.judgmentGateUsedIds, { userInput: input }).catch((err) =>
+        console.warn('[PiAgent] recordJudgmentUsage failed:', err)
+      );
+      // P0.5: 把 usedIds 通过 stream 事件回传给调用方 (server.ts 写到 session message)
+      try { onStream({ type: 'used_judgments', usedIds: this.judgmentGateUsedIds, content: '' } as any); } catch {}
+    }
+
+    // P3 监控门: fire-and-forget 审计 AI 回复是否违反原则
+    monitorAfterReply(input, result);
+
+    // Bootstrap Stop hook: fire-and-forget 写本次 session 摘要
+    const stopStartTime = this.promptStartTime || Date.now();
+    onStop({
+      channelId: this.currentChannelId || 'unknown',
+      durationMs: Date.now() - stopStartTime,
+      usedJudgmentIds: [...this.judgmentGateUsedIds],
+    }).catch((err) => console.warn('[PiAgent] onStop failed:', err));
+
+    // 用完即清, 避免污染下一轮
+    this.clearJudgmentGate();
+    this.currentOnStream = null;
+    this.currentSignal = null;
+    this.bootstrapAddition = '';
+    this.promptStartTime = 0;
+
     return result;
   }
 
-  async promptWithPivotLoop(input: string, config?: PivotLoopConfig): Promise<LoopResult> {
+  async promptWithPivotLoop(input: string, config?: PivotLoopConfig, channelId?: string): Promise<LoopResult> {
+    this.currentChannelId = channelId ?? this.currentChannelId;
     if (!this.minimaxAvailable) {
       const response = await this.handleFallback(input);
       return {
@@ -1073,13 +1215,16 @@ class PiAgentSession implements AgentSession {
       loop.registerTool(tool);
     }
 
+    // P0 注入门: 在构造 systemPrompt 之前算一次, 拼到末尾
+    await this.computeJudgmentGate(input);
+
     const personaSection = this.persona ? `
 角色描述: ${this.persona.description || '无'}
 性格特点: ${this.persona.personality || '无'}
 问候语: ${this.persona.greeting || '无'}
 ` : '';
 
-    const systemPrompt = `你是 ${this.identity.name}，基于ReAct (Reasoning + Acting)模式工作。${personaSection}
+    const systemPrompt = `${this.bootstrapAddition}你是 ${this.identity.name}，基于ReAct (Reasoning + Acting)模式工作。${personaSection}
 当前工作目录: ${this.cwd}
 当前身份: ${this.identity.name} (${this.identity.did})
 
@@ -1096,7 +1241,7 @@ ${this.getToolDefinitions()}
 - 每次只调用一个工具
 - 仔细分析工具返回结果
 - 当任务完成时，必须在回答末尾添加 <final gen> 标记表示结束
-- 如果需要更多信息，继续调用工具`;
+- 如果需要更多信息，继续调用工具${this.judgmentGateAddition}`;
 
     const result = await loop.execute(input, llm, systemPrompt);
 
@@ -1105,10 +1250,18 @@ ${this.getToolDefinitions()}
       this.messageHistory.push({ role: 'assistant', content: result.response });
     }
 
+    // 回溯 + 清场
+    if (this.judgmentGateUsedIds.length > 0) {
+      recordJudgmentUsage(this.judgmentGateUsedIds, { userInput: input }).catch((err) =>
+        console.warn('[PiAgent] recordJudgmentUsage failed:', err)
+      );
+    }
+    this.clearJudgmentGate();
+
     return result;
   }
 
-  private async runReActLoop(onStream?: StreamCallback): Promise<string> {
+  private async runReActLoop(onStream?: StreamCallback, signal?: AbortSignal): Promise<string> {
     const llm = getMinimax();
     let iteration = 0;
     let finalResponse = '';
@@ -1125,6 +1278,14 @@ ${this.getToolDefinitions()}
       onStream({ type: 'status', content: '🔄 开始 ReAct 循环...', tool: 'system' });
     }
 
+    // React Harness: 循环开始 (重置 turn 计数 + 触发 harness sessionStart)
+    // 失败静默 (fail-open), 不阻塞主循环
+    try {
+      await this.reactHarness.onSessionStart(this.currentChannelId || undefined);
+    } catch (err) {
+      console.warn('[PiAgent] reactHarness.onSessionStart failed (non-fatal):', err);
+    }
+
     while (iteration < this.MAX_REACT_ITERATIONS) {
       iteration++;
 
@@ -1154,7 +1315,7 @@ ${this.getToolDefinitions()}
 问候语: ${this.persona.greeting || '无'}
 ` : '';
 
-      const systemPrompt = `你是 ${this.identity.name}，基于ReAct (Reasoning + Acting)模式工作。${personaSection}
+      const systemPrompt = `${this.bootstrapAddition}你是 ${this.identity.name}，基于ReAct (Reasoning + Acting)模式工作。${personaSection}
 当前工作目录: ${this.cwd}
 当前身份: ${this.identity.name} (${this.identity.did})
 ${refineContext}
@@ -1172,9 +1333,9 @@ ${toolDefs}
 - 每次只调用一个工具
 - 仔细分析工具返回结果
 - 当任务完成时，必须在回答末尾添加 <final gen> 标记表示结束
-- 如果需要更多信息，继续调用工具`;
+- 如果需要更多信息，继续调用工具${this.judgmentGateAddition}`;
 
-      const response = await llm.chat(context, systemPrompt);
+      const response = await llm.chat(context, systemPrompt, signal);
       const reply = response.reply.trim();
 
       console.log(`[PiAgent] LLM 回复长度: ${reply.length}, 内容预览: "${reply.substring(0, 80)}..."`);
@@ -1226,9 +1387,114 @@ ${toolDefs}
           continue;
         }
 
+        // Bootstrap PreToolUse hook: 调工具前校验 (危险命令拦截)
+        // 失败静默 — hook 自身挂掉 = 放行
+        let toolToExecute = tool;
+        try {
+          const pre = await onPreToolUse({ tool: toolCall.name, args: toolCall.args || {} });
+          if (!pre.allowed) {
+            const deniedResult: ToolResult = {
+              success: false,
+              error: `PreToolUse 拒绝: ${pre.reason || '未通过安全校验'}`,
+            };
+            this.messageHistory.push({
+              role: 'tool',
+              content: JSON.stringify(deniedResult),
+              toolResult: deniedResult,
+            });
+            this.logToHarness(toolCall.name, toolCall.args, deniedResult);
+            if (onStream) {
+              onStream({
+                type: 'error',
+                content: `🛡️ PreToolUse 拒绝 ${toolCall.name}: ${pre.reason || '安全校验失败'}`,
+                tool: toolCall.name,
+              });
+            }
+            console.warn(`[PiAgent] PreToolUse denied ${toolCall.name}: ${pre.reason}`);
+            // 不调 tool.execute, 也不计 consecutiveErrors (这是用户级拒绝, 不是工具错)
+            continue;
+          }
+        } catch (err) {
+          console.warn('[PiAgent] onPreToolUse failed (non-fatal, allowing):', err);
+        }
+
+        // React Harness: 8-gate + builtin-guards 校验 (在 PreToolUse 之后, 串接双层)
+        // 失败静默, 拒绝时不调 tool.execute
         try {
-          const result = await tool.execute(toolCall.args);
+          const pre = await this.reactHarness.preToolCall(
+            toolCall.name,
+            toolCall.args || {},
+            this.currentChannelId || undefined
+          );
+          if (!pre.allowed) {
+            const deniedResult: ToolResult = {
+              success: false,
+              error: `Harness gate 拒绝 (${pre.details.rejectedBy}): ${pre.reason || '未通过安全校验'}`,
+            };
+            this.messageHistory.push({
+              role: 'tool',
+              content: JSON.stringify(deniedResult),
+              toolResult: deniedResult,
+            });
+            this.logToHarness(toolCall.name, toolCall.args, deniedResult);
+            if (onStream) {
+              onStream({
+                type: 'error',
+                content: `🛡️ Harness ${pre.details.rejectedBy} 拒绝 ${toolCall.name}: ${pre.reason || '安全校验失败'}`,
+                tool: toolCall.name,
+              });
+            }
+            console.warn(`[PiAgent] Harness denied ${toolCall.name} (${pre.details.rejectedBy}): ${pre.reason}`);
+            continue;
+          }
+        } catch (err) {
+          console.warn('[PiAgent] reactHarness.preToolCall failed (non-fatal, allowing):', err);
+        }
+
+        try {
+          let result = await tool.execute(toolCall.args);
           console.log(`[PiAgent] 工具 ${toolCall.name} 执行完成: success=${result.success}`);
+
+          // Context router: 拿最近一次 preToolCall 算的 hint, 拼到 tool result messageHistory
+          // (LLM 下次看到 tool result 时, 能"记得"这次调用的安全约束)
+          const routeHint = this.reactHarness.getLastRouteHint();
+          if (routeHint && routeHint.systemAddition) {
+            this.messageHistory.push({
+              role: 'system',
+              content: `[Harness Router Hint: ${routeHint.reason}]\n${routeHint.systemAddition}`,
+            });
+            this.reactHarness.clearRouteHint();
+          }
+
+          // React Harness: post-tool call (output 审计: secret leak 等)
+          // 拒绝时 result.output 含敏感 → 替换为 generic message, 不污染 messageHistory
+          try {
+            const post = await this.reactHarness.postToolCall(
+              toolCall.name,
+              String(result.output || ''),
+              this.currentChannelId || undefined
+            );
+            if (!post.allowed) {
+              if (onStream) {
+                onStream({
+                  type: 'error',
+                  content: `🛡️ Harness output 拒绝 ${toolCall.name}: ${post.reason || '输出含敏感信息'}`,
+                  tool: toolCall.name,
+                });
+              }
+              console.warn(`[PiAgent] Harness output denied ${toolCall.name}: ${post.reason}`);
+              // 替换 result: success 仍保留 (tool 本身没错), 但 output 改成 generic
+              // 这样 LLM 下轮看 output 不会拿到秘密, 但 success 标志让它知道 "工具执行了"
+              result = {
+                ...result,
+                output: `[harness output gate: output 含敏感内容, 已屏蔽. 原因: ${post.reason || 'unknown'}]`,
+                _harnessDenied: true,
+              } as typeof result;
+            }
+          } catch (err) {
+            console.warn('[PiAgent] reactHarness.postToolCall failed (non-fatal, allowing):', err);
+          }
+
           this.messageHistory.push({ role: 'tool', content: JSON.stringify(result), toolResult: result });
           this.logToHarness(toolCall.name, toolCall.args, result);
 
@@ -1373,6 +1639,14 @@ Workspace root folder: ${this.cwd}
     finalResponse = identityPrefix + finalResponse;
 
     this.messageHistory.push({ role: 'assistant', content: finalResponse });
+
+    // React Harness: 循环结束
+    try {
+      await this.reactHarness.onSessionEnd();
+    } catch (err) {
+      console.warn('[PiAgent] reactHarness.onSessionEnd failed (non-fatal):', err);
+    }
+
     return finalResponse;
   }
 
@@ -1885,6 +2159,10 @@ ${this.extractOperationsFromRef(operationsRef)}
     this.identity = { ...this.identity, ...updates };
   }
 
+  setCurrentChannelId(channelId: string): void {
+    this.currentChannelId = channelId;
+  }
+
   getSessionState(): PiSessionState {
     return this.sessionManager.getState();
   }

package/src/bootstrap/bootstrap.ts

@@ -0,0 +1,132 @@
+/**
+ * Bolloon Bootstrap — 启动入口
+ *
+ * web server 启动时 (或 CLI 模式) 调一次, 完成 3 件事:
+ * 1. 跑类 B 自适应扫描 (暖缓存 + 写 evolution.jsonl 启动事件)
+ * 2. 收集项目 Context (Bolloon.md / git / persona / judgments / skills)
+ * 3. 挂每天 0:00 定时任务
+ *
+ * 失败静默: 任意步骤失败 console.warn, 不抛错 (主流程不被阻塞)
+ */
+
+import { runAdaptiveScan, logEvolution } from '../pi-ecosystem-judgment/adaptive-scan.js';
+import { collectBolloonContext, type BolloonContext } from './context-collector.js';
+import type { AdaptiveScanResult } from '../pi-ecosystem-judgment/adaptive-scan.js';
+
+export interface BootstrapResult {
+  context: BolloonContext;
+  scanResult: AdaptiveScanResult;
+  durationMs: number;
+  // 失败的部分不影响主流程
+  errors: string[];
+}
+
+/**
+ * 入口: web server / CLI 启动时调一次
+ */
+export async function bootstrapBolloon(opts: { cwd?: string } = {}): Promise<BootstrapResult> {
+  const start = Date.now();
+  const errors: string[] = [];
+
+  // 1. 类 B 启动扫描
+  let scanResult: AdaptiveScanResult = {
+    scannedAt: new Date().toISOString(),
+    judgmentsTotal: 0,
+    usageEntriesScanned: 0,
+    suggestions: [],
+  };
+  try {
+    scanResult = await runAdaptiveScan();
+    await logEvolution({
+      ts: new Date().toISOString(),
+      action: 'accept',  // 用 accept 表示"系统记录" (跟 reject 区分)
+      suggestion: {
+        key: 'bootstrap-startup',
+        kind: 'unused',  // 占位
+        judgmentId: '__bootstrap__',
+        decision: 'Bolloon 启动扫描',
+        reason: `本次启动扫描了 ${scanResult.judgmentsTotal} 条原则, ${scanResult.usageEntriesScanned} 条使用记录, 生成 ${scanResult.suggestions.length} 条建议`,
+        action: 'review',
+        metrics: { usage7d: 0, usage30d: 0, daysSinceLastUse: 0, totalUsage: 0 },
+        scannedAt: scanResult.scannedAt,
+      },
+    });
+    console.log(`[bootstrap] 类 B 启动扫描完成: ${scanResult.suggestions.length} 条建议`);
+  } catch (err) {
+    errors.push(`scan: ${(err as Error).message}`);
+    console.warn('[bootstrap] 启动扫描失败 (非致命):', err);
+  }
+
+  // 2. 收集项目 Context
+  let context: BolloonContext = {
+    projectRoot: opts.cwd ?? process.cwd(),
+    projectName: 'unknown',
+    bolloonMd: null,
+    git: null,
+    persona: null,
+    judgmentsSummary: { total: 0, active: 0, superseded: 0, rejected: 0, topValues: [] },
+    skills: [],
+    env: { os: 'unknown', nodeVersion: 'unknown', llmProvider: 'unknown' },
+    pending: { goals: [], todos: [] },
+    collectedAt: new Date().toISOString(),
+  };
+  try {
+    context = await collectBolloonContext({ cwd: opts.cwd ?? process.cwd() });
+    console.log(`[bootstrap] context 收集完成: ${context.judgmentsSummary.total} judgments, ${context.skills.length} skills`);
+  } catch (err) {
+    errors.push(`context: ${(err as Error).message}`);
+    console.warn('[bootstrap] context 收集失败 (非致命):', err);
+  }
+
+  // 3. 挂定时任务 (每天 0:00 跑扫描, server 重启时丢失可接受)
+  try {
+    scheduleAdaptiveScanDaily();
+    console.log('[bootstrap] 定时任务已挂: 每天 0:00 跑类 B 扫描');
+  } catch (err) {
+    errors.push(`schedule: ${(err as Error).message}`);
+    console.warn('[bootstrap] 定时任务挂载失败 (非致命):', err);
+  }
+
+  const durationMs = Date.now() - start;
+  console.log(`[bootstrap] 完成 (${durationMs}ms, ${errors.length} 个错误)`);
+
+  return { context, scanResult, durationMs, errors };
+}
+
+// ============================================================
+// 定时任务: 每天 0:00 跑类 B 自适应扫描
+// ============================================================
+
+let scheduled = false;
+
+function scheduleAdaptiveScanDaily(): void {
+  if (scheduled) return;
+  scheduled = true;
+
+  const now = new Date();
+  const next = new Date(now);
+  next.setHours(24, 0, 0, 0);
+  const msUntilMidnight = next.getTime() - now.getTime();
+
+  // 第一次: 等到明天 0:00
+  setTimeout(() => {
+    runAdaptiveScan().then((result) => {
+      console.log(`[bootstrap] 定时扫描完成: ${result.suggestions.length} 条建议`);
+    }).catch((err) => {
+      console.warn('[bootstrap] 定时扫描失败:', err);
+    });
+    // 之后: 每 24h
+    setInterval(() => {
+      runAdaptiveScan().then((result) => {
+        console.log(`[bootstrap] 定时扫描完成: ${result.suggestions.length} 条建议`);
+      }).catch((err) => {
+        console.warn('[bootstrap] 定时扫描失败:', err);
+      });
+    }, 24 * 60 * 60 * 1000);
+  }, msUntilMidnight);
+}
+
+/** 测试辅助: 重置 scheduled 标志 */
+export function _resetScheduleForTest(): void {
+  scheduled = false;
+}