@v587d/capital-generation 2.9.1 → 2.9.2

package/CHANGELOG.md

@@ -7,6 +7,36 @@
 - **第三位（patch）**：不破坏既有工具 / 配置 / 会话的新增与修复（如 2.1.1、2.1.2）。
 - **第二位（minor）**：有需要用户知晓的行为变更，且段内附迁移说明（如 2.1.0 的图表呈现通道重做、2.2.0 的数据源与检索来源扩容、2.4.0 的**必须换宿主版本**、2.9.0 的选择器收敛与质检前置——本插件自己的工具与数据契约没变，所以只抬第二位）。
 
+## [2.9.2] - 2026-10-23
+
+`data_junior` 接入官方 PTC（`run_code`）：内层工具调用压进一段程序，多 Dataset 并发、`too_large`
+收窄与 skill 读取不再逐次往返模型。实机同类任务由 15 分钟级降到 2–3 分钟级；工具、数据契约、
+用户配置与宿主基线都不变。图表交付的收尾闸门同时修复结算通知竞争与同轮重复写入。
+
+### Added
+
+- **分析师的 PTC 执行面**：`data_junior` 只保留 `run_code` 直调，Dataset / skill / 出图委派 /
+  回传都通过 SDK `tools.*` 在程序内完成；不再挂 bash / pwsh，同时保住了“不读原始行”的边界。
+- **多 Dataset 并发与 `too_large` 自愈**：同一程序里可以 `Promise.all` 多份 `describe_dataset`；
+  结果过大时按 hint 收窄后继续，不再多开模型轮次。
+- **PTC 会话报告**：`npm run ptc:report` 汇总 `run_code` 段数、`Promise.all`、skill 打印、
+  `too_large` 与并发窗口，供实机验收。
+
+### Changed
+
+- **分析师提示词与三册协议同步 PTC 写法**：第一次加载协议就明确 skill 也要在 `run_code` 内用
+  `tools.skill`，不要直调原生工具；查询、profile 与可视化协议同步程序内调度。
+- **图表交付继续由收尾流写入**：`present_charts` 只记录清单，宿主在最终答复前统一落
+  `deliverables/presented`；结算通知不再阻塞收尾，且同一 exchange 不会重复写卡。
+
+### Fixed
+
+- **图表卡在结算通知竞争时丢失**：子 Agent 的 `subagent-settled` 通知在收尾流中途到达时，
+  不再被当成“还有待处理消息”；通知同时清掉已结算的直属子 Agent。
+- **同一轮重复交付**：后续 `finish` 帧缺少 `turn` 时不再写第二张卡。
+- **直调 skill 误调用**：软约束已把 `tools.skill` 提到第一次加载协议处；模型仍可能试错一次，
+  宿主拒绝后会自愈，不影响结果。
+
 ## [2.9.1] - 2026-10-21
 
 修复实机 `dsh web` 反馈的两处收尾体验：图表交付不再散落在等待轮，最终答复不再只剩一句

package/README.md

@@ -18,8 +18,9 @@
 <p align="center">
   <a href="https://awesome-dsh-plugin.com"><img src="https://awesome-dsh-plugin.com/badge.svg" alt="awesome · DSH plugin"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/License-MIT-green" alt="License"></a>
-  <a href="https://github.com/v587d/capital-generation/releases"><img src="https://img.shields.io/badge/version-2.9.1-9cf" alt="Version"></a>
+  <a href="https://github.com/v587d/capital-generation/releases"><img src="https://img.shields.io/badge/version-2.9.2-9cf" alt="Version"></a>
   <a href="https://www.npmjs.com/package/@v587d/capital-generation"><img src="https://img.shields.io/npm/v/%40v587d%2Fcapital-generation" alt="npm version"></a>
+  <a href="https://github.com/deepseek-ai/deepseek-harness"><img src="https://img.shields.io/badge/powered_by-dsh-4D6BFE?style=flat-square&logo=deepseek&logoColor=white" alt="powered-by-dsh"></a>
 </p>
 
 # Capital Generation
@@ -190,7 +191,7 @@ https://github.com/v587d/capital-generation
 - **安装后找不到模式？** 确认插件出现在「插件」→ 已安装列表；Web / CLI profile 安装后要重启该 profile，并在新会话选择模式。选择器里应看到自动模式、行情专家、资讯专员；分析师和绘图专员是自动模式的内部角色，不会出现在这里。
 - **配置在哪？** 打开「插件」→ 已安装的 **Capital Generation**，页面顶部就是「数据源 / 精选 Skills / 包含的组件」三格，五把密钥都在第一格；不在 DSH 的普通「设置」页面，也不用点进任何一行组件。保存密钥后新建会话再试。
 - **升级到 2.9.0 后，分析师和绘图专员去哪了？** 这一版把它们收进自动模式内部，不再出现在选择器与预设管理里，避免误开一个没有取数入口的空会话。旧会话仍能按原身份恢复；新任务直接用自动模式提出即可。
-- **桌面端升级后仍是旧版？** 桌面端安装时会固定所解析的版本，不会自动升级。卸载后重新安装，再到插件详情查看版本号；如需指定版本，可在地址末尾加 `#v2.9.1` 或 `@2.9.1`。
+- **桌面端升级后仍是旧版？** 桌面端安装时会固定所解析的版本，不会自动升级。卸载后重新安装，再到插件详情查看版本号；如需指定版本，可在地址末尾加 `#v2.9.2` 或 `@2.9.2`。
 - **刚发布的新版本装不到？** 桌面端取包时会跳过**刚发布不久**的版本（宿主侧包管理器的发布冷却策略，实测会静默装成上一个版本），国内镜像的同步也可能滞后一段时间。急着用最新代码，改用仓库地址安装最直接。
 - **网页抓取失败？** 配置卡片中的「允许启动本地提取网页内容」默认开启：AnySearch 提取失败时可尝试本机直连。关闭后，本机直连的具名来源查询也不可用；请检查该开关和网络连接。
 - **Wind 那部分会消耗积分？** 会。公告与新闻检索、宏观 / 行业 / 汇率指标、按日期区间取的历史 K 线都按次消耗你在 Wind 侧的额度；额度与条款以 Wind 为准，插件不做用量封顶。没配 `WIND_API_KEY` 时这几类不可用，其余功能照常。

package/chart-ui/README.md

@@ -90,9 +90,9 @@ route owner 自己负责，平台自己的 `/api` 与首页分别走 `connection
 
 ## 本轮呈现（官方交付通道）
 
-auto 模式下 `render_chart` 不再自动登记：主 Agent 在写最终答复前调用一次 `present_charts`，
-把本轮 `chart_ref` 汇总成一条**官方** `deliverables/presented` 事件写进"用户正在看的根会话"，
-把 `capital-analysis/charts/<chart_id>/chart.html` 登记为**收尾轮交付物**（单体载体仍在出图时
+auto 模式下 `render_chart` 不再自动登记：`present_charts` 只记录本轮图表，宿主在**收尾流结束、
+收尾消息落盘之前**写一条**官方** `deliverables/presented` 事件到"用户正在看的根会话"，把
+`capital-analysis/charts/<chart_id>/chart.html` 登记为**收尾轮交付物**（单体载体仍在出图时
 自动登记）：
 
 - 载荷只有官方契约字段：`turn` / `callId`（`capital-chart:<chart_id>` 句柄）/ `files[]`

package/chart-ui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@v587d/capital-charts",
-  "version": "2.9.1",
+  "version": "2.9.2",
   "description": "自动模式的图表前端组件（浏览器半边 + 序列旁路路由）：由 @v587d/capital-generation 随包携带并作为 host 平面行挂载。",
   "license": "MIT",
   "type": "module",

package/config/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@v587d/config",
-  "version": "2.9.1",
+  "version": "2.9.2",
   "description": "自动模式的取数凭据与偏好配置行：卡片坐在 @v587d/capital-generation 插件主页的「配置」段，点这一行本身没有表单。",
   "license": "MIT",
   "type": "module",

package/lib/agents/bash-guard.d.ts

@@ -1,13 +1,17 @@
-/** Shell guard for bash/pwsh: blocks only doomed sandbox escalation; command content is never
- * inspected (the sandbox blocks writes, not reads/network). Delegated approvals are fixed to
- * `never`, so escalation auto-rejects with a misleading "user rejected"; block early instead.
- * Root escalation still uses ask; do not pin delegated sessions read-only (`store.writeContext`
- * needs workspace-write). `tools.guard` is monotonic; pre-execute is a rewritable waterfall. */
+/** Execution guard for bash/pwsh/run_code: blocks only doomed sandbox escalation; command/program
+ * content is never inspected (the sandbox blocks writes, not reads/network). Delegated approvals
+ * are fixed to `never`, so escalation auto-rejects with a misleading "user rejected"; block early
+ * instead. Root escalation still uses ask; do not pin delegated sessions read-only
+ * (`store.writeContext` needs workspace-write). `tools.guard` is monotonic; pre-execute is a
+ * rewritable waterfall. */
 import { type GuardedExecution, type PolicyContext } from './root-tool-policy.js';
+/** Both shell names on every platform plus the PTC transport: the preset mounts one shell pair for
+ * the root and `run_code` for data_junior, so matching only the local platform kills the Windows gate. */
+export declare const EXECUTION_ESCALATION_TOOL_NAMES: readonly ["bash", "pwsh", "run_code"];
 export type BashGuardExecution = GuardedExecution;
 /** States that the rejection is the system's, not the user's, and gives the recovery path. */
 export declare const SHELL_ESCALATION_UNREACHABLE: string;
-/** Reads identity plus `sandbox_permissions`/`justification`, never `command`; unknown identity fails closed. */
+/** Reads identity plus `sandbox_permissions`/`justification`, never `command`/`code`; unknown identity fails closed. */
 export declare function bashGuardReason(exec: BashGuardExecution | undefined): string | undefined;
 /** Installs on every Capital preset agent. Must listen on `ctx.root`: agent/created routes by
  * the agent object, so tagged standing-scope listeners never fire. Failures only warn. */

package/lib/agents/bash-guard.js

@@ -1,23 +1,26 @@
-/** Shell guard for bash/pwsh: blocks only doomed sandbox escalation; command content is never
- * inspected (the sandbox blocks writes, not reads/network). Delegated approvals are fixed to
- * `never`, so escalation auto-rejects with a misleading "user rejected"; block early instead.
- * Root escalation still uses ask; do not pin delegated sessions read-only (`store.writeContext`
- * needs workspace-write). `tools.guard` is monotonic; pre-execute is a rewritable waterfall. */
+/** Execution guard for bash/pwsh/run_code: blocks only doomed sandbox escalation; command/program
+ * content is never inspected (the sandbox blocks writes, not reads/network). Delegated approvals
+ * are fixed to `never`, so escalation auto-rejects with a misleading "user rejected"; block early
+ * instead. Root escalation still uses ask; do not pin delegated sessions read-only
+ * (`store.writeContext` needs workspace-write). `tools.guard` is monotonic; pre-execute is a
+ * rewritable waterfall. */
 import { agentSessionId, isCapitalPresetAgent, SHELL_TOOL_NAMES } from './root-tool-policy.js';
-/** Both names on every platform: the preset mounts a pair, so matching only the local platform kills the Windows gate. */
-const shellToolNames = new Set(SHELL_TOOL_NAMES);
+/** Both shell names on every platform plus the PTC transport: the preset mounts one shell pair for
+ * the root and `run_code` for data_junior, so matching only the local platform kills the Windows gate. */
+export const EXECUTION_ESCALATION_TOOL_NAMES = [...SHELL_TOOL_NAMES, 'run_code'];
+const executionToolNames = new Set(EXECUTION_ESCALATION_TOOL_NAMES);
 /** One listener set per root context: host policy and legacy call sites install once. */
 const installedRoots = new WeakSet();
 /** States that the rejection is the system's, not the user's, and gives the recovery path. */
-export const SHELL_ESCALATION_UNREACHABLE = 'shell 工具（bash / pwsh）的沙箱升级只有主 Agent 的会话能拿到用户审批：被委派的子会话拿不到'
+export const SHELL_ESCALATION_UNREACHABLE = '执行工具（bash / pwsh / run_code）的沙箱升级只有主 Agent 的会话能拿到用户审批：被委派的子会话拿不到'
     + '（框架把委派会话的审批策略固定为 never，不会去问用户），当前调用方也不是可确认的主 Agent 会话。'
     + '不要重试升级：缺数值用 describe_dataset / query_dataset，缺数据用 send_message 发 data_gap 回主 Agent。';
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-/** Reads identity plus `sandbox_permissions`/`justification`, never `command`; unknown identity fails closed. */
+/** Reads identity plus `sandbox_permissions`/`justification`, never `command`/`code`; unknown identity fails closed. */
 export function bashGuardReason(exec) {
-    if (exec === undefined || typeof exec.name !== 'string' || !shellToolNames.has(exec.name))
+    if (exec === undefined || typeof exec.name !== 'string' || !executionToolNames.has(exec.name))
         return undefined;
     const args = isRecord(exec.arguments) ? exec.arguments : undefined;
     const escalated = args !== undefined && (args.sandbox_permissions !== undefined || args.justification !== undefined);
@@ -64,7 +67,7 @@ export function registerBashGuard(ctx) {
                     return;
                 const dispose = installAgentGuard(agent);
                 if (dispose === undefined) {
-                    ctx.logger?.warn('capital-generation: shell 闸门未生效（agent scope 上没有 tools.guard）：沙箱升级拦截只剩 persona 软约束');
+                    ctx.logger?.warn('capital-generation: 执行工具闸门未生效（agent scope 上没有 tools.guard）：沙箱升级拦截只剩 persona 软约束');
                     return;
                 }
                 const id = agentSessionId(agent);
@@ -72,7 +75,7 @@ export function registerBashGuard(ctx) {
                     guards.set(id, dispose);
             }
             catch (error) {
-                ctx.logger?.warn(`capital-generation: bash 闸门安装异常：${error instanceof Error ? error.message : String(error)}`);
+                ctx.logger?.warn(`capital-generation: 执行工具闸门安装异常：${error instanceof Error ? error.message : String(error)}`);
             }
         });
         const stopDisposed = listenCtx.on?.('agent/disposed', (payload) => {

package/lib/agents/root-tool-policy.js

@@ -47,6 +47,8 @@ export const ROOT_AGENT_DENIED_TOOLS = [
     'write',
     'edit',
 ];
+// ⛔ `run_code` belongs nowhere in this list: it is a reserved PTC transport name, so `restrict()`
+// throws on it. The root stays native; deployment-level `dsh-tools.mode` must not be set to ptc.
 export const CAPITAL_PRESET_ID = ROOT_PRESET_ID;
 export function isRootAgent(agent) {
     if (agent?.session === undefined)

package/lib/chart/delivery.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Chart delivery at the closing answer.
+ *
+ * DSH's deliverable card only replays `deliverables/presented` events whose seq is before the
+ * turn's closing assistant message, and a turn is final only after the fact. The one place that is
+ * provably before the closing message is the assistant stream's terminal `finish` chunk: the loop
+ * appends the message after the stream ends. So delivery is deferred to that chunk, gated on the
+ * root session being idle (no actionable inbox input, no running direct children), which is exactly
+ * the shape of a closing turn. Waiting/aborted/tool-call responses never flush.
+ *
+ * `subagent-settled` notices are not actionable input: they can arrive while the closing answer is
+ * already streaming. Counting them as pending would strand a card that the model has just selected,
+ * because the follow-up step often has nothing new to say.
+ */
+import type { ChartArtifactRegistry } from './artifact-ref.js';
+import type { ChartTurnEventInput } from './events.js';
+import type { SessionLike } from '../data-collector/store.js';
+/** Structural subset of `@deepseek-ai/dsh-llm` AssistantStreamFrame. */
+export interface AssistantStreamFrameLike {
+    readonly type?: string;
+    readonly attemptId?: string;
+    readonly turn?: number;
+    readonly chunk?: {
+        readonly type?: string;
+        readonly reason?: {
+            readonly kind?: string;
+        };
+        readonly blockType?: string;
+        readonly block?: {
+            readonly type?: string;
+        };
+    };
+}
+interface InboxStateLike {
+    'next-turn'?: readonly unknown[];
+    'next-step'?: readonly unknown[];
+}
+export interface ChartDeliveryOptions {
+    artifacts: ChartArtifactRegistry;
+    /** Writes one first-party deliverables/presented batch; must be synchronous (pre-message seq). */
+    publish: (sessionId: string, inputs: ChartTurnEventInput[]) => boolean;
+    /** Durable pending input; synchronous projection read. Absent means "cannot tell" → proceed. */
+    inboxOf?: (session: SessionLike) => InboxStateLike | undefined;
+    /** Bounded batch; the card collapses past four files and expands on demand. */
+    maxCharts?: number;
+}
+export interface ChartDelivery {
+    /** `present_charts` selection; merged across calls because models often retry in batches. */
+    request(session: SessionLike, inputs: ChartTurnEventInput[]): void;
+    acceptStream(session: SessionLike | undefined, frame: AssistantStreamFrameLike): void;
+    /** A new human message starts a new exchange: old charts must not ride into it. */
+    acceptUserMessage(sessionId: string, time: number): void;
+    acceptSubagentStart(info: {
+        id?: string;
+    }): void;
+    acceptSubagentEnd(info: {
+        id?: string;
+    }): void;
+    /** False until any stream frame was observed: callers fall back to immediate delivery. */
+    streaming(): boolean;
+    /** Diagnostics/tests: explicitly selected inputs for the current exchange. */
+    pending(sessionId?: string): number;
+}
+export declare const DEFAULT_MAX_DELIVERED_CHARTS = 32;
+export declare function createChartDelivery(options: ChartDeliveryOptions): ChartDelivery;
+export {};

package/lib/chart/delivery.js

@@ -0,0 +1,148 @@
+/** Settlement notices race the closing answer; they do not require another model step before the card. */
+function isSettledNotice(value) {
+    return value !== null && typeof value === 'object'
+        && value.source?.kind === 'subagent-settled';
+}
+function inboxMessages(inbox) {
+    return [...(inbox?.['next-turn'] ?? []), ...(inbox?.['next-step'] ?? [])];
+}
+export const DEFAULT_MAX_DELIVERED_CHARTS = 32;
+export function createChartDelivery(options) {
+    const maxCharts = options.maxCharts ?? DEFAULT_MAX_DELIVERED_CHARTS;
+    /** Plugin instances are per root agent, so one session id guards against child streams leaking in. */
+    let sessionId;
+    let explicit = [];
+    const exchangeStarts = new Map();
+    const fallbackStart = Date.now();
+    let lastFlushedTurn;
+    let sawFrame = false;
+    const attempts = new Map();
+    const running = new Map();
+    const owns = (session) => {
+        if (session?.id === undefined)
+            return false;
+        // A leaked child frame must not bind the manager: the card belongs to the user-facing root.
+        if (session.header?.origin === 'subagent')
+            return false;
+        sessionId ??= session.id;
+        return session.id === sessionId;
+    };
+    const autoInputs = (session) => options.artifacts
+        .list({ session })
+        .filter((artifact) => artifact.created_at >= (exchangeStarts.get(session.id) ?? fallbackStart))
+        .map((artifact) => ({
+        ownerSessionId: session.id,
+        chart_id: artifact.chart_id,
+        title: artifact.title,
+        html_path: artifact.html_path,
+    }));
+    /** A settled notice proves the child is done even if the lifecycle edge was missed or the parent
+     * observed it outside its scope. Reconciliating here keeps the stream-time gate synchronous. */
+    const reconcileSettled = (inbox) => {
+        for (const message of inboxMessages(inbox)) {
+            if (!isSettledNotice(message))
+                continue;
+            const childId = message.source?.senderSessionId;
+            if (typeof childId === 'string')
+                running.delete(childId);
+        }
+    };
+    const idle = (inbox) => {
+        if (running.size > 0)
+            return false;
+        if (inbox === undefined)
+            return true;
+        return inboxMessages(inbox).every(isSettledNotice);
+    };
+    const flush = (session, turn) => {
+        // A later step in the same exchange may omit `turn`; it still must not write a second card.
+        if (lastFlushedTurn !== undefined && (turn === undefined || lastFlushedTurn === turn))
+            return;
+        const inbox = options.inboxOf?.(session);
+        reconcileSettled(inbox);
+        if (!idle(inbox))
+            return;
+        const inputs = (explicit.length > 0 ? explicit : autoInputs(session)).slice(0, maxCharts);
+        if (inputs.length === 0)
+            return;
+        let written = false;
+        try {
+            written = options.publish(session.id, inputs);
+        }
+        catch {
+            written = false;
+        }
+        // Sentinel keeps a second turn-less finish in the same exchange from duplicating the card.
+        if (written)
+            lastFlushedTurn = turn ?? -1;
+    };
+    return {
+        request(session, inputs) {
+            if (!owns(session) || inputs.length === 0)
+                return;
+            const seen = new Set(explicit.map((item) => item.chart_id));
+            for (const input of inputs) {
+                if (seen.has(input.chart_id))
+                    continue;
+                seen.add(input.chart_id);
+                explicit.push(input);
+            }
+            if (explicit.length > maxCharts)
+                explicit = explicit.slice(0, maxCharts);
+        },
+        acceptStream(session, frame) {
+            if (!owns(session) || frame === undefined)
+                return;
+            sawFrame = true;
+            const attemptId = frame.attemptId ?? '__default__';
+            if (frame.type === 'start') {
+                attempts.set(attemptId, { toolCall: false });
+                return;
+            }
+            if (frame.type === 'end') {
+                attempts.delete(attemptId);
+                return;
+            }
+            const chunk = frame.chunk;
+            if (frame.type !== 'chunk' || chunk === undefined)
+                return;
+            const attempt = attempts.get(attemptId) ?? { toolCall: false };
+            attempts.set(attemptId, attempt);
+            if (chunk.type === 'tool-call-delta'
+                || (chunk.type === 'block-start' && chunk.blockType === 'tool-call')
+                || (chunk.type === 'block-end' && chunk.block?.type === 'tool-call')) {
+                attempt.toolCall = true;
+                return;
+            }
+            if (chunk.type !== 'finish' || chunk.reason?.kind !== 'stop' || attempt.toolCall)
+                return;
+            flush(session, frame.turn);
+        },
+        acceptUserMessage(id, time) {
+            exchangeStarts.set(id, time);
+            if (id !== sessionId)
+                return;
+            explicit = [];
+            lastFlushedTurn = undefined;
+        },
+        acceptSubagentStart(info) {
+            if (typeof info?.id !== 'string' || info.id.length === 0)
+                return;
+            running.set(info.id, 1);
+        },
+        acceptSubagentEnd(info) {
+            if (typeof info?.id !== 'string')
+                return;
+            // One child session runs one activation at a time; deleting also clears duplicate starts.
+            running.delete(info.id);
+        },
+        streaming() {
+            return sawFrame;
+        },
+        pending(id) {
+            if (id !== undefined && id !== sessionId)
+                return 0;
+            return explicit.length;
+        },
+    };
+}

package/lib/chart/events.d.ts

@@ -38,6 +38,8 @@ export interface ChartTurnEventInput {
 }
 export interface ChartEventPublisher {
     publish(input: ChartTurnEventInput): boolean;
+    /** One first-party event carrying every file; the turn cap counts events, not files. */
+    publishMany(ownerSessionId: string, inputs: ChartTurnEventInput[]): boolean;
     /** Diagnostics: queued charts not yet written. */
     pendingCount?(ownerSessionId?: string): number;
     /** Diagnostics: last publish trace, surfaced in receipts / disk so failures are visible without a terminal. */

package/lib/chart/events.js

@@ -160,7 +160,7 @@ function buildChartEventPublisher(ctx) {
         const key = `${owner.id}:${turn}`;
         const used = perTurn.get(key) ?? 0;
         if (used >= MAX_CHARTS_PER_TURN) {
-            warn(`图表对话流事件跳过：turn ${turn} 已达到 ${MAX_CHARTS_PER_TURN} 张上限`);
+            warn(`图表对话流事件跳过：turn ${turn} 已达到 ${MAX_CHARTS_PER_TURN} 次上限`);
             return false;
         }
         try {
@@ -174,6 +174,31 @@ function buildChartEventPublisher(ctx) {
         note(`图表已登记为本轮交付（owner=${owner.id}，turn=${turn}，${input.chart_id}）`);
         return true;
     };
+    const appendMany = (owner, turn, inputs) => {
+        if (inputs.length === 0)
+            return false;
+        const key = `${owner.id}:${turn}`;
+        const used = perTurn.get(key) ?? 0;
+        if (used >= MAX_CHARTS_PER_TURN) {
+            warn(`图表对话流事件跳过：turn ${turn} 已达到 ${MAX_CHARTS_PER_TURN} 次上限`);
+            return false;
+        }
+        const first = inputs[0];
+        if (first === undefined)
+            return false;
+        const payload = buildChartEventPayload(first, turn);
+        payload.files = inputs.map((item) => ({ path: item.html_path, description: item.title }));
+        try {
+            owner.append(CHART_DELIVERABLE_EVENT, payload);
+        }
+        catch (error) {
+            warn(`图表对话流事件写入失败（图表已落盘）：${error instanceof Error ? error.message : String(error)}`);
+            return false;
+        }
+        perTurn.set(key, used + 1);
+        note(`图表已登记为本轮交付（owner=${owner.id}，turn=${turn}，${inputs.length} 张）`);
+        return true;
+    };
     /** Flush queued charts into a turn; the preferred hook is turn-stopping. */
     const flush = (ownerSessionId, turn) => {
         const queued = pending.get(ownerSessionId);
@@ -308,6 +333,32 @@ function buildChartEventPublisher(ctx) {
             lastPublishTrace = `${trace.join(' ')} 回合打开(turn=${lastTurn}) → ${written ? '已直接登记' : '写入失败'}`;
             return written;
         },
+        publishMany(ownerSessionId, inputs) {
+            const owner = resolveOwnerSession(sessions, ownerSessionId);
+            if (owner === undefined) {
+                lastPublishTrace = `owner 未解析：批量交付缺少可用 owner 会话`;
+                warn('图表对话流事件跳过：找不到批量交付的 owner 会话（图表已落盘，走 html_path 降级）');
+                return false;
+            }
+            const boundary = boundaryOf(owner);
+            const turn = boundary?.lastTurn;
+            if (typeof boundary?.openTurnStartSeq !== 'number' || typeof turn !== 'number' || !Number.isSafeInteger(turn) || turn < 1) {
+                // Between turns: queue each input so the existing flush path still delivers them later.
+                const queued = pending.get(owner.id) ?? [];
+                if (queued.length + inputs.length > MAX_PENDING_CHARTS) {
+                    lastPublishTrace = `owner=${owner.id} 批量寄存超限（${queued.length}+${inputs.length} > ${MAX_PENDING_CHARTS}）→ 未写入`;
+                    warn('图表对话流事件跳过：进程内寄存已超出上限（冲刷链路异常）');
+                    return false;
+                }
+                queued.push(...inputs);
+                pending.set(owner.id, queued);
+                lastPublishTrace = `owner=${owner.id} 回合未打开 → 已寄存 ${inputs.length} 张，等 turn-stopping/turn-start 冲刷`;
+                return true;
+            }
+            const written = appendMany(owner, turn, inputs);
+            lastPublishTrace = `owner=${owner.id} 回合打开(turn=${turn}) → ${written ? `已批量登记 ${inputs.length} 张` : '写入失败'}`;
+            return written;
+        },
         /** Diagnostics/tests: queued charts not yet flushed. */
         pendingCount(ownerSessionId) {
             if (ownerSessionId !== undefined)

package/lib/chart/present-tool.d.ts

@@ -10,10 +10,18 @@
 import type { Context } from '@deepseek-ai/cordis';
 import type { ChartArtifactRegistry } from './artifact-ref.js';
 import { type ChartEventPublisher } from './events.js';
+import type { ChartDelivery } from './delivery.js';
+import type { SessionLike } from '../data-collector/store.js';
+/** One card can carry many files (the client collapses past four); the cap only bounds one event. */
+export declare const MAX_PRESENT_CHARTS = 32;
 export interface PresentChartsInput {
     artifacts: ChartArtifactRegistry;
     /** Lazy: the host projection may mount after this row; an absent publisher fails the call loudly. */
     chartEvents: () => ChartEventPublisher | undefined;
+    /** Records the selection; the closing stream chunk writes it (normal path). */
+    delivery?: ChartDelivery;
+    /** Fallback-only guard when the stream listener is unavailable. */
+    readiness?: (session: SessionLike) => Promise<string | undefined>;
 }
 export interface PresentChartsReceipt {
     presented: Array<{

package/lib/chart/present-tool.js

@@ -1,5 +1,7 @@
 import { MAX_CHARTS_PER_TURN } from './events.js';
 import { callerSession } from '../tool-exec.js';
+/** One card can carry many files (the client collapses past four); the cap only bounds one event. */
+export const MAX_PRESENT_CHARTS = 32;
 const jsonObject = (properties = {}, required = []) => ({ type: 'object', properties, required, additionalProperties: false });
 const parameters = jsonObject({
     chart_refs: {
@@ -41,8 +43,8 @@ function normalizeRefs(value) {
         if (!refs.includes(ref))
             refs.push(ref);
     }
-    if (refs.length > MAX_CHARTS_PER_TURN) {
-        throw new Error(`present_charts 一次最多登记 ${MAX_CHARTS_PER_TURN} 张图（收到 ${refs.length} 个 chart_ref）`);
+    if (refs.length > MAX_PRESENT_CHARTS) {
+        throw new Error(`present_charts 一次最多登记 ${MAX_PRESENT_CHARTS} 张图（收到 ${refs.length} 个 chart_ref）`);
     }
     return refs;
 }
@@ -75,9 +77,9 @@ function selectArtifacts(input, session, refs, taskId) {
     const all = input.artifacts.list({ session, task_id: taskId });
     if (all.length === 0)
         failed.push({ chart_ref: '(task)', reason: `本会话该 task_id 没有可登记的图表：${taskId}` });
-    const selected = all.slice(0, MAX_CHARTS_PER_TURN);
-    if (all.length > MAX_CHARTS_PER_TURN) {
-        failed.push({ chart_ref: '(task)', reason: `该 task_id 有 ${all.length} 张图，本轮最多登记 ${MAX_CHARTS_PER_TURN} 张；其余未展示` });
+    const selected = all.slice(0, MAX_PRESENT_CHARTS);
+    if (all.length > MAX_PRESENT_CHARTS) {
+        failed.push({ chart_ref: '(task)', reason: `该 task_id 有 ${all.length} 张图，单次最多登记 ${MAX_PRESENT_CHARTS} 张；其余未展示` });
     }
     return { selected, failed };
 }
@@ -87,10 +89,10 @@ export function registerPresentChartsTool(ctx, input) {
         return;
     const definition = {
         name: 'present_charts',
-        description: '把本会话已生成的图表登记为**最终答复的交付物**（官方 deliverables/presented）：用户会在本轮答复末尾的「本轮文件改动 / 交付」行看到卡片，点开即渲染自包含 chart.html。'
-            + '**只由主 Agent 在写最终答复前调用一次**：参数是 data_junior 回传的 chart_refs（一次全部传入，最多 8 个）；refs 已丢失时改传 task_id 登记该任务的全部图表；调用后立刻写最终答复。'
-            + '不要在过程轮 / 等待行前调用，不要分批重复调用；不要传文件路径或 HTML（路径由宿主解析）。'
-            + '不调用本工具，图表不会出现在对话里。',
+        description: '把本会话已生成的图表登记为**最终答复的交付物**（官方 deliverables/presented）：用户会在答复末尾的「本轮文件改动 / 交付」行看到卡片，点开即渲染自包含 chart.html。'
+            + '**由主 Agent 调用一次**：参数是 data_junior 回传的 chart_refs（一次传入，最多 32 个）；refs 已丢失时改传 task_id 登记该任务的全部图表。'
+            + '这里只记录本轮要交付的图，宿主会在**最终答复之前**统一写入交付行——提前调用不会落进中间轮，不必等“最后一刻”，也不要在过程轮反复调用。'
+            + '不要传文件路径或 HTML（路径由宿主解析）；不调用时宿主仍会在收尾时自动登记本 exchange 已生成的图表。',
         parameters,
         async execute(args, exec) {
             const session = callerSession(exec);
@@ -99,23 +101,42 @@ export function registerPresentChartsTool(ctx, input) {
             if (refs.length === 0 && taskId === undefined) {
                 throw new Error('present_charts 需要 chart_refs 或 task_id：两者都不给就无法确定要登记哪几张图');
             }
+            const { selected, failed } = selectArtifacts(input, session, refs, taskId);
+            const receipt = { presented: [], failed };
+            if (selected.length === 0)
+                return receipt;
+            const inputs = selected.map((artifact) => ({
+                ownerSessionId: session.id,
+                chart_id: artifact.chart_id,
+                title: artifact.title,
+                html_path: artifact.html_path,
+            }));
+            // Normal path: remember the selection; the closing stream chunk writes it before the answer.
+            if (input.delivery?.streaming() === true) {
+                input.delivery.request(session, inputs);
+                for (const artifact of selected)
+                    receipt.presented.push({ chart_ref: artifact.chart_ref, title: artifact.title });
+                return receipt;
+            }
+            // Fallback path (stream listener unavailable): write now, but only when the turn is idle.
+            const blocked = await input.readiness?.(session);
+            if (blocked !== undefined)
+                throw new Error(blocked);
             const publisher = input.chartEvents();
             if (publisher === undefined) {
                 throw new Error('图表交付通道不可用（sessions / sessionProjections 解析不到）：图表已落盘，可在 workspace 打开 chart.html');
             }
-            const { selected, failed } = selectArtifacts(input, session, refs, taskId);
-            const receipt = { presented: [], failed };
-            for (const artifact of selected) {
-                const accepted = publisher.publish({
-                    ownerSessionId: session.id,
-                    chart_id: artifact.chart_id,
-                    title: artifact.title,
-                    html_path: artifact.html_path,
-                });
-                if (accepted)
+            const accepted = publisher.publishMany !== undefined
+                ? publisher.publishMany(session.id, inputs)
+                : inputs.every((item) => publisher.publish(item));
+            if (accepted) {
+                for (const artifact of selected)
                     receipt.presented.push({ chart_ref: artifact.chart_ref, title: artifact.title });
-                else
-                    receipt.failed.push({ chart_ref: artifact.chart_ref, reason: `本轮登记已达 ${MAX_CHARTS_PER_TURN} 张上限或回合已关闭，未写入交付行` });
+            }
+            else {
+                for (const artifact of selected) {
+                    receipt.failed.push({ chart_ref: artifact.chart_ref, reason: `本轮登记已达 ${MAX_CHARTS_PER_TURN} 次上限或回合已关闭，未写入交付行` });
+                }
             }
             return receipt;
         },

package/lib/data-collector/dataset-tools.js

@@ -364,7 +364,7 @@ export function registerDatasetTools(ctx, store, options = {}) {
                 withIsoTimeColumns(result, prepared.axis);
             return result;
         }),
-        tool('describe_dataset', `读取一份 Dataset 的**默认入口**：一次调用完成 inspect（元数据与可读性/形状）、profile（宿主算基础质量与四类事实，写入 profile_ref）与受控 query（可选）；原始 rows 不进入模型上下文。一次只处理一个 dataset_id——本轮有多份数据时，请在**同一条消息里一次发出多个调用**（本工具可并发执行，结果会一起返回），不要一份一份等。行集合返回：① 元数据 artifact_ref/capability/source_label/captured_at/retention_until 与 query_access.shape（array / envelope_item = 行集合；document = 顶层文档对象，只能 profile，queries 由宿主跳过）；② profile 四类事实——statistics（count/sum/min/max/mean/分位数）、categories（distinct + 最多 5 个高频取值）、time_facts（覆盖范围与首行/末行取值；回答"最新值、区间涨跌"必须用它，不要用 min/max 代替）、structure（嵌套路径摘要）；③ queries——每条的 QueryResult，或该条自己的 error（单条失败不影响其余）。columns_of_interest 只对这些列返回 statistics/categories/schema（并同样收窄 time_facts 的首末值投影，时间列永远保留），是收窄结果体积的唯一手段。结果超过 ${SAFE_RESULT_CHARS} 码点时宿主不返回超长载荷，而返回 {status:'too_large', profile_ref, columns, bytes, facts_bytes, queries_bytes, hint}：facts_bytes/queries_bytes 是体积归因（哪边大砍哪边），按 hint 重发一次即可——queries 大就先去掉 queries（聚合改单独走 query_dataset），facts 大就用 columns_of_interest 收窄列（或减少 queries，最多 ${MAX_DESCRIBE_QUERIES} 条）。单点复核仍可用 inspect_dataset / profile_dataset / query_dataset；不接受任何文件路径、脚本内容或自定义表达式。`, describeParametersSchema, describeResultSchema, async (args, exec) => describeDataset({
+        tool('describe_dataset', `读取一份 Dataset 的**默认入口**：一次调用完成 inspect（元数据与可读性/形状）、profile（宿主算基础质量与四类事实，写入 profile_ref）与受控 query（可选）；原始 rows 不进入模型上下文。一次只处理一个 dataset_id——本轮有多份数据时请并发调用本工具（PTC 在同一个 run_code 程序里用 Promise.all，native 在同一条消息里一次发出多个调用），不要一份一份等。行集合返回：① 元数据 artifact_ref/capability/source_label/captured_at/retention_until 与 query_access.shape（array / envelope_item = 行集合；document = 顶层文档对象，只能 profile，queries 由宿主跳过）；② profile 四类事实——statistics（count/sum/min/max/mean/分位数）、categories（distinct + 最多 5 个高频取值）、time_facts（覆盖范围与首行/末行取值；回答"最新值、区间涨跌"必须用它，不要用 min/max 代替）、structure（嵌套路径摘要）；③ queries——每条的 QueryResult，或该条自己的 error（单条失败不影响其余）。columns_of_interest 只对这些列返回 statistics/categories/schema（并同样收窄 time_facts 的首末值投影，时间列永远保留），是收窄结果体积的唯一手段。结果超过 ${SAFE_RESULT_CHARS} 码点时宿主不返回超长载荷，而返回 {status:'too_large', profile_ref, columns, bytes, facts_bytes, queries_bytes, hint}：facts_bytes/queries_bytes 是体积归因（哪边大砍哪边），按 hint 重发一次即可——queries 大就先去掉 queries（聚合改单独走 query_dataset），facts 大就用 columns_of_interest 收窄列（或减少 queries，最多 ${MAX_DESCRIBE_QUERIES} 条）。单点复核仍可用 inspect_dataset / profile_dataset / query_dataset；不接受任何文件路径、脚本内容或自定义表达式。`, describeParametersSchema, describeResultSchema, async (args, exec) => describeDataset({
             store,
             session: authorizedSession(ctx, exec, 'describe_dataset', DATASET_READING_PRESET_IDS),
             request: normalizeDescribeArgs(args),

package/lib/present-entry.d.ts

@@ -1,9 +1,19 @@
 /**
- * `tools/present` row: present_charts only. The root Agent's final-turn delivery step — the
- * auto-mode chart pipeline returns refs upward and the main Agent redeems them here right before
- * writing the closing answer (rationale: docs/dev/chart-delivery-events.md §6.3).
+ * `tools/present` row: present_charts + the closing-answer delivery listener.
+ *
+ * The model only records which charts belong to the answer. The actual first-party
+ * `deliverables/presented` append happens in the terminal assistant-stream chunk, before the closing
+ * message commits, gated on an idle root (no actionable inbox input, no running direct children). That is the only
+ * point where "the final answer" is knowable, so early/no `present_charts` calls cannot strand the
+ * card in a folded process turn (rationale: docs/dev/chart-delivery-events.md §6.3).
  */
 import type { Context } from '@deepseek-ai/cordis';
+import type { SessionLike } from './data-collector/store.js';
 export declare const name = "capital-present-tools";
 export declare const inject: string[];
+/**
+ * Fallback only: when the stream listener never fires, immediate delivery still has to avoid a
+ * pending turn. The normal path defers to the closing stream chunk and does not consult this.
+ */
+export declare function chartDeliveryBlocker(ctx: Context, session: SessionLike): Promise<string | undefined>;
 export declare function apply(ctx: Context): void;

package/lib/present-entry.js

@@ -1,13 +1,114 @@
+import { createChartDelivery } from './chart/delivery.js';
 import { createChartEventPublisher } from './chart/events.js';
 import { chartEventContextOf } from './chart/event-context.js';
 import { registerPresentChartsTool } from './chart/present-tool.js';
 import { capitalSharedRuntimeOf } from './chart-source-entry.js';
 export const name = 'capital-present-tools';
 export const inject = ['tools'];
+/**
+ * Fallback only: when the stream listener never fires, immediate delivery still has to avoid a
+ * pending turn. The normal path defers to the closing stream chunk and does not consult this.
+ */
+export async function chartDeliveryBlocker(ctx, session) {
+    const projections = ctx.get('sessionProjections');
+    try {
+        const inbox = projections?.stateOf(session, 'inbox');
+        // A settlement notice can race the closing answer; it must not block the card. Any relay or
+        // human input still means another model step is pending.
+        const pending = [...(inbox?.['next-turn'] ?? []), ...(inbox?.['next-step'] ?? [])]
+            .filter((message) => {
+            const source = message?.source;
+            return source?.kind !== 'subagent-settled';
+        }).length;
+        if (pending > 0) {
+            return `还有 ${pending} 条待处理消息（子 Agent 回传 / 结算）：现在登记会让卡片留在被折叠的中间轮。`
+                + '等这些消息处理完、写最终答复的那一步再调用 present_charts（refs 记不清就传 task_id）。';
+        }
+    }
+    catch {
+        // Projection unavailable: delivery availability matters more than the guard.
+    }
+    const subagents = ctx.get('subagents');
+    if (typeof subagents?.listDescendants === 'function') {
+        try {
+            const rows = await subagents.listDescendants(session.id);
+            const running = rows.filter((row) => row?.kind === 'child' && row?.activity === 'running').length;
+            if (running > 0) {
+                return `还有 ${running} 个子 Agent 在运行：现在登记会让卡片留在被折叠的中间轮。`
+                    + '等它们全部结算、写最终答复的那一步再调用 present_charts（refs 记不清就传 task_id）。';
+            }
+        }
+        catch {
+            // Subagent service unavailable: don't block delivery for a missing optional check.
+        }
+    }
+    return undefined;
+}
+function inboxOf(ctx) {
+    const projections = ctx.get('sessionProjections');
+    return (session) => {
+        try {
+            return projections?.stateOf(session, 'inbox');
+        }
+        catch {
+            return undefined;
+        }
+    };
+}
 export function apply(ctx) {
     const shared = capitalSharedRuntimeOf(ctx);
+    const publisherOf = () => createChartEventPublisher(chartEventContextOf(ctx));
+    const eventCtx = ctx;
+    const delivery = createChartDelivery({
+        artifacts: shared.artifacts,
+        publish: (sessionId, inputs) => publisherOf()?.publishMany(sessionId, inputs) ?? false,
+        inboxOf: inboxOf(ctx),
+    });
+    // The preset row is applied in the root agent's scope: these events are the root's own.
+    const disposers = [];
+    if (typeof eventCtx.on === 'function') {
+        disposers.push(eventCtx.on('agent/assistant-stream', (...args) => {
+            const payload = args[0];
+            if (payload?.frame === undefined)
+                return;
+            delivery.acceptStream(payload.agent?.session, payload.frame);
+        }));
+        disposers.push(eventCtx.on('subagent/start', (...args) => delivery.acceptSubagentStart(args[0])));
+        disposers.push(eventCtx.on('subagent/end', (...args) => delivery.acceptSubagentEnd(args[0])));
+    }
+    // Session events are not agent-scoped: listen on the unscoped root and filter by payload.
+    const listen = (eventCtx.root ?? ctx);
+    if (typeof listen.on === 'function') {
+        disposers.push(listen.on('session/event', (...args) => {
+            const session = args[0];
+            const event = args[1];
+            if (event?.type !== 'user/message')
+                return;
+            const source = event.data?.source;
+            // The settlement notice is authoritative even when the lifecycle edge was missed; clearing
+            // here keeps the stream-time idle check from waiting on a child that is already done.
+            if (source?.kind === 'subagent-settled') {
+                if (typeof source.senderSessionId === 'string')
+                    delivery.acceptSubagentEnd({ id: source.senderSessionId });
+                return;
+            }
+            if (source?.kind !== 'user')
+                return;
+            if (typeof session?.id !== 'string')
+                return;
+            delivery.acceptUserMessage(session.id, typeof event.time === 'number' ? event.time : Date.now());
+        }));
+    }
+    ctx.effect(() => () => {
+        for (const dispose of disposers) {
+            if (typeof dispose === 'function')
+                dispose();
+        }
+    }, 'capital-generation.chart-delivery()');
     registerPresentChartsTool(ctx, {
         artifacts: shared.artifacts,
-        chartEvents: () => createChartEventPublisher(chartEventContextOf(ctx)),
+        chartEvents: publisherOf,
+        readiness: (session) => chartDeliveryBlocker(ctx, session),
+        delivery,
     });
 }

package/lib/web-retriever/local-fetch.d.ts

@@ -3,7 +3,7 @@
  * Known limit: DNS resolves per request but the IP is not pinned to the connection,
  * so a rebinding window remains (same trade-off as dsh-search-first).
  */
-export declare const LOCAL_FETCH_CLIENT_VERSION = "2.9.1";
+export declare const LOCAL_FETCH_CLIENT_VERSION = "2.9.2";
 export declare const LOCAL_FETCH_MAX_URL_LENGTH = 2048;
 export type LocalFetchErrorCode = 'ABORTED' | 'TIMEOUT' | 'INVALID_URL' | 'BLOCKED_URL' | 'DNS' | 'REDIRECT' | 'HTTP' | 'TOO_LARGE' | 'UNSUPPORTED_CONTENT_TYPE';
 export declare class LocalFetchError extends Error {

package/lib/web-retriever/local-fetch.js

@@ -4,7 +4,7 @@
  * so a rebinding window remains (same trade-off as dsh-search-first).
  */
 import { htmlToMarkdown, stripInvisibleText } from './html-markdown.js';
-export const LOCAL_FETCH_CLIENT_VERSION = '2.9.1';
+export const LOCAL_FETCH_CLIENT_VERSION = '2.9.2';
 export const LOCAL_FETCH_MAX_URL_LENGTH = 2048;
 export class LocalFetchError extends Error {
     code;

package/lib/web-retriever/wind-client.d.ts

@@ -35,7 +35,7 @@ export interface WindCallResult {
     code?: WindErrorCode;
 }
 /** Must match `package.json` version; a test pins the two together. */
-export declare const WIND_CLIENT_VERSION = "2.9.1";
+export declare const WIND_CLIENT_VERSION = "2.9.2";
 export interface WindClient {
     callTool(toolName: string, args: Record<string, unknown>, signal?: AbortSignal): Promise<WindCallResult>;
 }

package/lib/web-retriever/wind-client.js

@@ -19,7 +19,7 @@ export const WIND_SERVER_ENDPOINTS = {
     analytics_data: 'https://mcp.wind.com.cn/vserver_analytics_data/mcp/',
 };
 /** Must match `package.json` version; a test pins the two together. */
-export const WIND_CLIENT_VERSION = '2.9.1';
+export const WIND_CLIENT_VERSION = '2.9.2';
 function errorText(error) {
     return error instanceof Error ? error.message : String(error);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@v587d/capital-generation",
-  "version": "2.9.1",
+  "version": "2.9.2",
   "description": "Capital Generation：面向中国散户的 AI 投资助手插件（自动模式 Agent Preset）",
   "icon": "assets/cg-icon.png",
   "author": "v587d",
@@ -140,7 +140,8 @@
     "contract:probe": "node scripts/contract-probe.mjs",
     "docs:capabilities": "npm run build && node scripts/gen-capability-table.mjs",
     "verify:sessions": "node scripts/verify-sessions.mjs",
-    "audit:tool-errors": "node scripts/audit-tool-errors.mjs"
+    "audit:tool-errors": "node scripts/audit-tool-errors.mjs",
+    "ptc:report": "node scripts/ptc-session-report.mjs"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.2",

package/preset/capital-generation/README.md

@@ -148,15 +148,32 @@
   （新工具必须先有族行带它、行契约同步）；更新 `AGENTS.md`、`docs/dev/data-roles.md` 与
   `test/persona.test.mjs` 的预留期断言。
 
-## 5.1 shell 与文件口：开 read、保留 bash、不给写（2026-10-15 用户决策）
+## 5.1 shell 与文件口：主 Agent 保留 shell，data_junior 用 PTC（2026-10-15 / 2026-10-23）
 
 - **动机**：`query_dataset` 只有 `count/min/max/avg/sum`，变化量 / 增幅 / CAGR / 比值这类派生
   指标没有宿主工具；模型只能拿 `time_facts.first/last` 心算——那正是 §1.3 那次 41,961 字符
-  时间戳心算的同型浪费。所以给 data_junior 一个纯计算兜底。**不是**给它开取数通道。
+  时间戳心算的同型浪费。所以给 data_junior 一个程序面。**不是**给它开取数通道。
 - **2026-10-15 起主 Agent 也持有 shell 与 `read`**（用户决策「开 read、同时保留 bash」，推翻
   2026-09-30 的"主 Agent 不给 shell"）：主 Agent 需要 `read` 读 skill 分册与工作区文件
   （此前只能 `bash cat`，能力等价但绕远），shell 保留纯计算兜底。`ROOT_AGENT_DENIED_TOOLS`
   里的 `bash` / `pwsh` 随之移出，名单改为出图三件套 + 十三个出网工具 + `write` / `edit`。
+
+### 5.1.1 PTC：只给 data_junior，主 Agent 仍是 native
+
+- **一行怎么落**：junior preset 挂 `@deepseek-ai/dsh-agent-tool-presentation`（`mode: ptc`），
+  同时删掉 `tool-bash` / `tool-pwsh`。宿主 `ptc-runtime` 由 `dsh-base` 提供，preset 写不进去；
+  `smoke:boot` 同时断言 presentation 行 `fiberState=2` 与 `ctx.get('ptcRuntime')` 在场。
+- **为什么删 shell 而不是并存**：PTC SDK 在可见 `bash` 时会主动塞一条 `tools.bash({command:'pwd'})`
+  示例，并存等于官方提示词把模型往 shell 引；junior 只需要一个执行面。主 Agent 仍是 native，
+  拿到的是原生 shell，根侧 `restrict()` 不能点名保留名 `run_code`（只在部署级 `tools.mode`
+  被改成 `ptc` 时才会出现，本仓只允许 preset 行）。
+- **省的是回合与抄写，不是安全升级**：`run_code` 里的 Node 仍能 `import('node:fs/promises')` /
+  `fetch` / `child_process`；宿主沙箱只拦写。`# PROGRAM DISCIPLINE` 与
+  `capital-data-query` §3.3 是纪律，不是边界；要硬隔离只能换容器 / VM / 远端 runtime。
+- **结果体积不变**：describe 仍是 7000 码点小回执 + hint；`run_code` 外层只过宿主 pruner（8192），
+  本仓不新设第二道闸门。per-call（每次新进程）是默认，不使用 `persistent-in-memory`。
+- **回滚**：整颗改动（composition 行 + persona + 三册 skill + guard）是一个 commit；回滚后
+  junior 回到 bash + native，恢复两行 YAML 与 `# BASH DISCIPLINE` 即可。
 - **文件写口不开，但"不开"靠的是调用级闸门，不是行配置**：根 preset 那行 `read: true /
   write: false / edit: false` 只决定**本层变体**——2026-10-19 实测手开 Capital 里 `write` 仍在工具表
   中且真的落盘，缺席不等于移除（`ScopedLayers.merge` 用 global 打底，账本 L33）。所以拦下写口的只有一颗：全局 `tools.guard()`
@@ -167,25 +184,26 @@
   本来就有正路（`store.writeContext` 等工具实现）。角色一侧同一条判据：本插件的六颗 preset 一律
   不许直接写文件，原始 rows 也永不出工具层。
 - **平台成对挂载**：Windows 上 host 层挂的是 `pwsh-sandbox`，没有 `bash-sandbox`；只挂
-  `tool-bash` 会让名为 bash 的工具实际执行 PowerShell。所以两行互补 `disabled: !!js`。0.2.1 起
-  这份 YAML 里不再出现工具名，shell 名改为在 `src/agents/role-tool-policy.ts` 按平台取一颗
-  （`SHELL_TOOL`）进 data_junior 的清单——取错那颗会整批 restrict 报错、该角色完全不收敛，
-  所以 `test/bash-guard.test.mjs` 另钉一条"preset 挂的每一行 shell，闸门与角色工具面都必须认"，
+  `tool-bash` 会让名为 bash 的工具实际执行 PowerShell。所以两行互补 `disabled: !!js`。
+  0.2.1 起这份 YAML 里不再出现工具名，shell 名在 `src/agents/root-tool-policy.ts` 的
+  `SHELL_TOOL_NAMES` 定义一份，`bash-guard.ts` 再并进 `run_code`；
+  `test/bash-guard.test.mjs` 钉"preset 挂的每一行 shell，闸门都必须认"，
   成对挂载与后台执行那一格仍由 `test/persona.test.mjs`「shell 行：平台成对挂载……」看着。
+  2026-10-23 起 junior 不再挂这两行，成对挂载只剩主 Agent。
 - **不给后台执行**：`enableRunInBackground: false`。本 preset 不挂 `tool-jobs`，开着后台只会让
   模型拿到一个永远读不回来的 jobId（本 preset 压根没挂 `tool-jobs` 那一行）。
-- **shell 闸门只剩一层，且不是安全边界**（`src/agents/bash-guard.ts`）：拦掉
+- **执行面闸门只剩一层，且不是安全边界**（`src/agents/bash-guard.ts`）：拦掉
   `sandbox_permissions` / `justification`——被委派会话的审批策略由框架固定为 `never`，升级必然
   失败，而且模型会收到「the user rejected…」这种把系统拒绝说成用户拒绝的文案；被委派或身份
   不可考的调用方 fail closed。主 Agent 的升级走正常 ask 审批（2026-10-15 前的"只对被委派子会话
-  开放"一层随决策移除，断言迁移见 `test/bash-guard.test.mjs`）。**刻意不解析 `command`**：本仓
-  实测沙箱只拦写、不拦读（`~/.dsh/.credentials.yaml` 与 `sessions/**` 整机可读）、不拦网络
-  （`curl` 直连 200），而正则挡不住 `node -e` / `python3 -c`——那正是引入 bash 的目的。禁区与
-  出网纪律是 data_junior persona 的 `# BASH DISCIPLINE` 软约束。
+  开放"一层随决策移除，断言迁移见 `test/bash-guard.test.mjs`）。**刻意不解析 `command` / `code`**：
+  本仓实测沙箱只拦写、不拦读（`~/.dsh/.credentials.yaml` 与 `sessions/**` 整机可读）、不拦网络
+  （`curl` 直连 200），而正则挡不住 `node -e` / `python3 -c` / 动态 `import()`——那正是引入程序面的
+  目的。禁区与出网纪律是 data_junior persona 的 `# PROGRAM DISCIPLINE` 软约束。
 - **写边界收不窄到会话**：`store.writeContext()` 用**调用方 session** 的 policy 且要求
   `mode ∈ {workspace-write, danger-full-access}`，而 `describe_dataset` 会用 data_junior 的会话写
-  `profile.json`；把它的会话钉成 `read-only` 会直接打断 describe_dataset。bash 与 Dataset 管线
-  共用同一把尺子（session policy），所以模型侧写口只能靠上一条的调用期闸门收。
+  `profile.json`；把它的会话钉成 `read-only` 会直接打断 describe_dataset。`run_code` / bash 与
+  Dataset 管线共用同一把尺子（session policy），所以模型侧写口只能靠上一条的调用期闸门收。
 - **要真正收紧**只有两条路：换掉 `ctx.shell`（容器 / 微 VM / 远端执行器），或给 dsh 进程做出网
   限制。两者都不是 `ctx.sandbox` 能提供的。
 

package/preset/capital-generation/agent.patch.yml

@@ -133,24 +133,24 @@
                 （不做投资判断、不输出买卖建议），也不改写原始 Dataset。你是主 Agent 的直接子 Agent，
                 与 data_collector 是兄弟：你不会被 data_collector 创建或指挥，互通一律经主 Agent 中继；
                 visualization_specialist 是你的异步子 Agent，不向主 Agent 直接发消息。
-                就本插件工具面而言，你无外部行情 API、无网页检索、无凭据读取能力；宿主若仍暴露 web_search / web_fetch 等通用工具，也不得用于取数或查资料。不索取或保存账户密码。
+                工具面没有外部行情 API、网页检索与凭据入口；run_code 里的 Node 也不得用于取数、联网或读凭据；宿主若暴露 web_search / web_fetch 也不得用于取数或查资料。不索取或保存账户密码。
 
                 # DUTIES
-                0. 第一步先加载协议：调用 Dataset 工具前先 skill capital-data-profile；要写 query_request
-                   或做派生算术再加 skill capital-data-query；描述完成
-                   （describe_dataset / profile_dataset）后无条件加载 skill capital-visualization-protocol，
+                0. 第一步先加载协议：Dataset 工具前先 skill capital-data-profile（必须 tools.skill，别直调）；写 query_request
+                   或做算术再加 skill capital-data-query；描述后无条件加载 skill capital-visualization-protocol，
                    再选择 gate。载荷样例、事实读法、data_gap 与 QuerySpec 细则都在 skill 里。
-                1. 启动自检：缺少 describe_dataset（或 inspect_dataset/profile_dataset/query_dataset）时 send_message 回告；正常时登记 data_junior_ready。
+                1. 启动自检：先看 SDK 有无 tools.describe_dataset，没有就 send_message 回告；正常时登记 data_junior_ready。
 
                 2. 只用受控工具：dataset_ids 按主 Agent 转发的原样使用；一切路径都是 opaque
-                   artifact_ref（workspace://...），由受控工具解析；不接受路径、脚本或自定义表达式。
-                3. 默认用 describe_dataset 读 Dataset（一次一份；多份在**同一条消息**里一次发完，可并发）；inspect_dataset/profile_dataset/query_dataset 只用于单点复核。优先用 profile 的 time_facts 与 structure；query_dataset 只做受控聚合，你取不到原始行。
+                   artifact_ref（workspace://...），由受控工具解析；Dataset 工具只收 dataset_id 与 QuerySpec，
+                   run_code 只调度工具与算术，不得读文件。
+                3. 默认用 describe_dataset 读 Dataset（多份在同一 run_code 程序里 Promise.all，见 PROGRAM DISCIPLINE）；inspect_dataset/profile_dataset/query_dataset 只用于单点复核。优先用 profile 的 time_facts 与 structure；query_dataset 只做受控聚合，你取不到原始行。
 
                 4. 数据缺口：先分清「数据里确实没有」与「那份数据还没取」。后者不要写成「无法确认」，
                    立即用 send_message 向父 Agent 发一次 data_gap（task_id / dataset_id / need / reason /
                    blocking），同一条缺口只发一次，这是请求不是结论。你不得自行取数、也不得直接找
                    data_collector（取数由主 Agent 转交）；不要为了填空编造能力名。
-                5. 回传：逐份回传结构化载荷（type / task_id / dataset_id / profile_ref
+                5. 回传：用 tools.send_message 逐份回传结构化载荷（type / task_id / dataset_id / profile_ref
                    或 query_result），字段按工具返回原样填入——字段名、数值、日期一律不改写；可附表或
                    摘要，禁止只回传 markdown 汇总。失败回传 profile_failed / query_failed 与 error/code，
                    绝不编造统计或查询结果；失败不影响原始 Dataset，可按主 Agent 指示重试。
@@ -163,12 +163,11 @@
                 任何时间窗/时间戳换算一律交给宿主：时间窗优先 resolve_data_time_range（传 dataset_id + period），
                 拿 bounds 填 filter；绝不自行把日期算成毫秒，看到 epoch 要加减乘除才能得出结论，就是走错了路。
 
-                # BASH DISCIPLINE
-                bash 只做纯计算兜底，只用于算变化量 / 增幅 / CAGR / 比值 / 单位换算这类派生指标，
-                不是取数通道：不联网、不跑 curl 或 wget 取任何外部数据，数据缺失走 data_gap 回告主 Agent。
-                不读文件、不碰 capital-data 下的任何路径（那是原始行与 Dataset 的边界）。
-                输出只留结论数字（原始行与中间数据不进回传），并注明算法与口径。
-                输入只敲标量（≤20 个）、逐数核对再算，不整行复制。
+                # PROGRAM DISCIPLINE
+                调用一律写进 run_code；skill 也走 tools.skill，console.log(s.content)，只 await 等于没读。
+                字段直接取返回值，不手抄；变化量/增幅/CAGR 在程序里算。
+                多份 describe 用 Promise.all，只返回结论；回传用 tools.send_message，不用原生名。
+                不读文件、不碰 capital-data、不 fetch、不申请升级（sandbox_permissions）；缺数据发 data_gap。
 
           - id: agent-instructions
             name: '@deepseek-ai/dsh-agent-instructions'
@@ -185,6 +184,12 @@
           - id: tool-skill
             name: '@deepseek-ai/dsh-tool-skill'
 
+          # PTC: presentation is preset-scoped; the host runtime (dsh-base) stays per-call.
+          - id: tool-presentation
+            name: '@deepseek-ai/dsh-agent-tool-presentation'
+            config:
+              mode: ptc
+
           # ── compaction: both rows must live in one realm; thresholdChars 8192 is the instance-wide single value ──
           - id: compaction
             name: cordis:group
@@ -206,19 +211,6 @@
                   headChars: 4096
                   tailChars: 1024
 
-          - id: tool-bash
-            name: '@deepseek-ai/dsh-tool-bash'
-            disabled: !!js process.platform === 'win32'
-            config:
-              # No tool-jobs row here: a background run would hand the model a jobId it can never read back.
-              enableRunInBackground: false
-
-          - id: tool-pwsh
-            name: '@deepseek-ai/dsh-tool-pwsh'
-            disabled: !!js process.platform !== 'win32'
-            config:
-              enableRunInBackground: false
-
           - id: tool-subagent-control
             name: '@deepseek-ai/dsh-tool-subagent-control'
 
@@ -511,7 +503,7 @@
                 # OUTPUT CONVENTIONS
                 关键指标与截止用表格；子 Agent 回传按原样引用。
                 图表由 data_junior 的可视化 gate 统一出品：你不画图、不评价图；派的时机与收窄见下方「数据调度纪律」。
-                图表交付（硬）：收到 chart_refs 后，**写最终答复前先调用一次 present_charts**（一次传全部 ref；refs 丢了就传 task_id），它把图表登记为最终答复的交付物（答复末尾的「交付」行）；不要在过程轮调用、不要分批、正文不要提图表、不在正文里罗列图表文件 / 路径 / HTML。图表是呈现不是分析：不用图推断数字，数值结论一律以 profile / query 回传为准。
+                图表交付：收到 chart_refs 后调用一次 present_charts（一次传全部 ref；refs 丢了就传 task_id）——它只记录清单，宿主会在最终答复前写入答复末尾的「交付」行，提前调用不会落进中间轮。正文不要提图表、不在正文里罗列图表文件 / 路径 / HTML。图表是呈现不是分析：不用图推断数字，数值结论一律以 profile / query 回传为准。
                 最终答（硬）：必须自足——结论、关键证据与来源标注、局限与风险、观察 / 验证 / 防守选项；归因准确。**禁止“分析已完成 / 结论见上 / 如上”这类指针式收尾**：界面只展示最后一轮答复、前面轮次会被折叠，指针句会让用户什么也看不到。被通知唤醒且无新增信息时：不输出可见正文（让上一条完整结论成为最后一轮），或重发一份自足总结；绝不写指针句。
 
                 # RULES & DISCIPLINE
@@ -608,7 +600,7 @@
                    不得冒充行情证据或补位缺失能力。不支持的频率如实披露，用已有粒度降级，不编造。
 
 
-          # Shell rows: bash/pwsh pair per platform, shared with data_junior; boundaries in ./README.md §5.1.
+          # Shell rows: bash/pwsh pair per platform, main Agent only (junior uses PTC `run_code`); README §5.1.
           - id: tool-bash
             name: '@deepseek-ai/dsh-tool-bash'
             disabled: !!js process.platform === 'win32'
@@ -642,7 +634,6 @@
               provider: spawn
               toolName: subagent_data_junior
               agentPreset: capital-data-junior
-              # Platform-selected shell name; must match the shell row above (restrict() fails on unknown names).
           - id: tool-subagent-web-retriever
             name: '@deepseek-ai/dsh-tool-subagent'
             config:

package/preset/capital-generation/skills/capital-data-profile/SKILL.md

@@ -15,6 +15,7 @@ description: Use when reading a Dataset back — describe_dataset as the default
 
 `data_junior` 读一份 Dataset 用 **`describe_dataset`**（一次调用完成 inspect + profile + 可选 queries），
 **不要再走 `inspect_dataset → profile_dataset → query_dataset` 三步**——那三步只保留给单点复核。
+`run_code` 与 `Promise.all` 的执行方式只对 data_junior 生效；主 Agent 只读事实块与回传格式。
 
 ```json
 {
@@ -27,8 +28,8 @@ description: Use when reading a Dataset back — describe_dataset as the default
 }
 ```
 
-- **一次一份**：一次调用只传一个 `dataset_id`。本轮有多份数据时，**在同一条 assistant 消息里一次发完**
-  多个调用（宿主会并发执行，结果一起返回），不要一份一份等。
+- **一次一份**：一次调用只传一个 `dataset_id`。本轮有多份数据时，在同一个 `run_code` 程序里用
+  `Promise.all` 并发 describe；结果留在程序里，只把结论 `return`。不要一份一份等。
 - 返回 = inspect 元数据（`artifact_ref` / `capability` / `source_label` / `captured_at` / `retention_until` /
   `query_access.shape`）+ profile 四类事实（`statistics` / `categories` / `time_facts` / `structure`）+
   `profile_ref` + 每条 query 的 `result`，或该条自己的 `error`（单条失败不影响其余）。
@@ -36,8 +37,9 @@ description: Use when reading a Dataset back — describe_dataset as the default
 - `columns_of_interest` 只对这些列返回 `statistics` / `categories` / `schema`（并同样收窄 `time_facts` 的首末值投影；时间列永远保留），是收窄结果体积的唯一手段。
 - **体积闸门**：结果超过 7000 码点时返回
   `{"status":"too_large","profile_ref":"...","columns":[...],"hint":"..."}`，而不是超长载荷。
-  按 hint 用 `columns_of_interest`（或减少 `queries`，一次最多 8 条）重发一次；文档型按 hint 直接调
-  `profile_dataset`。**看到 `too_large` 不是失败**——它带着完整列名，用来让你收窄。
+  在同一个程序里按 hint 用 `columns_of_interest`（或减少 `queries`，一次最多 8 条）重发一次；文档型按
+  hint 直接调 `profile_dataset`。**看到 `too_large` 不是失败**——它带着完整列名，用来让你收窄；
+  不要把它当异常、也不要另起一轮。
 - 单点复核（只看元数据 / 只要一份完整 profile / 补一条查询）仍可用 `inspect_dataset`、`profile_dataset`、
   `query_dataset`。
 
@@ -153,6 +155,9 @@ data_junior 发现「问题需要的那份数据还没取」时（不是「数
 }
 ```
 
+PTC 下发送是 `await tools.send_message({ agent_id: PARENT, message: JSON.stringify(payload) })`；
+payload 的 JSON 形状不变，父 Agent id 仍来自系统提示。
+
 | 字段 | 规则 |
 |------|------|
 | `type` | 固定 `data_gap` |

package/preset/capital-generation/skills/capital-data-query/SKILL.md

@@ -1,46 +1,61 @@
 ---
 name: capital-data-query
-description: Use when aggregating a Dataset or computing a derived number — the controlled QuerySpec (filters, group_by, aggregates, calendar time values, error codes) and data_junior's bash channel for derived arithmetic. Volume 3 of the Capital data protocol; payloads in capital-data-protocol, profile facts and the time axis in capital-data-profile.
+description: Use when aggregating a Dataset or computing a derived number — the controlled QuerySpec (filters, group_by, aggregates, calendar time values, error codes) and data_junior's run_code programs for derived arithmetic. Volume 3 of the Capital data protocol; payloads in capital-data-protocol, profile facts and the time axis in capital-data-profile.
 ---
 
 # Capital 数据协议 · 第三册：受控查询与派生算术
 
-本册是数据协议的第三册（§3.3 bash 只做纯计算 / §4 受控查询）。时间轴与 `time_facts` 在第二册
+本册是数据协议的第三册（§3.3 run_code 只做派生算术 / §4 受控查询）。时间轴与 `time_facts` 在第二册
 `capital-data-profile` §3.2，载荷契约与重试纪律在第一册 `capital-data-protocol`。
 
-## 3.3 bash：派生算术的兜底，不是第二条取数通道
+## 3.3 run_code：派生算术，不是第二条取数通道
 
-只有 data_junior 有 `bash`。它存在的唯一理由是 `query_dataset` 的聚合只有
-`count / min / max / avg / sum`——**变化量、增幅、CAGR、比值、单位换算**这类派生指标没有宿主
-工具，硬心算既慢又容易错。
+只有 data_junior 有 `run_code`；主 Agent 读本节是为了理解回传格式，不要照着执行。它存在的唯一
+理由是 `query_dataset` 的聚合只有 `count / min / max / avg / sum`——**变化量、增幅、CAGR、比值、
+单位换算**这类派生指标没有宿主工具。数字必须从工具返回值直接取，不手抄、不整行复制、不中转到
+别的语言。
 
-**可以做的**（拿手里已有的数字算）：
+**可以做的**（值来自工具返回对象，算完只返回结论）。第一段程序只读协议，`content` 必须打印出来，
+只 `await` 等于没读；也不要和 describe 混在同一段：
 
-```bash
-node -e 'const a=98.2,b=120.5; console.log(((b-a)/a*100).toFixed(2))'   # 区间涨幅
-python3 -c "print((120.5/98.2)**(252/60)-1)"                            # 年化
+```ts
+const s = await tools.skill({ name: 'capital-data-profile' })
+console.log(s.content)
 ```
 
-- **只敲最终参与计算的标量，一次 ≤20 个**：不整行/整表复制原始数字进脚本（2026-10-10 真机：
-  两次 bash 把整段聚合行逐数敲进去，转写出笔误又花 7.2K 字符发更正）；从工具回执到脚本的每个
-  数字**逐一核对**再执行，算完抽查 1-2 个对得上来源。要算的数超过 20 个就拆几批。
+```ts
+const r = await tools.describe_dataset({ dataset_id, task_id })
+const a = r.time_facts.first.close_price
+const b = r.time_facts.last.close_price
+return { pct: ((b - a) / a) * 100, from: a, to: b }
+```
+
+- `describe_dataset` 返回 `{status:'too_large', columns, hint}` 时，它在同一个程序里按 hint 用
+  `columns_of_interest` 重发一次；这是返回值不是异常，别用 `catch` 接、也别另起一轮。
+- 多份 Dataset 用 `Promise.all` 并发 describe（只有 `describe_dataset` 声明了并发安全）；
+  `query_dataset` 串行，不要混进同一批。某份可能失败时用 `Promise.allSettled`。
+- 一次程序只做一段事：先 `console.log(s.content)` 读协议，再 describe/算数，最后回传；
+  不要把整份 profile 或多个工具结果 `return` 回去（外层结果会过 8192 剪枝）。
+- 回传与 `data_gap` 用 `await tools.send_message({ agent_id, message })`；它返回 `{messageId}`，
+  不结束本轮。`agent_id` 取系统提示里的 parent agent id。
 
 **不许做的**（这是纪律，不是沙箱限制——沙箱只拦写，不拦读与网络）：
 
 | 不许 | 为什么 | 正确做法 |
 |---|---|---|
-| 读 `capital-data/**`、`raw.json` | 原始行**永不**进入你的上下文；而且工具结果会被剪枝成 head+tail，读了也算错 | 数值走 `describe_dataset` / `query_dataset` 的统计与聚合 |
+| 读 `capital-data/**`、`raw.json` | 原始行**永不**进入你的上下文；读了也算错 | 数值走 `describe_dataset` / `query_dataset` 的统计与聚合 |
 | 读 `~/.dsh/**`、`sessions/**` | 那是宿主凭据与全部会话日志 | 不碰；需要元数据用工具回执 |
 | 读 / 改 `preset/`、`src/`、`test/` | 那是装配与门禁本身 | 不碰 |
-| `curl` / `wget` / 任何网络请求、`git clone`、`npm i`、`pip install` | 你的角色没有网络能力，外部材料只经主 Agent 转交 `web_retriever` | 缺外部事实就在回传里写明缺口 |
-| 申请更高权限（`sandbox_permissions`） | 委派会话的审批策略被框架固定为 `never`，必然失败 | 不要试；缺数据发 `data_gap` |
+| `fetch` / 任何网络请求、`git clone`、`npm i`、`pip install` | 你的角色没有网络职责，外部材料只经主 Agent 转交 `web_retriever` | 缺外部事实就在回传里写明缺口 |
+| 申请更高权限（`sandbox_permissions`） | 委派会话的审批固定为 `never`，必然失败 | 不要试；缺数据发 `data_gap` |
 
 另外两条：
 
-- **输出只留结论数字**：bash 的工具结果同样会过剪枝器（>8192 字符中间段被剪掉），把中间过程
-  打印出来只会挤掉真正要看的东西；回传时注明算法与口径（如「按首末收盘价、未复权」）。
+- **输出只留结论数字**：`run_code` 的外层结果同样会过剪枝器（>8192 字符中间段被剪掉），把中间
+  过程或整份 profile 打印出来只会挤掉真正要看的东西；回传时注明算法与口径（如「按首末收盘价、
+  未复权」）。只返回结论，不要 `return` 整份 profile。
 - **时间窗仍归宿主**：窗口边界一律用 `time_facts.windows` / `resolve_data_time_range`
-  （`capital-data-profile` §3.2），不要用 `date` 命令自己造边界——口径错了数字就全错，而且没人会发现。
+  （`capital-data-profile` §3.2），不要在程序里把日期算成毫秒——口径错了数字就全错。
 
 `profile_dataset` 的统计项：数值字段的 count 与 sum（合计多少、覆盖多少条）、字符串字段的
 `distinct_count` 与高频取值、字段类型（observed / contract）、缺失值与显式 null、类型冲突、

package/preset/capital-generation/skills/capital-equity-research/SKILL.md

@@ -44,4 +44,7 @@ description: Use when the user requests a complete research report or comprehens
 
 每个会影响判断的数值注明能力/来源、报告期或交易日及采集时间；材料结论给可追溯的原文链接，或文件标题、发布主体与页码（无法提供原文时明说）。不要用已实施分红或历史价格推断股价下限，不把同业倍数排序写成“便宜/贵”的充分证据。对缺失、冲突和数据延迟给出它们如何改变判断的解释；未评估清单仅列与本轮问题或结论有关的缺口。区分投资者可采取的验证步骤与交易指令；不承诺收益、不输出没有可复现模型支持的目标价、概率或胜率。
 
-**这一段就是最后一轮的唯一可见内容**：写之前先调用一次 `present_charts`（有 chart_refs 时），报告正文不罗列图表文件，也不从图上反推数字；写完不要再补一行“已完成/结论见上”把报告盖掉。
+**这一段就是最后一轮的唯一可见内容**：写之前先调用一次 `present_charts`（有 chart_refs 时；refs 记不清就传 task_id 一次登记全部），报告正文不罗列图表文件，也不从图上反推数字；写完不要再补一行“已完成/结论见上”把报告盖掉。
+
+`present_charts` 只记录本轮图表清单，宿主会在**最终答复之前**统一写入交付行；提前调用也安全，
+不必留到最后一刻。调用后继续把取证做完也可以——最终答复仍由宿主在收尾时附上图表。

package/preset/capital-generation/skills/capital-visualization-protocol/SKILL.md

@@ -122,7 +122,8 @@ ohlc
 prepare_chart_source({ dataset_id, task_id })
 ```
 
-只使用工具返回的 `chart_source_ref`。不要自己构造 token、路径或 `raw.json` 地址。
+data_junior 在 `run_code` 里调用 `tools.prepare_chart_source(...)`；specialist 是 native，
+照旧直调 `render_chart`，不经过 `run_code`。只使用工具返回的 `chart_source_ref`。不要自己构造 token、路径或 `raw.json` 地址。
 
 **token 有 15 分钟 TTL，同一 task_id + dataset_id 重复签发幂等返回同一个 token**：仍建议先定好
 要出哪几张图、每张用哪份 Dataset，再一次性签发（省往返）；万一改了视图方案再签一次也无妨——
@@ -196,6 +197,9 @@ prepare_chart_source({ dataset_id, task_id })
 
 ## 4. 调用 render_chart
 
+data_junior 只在 `run_code` 程序里用 `tools.subagent_visualization_specialist(...)` 创建 specialist；
+specialist 是 native，照旧直调 `render_chart`。以下步骤属于 specialist。
+
 第一次调用前加载：
 
 ```text

package/watchlist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@v587d/watchlist",
-  "version": "2.9.1",
+  "version": "2.9.2",
   "description": "自动模式的用户自选股（宿主级清单 + Fuyao 报价快照 + /capital-watchlist 路由 + 输入框菜单弹窗）：由 @v587d/capital-generation 随包携带并作为 host 平面行挂载。",
   "license": "MIT",
   "type": "module",