@v587d/capital-generation 2.8.3 → 2.9.1

package/lib/chart/source-token.js

@@ -1,5 +1,8 @@
 import { ChartError } from './errors.js';
 import { DatasetStoreError, } from '../data-collector/store.js';
+// Authorization has one implementation (src/tool-exec.ts); the error shape stays chart-specific.
+import { authorizeToolSession } from '../tool-exec.js';
+import { CHART_SOURCE_PRESET_IDS } from '../preset-ids.js';
 const CHART_SOURCE_TOKEN_PATTERN = /^cs_[A-Za-z0-9_-]{1,128}$/;
 const DEFAULT_CHART_SOURCE_TTL_MS = 15 * 60 * 1000;
 const jsonObject = (properties = {}, required = []) => ({
@@ -25,10 +28,14 @@ function sessionOf(exec) {
     }
     return session;
 }
-function delegatedSession(exec) {
+/** Shared preset-based authorizer; chart_source_scope_mismatch shape stays here (test-pinned). */
+function authorizedChartSession(ctx, exec) {
     const session = sessionOf(exec);
-    if (typeof session.header?.parentSession !== 'string' || session.header.parentSession.length === 0) {
-        throw new ChartError('chart_source_scope_mismatch', 'prepare_chart_source is restricted to delegated data agents');
+    const decision = authorizeToolSession(ctx, exec, 'prepare_chart_source', CHART_SOURCE_PRESET_IDS);
+    if (!decision.allowed) {
+        throw new ChartError('chart_source_scope_mismatch', decision.via === 'preset'
+            ? `prepare_chart_source 不对人设 ${decision.presetId} 开放；签发出图读能力只属于数据角色`
+            : 'prepare_chart_source is restricted to delegated data agents');
     }
     return session;
 }
@@ -55,13 +62,8 @@ function readToken(value) {
     }
     return value;
 }
-/**
- * Short-lived capability tokens for nested visualization children.
- *
- * The token captures the direct data-agent session rather than asking a nested
- * child to re-prove the Dataset's one-hop session scope. Possession of the
- * opaque token is the capability; it is never converted into a filesystem path.
- */
+/** Short-lived capability tokens for nested visualization children. Possession is the capability;
+ * the token never becomes a filesystem path or raw rows. */
 export class ChartSourceTokenStore {
     tokens = new Map();
     now;
@@ -86,10 +88,8 @@ export class ChartSourceTokenStore {
         const taskId = readTaskId(input.task_id, true);
         const now = this.now();
         this.purgeExpired(now);
-        // 幂等：同一 session + task_id + dataset_id 在 TTL 内重复签发返回**同一个** token。
-        // 2026-10-10 真机（task_fh_300803_20261010）：data_junior 改了视图方案后为同一 dataset
-        // 重签，跟着就是 7.9K 字符的思考回合——skill 里的"不要重签"警告拦不住，所以把幂等沉到
-        // 工具层。token 是读能力而非一次性凭证（resolve 不消费），复用没有语义损失。
+        // Idempotent within TTL for the same session+task+dataset: re-issuing triggers huge thinking
+        // turns, and resolve() does not consume the token, so reuse has no semantic cost.
         for (const record of this.tokens.values()) {
             if (record.dataset_id === datasetId && record.task_id === taskId && record.sourceSession.id === input.session.id) {
                 return {
@@ -110,6 +110,7 @@ export class ChartSourceTokenStore {
         }
         if (this.tokens.has(token))
             throw new ChartError('chart_source_invalid', 'generated chart_source_ref already exists');
+        // Never outlive the dataset's retention.
         const expiresAt = Math.min(inspection.retention_until, now + this.ttlMs);
         const record = {
             chart_source_ref: token,
@@ -166,14 +167,14 @@ const outputSchema = jsonObject({
     task_id: { type: 'string' },
     expires_at: { type: 'integer' },
 }, ['chart_source_ref', 'dataset_id', 'task_id', 'expires_at']);
-/** Register the delegated-child-only token issuer. */
+/** Preset-based authorization; see authorizedChartSession. */
 export function registerChartSourceTool(ctx, options) {
     const tools = ctx.get('tools');
     if (!tools)
         return;
     const definition = {
         name: 'prepare_chart_source',
-        description: '为当前 delegated data agent 的指定 Dataset 签发短期 chart_source_ref，供 visualization_specialist 通过受控 render_chart 读取。' +
+        description: '为**当前数据角色会话**已授权的 Dataset 签发短期 chart_source_ref，供 visualization_specialist 通过受控 render_chart 读取（授权按人设判定，被委派与独立开启的数据模式都能签发）。' +
             '只返回 opaque token 和小型元数据，不返回原始数据、文件路径或数据行；必须提供 dataset_id，可选 task_id。' +
             '同一 task_id + dataset_id 重复调用幂等返回同一个 chart_source_ref（TTL 内），改了视图方案直接复用即可。',
         parameters: jsonObject({
@@ -183,7 +184,7 @@ export function registerChartSourceTool(ctx, options) {
         output: { schema: outputSchema, render },
         async execute(args, exec) {
             try {
-                const session = delegatedSession(exec);
+                const session = authorizedChartSession(ctx, exec);
                 return await options.tokens.issue({
                     store: options.store,
                     session,

package/lib/chart/spec.d.ts

@@ -15,14 +15,14 @@ export interface ChartOhlcSpec {
 export interface ChartMarkerSpec {
     text: string;
     position: MarkerPosition;
-    /** 与 x 同口径的时间值；与 index 二选一。 */
+    /** Time value matching x; mutually exclusive with index. */
     time?: string | number;
-    /** 过滤后序列中的 0 基行号。 */
+    /** 0-based row index into the filtered series. */
     index?: number;
 }
 export interface NormalizedChartSpec {
     kind: ChartKind;
-    /** time = 有真实时间列；index = 按行序（分类轴），标签由 labels 映射。 */
+    /** time = real time column; index = row order (category axis, labels mapped at render time). */
     axis: 'time' | 'index';
     timeField?: string;
     series: ChartSeriesSpec[];
@@ -38,14 +38,8 @@ export interface NormalizedChartSpec {
     title?: string;
 }
 export declare const CHART_KINDS: readonly ChartKind[];
-/**
- * 需要 OHLC 四字段（而不是单值字段选择）的 kind。
- *
- * 依据是图表库的数据契约本身：`CandlestickData` 与 `BarData` 都继承 `OhlcData`，
- * 而 `LineData` / `HistogramData` 继承 `SingleValueData`。把单值序列塞进 BarSeries
- * 不会报错，只会画出一张**空图** —— 所以这个约束必须在 spec 层硬拦，
- * 不能指望"模型会写对"（这是实测出来的坑，不是推演）。
- */
+/** OHLC kinds need four fields (library OhlcData vs SingleValueData); a single-value series in
+ * BarSeries silently draws an empty chart, so reject it at the spec layer. */
 export declare const OHLC_KINDS: readonly ChartKind[];
 export declare const CHART_SERIES_TYPES: readonly ChartSeriesType[];
 export declare const MARKER_POSITIONS: readonly MarkerPosition[];
@@ -53,6 +47,6 @@ export declare const MAX_CHART_SERIES = 6;
 export declare const MAX_CHART_MARKERS = 50;
 export declare const MAX_FIELD_NAME = 128;
 export declare const MAX_CHART_TITLE = 200;
-/** 面向模型的 kind 说明（错误信息与工具描述共用一处，避免两处措辞漂移）。 */
+/** Shared model-facing kind description so error text and tool docs cannot drift. */
 export declare function describeKinds(): string;
 export declare function normalizeChartSpec(raw: unknown): NormalizedChartSpec;

package/lib/chart/spec.js

@@ -1,24 +1,9 @@
-/**
- * 图表 spec 的归一化与校验。
- *
- * 设计要点（见内部设计文档 docs/design/chart-visualization.md §3.3）：
- *  - spec 用**自由对象**表达，协议细节写在 skill 里按需加载，常驻的只有工具 schema——
- *    这是"可视化不污染上下文"的关键：模型不需要在每轮都看一遍图表 DSL。
- *  - 但自由对象不等于放任：这里做一次严格归一化，错误必须**可自愈**（点名字段 + 给候选）。
- *  - 与 query_dataset 同源的宽容度：模型经常把对象/数组序列化成 JSON 字符串再传
- *    （实测教训见 src/data-collector/dataset-tools.ts 的注释），这里在**工具边界**
- *    做一次宽容解析，内部保持严格。
- */
+/** Normalize/validate the chart spec at the tool boundary. Errors must be self-correcting
+ * (name the field, list candidates); JSON-string forms are tolerated here, strict inside. */
 import { ChartError } from './errors.js';
 export const CHART_KINDS = ['line', 'area', 'column', 'candlestick', 'bar'];
-/**
- * 需要 OHLC 四字段（而不是单值字段选择）的 kind。
- *
- * 依据是图表库的数据契约本身：`CandlestickData` 与 `BarData` 都继承 `OhlcData`，
- * 而 `LineData` / `HistogramData` 继承 `SingleValueData`。把单值序列塞进 BarSeries
- * 不会报错，只会画出一张**空图** —— 所以这个约束必须在 spec 层硬拦，
- * 不能指望"模型会写对"（这是实测出来的坑，不是推演）。
- */
+/** OHLC kinds need four fields (library OhlcData vs SingleValueData); a single-value series in
+ * BarSeries silently draws an empty chart, so reject it at the spec layer. */
 export const OHLC_KINDS = ['candlestick', 'bar'];
 export const CHART_SERIES_TYPES = ['line', 'area', 'column'];
 export const MARKER_POSITIONS = ['aboveBar', 'belowBar', 'inBar'];
@@ -26,14 +11,7 @@ export const MAX_CHART_SERIES = 6;
 export const MAX_CHART_MARKERS = 50;
 export const MAX_FIELD_NAME = 128;
 export const MAX_CHART_TITLE = 200;
-/**
- * 容忍的说法 → canonical 名。
- *
- * `histogram` 是图表库的类名，但它画的是**着色柱**、不是统计分箱直方图；直接把它当
- * canonical 名会让模型以为"可以画分布"。canonical 用 `column`，同时接受旧说法以免硬失败。
- * 同理 `bar` 在中文语境里常被当成"柱状图"，而它其实是 OHLC 柱：单值柱状图会得到一条
- * 明确指向 `column` 的错误，而不是一张空图。
- */
+/** `histogram` maps to `column` (a colored bar, not a statistical bin); `bar` is an OHLC bar. */
 const KIND_ALIASES = {
     histogram: 'column',
     candles: 'candlestick',
@@ -42,14 +20,14 @@ const KIND_ALIASES = {
     candlestick_bar: 'bar',
 };
 const SERIES_TYPE_ALIASES = { histogram: 'column' };
-/** 面向模型的 kind 说明（错误信息与工具描述共用一处，避免两处措辞漂移）。 */
+/** Shared model-facing kind description so error text and tool docs cannot drift. */
 export function describeKinds() {
     return `${CHART_KINDS.join(' / ')}（candlestick 与 bar 需要 ohlc 四字段与真实时间列；单值柱状图用 column，本库没有统计分箱直方图）`;
 }
 function isRecord(value) {
     return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }
-/** 宽容解析：真对象直接用；JSON 字符串解析成对象后使用；其余返回 undefined。 */
+/** Tolerate JSON-string spec fragments at the tool boundary. */
 function coerceObject(value) {
     if (isRecord(value))
         return value;
@@ -66,7 +44,6 @@ function coerceObject(value) {
         return undefined;
     }
 }
-/** 宽容解析对象数组：真数组、JSON 数组字符串、单个对象（或其 JSON 字符串）都接受。 */
 function coerceObjectList(value) {
     if (Array.isArray(value))
         return value;
@@ -106,7 +83,6 @@ function readOptionalFieldName(value, where) {
         return undefined;
     return readFieldName(value, where);
 }
-/** 取第一个出现的别名键；用于容忍模型用 x / time / time_field 等等价说法。 */
 function pickAlias(source, names) {
     for (const name of names)
         if (source[name] !== undefined)

package/lib/chart/tool.d.ts

@@ -1,16 +1,6 @@
-/**
- * `render_chart`：把已经取到的数据渲染成图，**只回一条小回执**。
- *
- * 上下文经济学（这是本工具存在的理由）：
- *  - 常驻成本 = 一条工具 schema；协议细节在 skill `capital-chart-protocol` 里按需加载；
- *  - 每次调用成本 = spec（几十到一百多 token）+ 回执（几十 token）；
- *  - 序列数据 **0 token**：由宿主写进 workspace 产物，浏览器走旁路取。
- * 对照：让模型把 250 点日线写进参数 ≈ 5–8k token，还会被工具结果剪枝器截断。
- *
- * 权限边界（docs/dev/data-roles.md §1.1「数据调度纪律」的显式豁免）：本工具是**呈现**工具，不是数据工具。
- * 它读 Dataset 只在宿主进程内进行，回执不含任何 rows —— 因此不越过"数据内容不进主 Agent
- * 上下文"这条真正的边界。需要数值结论仍走 data_junior 的 profile / query。
- */
+/** render_chart: render data into workspace artifacts and return only a small receipt.
+ * Series costs zero model tokens and rows stay host-side; numeric conclusions still go through
+ * data_junior. */
 import type { Context } from '@deepseek-ai/cordis';
 import { WorkspaceDatasetStore } from '../data-collector/store.js';
 import { type ChartSourceTokenStore } from './source-token.js';
@@ -22,6 +12,7 @@ type AgentExecutionLike = {
         header?: {
             cwd?: string;
             parentSession?: string;
+            origin?: 'subagent';
         };
     };
 };
@@ -30,7 +21,7 @@ type ToolExecLike = {
     signal: AbortSignal;
 };
 export declare const CHART_ARTIFACT_DIR = "capital-analysis/charts";
-/** 回执字段全部是可以进上下文的小元数据；序列本体永远不在这里。 */
+/** Receipt is small metadata only; series never appears here. */
 export interface ChartReceipt {
     chart_ref: string;
     chart_id: string;
@@ -62,22 +53,9 @@ export interface RenderChartInput {
     store: WorkspaceDatasetStore;
     sourceTokens?: ChartSourceTokenStore;
     artifacts?: ChartArtifactRegistry;
-    /**
-     * 惰性解析 host 平面图表服务（`@v587d/capital-charts` 提供）。
-     *
-     * 每次画图时解析，而不是在 `apply` 时解析一次：host 平面行与本 preset 行的挂载先后
-     * 不由我们决定，一次性解析会把"服务稍后才可用"永久固化成 `chart_url=null`。
-     * 服务始终缺席（未安装/无 Web 载体/坏掉）时返回 undefined，整条链路照常降级：产物照样
-     * 落盘、`html_path` 照样可 present，只是 `chart_url` 为 null。
-     */
+    /** Resolve per render, not at apply: host rows may mount later; absence degrades to chart_url=null. */
     charts?: () => ChartPublisher | undefined;
-    /**
-     * 惰性解析"图表 → 本轮交付"发布器（官方 `deliverables/presented`）。
-     *
-     * 与 `charts` 同理每次出图解析一次：宿主平面的 `sessions` / `sessionProjections`
-     * 不可用时返回 undefined，整条链路照常降级——图仍在 workspace 里，回执照样给 html_path，
-     * 只是本轮交付行不会登记这张图。
-     */
+    /** Same lazy rule: an absent publisher skips only the deliverable row. */
     chartEvents?: () => ChartEventPublisher | undefined;
     now?: () => number;
 }

package/lib/chart/tool.js

@@ -56,10 +56,7 @@ function normalizeStoreError(error) {
             return undefined;
     }
 }
-/**
- * 工具框架对 throw 的错误只保留 message；把 ChartError 的 details 在这里展开成
- * JSON 信封，模型才能拿到 array_keys / available 等一次修正所需的信息。
- */
+/** Errors keep only message; expand details into JSON so the model can self-correct. */
 function toolVisibleError(error) {
     const normalized = error instanceof ChartError ? error : normalizeStoreError(error);
     if (!normalized)
@@ -115,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, {
@@ -126,13 +123,10 @@ export async function renderChart(input, args, exec) {
     const spec = normalizeChartSpec(args.spec);
     if (typeof args.title === 'string' && args.title.trim().length > 0)
         spec.title = args.title.trim().slice(0, 200);
-    // ── 取数：两条来源都在宿主进程内完成，rows 不进入任何消息 ────────────────────
+    // The token carries the direct data-agent session; the nested child never sees raw rows.
     let rows;
     let meta;
     if (datasetId !== undefined) {
-        // A chart_source_ref carries the direct data-agent session that already has
-        // access to the parent Dataset scope. The nested visualization child is
-        // only the caller of render_chart; it never receives raw rows.
         const readSession = tokenSource?.sourceSession ?? session;
         const { ref, rows: datasetRows } = await input.store.readPresentationRows({ session: readSession, dataset_id: datasetId, signal: exec.signal });
         rows = datasetRows;
@@ -144,7 +138,6 @@ export async function renderChart(input, args, exec) {
         rows = extracted.rows;
         meta = { source_kind: 'path' };
     }
-    // ── 有界化 ───────────────────────────────────────────────────────────────
     const chartId = newChartId();
     const payload = buildChartPayload({ chart_id: chartId, spec, rows, meta });
     const library = loadVendoredChartLibrary();
@@ -162,8 +155,7 @@ export async function renderChart(input, args, exec) {
         signal: exec.signal,
     });
     const pathOf = (name) => written.find((file) => file.name === name)?.path ?? `${dir}/${name}`;
-    // 序列旁路：把 series.json 的**绝对路径**登记给 host 平面路由，客户端凭 chart_url 取数。
-    // 登记失败（服务缺失/实现异常）不阻断出图——图已经落盘了，降级成"只有文件路径"。
+    // Register the absolute series.json path with the host route; failure degrades to file paths only.
     let chartUrl = null;
     const seriesFile = written.find((file) => file.name === 'series.json');
     if (input.charts && seriesFile !== undefined) {
@@ -185,20 +177,19 @@ 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'),
         html_path: pathOf('chart.html'),
         created_at: generatedAt,
     });
-    // Direct unit callers that do not install the production registry still get
-    // a stable receipt; production apply() always injects the registry.
+    // Unit callers without the registry still get a stable receipt.
     const chartRef = artifact?.chart_ref ?? `chart_${chartId.slice(3)}`;
-    // 对话流呈现：把这张图登记为**用户正在看的那条会话**的本轮交付物
-    // （owner scope 与 chart_ref 同源，因此 specialist 出的图正好落在主会话）。
-    // 走官方 `deliverables/presented`——**不能**改回自定义事件类型：会话日志的事件词汇表
-    // 是闭集，非 first-party 类型会让整份会话在冷加载时打不开（事故记录见 src/chart/events.ts）。
-    // 事件不进模型消息历史。呈现通道可选：写不进去不影响图表产物与回执。
+    // 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?.();
@@ -219,10 +210,7 @@ export async function renderChart(input, args, exec) {
     catch (error) {
         deliverableTrace = `交付登记抛错（已吞掉，不影响出图）：${error instanceof Error ? error.message : String(error)}`;
     }
-    // 诊断落盘**默认关闭**：交付行"静默不出现"是最难查的故障（2026-09-20 连查四轮），
-    // 而宿主终端不总能拿到（cordis logger 只进内存），所以留一条可从磁盘定位的出口；
-    // 但它属于调试产物，不该出现在对外版本的 workspace 里。
-    // 需要时用 `CAPITAL_CHART_TRACE=1` 启动宿主，图表产物目录会多出 deliverable-trace.txt。
+    // Trace file only under CAPITAL_CHART_TRACE=1; a debugging aid, not a release artifact.
     if (chartTraceEnabled()) {
         try {
             await input.store.writeWorkspaceFiles({
@@ -233,7 +221,7 @@ export async function renderChart(input, args, exec) {
             });
         }
         catch {
-            // 诊断落盘失败不影响出图。
+            // Trace write failures never affect chart output.
         }
     }
     return {
@@ -271,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

@@ -0,0 +1,10 @@
+/**
+ * `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`. 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";
+export declare const inject: string[];
+export declare function apply(ctx: Context): void;

package/lib/chart-render-entry.js

@@ -0,0 +1,14 @@
+import { registerChartTool } from './chart/tool.js';
+import { capitalDatasetStore } from './runtime.js';
+import { capitalSharedRuntimeOf } from './chart-source-entry.js';
+export const name = 'capital-chart-render-tools';
+export const inject = ['tools'];
+export function apply(ctx) {
+    const shared = capitalSharedRuntimeOf(ctx);
+    registerChartTool(ctx, {
+        store: capitalDatasetStore(ctx),
+        sourceTokens: shared.sourceTokens,
+        artifacts: shared.artifacts,
+        charts: () => ctx.get('capitalCharts'),
+    });
+}

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

@@ -0,0 +1,13 @@
+/**
+ * `tools/chart-source` row: prepare_chart_source. The token store must be the same
+ * instance used by `tools/chart-render`; separate stores make `render_chart` always
+ * report `chart_source_expired` without throwing. Prefer the host-plane runtime, fall
+ * back to the root-keyed module cache.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { type CapitalShared } from './runtime.js';
+export declare const name = "capital-chart-source-tools";
+export declare const inject: string[];
+export declare function apply(ctx: Context): void;
+/** Host row first, root-keyed module cache as fallback (monolith carriers). */
+export declare function capitalSharedRuntimeOf(ctx: Context): CapitalShared;

package/lib/chart-source-entry.js

@@ -0,0 +1,20 @@
+import { registerChartSourceTool } from './chart/source-token.js';
+import { capitalDatasetStore, capitalSharedRuntime } from './runtime.js';
+export const name = 'capital-chart-source-tools';
+export const inject = ['tools'];
+export function apply(ctx) {
+    const shared = capitalSharedRuntimeOf(ctx);
+    registerChartSourceTool(ctx, { store: capitalDatasetStore(ctx), tokens: shared.sourceTokens });
+}
+/** Host row first, root-keyed module cache as fallback (monolith carriers). */
+export function capitalSharedRuntimeOf(ctx) {
+    try {
+        const hostShared = ctx.get('capitalChartRuntime');
+        if (hostShared !== undefined)
+            return hostShared;
+    }
+    catch {
+        // Monolith carrier without the host row.
+    }
+    return capitalSharedRuntime(ctx);
+}

package/lib/collect-entry.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `tools/collect` row: request_data / list_capabilities / describe_capability /
+ * dc_status backed by hub + 128 sources. The preset isolates hub/store to this row;
+ * time tools live in `tools/time`.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+export declare const name = "capital-collect-tools";
+export declare const inject: string[];
+export declare function apply(ctx: Context): void;

package/lib/collect-entry.js

@@ -0,0 +1,10 @@
+import { createCollectorRuntime } from './collector-runtime.js';
+import { registerDataCollectorTools } from './data-collector/tools.js';
+import { readCollectorConfig } from './capital-settings.js';
+export const name = 'capital-collect-tools';
+export const inject = ['tools'];
+export function apply(ctx) {
+    const config = readCollectorConfig(ctx);
+    const { hub, diagnostics } = createCollectorRuntime(ctx, config);
+    registerDataCollectorTools(ctx, hub, diagnostics);
+}

package/lib/collector-runtime.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Shared data_collector assembly (store + hub + 128 sources). Both `tools/collect` and
+ * the monolith need it; duplicating would drift capability registration, credential
+ * probes and time tools. Collector domain only — no dataset/chart/watchlist tools.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { provideDataCollectorHub } from './data-collector/hub.js';
+import { type DataCollectorDiagnostics } from './data-collector/tools.js';
+import { capitalDatasetStore } from './runtime.js';
+export interface CollectorConfig {
+    fuyaoCredentialRef?: string;
+    ftshareCredentialRef?: string;
+    /** Flat projection of `retriever.windDocs.credentialRef`. */
+    windCredentialRef?: string;
+}
+export interface CollectorRuntime {
+    store: ReturnType<typeof capitalDatasetStore>;
+    hub: ReturnType<typeof provideDataCollectorHub>;
+    /** Injected into `dc_status` by the caller that owns the `tools/collect` row. */
+    diagnostics: DataCollectorDiagnostics;
+}
+export declare function createCollectorRuntime(ctx: Context, config?: CollectorConfig): CollectorRuntime;

package/lib/collector-runtime.js

@@ -0,0 +1,97 @@
+import { provideDataCollectorHub } from './data-collector/hub.js';
+import { capitalDatasetStore } from './runtime.js';
+import { rootPolicyProbes } from './agents/root-tool-policy.js';
+import { rolePolicyProbes } from './agents/role-tool-policy.js';
+import { createTencentSources } from './sources/tencent-http.js';
+import { createEastmoneySources } from './sources/eastmoney-http.js';
+import { createFuyaoRestSources, resolveFuyaoApiKey } from './sources/fuyao-rest.js';
+import { createFtshareSources, resolveFtshareApiKey } from './sources/ftshare-rest.js';
+import { createWindSources } from './sources/wind-mcp.js';
+import { createWindCredentialResolver } from './retriever-runtime.js';
+function diagnosticsFor(ctx, config) {
+    const fuyaoCredentialRef = config.fuyaoCredentialRef || 'FUYAO_API_KEY';
+    return {
+        probeApiKey: async () => {
+            try {
+                const credentials = ctx.get('credentials');
+                if (credentials?.resolve) {
+                    const resolved = await credentials.resolve(fuyaoCredentialRef);
+                    if (resolved?.value)
+                        return { present: true, source: resolved.source ?? `credentials(${fuyaoCredentialRef})` };
+                }
+                const processLike = globalThis.process;
+                if (processLike?.env?.[fuyaoCredentialRef])
+                    return { present: true, source: `env(${fuyaoCredentialRef})` };
+                return { present: false, source: null };
+            }
+            catch (error) {
+                return { present: false, source: null, error: error instanceof Error ? error.message : String(error) };
+            }
+        },
+        // dc_status readout for root/role convergence; desktop does not persist host logs.
+        // Keep the real session shape: opened root and delegated child converge differently.
+        rootPolicy: () => [
+            ...rootPolicyProbes().map((probe) => ({ ...probe, allowed: [] })),
+            ...rolePolicyProbes().map((probe) => ({
+                agentId: probe.agentId,
+                root: probe.root,
+                presetId: probe.presetId,
+                outcome: probe.outcome,
+                // Roles have no allow-list (family rows define the surface); report sibling
+                // denials and call-level guard rejections.
+                allowed: [],
+                denied: probe.denied,
+                failed: probe.failed,
+            })),
+        ],
+    };
+}
+/** Registers all 128 sources; registration is structural, credentials resolve per call. */
+function registerSources(ctx, hub, config) {
+    ctx.effect(() => {
+        const sources = createTencentSources();
+        const disposers = sources.map((dataSource) => hub.registerSource(dataSource));
+        ctx.logger.info(`capital-generation: 已注册 ${disposers.length} 个腾讯数据源（tencent_*）`);
+        return () => { for (const dispose of disposers)
+            dispose(); };
+    }, 'capital-generation.tencent-sources()');
+    ctx.effect(() => {
+        const sources = createEastmoneySources();
+        const disposers = sources.map((dataSource) => hub.registerSource(dataSource));
+        ctx.logger.info(`capital-generation: 已注册 ${disposers.length} 个东方财富数据源（eastmoney_*）`);
+        return () => { for (const dispose of disposers)
+            dispose(); };
+    }, 'capital-generation.eastmoney-sources()');
+    ctx.effect(() => {
+        const sources = createFuyaoRestSources(() => resolveFuyaoApiKey(ctx, config.fuyaoCredentialRef || 'FUYAO_API_KEY'));
+        const disposers = sources.map((dataSource) => hub.registerSource(dataSource));
+        ctx.logger.info(`capital-generation: 已注册 ${disposers.length} 个同花顺数据源（key 每次调用现取）`);
+        return () => { for (const dispose of disposers)
+            dispose(); };
+    }, 'capital-generation.fuyao-sources()');
+    ctx.effect(() => {
+        const sources = createFtshareSources(() => resolveFtshareApiKey(ctx, config.ftshareCredentialRef || 'FTSHARE_API_KEY'));
+        const disposers = sources.map((dataSource) => hub.registerSource(dataSource));
+        ctx.logger.info(`capital-generation: 已注册 ${disposers.length} 个 FTShare 数据源（ftshare_*，key 每次调用现取）`);
+        return () => { for (const dispose of disposers)
+            dispose(); };
+    }, 'capital-generation.ftshare-sources()');
+    const wind = createWindCredentialResolver(ctx, config.windCredentialRef);
+    ctx.effect(() => {
+        const sources = createWindSources(wind.resolve);
+        const disposers = sources.map((dataSource) => hub.registerSource(dataSource));
+        ctx.logger.info(`capital-generation: 已注册 ${disposers.length} 个 Wind 数据源（wind_*，与 wind_docs 共用 ${wind.credentialRef}）`);
+        return () => { for (const dispose of disposers)
+            dispose(); };
+    }, 'capital-generation.wind-sources()');
+}
+export function createCollectorRuntime(ctx, config = {}) {
+    const store = capitalDatasetStore(ctx);
+    // The collector preset isolates these services; keep them in the realm to avoid
+    // process-wide name collisions across presets.
+    ctx.provide('datasetStore', store);
+    const hub = provideDataCollectorHub(ctx, { store });
+    registerSources(ctx, hub, config);
+    // Builds runtime only; model tools belong to the `tools/collect` and `tools/time` rows.
+    return { store, hub, diagnostics: diagnosticsFor(ctx, config) };
+}

package/lib/data-collector/args.d.ts

@@ -1,38 +1,20 @@
 /**
- * Dataset 工具边界的**宽容参数解析**。
- *
- * 模型经常把数组/对象参数序列化成 JSON 字符串再传（实测：`"select": "[\"date_ms\"]"`、
- * `"group_by": "[]"`、`"aggregates": "[{...}]"`、`"limit": "1"`），于是参数其实是对的，
- * 却报 `query_spec_invalid: select must contain 1-32 column names`，模型只能反复试错。
- *
- * 这里在**工具边界**做一次宽容解析，查询引擎本身保持严格：能解析成正确类型就放行，
- * 解析不了就原样交给校验器报错（错误信息仍指向真实问题）。
- *
- * 本模块由 `query_dataset`（dataset-tools.ts）与 `describe_dataset`（describe.ts）共用，
- * 保证两个工具对同一种"字符串化的 JSON"给出**完全一致**的宽容度——两份实现漂移会让模型
- * 在换工具后重新踩同一个坑。
+ * Lenient parameter parsing at the Dataset tool boundary: models often send stringified JSON.
+ * Shared by query_dataset and describe_dataset so both accept exactly the same shapes.
  */
 export declare function isRecord(value: unknown): value is Record<string, unknown>;
 export declare function parseJsonContainer(value: unknown): unknown;
-/** 列名数组：接受真数组、JSON 数组字符串，或单个列名字符串。 */
+/** Accept a real array, a JSON array string, or a single column name. */
 export declare function coerceNameList(value: unknown): unknown;
-/** 对象数组：接受真数组、JSON 数组字符串，或单个对象（对象本身或其 JSON 字符串）。 */
 export declare function coerceObjectList(value: unknown): unknown;
 export declare function coerceLimit(value: unknown): unknown;
 export declare const QUERY_NAME_LIST_FIELDS: readonly ["select", "group_by"];
 export declare const QUERY_OBJECT_LIST_FIELDS: readonly ["filters", "aggregates", "order_by"];
-/** 把 QuerySpec 的数组/对象字段与 limit 统一解析成引擎期望的类型（不改其余字段）。 */
+/** Coerce QuerySpec array/object fields and limit to engine types; leave other fields untouched. */
 export declare function coerceQueryShape(input: Record<string, unknown>): Record<string, unknown>;
-/** dataset_id 的形态校验；不合法一律在工具边界抛错，绝不带进 store。 */
+/** Reject an invalid dataset_id at the tool boundary; never pass it to the store. */
 export declare function readDatasetId(value: unknown): string;
-/** task_id 是可选元数据：空值等同于未提供，只做长度上限校验。 */
 export declare function readOptionalTaskId(value: unknown): string | undefined;
-/** 可选的字符串参数（time_column / primary_key）：非字符串一律视为未提供。 */
 export declare function readOptionalString(value: unknown): string | undefined;
-/**
- * 列名过滤参数（describe_dataset 的 `columns_of_interest`）。
- *
- * 接受真数组 / JSON 数组字符串 / 单个列名字符串；解析结果不是数组就抛错——静默忽略一个
- * 写错的过滤条件会让模型以为"结果已经收窄"，而实际返回的是全量（或反过来），所以这里响亮失败。
- */
+/** columns_of_interest: accept array/JSON/single name; a wrong shape fails loudly rather than silently widening results. */
 export declare function readOptionalColumnList(value: unknown): string[] | undefined;