@lemoncat7/dsh-partner 1.12.0 → 1.14.0

package/lib/agent-runtime.js

@@ -1,33 +1,23 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { mkdir, realpath, stat, writeFile } from 'node:fs/promises';
 import { isAbsolute, join, relative, resolve, sep } from 'node:path';
-import { BlockAssembler, createToolResultMessage, createUserMessage } from '@deepseek-ai/dsh-llm';
-import { createScope, scopeOf, scopeParentOf } from '@deepseek-ai/dsh-scope';
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { scopeOf, scopeParentOf } from '@deepseek-ai/dsh-scope';
 import { SessionConfigurationIndex } from './companions/session-configuration.js';
+import { isMissingSession, SessionRecoveryJobs } from './companions/session-recovery.js';
 import { removeOwnedWorkspace } from './companions/workspace-cleanup.js';
 import { assertOwnedDirectory, removeOwnedDirectory } from './companions/directory-cleanup.js';
-import { concernObservationPrompt } from './autonomy.js';
 import { boundedConcernCheckMinutes } from './concern-domain.js';
 import { taskWorkContext } from './tasks/context.js';
 import { PARTNER_MEDIA_MAX_BYTES, safeMediaName } from './channel-message.js';
 import { listConcernFileSources } from './concern-sources.js';
 import { CONCERN_CREATED_NOTICE, renderConcernCreatedNotice } from './concern-notification.js';
-import { HEARTBEAT_LOCAL_COMMAND, heartbeatLocalCommandTool } from './heartbeat-command.js';
+import { executeObservationLoop } from './observation-loop.js';
 import { assistantTextAfter, renderPartnerPersona, renderToolProtocol, resolvePartnerAgentOptions as resolveAgentOptions } from './execution/agent-support.js';
 import { channelReplyPartsAfter } from './channels/delivery-policy.js';
 import { prepareChannelReply } from './channels/outbound-media.js';
 export { extractOutboundAttachments } from './channels/outbound-media.js';
 export { renderToolProtocol, resolvePartnerAgentOptions as resolveAgentOptions } from './execution/agent-support.js';
-const HEARTBEAT_TIMEOUT_MS = 115_000;
-const HEARTBEAT_DISCOVERY_BUDGET_MS = 72_000;
-const HEARTBEAT_TOOL_TIMEOUT_MS = 18_000;
-const HEARTBEAT_WEB_TOOL_TIMEOUT_MS = 30_000;
-const HEARTBEAT_TOOL_RESULT_LIMIT = 5_000;
-const HEARTBEAT_KNOWLEDGE_RESULT_LIMIT = 8_000;
-const HEARTBEAT_WEB_FETCH_RESULT_LIMIT = 40_000;
-const HEARTBEAT_WEB_SOURCE_RESULT_LIMIT = 125_000;
-const HEARTBEAT_AUDIT_INPUT_LIMIT = 320;
-const HEARTBEAT_AUDIT_OUTPUT_LIMIT = 520;
 const PARTNER_TASK_TIMEOUT_MS = 30 * 60_000;
 const HEARTBEAT_READ_ONLY_TOOLS = new Set([
     'knowledge_base_search',
@@ -41,8 +31,6 @@ const HEARTBEAT_READ_ONLY_TOOLS = new Set([
     'read',
 ]);
 const HEARTBEAT_FILE_UPDATE_TOOLS = new Set(['write', 'edit', 'str_replace_editor']);
-const HEARTBEAT_TOOLS = new Set([...HEARTBEAT_READ_ONLY_TOOLS, ...HEARTBEAT_FILE_UPDATE_TOOLS]);
-HEARTBEAT_TOOLS.add(HEARTBEAT_LOCAL_COMMAND);
 export class PartnerAgentRuntime {
     ctx;
     store;
@@ -66,6 +54,7 @@ export class PartnerAgentRuntime {
     preparedTurns = new WeakMap();
     observationJobs = new Map();
     agentSetupJobs = new Map();
+    sessionRecoveryJobs = new SessionRecoveryJobs();
     closed = false;
     questionAnswerer;
     constructor(ctx, store, defaultCwd, memory, reflection, concerns, composer) {
@@ -328,44 +317,6 @@ export class PartnerAgentRuntime {
                 this.heartbeatQueues.delete(key);
         }
     }
-    async persistKnowledgeObservations(companion, route, concerns, observations) {
-        const service = this.ctx.get('dshKnowledgeTracking');
-        if (service === undefined || observations.length === 0)
-            return;
-        const agent = await this.ensureAgent(companion, route);
-        const byId = new Map(concerns.map(item => [item.id, item]));
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(new Error('知识库观察记录超时')), 30_000);
-        timeout.unref?.();
-        try {
-            for (const observation of observations) {
-                if (observation.decision === 'drop')
-                    continue;
-                const concern = byId.get(observation.concernId);
-                if (concern === undefined)
-                    continue;
-                const references = concern.resources.filter(item => item.kind === 'knowledge').map(item => item.locator).slice(0, 4);
-                if (references.length === 0 && concern.watchKind !== 'knowledge')
-                    continue;
-                for (const reference of references.length > 0 ? references : [undefined]) {
-                    await service.record(agent, {
-                        id: observation.id,
-                        subject: concern.subject,
-                        event: observation.event,
-                        evidence: observation.evidence,
-                        source: observation.source,
-                        ...(reference === undefined ? {} : { reference }),
-                        at: observation.createdAt,
-                    }, controller.signal).catch(error => {
-                        this.ctx.logger.warn(`dsh-partner: knowledge observation fell back to local storage: ${errorMessage(error)}`);
-                    });
-                }
-            }
-        }
-        finally {
-            clearTimeout(timeout);
-        }
-    }
     async concernSources(companion, query = '') {
         const routes = this.store.snapshot().sessions
             .filter(item => item.companionId === companion.id)
@@ -390,6 +341,24 @@ export class PartnerAgentRuntime {
             clearTimeout(timeout);
         }
     }
+    async recordingSources(companion, query = '') {
+        const route = this.store.snapshot().sessions.filter(item => item.companionId === companion.id).sort((a, b) => b.lastMessageAt - a.lastMessageAt)[0];
+        const files = await listConcernFileSources(route?.cwd ?? partnerCwd(this.defaultCwd, companion.id), query, 24);
+        const bridge = this.ctx.get('dshKnowledgeNoteRecording');
+        const notes = bridge?.version === 1 ? await bridge.list(query, AbortSignal.timeout(8000)) : [];
+        return [...files.map(file => ({ kind: 'file', locator: file.label, label: file.label })), ...notes.map(note => ({ kind: 'note', locator: note.id, label: note.name }))];
+    }
+    async validateRecordingTarget(companion, raw) {
+        if (raw === undefined || raw === null)
+            return undefined;
+        if (!isRecord(raw) || typeof raw.locator !== 'string' || typeof raw.label !== 'string')
+            throw new Error('记录位置无效，请重新选择');
+        const choices = await this.recordingSources(companion, raw.kind === 'file' ? raw.locator : raw.label);
+        const selected = choices.find(item => item.kind === raw.kind && item.locator === raw.locator);
+        if (!selected)
+            throw new Error('记录位置已不存在或不可写，请重新选择');
+        return selected;
+    }
     async runHeartbeatWhenIdle(key, companion, route, concerns) {
         for (;;) {
             await this.queues.get(key)?.catch(() => { });
@@ -486,38 +455,9 @@ export class PartnerAgentRuntime {
         return true;
     }
     async driveScopedHeartbeat(conversation, companion, concerns) {
-        const scope = await createHeartbeatScope(this.ctx, conversation, concerns);
-        try {
-            return await this.driveEphemeralHeartbeat(scope.agent, companion, concerns);
-        }
-        finally {
-            await scope.dispose();
-        }
-    }
-    async driveEphemeralHeartbeat(agent, companion, concerns) {
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(new Error('伙伴心跳超过安全时限')), HEARTBEAT_TIMEOUT_MS);
-        timeout.unref?.();
-        try {
-            const execution = await runHeartbeatInference(this.ctx, agent, companion, concerns, controller.signal);
-            return controller.signal.aborted
-                ? { ...execution, error: '伙伴心跳超过安全时限，已收束并终止' }
-                : execution;
-        }
-        catch (error) {
-            const now = Date.now();
-            return {
-                concerns,
-                candidates: [],
-                startedAt: now,
-                completedAt: now,
-                tools: [],
-                error: controller.signal.aborted ? '伙伴心跳超过安全时限，已收束并终止' : errorMessage(error),
-            };
-        }
-        finally {
-            clearTimeout(timeout);
-        }
+        const access = await resolveHeartbeatFileAccess(conversation.session.header.cwd, concerns);
+        return executeObservationLoop({ ctx: this.ctx, conversation, companion, concerns, guard: (name, args) => heartbeatToolDenial(name, args, access), parse: parseConcernObservations, checkpoint: async (item, snapshot) => { if (!this.concerns)
+                throw new Error('关注存储不可用'); await this.concerns.checkpointRecording(item, snapshot); } });
     }
     async recordHeartbeatActivity(companion, route, execution, outcome, deliveryError) {
         const conversation = await this.ensureAgent(companion, route);
@@ -734,7 +674,7 @@ export class PartnerAgentRuntime {
         const id = companion.id;
         this.agentSetupJobs.set(id, (this.agentSetupJobs.get(id) ?? 0) + 1);
         try {
-            return await this.ensureAgentReady(companion, route);
+            return await this.sessionRecoveryJobs.run(route.sessionId, () => this.ensureAgentReady(companion, route));
         }
         finally {
             const left = (this.agentSetupJobs.get(id) ?? 1) - 1;
@@ -779,7 +719,10 @@ export class PartnerAgentRuntime {
                 setup,
             });
         }
-        catch {
+        catch (error) {
+            // Never turn a preset/loading/permission failure into a duplicate create.
+            if (!isMissingSession(error, route.sessionId))
+                throw error;
             handle = await this.ctx.agents.create({
                 sessionId: route.sessionId,
                 meta: {
@@ -960,123 +903,13 @@ export function renewedSession(previous, now = Date.now()) {
 export function partnerCwd(root, companionId) {
     return join(root, 'partners', companionId);
 }
-async function createHeartbeatScope(ctx, conversation, concerns) {
-    const parent = scopeOf(conversation.ctx);
-    if (parent === undefined)
-        throw new Error('伙伴心跳无法解析当前 Agent 作用域');
-    const availableTools = [...HEARTBEAT_TOOLS].filter(name => ctx.tools.get(name, conversation) !== undefined);
-    const policy = heartbeatToolPolicy(concerns, availableTools);
-    const allowedTools = [...policy.allowed];
-    const cwd = conversation.session.header.cwd;
-    if (!cwd)
-        throw new Error('伙伴心跳缺少当前伙伴工作目录');
-    const fileAccess = await resolveHeartbeatFileAccess(cwd, concerns);
-    const agent = {};
-    const scope = createScope(ctx, agent, { parent });
-    const agentCtx = scope.ctx.extend({ agent });
-    Object.assign(agent, {
-        id: conversation.id,
-        options: conversation.options,
-        session: conversation.session,
-        inbox: conversation.inbox,
-        status: 'idle',
-        ctx: agentCtx,
-        cancel: () => { },
-        whenIdle: async () => { },
-        runMaintenance: async (job) => job(new AbortController().signal),
-        send: () => { throw new Error('心跳作用域不接受会话消息'); },
-        followup: () => { throw new Error('心跳作用域不接受会话消息'); },
-        steer: () => { throw new Error('心跳作用域不接受会话消息'); },
-        inject: () => { throw new Error('心跳作用域不接受会话消息'); },
-    });
-    agentCtx.tools.presentAs('native');
-    agentCtx.tools.register(heartbeatLocalCommandTool(cwd));
-    if (allowedTools.length > 0)
-        agentCtx.tools.restrict({ allow: allowedTools });
-    agentCtx.tools.guard(exec => {
-        if (exec.name !== HEARTBEAT_LOCAL_COMMAND && !policy.allowed.has(exec.name))
-            return `当前挂念的来源策略不允许调用 ${exec.name}`;
-        return heartbeatToolDenial(exec.name, exec.arguments, fileAccess);
-    });
-    return { agent, dispose: () => scope.dispose() };
-}
 export function heartbeatToolPolicy(concerns, available) {
     const installed = new Set(available);
-    const hasLinkedFile = concerns.some(item => item.resources?.some(resource => resource.kind === 'file') === true);
+    const hasLinkedFile = concerns.some(item => item.recordTarget?.kind === 'file');
     return {
         allowed: new Set([...installed].filter(name => HEARTBEAT_READ_ONLY_TOOLS.has(name) || (hasLinkedFile && HEARTBEAT_FILE_UPDATE_TOOLS.has(name)))),
     };
 }
-async function runHeartbeatInference(ctx, agent, companion, concerns, signal) {
-    const startedAt = Date.now();
-    const traces = [];
-    const discoveryDeadline = startedAt + HEARTBEAT_DISCOVERY_BUDGET_MS;
-    try {
-        const selection = resolveAgentOptions(ctx.agentDefaultModel, companion);
-        if (!selection.provider || !selection.model)
-            throw new Error('伙伴心跳没有可用的模型路由');
-        const tools = ctx.tools.schemas(agent).filter(tool => HEARTBEAT_TOOLS.has(tool.name));
-        if (tools.length === 0)
-            throw new Error('伙伴心跳没有可用的只读发现工具');
-        const messages = [createUserMessage({
-                content: [{ type: 'text', text: concernObservationPrompt(concerns, agent.session.header.cwd) }],
-                source: { kind: 'plugin', plugin: '@lemoncat7/dsh-partner', form: 'notice', summary: '伙伴观察挂念变化' },
-            })];
-        for (;;) {
-            const discoveryOpen = Date.now() < discoveryDeadline;
-            const prepared = await ctx.llm.prepareCall(selection, signal);
-            const assembler = new BlockAssembler();
-            for await (const chunk of prepared.stream({
-                ...prepared.config,
-                messages,
-                system: renderPartnerPersona(companion, 'heartbeat'),
-                tools: discoveryOpen ? tools : [],
-                signal,
-            }))
-                assembler.push(chunk);
-            const finish = assembler.finish;
-            if (finish.kind === 'error' || finish.kind === 'aborted') {
-                throw new Error(`伙伴心跳模型调用失败：${finish.failure.message}`);
-            }
-            const response = assembler.message({ kind: 'model', provider: prepared.config.provider, model: prepared.config.model });
-            messages.push(response);
-            const pending = response.content.filter((block) => block.type === 'tool-call');
-            if (pending.length === 0) {
-                const output = textContent(response.content);
-                return {
-                    concerns,
-                    candidates: parseConcernObservations(output, new Set(concerns.map(item => item.id))),
-                    startedAt,
-                    completedAt: Date.now(),
-                    output,
-                    tools: traces,
-                };
-            }
-            for (const call of pending) {
-                const argumentsValue = boundHeartbeatToolArguments(call.name, parseHeartbeatToolArguments(call));
-                const toolStartedAt = Date.now();
-                const remainingDiscoveryMs = discoveryDeadline - toolStartedAt;
-                const result = remainingDiscoveryMs <= 0
-                    ? { isError: true, content: [{ type: 'text', text: '本轮发现阶段的时间预算已用完，请根据已有结果立即输出最终 Observation JSON。' }] }
-                    : await executeHeartbeatTool(ctx, agent, call, argumentsValue, signal, remainingDiscoveryMs);
-                const toolCompletedAt = Date.now();
-                const visibleContent = heartbeatToolContent(call.name, result.content);
-                traces.push({
-                    name: call.name,
-                    input: auditValue(argumentsValue, HEARTBEAT_AUDIT_INPUT_LIMIT),
-                    output: auditText(textContent(visibleContent) || '工具返回了非文本结果', HEARTBEAT_AUDIT_OUTPUT_LIMIT),
-                    startedAt: toolStartedAt,
-                    completedAt: toolCompletedAt,
-                    status: result.isError ? 'failed' : 'completed',
-                });
-                messages.push(createToolResultMessage({ callId: call.id, content: visibleContent, isError: result.isError }));
-            }
-        }
-    }
-    catch (error) {
-        return { concerns, candidates: [], startedAt, completedAt: Date.now(), tools: traces, error: errorMessage(error) };
-    }
-}
 export function parseConcernObservations(raw, allowedIds) {
     const match = raw.trim().match(/\{[\s\S]*\}/);
     if (!match)
@@ -1115,18 +948,10 @@ export function parseConcernObservations(raw, allowedIds) {
 function boundedScore(value) {
     return typeof value === 'number' && Number.isFinite(value) ? Math.min(1, Math.max(0, value)) : .5;
 }
-function parseHeartbeatToolArguments(call) {
-    try {
-        return JSON.parse(call.arguments);
-    }
-    catch {
-        return { __invalidArguments: call.arguments };
-    }
-}
 async function resolveHeartbeatFileAccess(cwd, concerns) {
     const root = await realpath(cwd);
     const writable = new Set();
-    const locators = concerns.flatMap(item => item.resources ?? []).filter(item => item.kind === 'file').map(item => item.locator);
+    const locators = concerns.flatMap(item => item.recordTarget?.kind === 'file' ? [item.recordTarget.locator] : []);
     for (const locator of new Set(locators)) {
         const lexical = resolve(root, locator);
         if (!pathInside(root, lexical) || isPartnerMemoryPath(relative(root, lexical)))
@@ -1144,6 +969,8 @@ async function resolveHeartbeatFileAccess(cwd, concerns) {
     return { root, writable };
 }
 export function heartbeatToolDenial(name, argumentsValue, access) {
+    if (['knowledge_note_references', 'knowledge_note_read', 'knowledge_note_update'].includes(name))
+        return '关注不处理依据中的笔记引用；记录仅使用手动配置的 recordTarget 和专用记录工具。';
     if (!isRecord(argumentsValue))
         return undefined;
     const isRead = ['glob', 'grep', 'read'].includes(name);
@@ -1165,70 +992,10 @@ export function heartbeatToolDenial(name, argumentsValue, access) {
     }
     return undefined;
 }
-async function executeHeartbeatTool(ctx, agent, call, argumentsValue, signal, remainingDiscoveryMs) {
-    const configuredTimeoutMs = call.name === 'web_fetch' || call.name === 'web_source' ? HEARTBEAT_WEB_TOOL_TIMEOUT_MS : HEARTBEAT_TOOL_TIMEOUT_MS;
-    const timeoutMs = Math.max(1, Math.min(configuredTimeoutMs, remainingDiscoveryMs));
-    const timeoutSignal = AbortSignal.timeout(timeoutMs);
-    const toolSignal = AbortSignal.any([signal, timeoutSignal]);
-    try {
-        return await ctx.tools.execute({ callId: call.id, name: call.name, arguments: argumentsValue, agent, signal: toolSignal });
-    }
-    catch (error) {
-        const message = timeoutSignal.aborted && !signal.aborted
-            ? `工具 ${call.name} 超过 ${timeoutMs / 1_000} 秒，已跳过；请按既有规则判断来源不可用，或根据已有结果收束。`
-            : `工具 ${call.name} 调用失败：${errorMessage(error)}`;
-        return { isError: true, content: [{ type: 'text', text: message }] };
-    }
-}
 function pathInside(root, target) {
     const value = relative(root, target);
     return value === '' || (value !== '..' && !value.startsWith(`..${sep}`) && !isAbsolute(value));
 }
-function boundHeartbeatToolArguments(name, value) {
-    if (!isRecord(value))
-        return value;
-    const bounded = { ...value };
-    if (name === 'knowledge_base_search' || name === 'knowledge_search')
-        bounded.limit = boundedInteger(value.limit, 4);
-    if (name === 'knowledge_read')
-        bounded.maxChars = boundedInteger(value.maxChars, HEARTBEAT_KNOWLEDGE_RESULT_LIMIT);
-    if (name === 'web_source')
-        bounded.max_chars = boundedInteger(value.max_chars, 120_000);
-    if (name === 'read')
-        bounded.limit = boundedInteger(value.limit, 80);
-    return bounded;
-}
-function heartbeatToolContent(name, content) {
-    let remaining = heartbeatToolResultLimit(name);
-    const bounded = [];
-    for (const block of content) {
-        if (remaining <= 0)
-            break;
-        if (block.type !== 'text') {
-            bounded.push(block);
-            continue;
-        }
-        const sanitized = name === 'glob'
-            ? block.text.split('\n').filter(line => !isPartnerMemoryPath(line.trim())).join('\n')
-            : block.text;
-        const text = sanitized.length <= remaining ? sanitized : `${sanitized.slice(0, Math.max(0, remaining - 1))}…`;
-        if (text)
-            bounded.push({ ...block, text });
-        remaining -= text.length;
-    }
-    if (bounded.length === 0 && name === 'glob')
-        return [{ type: 'text', text: '未发现可供心跳检查的普通工作文件；伙伴记忆与会话归档已从结果中排除。' }];
-    return bounded;
-}
-function heartbeatToolResultLimit(name) {
-    if (name === 'knowledge_read')
-        return HEARTBEAT_KNOWLEDGE_RESULT_LIMIT;
-    if (name === 'web_fetch')
-        return HEARTBEAT_WEB_FETCH_RESULT_LIMIT;
-    if (name === 'web_source')
-        return HEARTBEAT_WEB_SOURCE_RESULT_LIMIT;
-    return HEARTBEAT_TOOL_RESULT_LIMIT;
-}
 function isPartnerMemoryPath(value) {
     const normalized = value.replaceAll('\\', '/').replace(/^\.\//, '/');
     return /(?:^|\/)(?:memory(?:\/|-backup(?:-|\/)|$)|concerns(?:\/|$))/i.test(normalized);
@@ -1240,45 +1007,41 @@ function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 export function renderHeartbeatActivity(execution, outcome, deliveryError) {
-    const status = outcome === 'notified' ? '已通过微信提醒' : outcome === 'quiet' ? '无需主动提醒' : '执行失败';
+    const status = execution.blocked?.length ? '检查受阻' : outcome === 'notified' ? '已通过微信提醒' : outcome === 'quiet' ? '检查完成，无需主动提醒' : '执行失败';
     const lines = [
         `状态：${status}`,
         `本轮挂念：${execution.concerns.map(item => item.subject).join('；')}`,
         `用时：${formatDuration(execution.completedAt - execution.startedAt)}`,
         `工具：${execution.tools.length > 0 ? `${execution.tools.length} 次调用` : '未调用'}`,
+        ...(execution.recording ?? []).map(item => `记录同步：${execution.concerns.find(concern => concern.id === item.concernId)?.subject ?? item.concernId} · ${item.state === 'synced' ? '已写入手动指定位置' : '待同步（本轮未完成写入，下轮继续处理）'}`),
+        ...(execution.rounds?.length ? [`模型轮次：${execution.rounds.map(item => `${item.round}${item.phase === 'final' ? '（收尾）' : ''} / ${(item.modelMs / 1000).toFixed(1)}秒 / ${item.outputChars}字`).join('；')}`] : []),
     ];
     execution.tools.forEach((trace, index) => {
         lines.push('', `${index + 1}. ${trace.name} · ${trace.status === 'completed' ? '完成' : '失败'} · ${formatDuration(trace.completedAt - trace.startedAt)}`, `输入：${trace.input}`, `结果：${trace.output}`);
     });
+    for (const id of execution.blocked ?? [])
+        lines.push(`受阻事项：${execution.concerns.find(item => item.id === id)?.subject ?? id}；${execution.blockedReasons?.[id] ?? '目标数据尚未核实'}`);
     const changed = execution.observations ?? [];
     const conclusion = execution.error || deliveryError
         ? `失败原因：${deliveryError ?? execution.error}`
         : changed.length > 0
             ? `新变化：\n${changed.map(item => `- ${item.event}（${decisionLabel(item.decision)} · ${Math.round(item.interruptScore * 100)}）`).join('\n')}`
-            : '最终结论：本轮没有发现经过校验的新变化。';
+            : execution.concerns.some(item => item.recordingSnapshot) ? '最终结论：本轮仅执行记录同步，未抓取来源或发送变化提醒。' : '最终结论：本轮没有发现经过校验的新变化。';
     lines.push('', conclusion);
     return lines.join('\n');
 }
 function decisionLabel(value) {
     return value === 'notify' ? '已提醒' : value === 'feed' ? '伙伴动态' : value === 'defer' ? '顺手一提' : value === 'remember' ? '静默记下' : '忽略';
 }
-function auditValue(value, limit) {
-    try {
-        return auditText(JSON.stringify(value), limit);
-    }
-    catch {
-        return auditText(String(value), limit);
-    }
-}
-function auditText(value, limit) {
-    const text = value.trim().replace(/\n{3,}/g, '\n\n');
-    return text.length <= limit ? text : `${text.slice(0, limit - 1)}…`;
-}
 function formatDuration(milliseconds) {
     if (milliseconds < 1_000)
         return `${Math.max(0, milliseconds)} ms`;
     return `${(milliseconds / 1_000).toFixed(milliseconds < 10_000 ? 1 : 0)} 秒`;
 }
+function auditText(value, limit) {
+    const text = value.trim().replace(/\n{3,}/g, '\n\n');
+    return text.length <= limit ? text : `${text.slice(0, limit - 1)}…`;
+}
 function errorMessage(error) { return error instanceof Error ? error.message : String(error); }
 function textContent(content) {
     return content.filter((block) => block.type === 'text' && typeof block.text === 'string')