@v587d/capital-generation 2.9.0 → 2.9.2

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

@@ -0,0 +1,36 @@
+/**
+ * present_charts: the root Agent's final-turn delivery step.
+ *
+ * render_chart only mints a chart_ref (the specialist row no longer auto-delivers). DSH's
+ * deliverable card replays only declarations recorded before the closing assistant message, so
+ * the card has to be written by the turn that carries the final answer: the root Agent presents
+ * its collected refs/deliverables here immediately before writing that answer. Never a custom
+ * event type — the session-event vocabulary is closed (see events.ts).
+ */
+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<{
+        chart_ref: string;
+        title: string;
+    }>;
+    failed: Array<{
+        chart_ref: string;
+        reason: string;
+    }>;
+}
+export declare function registerPresentChartsTool(ctx: Context, input: PresentChartsInput): void;

package/lib/chart/present-tool.js

@@ -0,0 +1,149 @@
+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: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'data_junior 回传的全部 chart_ref，一次传完（最多 8 个，不猜写）。与 task_id 至少给一个。',
+    },
+    task_id: {
+        type: 'string',
+        description: '本任务 canonical task_id：省略 chart_refs 时按它登记本会话该任务的全部图表（上下文压缩后记不清 refs 时用）。',
+    },
+});
+const receiptSchema = jsonObject({
+    presented: {
+        type: 'array',
+        items: jsonObject({
+            chart_ref: { type: 'string' },
+            title: { type: 'string' },
+        }, ['chart_ref', 'title']),
+    },
+    failed: {
+        type: 'array',
+        items: jsonObject({
+            chart_ref: { type: 'string' },
+            reason: { type: 'string' },
+        }, ['chart_ref', 'reason']),
+    },
+}, ['presented', 'failed']);
+function normalizeRefs(value) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value))
+        throw new Error('present_charts 的 chart_refs 必须是字符串数组');
+    const refs = [];
+    for (const item of value) {
+        if (typeof item !== 'string' || item.trim().length === 0)
+            throw new Error('present_charts 的 chart_refs 里不能有空值');
+        const ref = item.trim();
+        if (!refs.includes(ref))
+            refs.push(ref);
+    }
+    if (refs.length > MAX_PRESENT_CHARTS) {
+        throw new Error(`present_charts 一次最多登记 ${MAX_PRESENT_CHARTS} 张图（收到 ${refs.length} 个 chart_ref）`);
+    }
+    return refs;
+}
+function normalizeTaskId(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string' || value.trim().length === 0)
+        throw new Error('present_charts 的 task_id 必须是非空字符串');
+    return value.trim();
+}
+/** Present refs first; otherwise present the whole task so compaction cannot strand the charts. */
+function selectArtifacts(input, session, refs, taskId) {
+    const failed = [];
+    if (refs.length > 0) {
+        const selected = [];
+        for (const chartRef of refs) {
+            try {
+                selected.push(input.artifacts.resolve({ session, chart_ref: chartRef, task_id: taskId }));
+            }
+            catch (error) {
+                failed.push({ chart_ref: chartRef, reason: error instanceof Error ? error.message : String(error) });
+            }
+        }
+        // A stale ref set must not strand charts the task_id can still find (compaction can mix both).
+        if (selected.length > 0 || taskId === undefined)
+            return { selected, failed };
+    }
+    if (taskId === undefined)
+        throw new Error('present_charts 需要 chart_refs 或 task_id：两者都不给就无法确定要登记哪几张图');
+    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_PRESENT_CHARTS);
+    if (all.length > MAX_PRESENT_CHARTS) {
+        failed.push({ chart_ref: '(task)', reason: `该 task_id 有 ${all.length} 张图，单次最多登记 ${MAX_PRESENT_CHARTS} 张；其余未展示` });
+    }
+    return { selected, failed };
+}
+export function registerPresentChartsTool(ctx, input) {
+    const tools = ctx.get('tools');
+    if (!tools)
+        return;
+    const definition = {
+        name: 'present_charts',
+        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);
+            const refs = normalizeRefs(args.chart_refs);
+            const taskId = normalizeTaskId(args.task_id);
+            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 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 {
+                for (const artifact of selected) {
+                    receipt.failed.push({ chart_ref: artifact.chart_ref, reason: `本轮登记已达 ${MAX_CHARTS_PER_TURN} 次上限或回合已关闭，未写入交付行` });
+                }
+            }
+            return receipt;
+        },
+        output: {
+            schema: receiptSchema,
+            render: (_args, value) => [{ type: 'text', text: JSON.stringify(value) }],
+        },
+    };
+    ctx.effect(() => tools.register(definition), 'capital-generation.tool(present_charts)');
+}

package/lib/chart/tool.d.ts

@@ -12,6 +12,7 @@ type AgentExecutionLike = {
         header?: {
             cwd?: string;
             parentSession?: string;
+            origin?: 'subagent';
         };
     };
 };

package/lib/chart/tool.js

@@ -112,7 +112,7 @@ export async function renderChart(input, args, exec) {
     if (sourceCount !== 1) {
         throw new ChartError('chart_source_invalid', 'provide exactly one data source: dataset_id, path, or chart_source_ref');
     }
-    if (session.header?.parentSession && chartSourceRef === undefined) {
+    if (session.header?.origin === 'subagent' && chartSourceRef === undefined) {
         throw new ChartError('chart_source_scope_mismatch', 'delegated visualization callers must use chart_source_ref');
     }
     const tokenSource = chartSourceRef === undefined ? undefined : chartSourceTokenForRender(input.sourceTokens, {
@@ -177,6 +177,7 @@ export async function renderChart(input, args, exec) {
         captured_at: meta.captured_at ?? null,
         kind: payload.kind,
         axis: payload.axis,
+        title: payload.title,
         chart_url: chartUrl,
         spec_path: pathOf('spec.json'),
         series_path: pathOf('series.json'),
@@ -185,9 +186,10 @@ export async function renderChart(input, args, exec) {
     });
     // Unit callers without the registry still get a stable receipt.
     const chartRef = artifact?.chart_ref ?? `chart_${chartId.slice(3)}`;
-    // Register as this turn's deliverable via first-party deliverables/presented — never a custom
-    // event type (closed vocabulary breaks cold load; see src/chart/events.ts). Owner scope matches
-    // chart_ref; these events never enter model message history.
+    // Monolith carriers still register this turn's deliverable here (first-party
+    // deliverables/presented only — never a custom event type; closed vocabulary breaks cold load).
+    // The auto-mode specialist row passes no chartEvents: the root Agent presents chart_refs in its
+    // final turn instead, so the card cannot land in a folded process turn.
     let deliverableTrace;
     try {
         const publisher = input.chartEvents?.();
@@ -257,7 +259,9 @@ export function registerChartTool(ctx, options) {
             `最多保留 ${MAX_CHART_POINTS} 个点（超出由宿主下采样并如实标注）。` +
             '字段语义、可用键与错误码见 skill capital-chart-protocol —— 首次画图前先加载它。' +
             '是否出图由 data_junior 的可视化协议决定；本工具只负责安全生成图表产物和小型回执。' +
-            '出图成功后宿主会把这张图登记为当前对话的**本轮交付物**（官方 deliverables/presented），用户可从收尾的交付行点开自包含图表；调用方**不要**在回传或正文里罗列图表文件、路径或 HTML。' +
+            (typeof options.chartEvents === 'function'
+                ? '出图成功后宿主会把这张图登记为当前对话的**本轮交付物**（官方 deliverables/presented），用户可从收尾的交付行点开自包含图表；调用方**不要**在回传或正文里罗列图表文件、路径或 HTML。'
+                : '交付登记由主 Agent 在最终答复前调用 present_charts 完成：你只把 chart_ref 回传给 data_junior 汇总，**不要**调用 present_charts、不要在回传或正文里罗列图表文件、路径或 HTML。') +
             '图表是呈现不是分析：需要数值结论（首末值、涨跌幅、分位数等）仍走 data_junior 的 profile / query，不要用图去推断数字。',
         parameters,
         output: { schema: receiptSchema, render },

package/lib/chart-render-entry.d.ts

@@ -1,7 +1,8 @@
 /**
  * `tools/chart-render` row: render_chart only. Row-level expression of "only the
  * visualization specialist holds the chart pipeline"; shares token/artifact state with
- * `tools/chart-source`.
+ * `tools/chart-source`. No chartEvents here: delivery is the root Agent's final-turn
+ * `present_charts` step, so the card never lands in a folded process turn.
  */
 import type { Context } from '@deepseek-ai/cordis';
 export declare const name = "capital-chart-render-tools";

package/lib/chart-render-entry.js

@@ -1,5 +1,3 @@
-import { createChartEventPublisher } from './chart/events.js';
-import { chartEventContextOf } from './chart/event-context.js';
 import { registerChartTool } from './chart/tool.js';
 import { capitalDatasetStore } from './runtime.js';
 import { capitalSharedRuntimeOf } from './chart-source-entry.js';
@@ -12,6 +10,5 @@ export function apply(ctx) {
         sourceTokens: shared.sourceTokens,
         artifacts: shared.artifacts,
         charts: () => ctx.get('capitalCharts'),
-        chartEvents: () => createChartEventPublisher(chartEventContextOf(ctx)),
     });
 }

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/data-collector/store.d.ts

@@ -184,6 +184,7 @@ export interface SessionLike {
     readonly header?: {
         readonly cwd?: string;
         readonly parentSession?: string;
+        readonly origin?: 'subagent';
     };
 }
 export interface SandboxPolicyResultLike {

package/lib/present-entry.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `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

@@ -0,0 +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: 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.0";
+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.0';
+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.0";
+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.0';
+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.0",
+  "version": "2.9.2",
   "description": "Capital Generation：面向中国散户的 AI 投资助手插件（自动模式 Agent Preset）",
   "icon": "assets/cg-icon.png",
   "author": "v587d",
@@ -57,6 +57,11 @@
       "import": "./lib/ocr-entry.js",
       "default": "./lib/ocr-entry.js"
     },
+    "./tools/present": {
+      "types": "./lib/present-entry.d.ts",
+      "import": "./lib/present-entry.js",
+      "default": "./lib/present-entry.js"
+    },
     "./tools/retrieve-search": {
       "types": "./lib/search-entry.d.ts",
       "import": "./lib/search-entry.js",
@@ -135,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` 能提供的。