minimal-agent 0.18.13 → 0.18.14

package/src/context/sshHosts.ts

@@ -1,312 +0,0 @@
-/**
- * ============================================================
- *  src/context/sshHosts.ts —— 工作区级 SSH 主机配置存储
- * ------------------------------------------------------------
- *  每个工作区（workspaceId，见 workspaceIndex.ts）独立一份 SSH 主机列表，
- *  **不进全局 config.json**——绿色版的 config.json 是卖家预置件（U 盘出厂
- *  即预配置好 API），不能承载终端用户自己录入的远程主机凭据（尤其是明文
- *  密码：Jetson 类设备常常只支持密码认证，见 SshHostConfig.authMethod）。
- *
- *  落盘路径：agentStateDir()/workspaces/<workspaceId>/ssh-hosts.json
- *  锁 + 原子写模式镜像 configFile.ts::acquireConfigLock（mkdir 锁目录 +
- *  owner.json + 陈旧锁检测），但这是独立文件独立锁，不与全局 config 锁
- *  互相阻塞。
- *
- *  workspaceId 缺失（临时/e2e/cron 工作目录，见 workspaceIndex.ts 的
- *  isTemporaryWorkspace）时，本模块的调用方（SSH/SSHUpload/SSHDownload
- *  三个工具）必须 fail-closed 报错，不得静默回落到某个共享位置——这与
- *  memoryAccess 默认 denied 是同一个哲学：没有工作区身份就没有可信的
- *  隔离边界。
- * ============================================================
- */
-
-import { randomUUID } from 'node:crypto';
-import { chmod, mkdir, readFile, rename, rm, stat, unlink, writeFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-
-import type { ShellKind } from '../tools/shared/permanentDeleteGuard.js';
-import { agentStateDir } from './agentHome.js';
-import { CONFIG_LIMITS, withinLimit } from '../config/numericLimits.js';
-
-export type SshAuthMethod = 'password' | 'privateKey';
-
-export interface SshHostConfig {
-  /** 模型和 CLI 都用这个引用主机；真实 host/密码永不进模型上下文。 */
-  alias: string;
-  host: string;
-  port: number;
-  username: string;
-  authMethod: SshAuthMethod;
-  password?: string;
-  privateKeyPath?: string;
-  passphrase?: string;
-  /**
-   * 远程执行命令时的 shell 语义——喂给 permanentDeleteReason() 挡永久删除。
-   * 必须显式声明：本地猜不出远程机器跑的是哪种 shell，历史上硬编码错过一次
-   * 真删过文件（见 permanentDeleteGuard.ts 头注），这里不能重蹈。
-   */
-  remoteShell: ShellKind;
-  /** 单次操作（连接+执行/传输）超时毫秒；缺省时调用方使用固定默认值。 */
-  timeoutMs?: number;
-}
-
-export interface SshHostsData {
-  hosts: SshHostConfig[];
-  defaultHostAlias: string | null;
-}
-
-interface SshHostsFileV1 {
-  version: 1;
-  hosts: SshHostConfig[];
-  defaultHostAlias: string | null;
-}
-
-const EMPTY_DATA: SshHostsData = { hosts: [], defaultHostAlias: null };
-const LOCK_STALE_MS = 120_000;
-const LOCK_WAIT_MS = 15_000;
-const ALIAS_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}$/;
-
-/** 标准 SSH 端口——唯一真值，向导默认值与 normalizeHost() 的兜底都从这里取。 */
-export const DEFAULT_SSH_PORT = 22;
-
-export function sshHostsFilePath(workspaceId: string): string {
-  return join(agentStateDir(), 'workspaces', workspaceId, 'ssh-hosts.json');
-}
-
-function processIsAlive(pid: number): boolean {
-  if (!Number.isInteger(pid) || pid <= 0) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return (error as NodeJS.ErrnoException).code === 'EPERM';
-  }
-}
-
-async function acquireLock(file: string): Promise<() => Promise<void>> {
-  const lockDir = `${file}.lock`;
-  const ownerFile = join(lockDir, 'owner.json');
-  const startedAt = Date.now();
-  await mkdir(dirname(file), { recursive: true, mode: 0o700 });
-  while (true) {
-    try {
-      await mkdir(lockDir, { mode: 0o700 });
-      await writeFile(ownerFile, JSON.stringify({ pid: process.pid, createdAt: Date.now() }), { mode: 0o600 });
-      return async () => { await rm(lockDir, { recursive: true, force: true }); };
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;
-      let stale = false;
-      try {
-        const [ownerRaw, info] = await Promise.all([readFile(ownerFile, 'utf8'), stat(lockDir)]);
-        const owner = JSON.parse(ownerRaw) as { pid?: number };
-        stale = typeof owner.pid === 'number' ? !processIsAlive(owner.pid) : Date.now() - info.mtimeMs > LOCK_STALE_MS;
-      } catch {
-        try { stale = Date.now() - (await stat(lockDir)).mtimeMs > LOCK_STALE_MS; } catch { stale = false; }
-      }
-      if (stale) { await rm(lockDir, { recursive: true, force: true }); continue; }
-      if (Date.now() - startedAt > LOCK_WAIT_MS) throw new Error('等待 SSH 主机配置锁超时');
-      await new Promise((resolveWait) => setTimeout(resolveWait, 40));
-    }
-  }
-}
-
-function normalizeHost(raw: unknown): SshHostConfig | null {
-  if (!raw || typeof raw !== 'object') return null;
-  const value = raw as Record<string, unknown>;
-  if (typeof value.alias !== 'string' || !ALIAS_RE.test(value.alias)) return null;
-  if (typeof value.host !== 'string' || !value.host.trim()) return null;
-  if (typeof value.username !== 'string' || !value.username.trim()) return null;
-  if (value.authMethod !== 'password' && value.authMethod !== 'privateKey') return null;
-  if (value.remoteShell !== 'bash' && value.remoteShell !== 'cmd' && value.remoteShell !== 'powershell') return null;
-  const port = typeof value.port === 'number' ? value.port : DEFAULT_SSH_PORT;
-  if (!withinLimit(port, CONFIG_LIMITS.sshPort)) return null;
-  const timeoutMs = typeof value.timeoutMs === 'number' ? value.timeoutMs : undefined;
-  if (timeoutMs !== undefined && !withinLimit(timeoutMs, CONFIG_LIMITS.sshTimeoutMs)) return null;
-  return {
-    alias: value.alias,
-    host: value.host,
-    port,
-    username: value.username,
-    authMethod: value.authMethod,
-    ...(typeof value.password === 'string' ? { password: value.password } : {}),
-    ...(typeof value.privateKeyPath === 'string' ? { privateKeyPath: value.privateKeyPath } : {}),
-    ...(typeof value.passphrase === 'string' ? { passphrase: value.passphrase } : {}),
-    remoteShell: value.remoteShell,
-    ...(timeoutMs !== undefined ? { timeoutMs } : {}),
-  };
-}
-
-function normalizeFile(parsed: unknown): SshHostsData | null {
-  if (!parsed || typeof parsed !== 'object') return null;
-  const raw = parsed as Record<string, unknown>;
-  if (raw.version !== 1 || !Array.isArray(raw.hosts)) return null;
-  const hosts = raw.hosts.flatMap((item) => {
-    const host = normalizeHost(item);
-    return host ? [host] : [];
-  });
-  const defaultHostAlias = typeof raw.defaultHostAlias === 'string' && hosts.some((h) => h.alias === raw.defaultHostAlias)
-    ? raw.defaultHostAlias
-    : null;
-  return { hosts, defaultHostAlias };
-}
-
-/** 读路径 fail-open：坏文件被隔离到旁路而不是让整个工作区永远读不出主机列表。 */
-async function quarantineCorruptFile(file: string, reason: string): Promise<void> {
-  const target = `${file}.corrupt-${Date.now()}`;
-  try {
-    await rename(file, target);
-    await writeFile(`${target}.reason.txt`, reason, { mode: 0o600 });
-  } catch { /* 文件在读和隔离之间消失也无妨，视同不存在 */ }
-}
-
-async function readUnlocked(workspaceId: string): Promise<SshHostsData> {
-  const file = sshHostsFilePath(workspaceId);
-  let raw: string;
-  try {
-    raw = await readFile(file, 'utf8');
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return EMPTY_DATA;
-    throw error;
-  }
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(raw);
-  } catch (error) {
-    await quarantineCorruptFile(file, `JSON 解析失败：${error instanceof Error ? error.message : String(error)}`);
-    return EMPTY_DATA;
-  }
-  const normalized = normalizeFile(parsed);
-  if (!normalized) {
-    await quarantineCorruptFile(file, 'SSH 主机配置文件结构不合法');
-    return EMPTY_DATA;
-  }
-  return normalized;
-}
-
-async function writeUnlocked(workspaceId: string, data: SshHostsData): Promise<void> {
-  const file = sshHostsFilePath(workspaceId);
-  const payload: SshHostsFileV1 = { version: 1, hosts: data.hosts, defaultHostAlias: data.defaultHostAlias };
-  const tmp = `${file}.${process.pid}.${randomUUID()}.tmp`;
-  try {
-    await mkdir(dirname(file), { recursive: true, mode: 0o700 });
-    await writeFile(tmp, JSON.stringify(payload, null, 2), { encoding: 'utf8', mode: 0o600 });
-    await rename(tmp, file);
-    await chmod(file, 0o600).catch(() => {});
-  } finally {
-    await unlink(tmp).catch(() => {});
-  }
-}
-
-/** 写入前的形状校验——别名唯一、必填字段非空、数字边界，defaultHostAlias 必须指向存在的主机或为 null。 */
-function assertValid(data: SshHostsData): void {
-  const seen = new Set<string>();
-  for (const host of data.hosts) {
-    if (!ALIAS_RE.test(host.alias)) throw new Error(`主机别名不合法：${host.alias}`);
-    if (seen.has(host.alias)) throw new Error(`主机别名重复：${host.alias}`);
-    seen.add(host.alias);
-    if (!host.host.trim()) throw new Error(`主机地址不能为空（alias=${host.alias}）`);
-    if (!host.username.trim()) throw new Error(`用户名不能为空（alias=${host.alias}）`);
-    if (!withinLimit(host.port, CONFIG_LIMITS.sshPort)) throw new Error(`端口超出范围（alias=${host.alias}）`);
-    if (host.timeoutMs !== undefined && !withinLimit(host.timeoutMs, CONFIG_LIMITS.sshTimeoutMs)) {
-      throw new Error(`超时时间超出范围（alias=${host.alias}）`);
-    }
-    if (host.authMethod === 'password' && !host.password) throw new Error(`密码认证缺少密码（alias=${host.alias}）`);
-    if (host.authMethod === 'privateKey' && !host.privateKeyPath) throw new Error(`密钥认证缺少私钥路径（alias=${host.alias}）`);
-  }
-  if (data.defaultHostAlias !== null && !seen.has(data.defaultHostAlias)) {
-    throw new Error(`默认主机 "${data.defaultHostAlias}" 不在主机列表中`);
-  }
-}
-
-/** 读-改-写的唯一入口：整个过程持锁，避免并发编辑丢更新。 */
-async function mutate(workspaceId: string, mutator: (current: SshHostsData) => SshHostsData): Promise<SshHostsData> {
-  const file = sshHostsFilePath(workspaceId);
-  const release = await acquireLock(file);
-  try {
-    const current = await readUnlocked(workspaceId);
-    const next = mutator(current);
-    assertValid(next);
-    await writeUnlocked(workspaceId, next);
-    return next;
-  } finally {
-    await release();
-  }
-}
-
-export async function listSshHosts(workspaceId: string): Promise<SshHostsData> {
-  return readUnlocked(workspaceId);
-}
-
-export async function addSshHost(workspaceId: string, host: SshHostConfig): Promise<SshHostsData> {
-  return mutate(workspaceId, (current) => {
-    if (current.hosts.some((h) => h.alias === host.alias)) throw new Error(`主机别名已存在：${host.alias}`);
-    const hosts = [...current.hosts, host];
-    return { hosts, defaultHostAlias: current.defaultHostAlias ?? (hosts.length === 1 ? host.alias : null) };
-  });
-}
-
-export async function updateSshHost(
-  workspaceId: string,
-  alias: string,
-  patch: Partial<Omit<SshHostConfig, 'alias'>>,
-): Promise<SshHostsData> {
-  return mutate(workspaceId, (current) => {
-    const index = current.hosts.findIndex((h) => h.alias === alias);
-    if (index < 0) throw new Error(`主机不存在：${alias}`);
-    const hosts = [...current.hosts];
-    hosts[index] = { ...hosts[index], ...patch };
-    return { hosts, defaultHostAlias: current.defaultHostAlias };
-  });
-}
-
-export async function removeSshHost(workspaceId: string, alias: string): Promise<SshHostsData> {
-  return mutate(workspaceId, (current) => {
-    const hosts = current.hosts.filter((h) => h.alias !== alias);
-    return {
-      hosts,
-      defaultHostAlias: current.defaultHostAlias === alias ? null : current.defaultHostAlias,
-    };
-  });
-}
-
-export async function setDefaultSshHost(workspaceId: string, alias: string | null): Promise<SshHostsData> {
-  return mutate(workspaceId, (current) => ({ ...current, defaultHostAlias: alias }));
-}
-
-export type ResolveSshHostResult =
-  | { ok: true; host: SshHostConfig }
-  | { ok: false; error: string };
-
-/**
- * 供 SSH/SSHUpload/SSHDownload 三个工具调用的解析入口：
- * 显式给了 alias 就按 alias 找；没给就退回该工作区的默认主机；
- * 两者都没有就明确报错，不静默选第一个（选错主机执行远程命令后果比报错严重）。
- */
-export async function resolveSshHost(workspaceId: string, aliasInput?: string): Promise<ResolveSshHostResult> {
-  const data = await listSshHosts(workspaceId);
-  if (aliasInput) {
-    const host = data.hosts.find((h) => h.alias === aliasInput);
-    if (!host) {
-      const known = data.hosts.map((h) => h.alias).join(', ') || '（无）';
-      return { ok: false, error: `未找到主机 "${aliasInput}"。已配置：${known}` };
-    }
-    return { ok: true, host };
-  }
-  if (data.defaultHostAlias) {
-    const host = data.hosts.find((h) => h.alias === data.defaultHostAlias);
-    if (host) return { ok: true, host };
-  }
-  if (data.hosts.length === 0) {
-    return { ok: false, error: '当前工作区尚未配置任何 SSH 主机，请先在 /config → 远程主机 (SSH) 中添加。' };
-  }
-  return { ok: false, error: `未指定主机且未设置默认主机。已配置：${data.hosts.map((h) => h.alias).join(', ')}` };
-}
-
-/** 给工具 description 用的轻量列表——只暴露 alias/host/username，绝不带密码。 */
-export async function describeSshHosts(workspaceId: string): Promise<string> {
-  const data = await listSshHosts(workspaceId);
-  if (data.hosts.length === 0) return '（当前工作区尚未配置任何 SSH 主机）';
-  return data.hosts
-    .map((h) => `${h.alias}(${h.username}@${h.host}:${h.port})${h.alias === data.defaultHostAlias ? ' [默认]' : ''}`)
-    .join(', ');
-}

package/src/loop/publication.js

@@ -1,94 +0,0 @@
-import { buildContextBudgetPlan } from '../context/budgetPlan.js';
-import { finalAnswerMessages } from '../runtime/finalAnswer.js';
-/** A one-way visibility boundary: never retract or regenerate visible text. */
-export async function* publishFinalAnswer(input) {
-    const { provider, messages, candidate, candidateFinishReason, output, chatFn, options, signal, conversationMode, turnUsage, } = input;
-    let lastFinishReason = candidateFinishReason;
-    let publicationError;
-    let publicationInterrupted = false;
-    let streamed = false;
-    let publishedText = '';
-    let publicationDone = false;
-    yield { type: 'stage_change', stage: 'streaming' };
-    try {
-        const publicationMessages = finalAnswerMessages(messages, candidate, output);
-        const publicationPlan = buildContextBudgetPlan({
-            provider,
-            history: publicationMessages,
-            tools: [],
-        });
-        if (publicationPlan.overBudget)
-            throw new Error('最终表达上下文超过模型输入上限，未发送请求。');
-        if (signal?.aborted || options.hasQueuedInput?.()) {
-            publicationInterrupted = true;
-            throw new Error('最终发布已取消。');
-        }
-        turnUsage.totalCalls += 1;
-        for await (const event of chatFn({
-            provider,
-            messages: publicationMessages,
-            tools: [],
-            signal,
-            conversationMode: conversationMode,
-            promptCache: options.promptCache,
-        })) {
-            if (event.type === 'done' && !publicationDone) {
-                publicationDone = true;
-                if (typeof event.promptTokens === 'number' || typeof event.outputTokens === 'number') {
-                    turnUsage.reportedCalls += 1;
-                    turnUsage.inputTokens += event.promptTokens ?? 0;
-                    turnUsage.outputTokens += event.outputTokens ?? 0;
-                }
-            }
-            if (signal?.aborted || options.hasQueuedInput?.()) {
-                publicationInterrupted = true;
-                break;
-            }
-            if (event.type === 'text_delta') {
-                // Final expression is live generation, not an exact-copy replay.
-                // Once visible, text is never replaced or joined with a different draft.
-                publishedText += event.delta;
-                streamed = true;
-                yield { type: 'text', delta: event.delta };
-            }
-            else if (event.type === 'tool_call_delta') {
-                throw new Error('最终表达阶段返回了非预期工具调用，未执行该工具。');
-            }
-            else if (event.type === 'done') {
-                publicationDone = true;
-                lastFinishReason = event.stopReason;
-                if (event.stopReason === 'aborted')
-                    publicationInterrupted = true;
-            }
-        }
-        if (!publicationDone && !publicationInterrupted)
-            throw new Error('最终答案流未正常结束。');
-        if (!publicationInterrupted && lastFinishReason !== 'stop' && lastFinishReason !== 'length')
-            throw new Error('最终答案流缺少有效的结束状态。');
-        if (!publishedText.trim() && !publicationInterrupted)
-            throw new Error('最终表达未返回正文。');
-    }
-    catch (error) {
-        publicationInterrupted ||=
-            signal?.aborted === true || options.hasQueuedInput?.() === true || error?.name === 'AbortError';
-        publicationError = error;
-    }
-    if (publicationError && !publicationInterrupted && !publishedText) {
-        yield {
-            type: 'warning',
-            message: '最终回答流未能开始，已一次性显示内部准备的答案；未进行新的事实核验。',
-        };
-        yield { type: 'text', delta: candidate };
-        streamed = true;
-        publishedText = candidate;
-        lastFinishReason = candidateFinishReason;
-        publicationError = undefined;
-    }
-    return {
-        text: publishedText,
-        lastFinishReason,
-        publicationError,
-        publicationInterrupted,
-        streamed,
-    };
-}

package/src/loop/publication.ts

@@ -1,124 +0,0 @@
-import { buildContextBudgetPlan } from '../context/budgetPlan.js';
-import { finalAnswerMessages } from '../runtime/finalAnswer.js';
-import type { OutputContract } from '../runtime/outputContract.js';
-import type { LoopEvent, Message, Provider, TurnResourceUsage } from '../types.js';
-import type { RunQueryOptions } from './options.js';
-
-type FinishReason = 'stop' | 'tool_calls' | 'length' | 'unknown' | 'aborted';
-/** A one-way visibility boundary: never retract or regenerate visible text. */
-export async function* publishFinalAnswer(input: {
-  provider: Provider;
-  messages: Message[];
-  candidate: string;
-  candidateFinishReason: FinishReason;
-  output: OutputContract;
-  chatFn: NonNullable<RunQueryOptions['chat']>;
-  options: Pick<RunQueryOptions, 'hasQueuedInput' | 'promptCache'>;
-  signal?: AbortSignal;
-  conversationMode: 'private' | 'group';
-  turnUsage: Omit<TurnResourceUsage, 'trustworthy'>;
-}): AsyncGenerator<
-  LoopEvent,
-  {
-    text: string;
-    lastFinishReason: FinishReason;
-    publicationError: unknown;
-    publicationInterrupted: boolean;
-    streamed: boolean;
-  }
-> {
-  const {
-    provider,
-    messages,
-    candidate,
-    candidateFinishReason,
-    output,
-    chatFn,
-    options,
-    signal,
-    conversationMode,
-    turnUsage,
-  } = input;
-  let lastFinishReason = candidateFinishReason;
-  let publicationError: unknown;
-  let publicationInterrupted = false;
-  let streamed = false;
-  let publishedText = '';
-  let publicationDone = false;
-  yield { type: 'stage_change', stage: 'streaming' };
-  try {
-    const publicationMessages = finalAnswerMessages(messages, candidate, output);
-    const publicationPlan = buildContextBudgetPlan({
-      provider,
-      history: publicationMessages,
-      tools: [],
-    });
-    if (publicationPlan.overBudget) throw new Error('最终表达上下文超过模型输入上限，未发送请求。');
-    if (signal?.aborted || options.hasQueuedInput?.()) {
-      publicationInterrupted = true;
-      throw new Error('最终发布已取消。');
-    }
-    turnUsage.totalCalls += 1;
-    for await (const event of chatFn({
-      provider,
-      messages: publicationMessages,
-      tools: [],
-      signal,
-      conversationMode: conversationMode,
-      promptCache: options.promptCache,
-    })) {
-      if (event.type === 'done' && !publicationDone) {
-        publicationDone = true;
-        if (typeof event.promptTokens === 'number' || typeof event.outputTokens === 'number') {
-          turnUsage.reportedCalls += 1;
-          turnUsage.inputTokens += event.promptTokens ?? 0;
-          turnUsage.outputTokens += event.outputTokens ?? 0;
-        }
-      }
-      if (signal?.aborted || options.hasQueuedInput?.()) {
-        publicationInterrupted = true;
-        break;
-      }
-      if (event.type === 'text_delta') {
-        // Final expression is live generation, not an exact-copy replay.
-        // Once visible, text is never replaced or joined with a different draft.
-        publishedText += event.delta;
-        streamed = true;
-        yield { type: 'text', delta: event.delta };
-      } else if (event.type === 'tool_call_delta') {
-        throw new Error('最终表达阶段返回了非预期工具调用，未执行该工具。');
-      } else if (event.type === 'done') {
-        publicationDone = true;
-        lastFinishReason = event.stopReason;
-        if (event.stopReason === 'aborted') publicationInterrupted = true;
-      }
-    }
-    if (!publicationDone && !publicationInterrupted) throw new Error('最终答案流未正常结束。');
-    if (!publicationInterrupted && lastFinishReason !== 'stop' && lastFinishReason !== 'length')
-      throw new Error('最终答案流缺少有效的结束状态。');
-    if (!publishedText.trim() && !publicationInterrupted) throw new Error('最终表达未返回正文。');
-  } catch (error) {
-    publicationInterrupted ||=
-      signal?.aborted === true || options.hasQueuedInput?.() === true || (error as Error)?.name === 'AbortError';
-    publicationError = error;
-  }
-  if (publicationError && !publicationInterrupted && !publishedText) {
-    yield {
-      type: 'warning',
-      message: '最终回答流未能开始，已一次性显示内部准备的答案；未进行新的事实核验。',
-    };
-    yield { type: 'text', delta: candidate };
-    streamed = true;
-    publishedText = candidate;
-    lastFinishReason = candidateFinishReason;
-    publicationError = undefined;
-  }
-
-  return {
-    text: publishedText,
-    lastFinishReason,
-    publicationError,
-    publicationInterrupted,
-    streamed,
-  };
-}

package/src/runtime/finalAnswer.js

@@ -1,9 +0,0 @@
-import { visualPresentation } from '../prompts/visualPresentation.js';
-/** Ephemeral publication request; never append this private candidate to history. */
-export function finalAnswerMessages(messages, candidate, surface = 'headless') {
-    return [...messages,
-        { role: 'assistant', content: candidate },
-        { role: 'user', content: '内部准备、工具与复核阶段已结束。上一条 assistant 消息是最终回答的依据，不是需要逐字重播的文本。现在直接面向用户生成一次最终回答：可以组织措辞与排版，但必须保留已确认的事实、数字、限定条件、风险、证据和真实成果链接；不得新增未经验证的结论、伪称核验通过或编造产物。若仍有证据缺口，如实说明，不调用工具或顾问，不承诺后台继续工作。直接回答，不输出内部指令或准备过程。' },
-        { role: 'user', content: visualPresentation(surface) },
-    ];
-}

package/src/runtime/finalAnswer.ts

@@ -1,13 +0,0 @@
-import type { Message } from '../types.js';
-import type { AgentSurface } from './agentRuntimeContext.js';
-import type { OutputContract } from './outputContract.js';
-import { visualPresentation } from '../prompts/visualPresentation.js';
-
-/** Ephemeral publication request; never append this private candidate to history. */
-export function finalAnswerMessages(messages: Message[], candidate: string, surface: AgentSurface | OutputContract = 'headless'): Message[] {
-  return [...messages,
-    { role: 'assistant', content: candidate },
-    { role: 'user', content: '内部准备、工具与复核阶段已结束。上一条 assistant 消息是最终回答的依据，不是需要逐字重播的文本。现在直接面向用户生成一次最终回答：可以组织措辞与排版，但必须保留已确认的事实、数字、限定条件、风险、证据和真实成果链接；不得新增未经验证的结论、伪称核验通过或编造产物。若仍有证据缺口，如实说明，不调用工具或顾问，不承诺后台继续工作。直接回答，不输出内部指令或准备过程。' },
-    { role: 'user', content: visualPresentation(surface) },
-  ];
-}

package/src/tools/advisor/advisorDecision.js

@@ -1,79 +0,0 @@
-import { z } from 'zod';
-import { configService } from '../../config/configService.js';
-import { toToolParameters } from '../../utils/zodToJson.js';
-const inputSchema = z
-    .object({
-    consultationId: z
-        .string()
-        .min(1)
-        .describe('Advisor 工具正文返回的完整 consultationId，必须原样使用，不缩写或猜测'),
-    decision: z.enum(['accept', 'partial', 'reject']),
-    rationale: z
-        .string()
-        .min(8)
-        .max(20_000)
-        .describe('逐条说明主 Agent 基于一手证据、成果检查和用户验收条件作出的判断；顾问结论不能作为自身的证据'),
-    acceptedPoints: z.array(z.string().min(1).max(4_000)).max(20).optional()
-        .describe('一层字符串数组，例如 ["补充互操作成本"]；不要嵌套数组或 XML item 标签'),
-    rejectedPoints: z.array(z.string().min(1).max(4_000)).max(20).optional()
-        .describe('一层字符串数组，例如 ["不采纳必须学的措辞：证据不足"]'),
-    verificationPlan: z.array(z.string().min(1).max(4_000)).max(20).optional()
-        .describe('一层字符串数组，每项一个待验证步骤；没有则省略'),
-    evidenceRefs: z.array(z.string().min(1).max(300)).max(40).optional()
-        .describe('已核对的一手工具结果 tool_call_id，必须真实存在。rationale 说明每条建议对应哪个引用；没有证据则省略并列 verificationPlan，记录为待验证而非通过'),
-})
-    .superRefine((value, ctx) => {
-    if (value.decision === 'partial' &&
-        (!value.acceptedPoints?.length || !value.rejectedPoints?.length)) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            path: ['decision'],
-            message: 'partial 必须同时列出 acceptedPoints 和 rejectedPoints',
-        });
-    }
-    if (value.decision === 'reject' && !value.rejectedPoints?.length) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            path: ['rejectedPoints'],
-            message: 'reject 必须列出被拒绝的顾问意见',
-        });
-    }
-});
-async function callWithContext(input, _signal, context) {
-    if (!context.advisorRuntime) {
-        return { ok: false, error: '当前运行没有待处理的 Advisor 协调器状态。' };
-    }
-    return context.advisorRuntime.recordDecision(input);
-}
-export const advisorDecisionTool = {
-    name: 'AdvisorDecision',
-    description: "Records the main Agent's evidence-based decision after a successful Advisor consultation. " +
-        'Optional audit record; this is not an execution or delivery gate. A recording error does not block the task. ' +
-        'The Advisor is a second opinion, not an authority: choose accept, partial, or reject based on primary evidence. ' +
-        'For partial/reject, explicitly identify rejected points and explain primary evidence and acceptance constraints. ' +
-        'Link evidenceRefs (existing tool_call_id) to points in rationale. Missing evidence is recorded as pending verification, not verified; continue the verificationPlan without another approval. A linked reference alone does not prove correctness.',
-    inputSchema,
-    parameters: toToolParameters(inputSchema),
-    isReadOnly: true,
-    isConcurrencySafe: false,
-    interruptBehavior: () => 'cancel',
-    resolveAvailability() {
-        const avail = configService.advisorAvailabilitySync();
-        if (!avail.configured)
-            return { available: false, signature: 'unconfigured' };
-        if (!avail.enabled || avail.mode === 'manual') {
-            return {
-                available: false,
-                signature: avail.enabled ? 'manual-only' : 'disabled',
-            };
-        }
-        return { available: true, signature: avail.modelId };
-    },
-    async call() {
-        return {
-            ok: false,
-            error: 'AdvisorDecision 只能在主 Agent 会话的 Advisor 咨询后调用。',
-        };
-    },
-    callWithContext,
-};