minimal-agent 0.10.0 → 0.12.0

package/src/plugins/transcript.ts

@@ -0,0 +1,208 @@
+/**
+ * ============================================================
+ *  src/plugins/transcript.ts —— Claude Code 风格的 JSONL transcript 写入
+ * ------------------------------------------------------------
+ *  插件 hook（如 stop-hook.sh）通过 stdin 收到 `transcript_path` 后
+ *  会 grep / jq 这份 JSONL 文件来还原对话。schema 必须与 Anthropic
+ *  Claude Code 真实 transcript 对齐：每行一个 JSON 对象，形如
+ *    { type, uuid, session_id, timestamp, message: { role, content: [...parts] } }
+ *  content 为 typed parts 数组：text / tool_use / tool_result。
+ *
+ *  设计要点：
+ *   - OpenAI 风格的 assistant.tool_calls 在这里被拍平成 content 数组
+ *     里的 tool_use parts（Claude Code 的真实格式）
+ *   - tool role 消息被包装成 type:'user' + tool_result part（上游惯例）
+ *   - 同步 appendFileSync —— spawn 的 hook 子进程要立刻看到最新内容
+ *   - 任何写入异常都被吞掉只 warn —— transcript 失败绝不能拖垮 agent
+ *   - 零依赖（只用 node 内置）
+ *
+ *  存储位置：~/.minimal-agent/transcripts/<sessionId>.jsonl
+ * ============================================================
+ */
+
+import { appendFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+import type { Message } from '../types.js';
+import { agentStateDir } from '../context/agentHome.js';
+
+export interface TranscriptHandle {
+  sessionId: string;
+  path: string;
+}
+
+// 模块级状态：当前会话的 handle（lazy 初始化）
+let current: TranscriptHandle | null = null;
+
+function transcriptDir(): string {
+  return join(agentStateDir(), 'transcripts');
+}
+
+function generateSessionId(): string {
+  return `${Date.now().toString(36)}-${randomUUID().slice(0, 8)}`;
+}
+
+function ensureHandle(sessionId?: string): TranscriptHandle {
+  // 三分支：指定 sessionId 且与当前相同 → 复用；未指定且已有当前 → 复用；
+  // 其余（指定了不同 sessionId / 尚无当前）→ 新建句柄（即"切到新文件"）。
+  if (sessionId && current && current.sessionId === sessionId) {
+    return current;
+  }
+  if (!sessionId && current) {
+    return current;
+  }
+
+  const sid = sessionId ?? generateSessionId();
+  const dir = transcriptDir();
+
+  try {
+    mkdirSync(dir, { recursive: true });
+  } catch (err) {
+    console.warn(
+      `[transcript] mkdir failed: ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+
+  const handle: TranscriptHandle = {
+    sessionId: sid,
+    path: join(dir, `${sid}.jsonl`),
+  };
+  current = handle;
+  return handle;
+}
+
+function writeLine(line: object): void {
+  try {
+    const handle = ensureHandle();
+    appendFileSync(handle.path, `${JSON.stringify(line)}\n`, 'utf8');
+  } catch (err) {
+    console.warn(
+      `[transcript] write failed: ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+}
+
+function nowIso(): string {
+  return new Date().toISOString();
+}
+
+/**
+ * 初始化 transcript：在 ~/.minimal-agent/transcripts/ 下打开 <sessionId>.jsonl。
+ * 如果未提供 sessionId，用时间戳 + 随机后缀生成。
+ * 多次调用同一 sessionId 会复用同一文件（append）。
+ */
+export function initTranscript(sessionId?: string): TranscriptHandle {
+  // 显式 init：即便 current 已存在也允许切换到指定 sessionId
+  if (sessionId) {
+    const dir = transcriptDir();
+    try {
+      mkdirSync(dir, { recursive: true });
+    } catch (err) {
+      console.warn(
+        `[transcript] mkdir failed: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
+    current = {
+      sessionId,
+      path: join(dir, `${sessionId}.jsonl`),
+    };
+    return current;
+  }
+
+  return ensureHandle();
+}
+
+/** 获取当前会话的 transcript 路径。未 init 时 lazy 初始化。 */
+export function getCurrentTranscriptPath(): string {
+  return ensureHandle().path;
+}
+
+/** 追加一条 user 消息。 */
+export function appendUserMessage(content: string): void {
+  const handle = ensureHandle();
+  writeLine({
+    type: 'user',
+    uuid: randomUUID(),
+    session_id: handle.sessionId,
+    timestamp: nowIso(),
+    message: {
+      role: 'user',
+      content: [{ type: 'text', text: content }],
+    },
+  });
+}
+
+/** 追加一条 assistant 消息。tool_calls 转成 content 数组里的 tool_use parts。 */
+export function appendAssistantMessage(
+  message: Extract<Message, { role: 'assistant' }>,
+): void {
+  const handle = ensureHandle();
+  const parts: Array<Record<string, unknown>> = [];
+
+  // 文本部分：null / 空字符串都跳过
+  if (typeof message.content === 'string' && message.content.length > 0) {
+    parts.push({ type: 'text', text: message.content });
+  }
+
+  // tool_calls 拍平成 tool_use parts
+  if (Array.isArray(message.tool_calls)) {
+    for (const tc of message.tool_calls) {
+      let input: unknown;
+      try {
+        input = JSON.parse(tc.function.arguments);
+      } catch {
+        input = { _raw: tc.function.arguments };
+      }
+      parts.push({
+        type: 'tool_use',
+        id: tc.id,
+        name: tc.function.name,
+        input,
+      });
+    }
+  }
+
+  writeLine({
+    type: 'assistant',
+    uuid: randomUUID(),
+    session_id: handle.sessionId,
+    timestamp: nowIso(),
+    message: {
+      role: 'assistant',
+      content: parts,
+    },
+  });
+}
+
+/** 追加一条 tool 执行结果（来自 tool role 消息）。 */
+export function appendToolResult(
+  toolCallId: string,
+  _toolName: string,
+  ok: boolean,
+  content: string,
+): void {
+  const handle = ensureHandle();
+  writeLine({
+    type: 'user',
+    uuid: randomUUID(),
+    session_id: handle.sessionId,
+    timestamp: nowIso(),
+    message: {
+      role: 'user',
+      content: [
+        {
+          type: 'tool_result',
+          tool_use_id: toolCallId,
+          content,
+          is_error: !ok,
+        },
+      ],
+    },
+  });
+}
+
+/** 重置当前 handle（用于测试 / /new 清屏后开新 session）。 */
+export function resetTranscript(): void {
+  current = null;
+}

package/src/prompts/lint.js

@@ -0,0 +1,169 @@
+/**
+ * ============================================================
+ *  src/prompts/lint.ts —— 系统提示词的跨层重复检查（确定性，无 LLM）
+ * ------------------------------------------------------------
+ *  **为什么需要它**：`promptAssembly.ts` 把提示词分成若干层（身份/纪律层、工具编排层、
+ *  Skills、Plugins、项目指令）。层与层之间很容易把同一条规则说两遍——写的时候各看各的段落，
+ *  读起来都通顺，拼起来就是重复烧 token、而且两处措辞一旦漂移就会互相矛盾。
+ *  人工清理一次能干净，但下一次加规则又会退化，所以要把「不重复」变成**回归护栏**。
+ *
+ *  **分层判据（去重时按它归位，不是凭感觉）**：
+ *    一条规则若在「该工具不存在时依然成立」→ 属身份层；否则属工具层。
+ *    例：「改文件前先读最新内容」没有 Edit 工具时无意义 → 工具层；
+ *        「只在无法推断时才提问」没有 AskUserQuestion 时仍成立（约束的是判断而非调用）→ 身份层。
+ *
+ *  **能力边界（必须如实说）**：这是**词面**近重复检测，不是语义检测。
+ *  「不用正则盲改源码」与「源码编辑优先专用工具」表达同一件事但几乎不共享字面，
+ *  本检查器**抓不到**——那类只能靠人读。它保证的是：已经清理干净的地方不会因为
+ *  有人复制粘贴一句旧措辞而悄悄退化。
+ *
+ *  **为什么按「子句」而不是整条规则比**：整条规则通常长且各带自己的补充说明，
+ *  即使核心重复，整条的 Jaccard 也只有 0.1 量级（实测），根本触发不了。
+ *  拆成子句后重复的那一句会高度重合。
+ *
+ *  **为什么用 containment 而不是 Jaccard**：我们要问的是「这句话是不是在别处已经说过了」，
+ *  即**包含**关系；短句被长句涵盖时 Jaccard 会被长句的其余部分稀释，containment 不会。
+ * ============================================================
+ */
+/** 数据型段落：内容来自用户目录/项目文件，不是我们写的策略，不参与去重。 */
+const DEFAULT_IGNORED_SECTIONS = ['Skills', 'Plugins', '项目指令'];
+/** 子句短于这个 token 数就不参与比较——短句碰巧重合太常见，会淹没真信号。 */
+const MIN_TOKENS = 6;
+/** containment 达到这个值即判为「已经在别处说过」。 */
+const DEFAULT_THRESHOLD = 0.7;
+/**
+ * 归一化：抹掉不影响语义的差异，让「先读取」和「读取」这类插字不至于把整句错开。
+ * 全角标点、markdown 强调、反引号代码标记一律去掉。
+ */
+function normalize(text) {
+    return text
+        .replace(/[`*_~]/g, '')
+        .replace(/[，。；、：？！（）【】「」《》,.;:?!()[\]{}"'/\\-]/g, '')
+        .replace(/\s+/g, '')
+        .toLocaleLowerCase();
+}
+/**
+ * 中文按 2-gram、拉丁词按整词切。中文没有空格分词，bigram 是这里最稳的近似
+ * （memoryService.ts::terms 出于同样理由也用 bigram，保持一致）。
+ */
+function tokenize(normalized) {
+    const tokens = new Set();
+    for (const word of normalized.match(/[a-z0-9]+/g) ?? []) {
+        if (word.length > 1)
+            tokens.add(word);
+    }
+    const cjk = normalized.replace(/[a-z0-9]+/g, '');
+    for (let index = 0; index + 1 < cjk.length; index += 1) {
+        tokens.add(cjk.slice(index, index + 2));
+    }
+    return tokens;
+}
+function containmentOf(a, b) {
+    const smaller = a.size <= b.size ? a : b;
+    const larger = smaller === a ? b : a;
+    let shared = 0;
+    for (const token of smaller)
+        if (larger.has(token))
+            shared += 1;
+    return smaller.size === 0 ? 0 : shared / smaller.size;
+}
+/**
+ * 把组装好的提示词拆成「段落 → 规则行 → 子句」。
+ * 只取以 `- ` 开头的规则行：段落里的说明性散文不是规则，重复也无害。
+ */
+export function extractPromptClauses(prompt, ignoredSections = DEFAULT_IGNORED_SECTIONS) {
+    const clauses = [];
+    let section = '（开头）';
+    for (const line of prompt.split(/\r?\n/)) {
+        const heading = line.match(/^#+\s+(.*)$/);
+        if (heading) {
+            section = heading[1].trim();
+            continue;
+        }
+        if (ignoredSections.some((ignored) => section.includes(ignored)))
+            continue;
+        const rule = line.match(/^\s*-\s+(.*)$/)?.[1];
+        if (!rule)
+            continue;
+        for (const piece of rule.split(/[；;。]/)) {
+            const text = piece.trim();
+            if (!text)
+                continue;
+            const tokens = tokenize(normalize(text));
+            if (tokens.size < MIN_TOKENS)
+                continue;
+            clauses.push({ section, rule, text, tokens });
+        }
+    }
+    return clauses;
+}
+function isExempt(a, b, exemptions) {
+    return exemptions.some((item) => (a.text.includes(item.a) && b.text.includes(item.b))
+        || (a.text.includes(item.b) && b.text.includes(item.a)));
+}
+/**
+ * 找出**跨段落**的近重复子句。同段落内的重复不报——同一段里连续两句共享措辞通常是
+ * 有意的并列表达，报出来只会逼人写豁免；真正烧 token 且会漂移的是跨层重复。
+ */
+export function findDuplicateClauses(prompt, options = {}) {
+    const threshold = options.threshold ?? DEFAULT_THRESHOLD;
+    const exemptions = options.exemptions ?? [];
+    const clauses = extractPromptClauses(prompt, options.ignoredSections);
+    const findings = [];
+    for (let i = 0; i < clauses.length; i += 1) {
+        for (let j = i + 1; j < clauses.length; j += 1) {
+            const a = clauses[i];
+            const b = clauses[j];
+            if (a.section === b.section)
+                continue;
+            const containment = containmentOf(a.tokens, b.tokens);
+            if (containment < threshold)
+                continue;
+            if (isExempt(a, b, exemptions))
+                continue;
+            findings.push({ a, b, containment });
+        }
+    }
+    return findings.sort((x, y) => y.containment - x.containment);
+}
+/** 供测试失败时打印——直接给出两处原文和所在段落，不用再去翻提示词。 */
+export function formatDuplicateFindings(findings) {
+    return findings
+        .map((item) => `[${item.containment.toFixed(2)}] 「${item.a.section}」${item.a.text}\n`
+        + `        ↔ 「${item.b.section}」${item.b.text}`)
+        .join('\n');
+}
+/**
+ * Cross-surface routing guard. The three Web tools intentionally have disjoint
+ * jobs, so stale fallback wording is a capability bug rather than style drift.
+ */
+export function findToolRoutingConflicts(prompt, tools) {
+    const conflicts = [];
+    const descriptions = new Map(tools.map((tool) => [
+        tool.name,
+        typeof tool.description === 'function' ? tool.description() : tool.description,
+    ]));
+    const browser = descriptions.get('WebBrowser') ?? '';
+    const combinedRouting = `${prompt}\n${browser}`;
+    if (/(?:Search\/Fetch|WebSearch\/WebFetch)[^\n]{0,100}(?:无法|失败|cannot obtain)[^\n]{0,100}(?:降级|fallback|WebBrowser)|supported fallback/i.test(combinedRouting)) {
+        conflicts.push({
+            toolName: 'WebBrowser',
+            reason: 'WebBrowser 被描述为 Search/Fetch 失败后的普通兜底',
+        });
+    }
+    const fetch = descriptions.get('WebFetch') ?? '';
+    if (/WebBrowser/i.test(fetch)) {
+        conflicts.push({
+            toolName: 'WebFetch',
+            reason: 'WebFetch description 不应把失败路由到 WebBrowser',
+        });
+    }
+    if (!/does not call another model/i.test(fetch)
+        && /process(?:es)?[^\n]{0,40}using an AI model|takes?[^\n]{0,30}prompt as input|performs? hidden summarization/i.test(fetch)) {
+        conflicts.push({
+            toolName: 'WebFetch',
+            reason: 'WebFetch description 声称存在实现中没有的模型处理步骤',
+        });
+    }
+    return conflicts;
+}

package/src/prompts/lint.ts

@@ -0,0 +1,220 @@
+/**
+ * ============================================================
+ *  src/prompts/lint.ts —— 系统提示词的跨层重复检查（确定性，无 LLM）
+ * ------------------------------------------------------------
+ *  **为什么需要它**：`promptAssembly.ts` 把提示词分成若干层（身份/纪律层、工具编排层、
+ *  Skills、Plugins、项目指令）。层与层之间很容易把同一条规则说两遍——写的时候各看各的段落，
+ *  读起来都通顺，拼起来就是重复烧 token、而且两处措辞一旦漂移就会互相矛盾。
+ *  人工清理一次能干净，但下一次加规则又会退化，所以要把「不重复」变成**回归护栏**。
+ *
+ *  **分层判据（去重时按它归位，不是凭感觉）**：
+ *    一条规则若在「该工具不存在时依然成立」→ 属身份层；否则属工具层。
+ *    例：「改文件前先读最新内容」没有 Edit 工具时无意义 → 工具层；
+ *        「只在无法推断时才提问」没有 AskUserQuestion 时仍成立（约束的是判断而非调用）→ 身份层。
+ *
+ *  **能力边界（必须如实说）**：这是**词面**近重复检测，不是语义检测。
+ *  「不用正则盲改源码」与「源码编辑优先专用工具」表达同一件事但几乎不共享字面，
+ *  本检查器**抓不到**——那类只能靠人读。它保证的是：已经清理干净的地方不会因为
+ *  有人复制粘贴一句旧措辞而悄悄退化。
+ *
+ *  **为什么按「子句」而不是整条规则比**：整条规则通常长且各带自己的补充说明，
+ *  即使核心重复，整条的 Jaccard 也只有 0.1 量级（实测），根本触发不了。
+ *  拆成子句后重复的那一句会高度重合。
+ *
+ *  **为什么用 containment 而不是 Jaccard**：我们要问的是「这句话是不是在别处已经说过了」，
+ *  即**包含**关系；短句被长句涵盖时 Jaccard 会被长句的其余部分稀释，containment 不会。
+ * ============================================================
+ */
+
+import type { Tool } from '../types.js';
+
+/** 数据型段落：内容来自用户目录/项目文件，不是我们写的策略，不参与去重。 */
+const DEFAULT_IGNORED_SECTIONS = ['Skills', 'Plugins', '项目指令'];
+
+/** 子句短于这个 token 数就不参与比较——短句碰巧重合太常见，会淹没真信号。 */
+const MIN_TOKENS = 6;
+
+/** containment 达到这个值即判为「已经在别处说过」。 */
+const DEFAULT_THRESHOLD = 0.7;
+
+export interface PromptClause {
+  /** 所属段落标题（`# xxx` 里的 xxx）；顶部无标题内容归入 '（开头）'。 */
+  section: string;
+  /** 该子句所属的完整规则行，报错时给人看上下文。 */
+  rule: string;
+  /** 子句原文。 */
+  text: string;
+  tokens: Set<string>;
+}
+
+export interface DuplicateFinding {
+  a: PromptClause;
+  b: PromptClause;
+  /** |A∩B| / min(|A|,|B|)，1 表示一方被另一方完全涵盖。 */
+  containment: number;
+}
+
+/** 显式豁免。`reason` 是必填的——没有理由的豁免等于把检查器关掉。 */
+export interface DedupExemption {
+  a: string;
+  b: string;
+  reason: string;
+}
+
+export interface DedupOptions {
+  threshold?: number;
+  ignoredSections?: string[];
+  exemptions?: DedupExemption[];
+}
+
+/**
+ * 归一化：抹掉不影响语义的差异，让「先读取」和「读取」这类插字不至于把整句错开。
+ * 全角标点、markdown 强调、反引号代码标记一律去掉。
+ */
+function normalize(text: string): string {
+  return text
+    .replace(/[`*_~]/g, '')
+    .replace(/[，。；、：？！（）【】「」《》,.;:?!()[\]{}"'/\\-]/g, '')
+    .replace(/\s+/g, '')
+    .toLocaleLowerCase();
+}
+
+/**
+ * 中文按 2-gram、拉丁词按整词切。中文没有空格分词，bigram 是这里最稳的近似
+ * （memoryService.ts::terms 出于同样理由也用 bigram，保持一致）。
+ */
+function tokenize(normalized: string): Set<string> {
+  const tokens = new Set<string>();
+  for (const word of normalized.match(/[a-z0-9]+/g) ?? []) {
+    if (word.length > 1) tokens.add(word);
+  }
+  const cjk = normalized.replace(/[a-z0-9]+/g, '');
+  for (let index = 0; index + 1 < cjk.length; index += 1) {
+    tokens.add(cjk.slice(index, index + 2));
+  }
+  return tokens;
+}
+
+function containmentOf(a: Set<string>, b: Set<string>): number {
+  const smaller = a.size <= b.size ? a : b;
+  const larger = smaller === a ? b : a;
+  let shared = 0;
+  for (const token of smaller) if (larger.has(token)) shared += 1;
+  return smaller.size === 0 ? 0 : shared / smaller.size;
+}
+
+/**
+ * 把组装好的提示词拆成「段落 → 规则行 → 子句」。
+ * 只取以 `- ` 开头的规则行：段落里的说明性散文不是规则，重复也无害。
+ */
+export function extractPromptClauses(
+  prompt: string,
+  ignoredSections: string[] = DEFAULT_IGNORED_SECTIONS,
+): PromptClause[] {
+  const clauses: PromptClause[] = [];
+  let section = '（开头）';
+  for (const line of prompt.split(/\r?\n/)) {
+    const heading = line.match(/^#+\s+(.*)$/);
+    if (heading) {
+      section = heading[1]!.trim();
+      continue;
+    }
+    if (ignoredSections.some((ignored) => section.includes(ignored))) continue;
+    const rule = line.match(/^\s*-\s+(.*)$/)?.[1];
+    if (!rule) continue;
+    for (const piece of rule.split(/[；;。]/)) {
+      const text = piece.trim();
+      if (!text) continue;
+      const tokens = tokenize(normalize(text));
+      if (tokens.size < MIN_TOKENS) continue;
+      clauses.push({ section, rule, text, tokens });
+    }
+  }
+  return clauses;
+}
+
+function isExempt(a: PromptClause, b: PromptClause, exemptions: DedupExemption[]): boolean {
+  return exemptions.some((item) =>
+    (a.text.includes(item.a) && b.text.includes(item.b))
+    || (a.text.includes(item.b) && b.text.includes(item.a)));
+}
+
+/**
+ * 找出**跨段落**的近重复子句。同段落内的重复不报——同一段里连续两句共享措辞通常是
+ * 有意的并列表达，报出来只会逼人写豁免；真正烧 token 且会漂移的是跨层重复。
+ */
+export function findDuplicateClauses(
+  prompt: string,
+  options: DedupOptions = {},
+): DuplicateFinding[] {
+  const threshold = options.threshold ?? DEFAULT_THRESHOLD;
+  const exemptions = options.exemptions ?? [];
+  const clauses = extractPromptClauses(prompt, options.ignoredSections);
+  const findings: DuplicateFinding[] = [];
+  for (let i = 0; i < clauses.length; i += 1) {
+    for (let j = i + 1; j < clauses.length; j += 1) {
+      const a = clauses[i]!;
+      const b = clauses[j]!;
+      if (a.section === b.section) continue;
+      const containment = containmentOf(a.tokens, b.tokens);
+      if (containment < threshold) continue;
+      if (isExempt(a, b, exemptions)) continue;
+      findings.push({ a, b, containment });
+    }
+  }
+  return findings.sort((x, y) => y.containment - x.containment);
+}
+
+/** 供测试失败时打印——直接给出两处原文和所在段落，不用再去翻提示词。 */
+export function formatDuplicateFindings(findings: DuplicateFinding[]): string {
+  return findings
+    .map((item) =>
+      `[${item.containment.toFixed(2)}] 「${item.a.section}」${item.a.text}\n`
+      + `        ↔ 「${item.b.section}」${item.b.text}`)
+    .join('\n');
+}
+
+export interface ToolRoutingConflict {
+  toolName: string;
+  reason: string;
+}
+
+/**
+ * Cross-surface routing guard. The three Web tools intentionally have disjoint
+ * jobs, so stale fallback wording is a capability bug rather than style drift.
+ */
+export function findToolRoutingConflicts(
+  prompt: string,
+  tools: readonly Tool[],
+): ToolRoutingConflict[] {
+  const conflicts: ToolRoutingConflict[] = [];
+  const descriptions = new Map(tools.map((tool) => [
+    tool.name,
+    typeof tool.description === 'function' ? tool.description() : tool.description,
+  ]));
+  const browser = descriptions.get('WebBrowser') ?? '';
+  const combinedRouting = `${prompt}\n${browser}`;
+  if (/(?:Search\/Fetch|WebSearch\/WebFetch)[^\n]{0,100}(?:无法|失败|cannot obtain)[^\n]{0,100}(?:降级|fallback|WebBrowser)|supported fallback/i.test(combinedRouting)) {
+    conflicts.push({
+      toolName: 'WebBrowser',
+      reason: 'WebBrowser 被描述为 Search/Fetch 失败后的普通兜底',
+    });
+  }
+  const fetch = descriptions.get('WebFetch') ?? '';
+  if (/WebBrowser/i.test(fetch)) {
+    conflicts.push({
+      toolName: 'WebFetch',
+      reason: 'WebFetch description 不应把失败路由到 WebBrowser',
+    });
+  }
+  if (
+    !/does not call another model/i.test(fetch)
+    && /process(?:es)?[^\n]{0,40}using an AI model|takes?[^\n]{0,30}prompt as input|performs? hidden summarization/i.test(fetch)
+  ) {
+    conflicts.push({
+      toolName: 'WebFetch',
+      reason: 'WebFetch description 声称存在实现中没有的模型处理步骤',
+    });
+  }
+  return conflicts;
+}

package/src/prompts/pluginList.js

@@ -12,8 +12,8 @@ import { discoverPlugins } from '../plugins/commandRouter.js';
  * 扫描 plugins/ 目录，返回已安装插件的元数据摘要。
  * 复用 discoverPlugins() 的缓存结果，只提取轻量信息。
  */
-export async function getPluginMetaList() {
-    const manifests = await discoverPlugins();
+export async function getPluginMetaList(workingDir) {
+    const manifests = await discoverPlugins(workingDir);
     return manifests.map((m) => ({
         name: m.name,
         description: m.description ?? '(no description)',
@@ -31,24 +31,40 @@ export async function getPluginMetaList() {
  *   - 明确标注触发方式（"由用户通过 /xxx 激活"）
  *   - 无插件时返回空字符串（调用方自行决定是否追加）
  */
+/** 与 skillList 的 MAX_CATALOG_CHARS 同构：插件同样来自用户目录，条数不可预知。 */
+const MAX_CATALOG_CHARS = 4_000;
+const MAX_DESCRIPTION = 160;
 export function formatPluginHint(plugins) {
     if (plugins.length === 0)
         return '';
     const lines = [
-        '# 可用插件（/激活）',
-        '',
-        '以下是当前已安装的插件。插件只能由用户输入 /xxx 激活——**你不能代替用户执行插件命令，也绝不能模拟/伪造插件的输出**。',
-        '当用户的需求明显匹配某个插件时（如想定时执行任务而装有 cron 类插件），可以一句话告知对应的 /xxx 命令存在，由用户自己决定是否运行；其余时候不必主动提及插件。',
-        '',
+        '# Plugins',
+        '插件命令只能由用户输入 `/命令` 激活。你可以提示匹配的命令，但不能代替用户激活或伪造插件输出。',
     ];
-    for (const p of plugins) {
-        lines.push(`## /${p.name}`);
-        lines.push(`- **描述**: ${p.description}`);
-        if (p.commands.length > 0) {
-            const cmdList = p.commands.map((c) => `\`/${c.name}\``).join('、');
-            lines.push(`- **激活**: ${cmdList}`);
-        }
-        lines.push('');
+    // 预算与降级和 skillList 保持同一套语义：先丢描述、再丢条目，且被丢弃的条数如实报出。
+    // 插件列表来自 cwd + packageRoot 双源扫描，装得多时条数不可预知，此前完全没有上限。
+    const render = (withDescription) => plugins.map((plugin) => {
+        const commands = plugin.commands.map((command) => `/${command.name}`).join(', ');
+        const description = withDescription ? `: ${plugin.description.slice(0, MAX_DESCRIPTION)}` : '';
+        return `- ${plugin.name}${description}${commands ? ` — ${commands}` : ''}`;
+    });
+    const full = render(true);
+    if (full.join('\n').length <= MAX_CATALOG_CHARS)
+        return [...lines, ...full].join('\n');
+    const compact = render(false);
+    const kept = [];
+    let used = 0;
+    for (const line of compact) {
+        if (used + line.length > MAX_CATALOG_CHARS)
+            break;
+        used += line.length + 1;
+        kept.push(line);
     }
-    return lines.join('\n');
+    const dropped = plugins.length - kept.length;
+    return [
+        ...lines,
+        '- （插件较多，此处只列名称与命令入口。）',
+        ...kept,
+        ...(dropped > 0 ? [`- （另有 ${dropped} 个插件因篇幅未列出。）`] : []),
+    ].join('\n');
 }