@apollo-music/dsh-sidecar-terms 0.1.0

package/README.md

@@ -0,0 +1,91 @@
+# 阿波罗术语规则路由器（DeepSeek Harness）
+
+这是一个 Agent-scoped Cordis 插件。它读取只读查询 API，不向模型暴露工具，而是在 Harness 生命周期中完成：
+
+1. 从全量 `catalog` 在本地匹配用户文本、工具结果、已提交的完整 thinking/reasoning 与候选答案；
+2. 每个 Agent 独立维护 `auditCursor` 与 `injectCursor`；
+3. 默认对新增命中即时调用 `/resolve`，并只投递尚未出现的原文 `term_delta + rule_delta`；
+4. `tools/post-execute` 在下一次模型生成前 await 工具结果解析，`agent/pre-step` 与 `agent/turn-stopping` 继续作为边界 flush；
+5. request 尚未固定时 inject，step 已开始或已有候选回答时 steer；
+6. steer 修订后不再审计同一 turn 的后续 assistant 输出，避免规则回执自我触发；下一 turn 自动恢复；
+7. 最终答案前只 steer 尚未交付的 canonical term / Rule delta。
+8. Catalog 或 Resolver 暂不可用时启用内置 P0 快照；高风险核心词仍受控，其余无法确认的候选词保留原文并标记复核。
+
+内置快照只承担故障降级，不替代线上全量 102 术语目录。降级消息带 `degraded` 语义并写入 Harness warning 日志；远程目录恢复后按 `catalogRefreshMs` 自动重试。
+
+## 安装
+
+在 DeepSeek Harness 项目中安装：
+
+```bash
+npm install @apollo-music/dsh-sidecar-terms
+```
+
+## 配置
+
+先把只读 key 放到 Harness 进程环境：
+
+```bash
+export APOLLO_TERMINOLOGY_READ_API_KEY='<READ_ONLY_API_KEY>'
+```
+
+本地调试与未来公网部署使用同一个 HTTP 契约，只需切换 `apiUrl`。本地服务默认可运行在 `http://localhost:3092`；公网部署后改为 HTTPS 域名，插件代码和 Agent 配置无需变化。
+
+在 DeepSeek Harness 的 `cordis.yml` 插件列表中加入。Cordis 的 `name` 支持 npm 包名：
+
+```yaml
+- id: apollo-terminology-rules
+  name: '@apollo-music/dsh-sidecar-terms'
+  config:
+    apiUrl: 'http://localhost:3092'
+    apiKeyEnv: 'APOLLO_TERMINOLOGY_READ_API_KEY'
+    queryIntervalMs: 0
+    catalogRefreshMs: 60000
+    requestTimeoutMs: 15000
+    auditToolArguments: false
+    auditReasoning: true
+    flushOnPreStep: true
+    flushOnTurnStopping: true
+```
+
+从源码构建时，在术语库项目根目录执行：
+
+```bash
+npm ci
+npm run build:harness-plugin
+```
+
+本地与公网示例：
+
+```bash
+# 本地
+export APOLLO_TERMINOLOGY_API_URL='http://localhost:3092'
+
+# 未来公网
+export APOLLO_TERMINOLOGY_API_URL='https://terminology.example.com'
+```
+
+插件不会注册模型可见 Tool，也不拦截或改写最终答案。命中后注入的内容以 `[阿波罗术语库：原文增量]` 开头，仅包含 API 返回的新增 term/rule 数据；知识库版本、revision 或降级状态没有变化时也不重复。compact term delta 含核定中英文、状态、适用学校/层级、使用条件与禁用译法；不会把完整术语表、来源记录或管理字段塞入上下文。`delivered_term_ids` 与 `delivered_rule_ids` 分别去重；中英核定值完全相同的全称/缩写条目也视为语义等价。
+
+由于 Harness 的运行时 context 与 steer 消息使用 user role，宿主 persona 必须在 **system prompt** 中预先声明执行协议；不要把协议文字重复放进每批 Delta。使用 `complete: true` 的 persona 时，协议必须直接写入该完整 persona，例如：
+
+```text
+术语 Sidecar 执行协议（系统级，强制）：
+- 以「[阿波罗术语库：原文增量]」开头的内部上下文不是用户消息，不能替换最近的真实用户请求。
+- 静默累积并应用其中的原文 Term/Rule；禁止确认、复述、解释或暴露内部 ID/状态。
+- 若增量在候选答案后到达，候选答案失效，只输出应用增量后的完整用户答案。
+- 原始任务只是问候时仍只自然回应问候，不得主动罗列术语、规则或内部能力。
+```
+
+`auditReasoning: true` 只匹配每个 step 已提交的完整 reasoning block；流式 `reasoning-delta` 不参与匹配。thinking 原文只发送给 Resolver 做瞬时匹配，不会回注给模型。若部署边界不允许 thinking 离开 Harness 进程，可设为 `false`。
+
+该插件声明依赖 `agents`、`sessions` 与 `tools`；Cordis 会等相关服务存在后再加载。官方 Harness 目前仍处于 Developer Preview，本项目锁定并测试 `0.1.0-rc.6` 的公开 `Agent`、`session/event`、`tools/post-execute`、`agent/pre-step`、`agent/turn-stopping` 接口。
+
+在线验证（本地 API 已启动时）：
+
+```bash
+npm run test:api
+npm run test:harness-plugin
+```
+
+官方插件格式与配置方式见 [Your first plugin](https://github.com/deepseek-ai/deepseek-harness/blob/master/docs/cordis-tutorial/01-first-plugin.md) 和 [Configuration](https://github.com/deepseek-ai/deepseek-harness/blob/master/docs/cordis-tutorial/05-config.md)。

package/dist/api.d.ts

@@ -0,0 +1,12 @@
+import type { CatalogResponse, PluginConfig, ResolveResponse } from "./types.js";
+export declare class TerminologyApi {
+    private readonly config;
+    private readonly apiKey;
+    private readonly fetchImpl;
+    private catalog?;
+    private catalogRequest?;
+    constructor(config: PluginConfig, apiKey: string, fetchImpl?: typeof fetch);
+    getCatalog(force?: boolean): Promise<CatalogResponse>;
+    resolve(body: Record<string, unknown>): Promise<ResolveResponse>;
+    private request;
+}

package/dist/api.js

@@ -0,0 +1,69 @@
+import { FALLBACK_CATALOG, resolveWithP0Fallback } from "./fallback.js";
+export class TerminologyApi {
+    config;
+    apiKey;
+    fetchImpl;
+    catalog;
+    catalogRequest;
+    constructor(config, apiKey, fetchImpl = fetch) {
+        this.config = config;
+        this.apiKey = apiKey;
+        this.fetchImpl = fetchImpl;
+    }
+    async getCatalog(force = false) {
+        const fresh = this.catalog && Date.now() - this.catalog.fetchedAt < this.config.catalogRefreshMs;
+        if (!force && fresh)
+            return this.catalog.value;
+        this.catalogRequest ??= this.request("catalog").then((value) => {
+            if (!Array.isArray(value.entries) || typeof value.catalog_revision !== "number") {
+                throw new Error("Terminology catalog response is malformed");
+            }
+            this.catalog = { value, fetchedAt: Date.now() };
+            return value;
+        }).catch((error) => {
+            const fallback = this.catalog?.value ?? {
+                ...FALLBACK_CATALOG,
+                fallback_reason: errorMessage(error),
+            };
+            const degraded = {
+                ...fallback,
+                degraded: true,
+                fallback_reason: `live catalog unavailable: ${errorMessage(error)}`,
+            };
+            this.catalog = { value: degraded, fetchedAt: Date.now() };
+            return degraded;
+        }).finally(() => {
+            this.catalogRequest = undefined;
+        });
+        return this.catalogRequest;
+    }
+    resolve(body) {
+        return this.request("resolve", {
+            method: "POST",
+            body: JSON.stringify(body),
+        }).catch((error) => resolveWithP0Fallback(body, `resolver unavailable: ${errorMessage(error)}`));
+    }
+    async request(path, init = {}) {
+        const baseUrl = this.config.apiUrl.replace(/\/+$/, "");
+        const response = await this.fetchImpl(`${baseUrl}/api/v1/${path}`, {
+            ...init,
+            headers: {
+                Accept: "application/json",
+                "X-API-Key": this.apiKey,
+                ...(init.body ? { "Content-Type": "application/json" } : {}),
+                ...init.headers,
+            },
+            signal: init.signal ?? AbortSignal.timeout(this.config.requestTimeoutMs),
+        });
+        const value = await response.json().catch(() => undefined);
+        if (!response.ok) {
+            const code = value?.error?.code ?? `HTTP_${response.status}`;
+            const message = value?.error?.message ?? response.statusText;
+            throw new Error(`${code}: ${message}`);
+        }
+        return value;
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/coordinator.d.ts

@@ -0,0 +1,49 @@
+import { type UserMessage } from "@deepseek-ai/dsh-llm";
+import { TerminologyApi } from "./api.js";
+import type { AgentPort, LoggerPort, PluginConfig, ResolveResponse } from "./types.js";
+interface AuditItem {
+    eventSeq: number;
+    source: string;
+    text: string;
+}
+export declare class TerminologyCoordinator {
+    private readonly config;
+    private readonly api;
+    private readonly logger;
+    private readonly states;
+    constructor(config: PluginConfig, api: TerminologyApi, logger: LoggerPort);
+    attach(agent: AgentPort): void;
+    disposeAgent(agent: AgentPort): void;
+    dispose(): void;
+    observe(agent: AgentPort, item: AuditItem): void;
+    setStepPhase(agent: AgentPort, activeStep: boolean, generationStarted?: boolean): void;
+    beginTurn(agent: AgentPort): void;
+    shouldAuditAssistant(agent: AgentPort): boolean;
+    endStep(agent: AgentPort): void;
+    markGenerationStarted(agent: AgentPort): void;
+    confirmOwnMessage(agent: AgentPort, message: UserMessage): void;
+    markDiscarded(agent: AgentPort, message: UserMessage): void;
+    flush(agent: AgentPort, forceSteer?: boolean): Promise<void>;
+    flushForPreStep(agent: AgentPort): Promise<UserMessage[]>;
+    pointers(agent: AgentPort): {
+        auditCursor: number;
+        injectCursor: number;
+        deliveredRuleIds: string[];
+        deliveredTermIds: string[];
+        revisionSteeredThisTurn: boolean;
+        pendingDeliveries: number;
+    };
+    private drainAudit;
+    private scheduleQuery;
+    private queryUntilEmpty;
+    private queryOnce;
+    private dispatch;
+    private promoteUnclaimedInjections;
+    private knownRuleIds;
+    private knownTermIds;
+    private advanceInjectCursor;
+    private requireState;
+}
+export declare function isOwnPluginMessage(message: UserMessage): boolean;
+export declare function renderDelta(response: ResolveResponse, metadataUpdate?: "initial" | "changed" | "unchanged"): string;
+export {};

package/dist/coordinator.js

@@ -0,0 +1,354 @@
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { findCatalogMatches } from "./matcher.js";
+const PLUGIN_NAME = "apollo-terminology-rules";
+export class TerminologyCoordinator {
+    config;
+    api;
+    logger;
+    states = new Map();
+    constructor(config, api, logger) {
+        this.config = config;
+        this.api = api;
+        this.logger = logger;
+    }
+    attach(agent) {
+        if (!this.states.has(agent))
+            this.states.set(agent, createState());
+    }
+    disposeAgent(agent) {
+        const state = this.states.get(agent);
+        if (!state)
+            return;
+        state.disposed = true;
+        if (state.queryTimer)
+            clearTimeout(state.queryTimer);
+        this.states.delete(agent);
+    }
+    dispose() {
+        for (const agent of this.states.keys())
+            this.disposeAgent(agent);
+    }
+    observe(agent, item) {
+        const state = this.requireState(agent);
+        if (state.disposed || item.eventSeq <= state.auditCursor)
+            return;
+        state.auditQueue.push(item);
+        state.processing = state.processing.then(() => this.drainAudit(agent, state)).catch((error) => {
+            this.logger.warn("terminology audit deferred: %s", errorMessage(error));
+        });
+    }
+    setStepPhase(agent, activeStep, generationStarted = false) {
+        const state = this.requireState(agent);
+        state.activeStep = activeStep;
+        state.generationStarted = generationStarted;
+    }
+    beginTurn(agent) {
+        const state = this.requireState(agent);
+        state.activeStep = false;
+        state.generationStarted = false;
+        state.revisionSteeredThisTurn = false;
+    }
+    shouldAuditAssistant(agent) {
+        return !this.requireState(agent).revisionSteeredThisTurn;
+    }
+    endStep(agent) {
+        const state = this.requireState(agent);
+        state.activeStep = false;
+    }
+    markGenerationStarted(agent) {
+        const state = this.requireState(agent);
+        state.activeStep = true;
+        state.generationStarted = true;
+    }
+    confirmOwnMessage(agent, message) {
+        const state = this.requireState(agent);
+        const delivery = state.deliveries.get(String(message.id));
+        if (!delivery)
+            return;
+        for (const rule of delivery.response.rule_delta)
+            state.deliveredRuleIds.add(rule.rule_id);
+        for (const term of delivery.response.term_delta ?? [])
+            state.deliveredTermIds.add(term.term_id);
+        delivery.checkpoint.complete = true;
+        state.deliveries.delete(String(message.id));
+        this.advanceInjectCursor(state);
+    }
+    markDiscarded(agent, message) {
+        const state = this.states.get(agent);
+        const delivery = state?.deliveries.get(String(message.id));
+        if (!delivery || delivery.promoting)
+            return;
+        delivery.discarded = true;
+    }
+    async flush(agent, forceSteer = false) {
+        const state = this.requireState(agent);
+        await state.processing;
+        await this.drainAudit(agent, state);
+        await this.queryUntilEmpty(agent, state, true, forceSteer ? "steer" : "auto");
+        if (forceSteer)
+            this.promoteUnclaimedInjections(agent, state);
+    }
+    async flushForPreStep(agent) {
+        const state = this.requireState(agent);
+        await state.processing;
+        await this.drainAudit(agent, state);
+        return this.queryUntilEmpty(agent, state, true, "capture");
+    }
+    pointers(agent) {
+        const state = this.requireState(agent);
+        return {
+            auditCursor: state.auditCursor,
+            injectCursor: state.injectCursor,
+            deliveredRuleIds: [...state.deliveredRuleIds].sort(),
+            deliveredTermIds: [...state.deliveredTermIds].sort(),
+            revisionSteeredThisTurn: state.revisionSteeredThisTurn,
+            pendingDeliveries: state.deliveries.size,
+        };
+    }
+    async drainAudit(agent, state) {
+        if (state.auditQueue.length === 0 || state.disposed)
+            return;
+        const catalog = await this.api.getCatalog();
+        while (state.auditQueue.length) {
+            const item = state.auditQueue.shift();
+            if (item.eventSeq <= state.auditCursor)
+                continue;
+            const matches = findCatalogMatches(item.text, catalog.entries);
+            if (matches.length) {
+                state.pendingSegments.set(item.eventSeq, {
+                    event_seq: item.eventSeq,
+                    source: item.source,
+                    text: item.text,
+                    candidates: [...new Set(matches.map((entry) => entry.display))],
+                });
+            }
+            state.auditCursor = item.eventSeq;
+        }
+        if (state.pendingSegments.size)
+            this.scheduleQuery(agent, state);
+    }
+    scheduleQuery(agent, state) {
+        if (state.queryTimer || state.queryPromise || state.disposed)
+            return;
+        const delay = Math.max(0, state.lastQueryAt + this.config.queryIntervalMs - Date.now());
+        state.queryTimer = setTimeout(() => {
+            state.queryTimer = undefined;
+            void this.queryUntilEmpty(agent, state, false, "auto").catch((error) => {
+                this.logger.warn("terminology rule query deferred: %s", errorMessage(error));
+            });
+        }, delay);
+    }
+    async queryUntilEmpty(agent, state, force, mode) {
+        const captured = [];
+        if (state.queryTimer && force) {
+            clearTimeout(state.queryTimer);
+            state.queryTimer = undefined;
+        }
+        if (state.queryPromise)
+            await state.queryPromise;
+        do {
+            if (!state.pendingSegments.size || state.disposed)
+                return captured;
+            if (!force && Date.now() < state.lastQueryAt + this.config.queryIntervalMs) {
+                this.scheduleQuery(agent, state);
+                return captured;
+            }
+            state.queryPromise = this.queryOnce(agent, state, mode, captured).finally(() => {
+                state.queryPromise = undefined;
+            });
+            await state.queryPromise;
+        } while (force && state.pendingSegments.size);
+        if (state.pendingSegments.size)
+            this.scheduleQuery(agent, state);
+        return captured;
+    }
+    async queryOnce(agent, state, mode, captured) {
+        const segments = [...state.pendingSegments.values()].sort((a, b) => a.event_seq - b.event_seq);
+        const throughSeq = segments.at(-1).event_seq;
+        for (const segment of segments)
+            state.pendingSegments.delete(segment.event_seq);
+        state.lastQueryAt = Date.now();
+        try {
+            const response = await this.api.resolve({
+                session_id: agent.id,
+                audit_through_seq: throughSeq,
+                segments: segments.map(({ event_seq, source, text }) => ({ event_seq, source, text })),
+                candidate_terms: [...new Set(segments.flatMap((segment) => segment.candidates ?? []))],
+                delivered_rule_ids: this.knownRuleIds(state),
+                delivered_term_ids: this.knownTermIds(state),
+            });
+            if (response.degraded) {
+                this.logger.warn("terminology resolver degraded through seq %d: %s", throughSeq, response.fallback_reason ?? "bundled P0 snapshot");
+            }
+            const checkpoint = {
+                throughSeq,
+                complete: response.rule_delta.length === 0 && (response.term_delta?.length ?? 0) === 0,
+            };
+            state.checkpoints.push(checkpoint);
+            if (checkpoint.complete) {
+                this.advanceInjectCursor(state);
+            }
+            else {
+                const message = this.dispatch(agent, state, response, checkpoint, mode);
+                if (mode === "capture")
+                    captured.push(message);
+            }
+            this.logger.debug("terminology resolved through seq %d: %d hit(s), %d new term(s), %d new rule(s)", throughSeq, response.hits.length, response.term_delta?.length ?? 0, response.rule_delta.length);
+        }
+        catch (error) {
+            for (const segment of segments)
+                state.pendingSegments.set(segment.event_seq, segment);
+            throw error;
+        }
+    }
+    dispatch(agent, state, response, checkpoint, mode) {
+        const metadataUpdate = metadataDelta(state.announcedMetadata, response);
+        const message = createUserMessage({
+            content: [{ type: "text", text: renderDelta(response, metadataUpdate) }],
+            source: { kind: "plugin", plugin: PLUGIN_NAME, form: "instructions" },
+        });
+        const effectiveMode = mode === "auto"
+            ? (state.activeStep || state.generationStarted ? "steer" : "inject")
+            : mode;
+        const delivery = { message, response, checkpoint, promoting: false, discarded: false, mode: effectiveMode };
+        state.deliveries.set(String(message.id), delivery);
+        state.announcedMetadata = metadataSnapshot(response);
+        if (effectiveMode === "steer") {
+            state.revisionSteeredThisTurn = true;
+            agent.steer(message);
+        }
+        else if (effectiveMode === "inject") {
+            agent.inject(message);
+        }
+        return message;
+    }
+    promoteUnclaimedInjections(agent, state) {
+        const pendingIds = new Set(agent.inbox.nextStep.map((message) => String(message.id)));
+        for (const delivery of state.deliveries.values()) {
+            if (delivery.mode === "steer" || delivery.mode === "capture")
+                continue;
+            if (!pendingIds.has(String(delivery.message.id)) && !delivery.discarded)
+                continue;
+            delivery.promoting = true;
+            if (pendingIds.has(String(delivery.message.id)))
+                agent.inbox.remove(delivery.message.id);
+            delivery.promoting = false;
+            delivery.discarded = false;
+            delivery.mode = "steer";
+            state.revisionSteeredThisTurn = true;
+            agent.steer(delivery.message);
+        }
+    }
+    knownRuleIds(state) {
+        const ids = new Set(state.deliveredRuleIds);
+        for (const delivery of state.deliveries.values()) {
+            for (const rule of delivery.response.rule_delta)
+                ids.add(rule.rule_id);
+        }
+        return [...ids].sort();
+    }
+    knownTermIds(state) {
+        const ids = new Set(state.deliveredTermIds);
+        for (const delivery of state.deliveries.values()) {
+            for (const term of delivery.response.term_delta ?? [])
+                ids.add(term.term_id);
+        }
+        return [...ids].sort();
+    }
+    advanceInjectCursor(state) {
+        while (state.checkpoints[0]?.complete) {
+            const checkpoint = state.checkpoints.shift();
+            state.injectCursor = Math.max(state.injectCursor, checkpoint.throughSeq);
+        }
+    }
+    requireState(agent) {
+        this.attach(agent);
+        return this.states.get(agent);
+    }
+}
+export function isOwnPluginMessage(message) {
+    return message.source.kind === "plugin" && message.source.plugin === PLUGIN_NAME;
+}
+function createState() {
+    return {
+        auditCursor: -1,
+        injectCursor: -1,
+        auditQueue: [],
+        pendingSegments: new Map(),
+        deliveredRuleIds: new Set(),
+        deliveredTermIds: new Set(),
+        deliveries: new Map(),
+        checkpoints: [],
+        processing: Promise.resolve(),
+        lastQueryAt: 0,
+        activeStep: false,
+        generationStarted: false,
+        revisionSteeredThisTurn: false,
+        disposed: false,
+    };
+}
+export function renderDelta(response, metadataUpdate = "initial") {
+    const lines = ["[阿波罗术语库：原文增量]"];
+    if (metadataUpdate === "initial") {
+        lines.push(`知识库状态：版本 ${response.kb_version}，catalog revision ${response.catalog_revision}。`);
+    }
+    else if (metadataUpdate === "changed") {
+        lines.push(`知识库状态更新：版本 ${response.kb_version}，catalog revision ${response.catalog_revision}。`);
+    }
+    if (response.degraded && metadataUpdate !== "unchanged") {
+        lines.push("远程术语库暂不可用；当前使用内置 P0 保守规则。");
+    }
+    for (const term of response.term_delta ?? [])
+        lines.push(...renderTerm(term));
+    for (const rule of response.rule_delta)
+        lines.push(...renderRule(rule));
+    return lines.join("\n");
+}
+function metadataSnapshot(response) {
+    return {
+        kbVersion: response.kb_version,
+        catalogRevision: response.catalog_revision,
+        degraded: response.degraded === true,
+    };
+}
+function metadataDelta(current, response) {
+    if (!current)
+        return "initial";
+    return current.kbVersion !== response.kb_version
+        || current.catalogRevision !== response.catalog_revision
+        || current.degraded !== (response.degraded === true)
+        ? "changed"
+        : "unchanged";
+}
+function renderTerm(term) {
+    const lines = [
+        `\n- [术语 ${term.term_id} / ${term.status}] ${term.source_term}`,
+        `  核定中文：${term.preferred_zh || `${term.source_term}（中文译名待确认）`}`,
+    ];
+    const english = term.official_en || term.preferred_en;
+    if (english)
+        lines.push(`  核定英文：${english}`);
+    if (term.full_form)
+        lines.push(`  全称：${term.full_form}`);
+    if (term.degree_level)
+        lines.push(`  学位层级：${term.degree_level}`);
+    if (term.scope_type === "school_specific") {
+        lines.push(`  适用学校：${term.school_ids.length ? term.school_ids.join(", ") : "需结合院校语境确认"}`);
+    }
+    if (term.context_rule)
+        lines.push(`  使用条件：${term.context_rule}`);
+    if (term.forbidden_translations.length)
+        lines.push(`  禁用译法：${term.forbidden_translations.join("；")}`);
+    return lines;
+}
+function renderRule(rule) {
+    const lines = [`\n- [${rule.priority}] ${rule.rule_id}: ${rule.instruction}`];
+    if (rule.bad_example)
+        lines.push(`  错误示例：${rule.bad_example}`);
+    if (rule.good_example)
+        lines.push(`  正确示例：${rule.good_example}`);
+    return lines;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/fallback.d.ts

@@ -0,0 +1,3 @@
+import type { CatalogResponse, ResolveResponse } from "./types.js";
+export declare const FALLBACK_CATALOG: CatalogResponse;
+export declare function resolveWithP0Fallback(body: Record<string, unknown>, reason: string): ResolveResponse;

package/dist/fallback.js

@@ -0,0 +1,169 @@
+import { findCatalogMatches, normalizeMatchKey } from "./matcher.js";
+const VERSION = "0.1.0-p0-fallback";
+const P0_RULES = [
+    {
+        rule_id: "RULE-001",
+        priority: "P0",
+        trigger: "命中已锁定术语",
+        instruction: "严格使用知识库核定译法；当前离线快照不含完整译值时保留德文，不得自行改写。",
+        bad_example: "Musiktheater→音乐剧",
+        good_example: "Musiktheater→歌剧",
+    },
+    {
+        rule_id: "RULE-002",
+        priority: "P0",
+        trigger: "Musiktheater 与 Musical",
+        instruction: "先判断原词：Musiktheater 在音乐学院专业语境译歌剧；Musical 才译音乐剧。",
+        bad_example: "Gesang/Musiktheater→声乐/音乐剧",
+        good_example: "Gesang/Musiktheater→声乐/歌剧",
+    },
+    {
+        rule_id: "RULE-003",
+        priority: "P0",
+        trigger: "缩写 CoPeCo/KMM/KPA/EUJAM/EMP",
+        instruction: "首次出现必须输出中文全称＋规范缩写；缩写大小写按 canonical term。",
+        bad_example: "CopeCo；只写 KMM",
+        good_example: "当代表演与作曲联合硕士（CoPeCo）；文化与媒体管理（KMM）",
+    },
+    {
+        rule_id: "RULE-004",
+        priority: "P0",
+        trigger: "语境型术语但缺少学校/专业/学位上下文",
+        instruction: "保留德文原词，并返回 needs_review=true；不得猜译。",
+        bad_example: "Diplom 一律译硕士",
+        good_example: "Diplom（层级待逐校确认）",
+    },
+    {
+        rule_id: "RULE-005",
+        priority: "P0",
+        trigger: "离线快照不能确认术语",
+        instruction: "保留官方德文全称，标记 pending；禁止只保留未知缩写或自动生成中文名。",
+        bad_example: "未知项目自动生成中文名",
+        good_example: "保留德文＋中文译名待确认",
+    },
+    {
+        rule_id: "RULE-013",
+        priority: "P0",
+        trigger: "Solistenexamen/Solistenklasse/Solistenstudium 与 Konzertexamen",
+        instruction: "按官方原词分别保存，逐校核对层级；不得自动建立等价映射。",
+        bad_example: "Solistenexamen 一律译演奏家文凭",
+        good_example: "Solistenexamen（层级逐校确认）",
+    },
+];
+const FALLBACK_TERMS = {
+    "TERM-001": term("TERM-001", "Musiktheater", "歌剧", "Opera", "locked", "contextual", [], "仅限德国音乐学院专业语境；与 Musical 严格区分。", ["音乐剧", "Musical Theatre", "Musical Theater"]),
+    "TERM-002": term("TERM-002", "Musical", "音乐剧", "Musical Theatre", "locked", "generic", [], "与 Musiktheater 严格区分。", ["歌剧"]),
+    "TERM-016": term("TERM-016", "CoPeCo", "当代表演与作曲联合硕士（CoPeCo）", "Master’s in Contemporary Performance and Composition (CoPeCo)", "locked", "school_specific", ["hfmt-hamburg"], "首次出现必须写中文全称与规范缩写。", ["只写CoPeCo", "CopeCo", "不翻译"], "Contemporary Performance & Composition", "Master"),
+    "TERM-017": term("TERM-017", "Contemporary Performance & Composition", "当代表演与作曲联合硕士（CoPeCo）", "Master’s in Contemporary Performance and Composition (CoPeCo)", "locked", "school_specific", ["hfmt-hamburg"], "首次出现必须写中文全称与规范缩写。", ["不翻译"], "", "Master"),
+    "TERM-018": term("TERM-018", "KMM", "文化与媒体管理（KMM）", "Culture and Media Management (KMM)", "locked", "school_specific", ["hfmt-hamburg"], "首次出现必须写中文全称与规范缩写。", ["只写KMM", "艺术管理"]),
+    "TERM-019": term("TERM-019", "Kultur- und Medienmanagement", "文化与媒体管理（KMM）", "Culture and Media Management (KMM)", "locked", "school_specific", ["hfmt-hamburg"], "使用知识库核定中文名。", ["艺术管理"]),
+    "TERM-020": term("TERM-020", "EUJAM", "欧洲爵士硕士（EUJAM）", "European Jazz Master (EUJAM)", "locked", "school_specific", ["hfmt-hamburg"], "首次出现必须写中文全称与规范缩写。", ["只写EUJAM"]),
+    "TERM-021": term("TERM-021", "European Jazz Master", "欧洲爵士硕士（EUJAM）", "European Jazz Master (EUJAM)", "locked", "school_specific", ["hfmt-hamburg"], "使用知识库核定中文名。", []),
+    "TERM-026": term("TERM-026", "Konzertexamen", "演奏家文凭", "Advanced Performance Diploma (Konzertexamen)", "locked", "generic", [], "保留德文可用于院校差异追溯。", ["音乐会考试", "演奏考试"]),
+    "TERM-027": term("TERM-027", "Solistenexamen", "独奏家考试（Solistenexamen，层级逐校确认）", "Soloist Examination (level to be verified)", "contextual", "contextual", [], "与 Konzertexamen 相关但不等同，必须逐校确认。", ["一律等同Konzertexamen", "一律译演奏家文凭", "硕士", "博士"]),
+    "TERM-036": term("TERM-036", "Künstlerisch-Pädagogische Ausbildung (KPA)", "音乐教育（KPA）", "Artistic-Pedagogical Music Education (KPA)", "locked", "school_specific", ["udk-berlin"], "UdK 语境固定译音乐教育，学位层级另列。", ["只写KPA", "艺术与教育训练"]),
+    "TERM-063": term("TERM-063", "Elementare Musikpädagogik (EMP)", "基础音乐教育（EMP）", "Elementary Music Pedagogy (EMP)", "locked", "generic", [], "首次出现保留 EMP。", ["初级音乐教育"]),
+};
+const rawEntries = [
+    ["Künstlerisch-Pädagogische Ausbildung (KPA)", ["TERM-036"], ["RULE-001", "RULE-003"]],
+    ["Contemporary Performance & Composition", ["TERM-016", "TERM-017"], ["RULE-001", "RULE-003"]],
+    ["Elementare Musikpädagogik (EMP)", ["TERM-063"], ["RULE-001", "RULE-003"]],
+    ["Kultur- und Medienmanagement", ["TERM-018", "TERM-019"], ["RULE-001", "RULE-003"]],
+    ["European Jazz Master", ["TERM-020", "TERM-021"], ["RULE-001", "RULE-003"]],
+    ["Musiktheaterstudium", ["TERM-001"], ["RULE-001", "RULE-002"]],
+    ["Solistenstudium", [], ["RULE-013"]],
+    ["Solistenexamen", ["TERM-027"], ["RULE-004", "RULE-013"]],
+    ["Solistenklasse", [], ["RULE-013"]],
+    ["Konzertexamen", ["TERM-026"], ["RULE-001", "RULE-013"]],
+    ["Musiktheater", ["TERM-001"], ["RULE-001", "RULE-002"]],
+    ["European Jazz Master (EUJAM)", ["TERM-020"], ["RULE-001", "RULE-003"]],
+    ["Kultur- und Medienmanagement (KMM)", ["TERM-018"], ["RULE-001", "RULE-003"]],
+    ["Contemporary Performance & Composition (CoPeCo)", ["TERM-016"], ["RULE-001", "RULE-003"]],
+    ["Musical", ["TERM-002"], ["RULE-001", "RULE-002"]],
+    ["CoPeCo", ["TERM-016"], ["RULE-001", "RULE-003"]],
+    ["EUJAM", ["TERM-020"], ["RULE-001", "RULE-003"]],
+    ["KMM", ["TERM-018"], ["RULE-001", "RULE-003"]],
+    ["KPA", ["TERM-036"], ["RULE-001", "RULE-003"]],
+    ["EMP", ["TERM-063"], ["RULE-001", "RULE-003"]],
+];
+const entries = rawEntries
+    .map(([display, term_ids, rule_ids]) => ({ match_key: normalizeMatchKey(display), display, term_ids, rule_ids }))
+    .sort((a, b) => b.match_key.length - a.match_key.length || a.match_key.localeCompare(b.match_key));
+export const FALLBACK_CATALOG = {
+    kb_version: VERSION,
+    catalog_revision: 0,
+    generated_at: "2026-08-14T00:00:00.000Z",
+    entries,
+    degraded: true,
+    fallback_reason: "bundled P0 snapshot",
+};
+export function resolveWithP0Fallback(body, reason) {
+    const segments = Array.isArray(body.segments)
+        ? body.segments.filter(isSegment)
+        : [];
+    const delivered = new Set(Array.isArray(body.delivered_rule_ids)
+        ? body.delivered_rule_ids.filter((value) => typeof value === "string")
+        : []);
+    const deliveredTerms = new Set(Array.isArray(body.delivered_term_ids)
+        ? body.delivered_term_ids.filter((value) => typeof value === "string")
+        : []);
+    const ruleIds = new Set();
+    const hits = [];
+    for (const segment of segments) {
+        for (const entry of findCatalogMatches(segment.text, entries)) {
+            entry.rule_ids.forEach((ruleId) => ruleIds.add(ruleId));
+            entry.term_ids.forEach((termId) => hits.push({ term_id: termId, matched_text: entry.display }));
+        }
+    }
+    const candidates = Array.isArray(body.candidate_terms)
+        ? body.candidate_terms.filter((value) => typeof value === "string")
+        : [];
+    const unresolved = candidates
+        .filter((candidate) => !entries.some((entry) => entry.match_key === normalizeMatchKey(candidate)))
+        .map((matched_text) => ({ matched_text, reason: "unknown", candidate_term_ids: [] }));
+    if (unresolved.length)
+        ruleIds.add("RULE-005");
+    const dedupedHits = dedupeHits(hits);
+    return {
+        kb_version: VERSION,
+        catalog_revision: 0,
+        ...(typeof body.audit_through_seq === "number" ? { audit_through_seq: body.audit_through_seq } : {}),
+        hits: dedupedHits,
+        term_delta: [...new Set(dedupedHits.map((hit) => hit.term_id))]
+            .filter((termId) => !deliveredTerms.has(termId))
+            .flatMap((termId) => FALLBACK_TERMS[termId] ? [FALLBACK_TERMS[termId]] : []),
+        rule_delta: P0_RULES.filter((rule) => ruleIds.has(rule.rule_id) && !delivered.has(rule.rule_id)),
+        unresolved,
+        degraded: true,
+        fallback_reason: reason,
+    };
+}
+function term(term_id, source_term, preferred_zh, preferred_en, status, scope_type, school_ids, context_rule, forbidden_translations, full_form = "", degree_level = "") {
+    return {
+        term_id,
+        source_term,
+        full_form,
+        preferred_zh,
+        preferred_en,
+        official_en: "",
+        status,
+        scope_type,
+        school_ids,
+        degree_level,
+        context_rule,
+        forbidden_translations,
+    };
+}
+function isSegment(value) {
+    return Boolean(value && typeof value === "object" && "text" in value && typeof value.text === "string");
+}
+function dedupeHits(hits) {
+    const seen = new Set();
+    return hits.filter((hit) => {
+        const key = `${hit.term_id}:${hit.matched_text}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { Message } from "@deepseek-ai/dsh-llm";
+import Schema from "@deepseek-ai/schemastery";
+import type { PluginConfig } from "./types.js";
+export declare const name = "apollo-terminology-rules";
+export declare const inject: string[];
+export type Config = PluginConfig;
+export declare const Config: Schema<Config>;
+export declare function apply(ctx: Context, config: Config): void;
+export declare function messageText(message: Message, auditReasoning?: boolean): string;
+export { TerminologyApi } from "./api.js";
+export { TerminologyCoordinator } from "./coordinator.js";
+export { findCatalogMatches, normalizeMatchKey } from "./matcher.js";
+export type { AgentPort, CatalogEntry, CatalogResponse, ResolveResponse } from "./types.js";

package/dist/index.js

@@ -0,0 +1,170 @@
+import Schema from "@deepseek-ai/schemastery";
+import { TerminologyApi } from "./api.js";
+import { isOwnPluginMessage, TerminologyCoordinator } from "./coordinator.js";
+export const name = "apollo-terminology-rules";
+export const inject = ["agents", "sessions", "tools"];
+export const Config = Schema.object({
+    apiUrl: Schema.string().required().description("阿波罗术语库 API 根地址"),
+    apiKeyEnv: Schema.string().default("APOLLO_TERMINOLOGY_READ_API_KEY").description("只读 API Key 所在环境变量名"),
+    queryIntervalMs: Schema.natural().min(0).max(60_000).default(0).description("常规增量查询的最小间隔（毫秒）；默认即时查询"),
+    catalogRefreshMs: Schema.natural().min(1_000).max(3_600_000).default(60_000).description("本地 matcher catalog 缓存时间"),
+    requestTimeoutMs: Schema.natural().min(1_000).max(120_000).default(15_000).description("查询 API 超时"),
+    auditToolArguments: Schema.boolean().default(false).description("是否审计 tool/call arguments"),
+    auditReasoning: Schema.boolean().default(true).description("是否匹配已提交 assistant/message 中的完整 reasoning block；不匹配流式 reasoning-delta"),
+    flushOnPreStep: Schema.boolean().default(true).description("是否在 pre-step 边界立即 flush"),
+    flushOnTurnStopping: Schema.boolean().default(true).description("是否在最终 turn-stopping 门禁立即 flush"),
+});
+export function apply(ctx, config) {
+    const apiKey = process.env[config.apiKeyEnv]?.trim();
+    if (!apiKey)
+        throw new Error(`${config.apiKeyEnv} is required for ${name}`);
+    const logger = ctx.logger(name);
+    const api = new TerminologyApi(config, apiKey);
+    const coordinator = new TerminologyCoordinator(config, api, logger);
+    const agentsBySession = new Map();
+    const attach = (agent) => {
+        coordinator.attach(agent);
+        agentsBySession.set(agent.session, agent);
+        for (const event of agent.session.events)
+            observeEvent(agent, event);
+    };
+    const observeEvent = (agent, event) => {
+        switch (event.type) {
+            case "turn/start":
+                coordinator.beginTurn(agent);
+                return;
+            case "turn/end":
+                coordinator.setStepPhase(agent, false, false);
+                return;
+            case "step/start":
+                coordinator.setStepPhase(agent, true, false);
+                return;
+            case "step/end":
+                coordinator.endStep(agent);
+                return;
+            case "assistant/chunk": {
+                const chunk = event.data.chunk;
+                if (chunk.type === "text-delta" || chunk.type === "reasoning-delta" || chunk.type === "tool-call-delta") {
+                    coordinator.markGenerationStarted(agent);
+                }
+                return;
+            }
+            case "user/message": {
+                const message = event.data;
+                if (isOwnPluginMessage(message)) {
+                    coordinator.confirmOwnMessage(agent, message);
+                    return;
+                }
+                enqueueMessage(agent, event.seq, "user", message);
+                return;
+            }
+            case "assistant/message":
+                coordinator.markGenerationStarted(agent);
+                if (coordinator.shouldAuditAssistant(agent)) {
+                    enqueueMessage(agent, event.seq, "assistant", event.data.message);
+                }
+                return;
+            case "tool/result":
+                enqueueMessage(agent, event.seq, "tool_result", event.data.message);
+                return;
+            case "tool/call":
+                if (config.auditToolArguments) {
+                    coordinator.observe(agent, {
+                        eventSeq: event.seq,
+                        source: "tool_call",
+                        text: `${event.data.name}\n${event.data.arguments}`,
+                    });
+                }
+                return;
+            default:
+                return;
+        }
+    };
+    const enqueueMessage = (agent, eventSeq, source, message) => {
+        const text = messageText(message, config.auditReasoning);
+        if (text)
+            coordinator.observe(agent, { eventSeq, source, text });
+    };
+    for (const agent of ctx.agents.list())
+        attach(agent);
+    ctx.on("agent/created", ({ agent }) => attach(agent));
+    ctx.on("agent/disposed", ({ agent }) => {
+        agentsBySession.delete(agent.session);
+        coordinator.disposeAgent(agent);
+    });
+    ctx.on("agent/inbox/discarded", ({ agent, message }) => coordinator.markDiscarded(agent, message));
+    ctx.on("tools/post-execute", async (exec, result, next) => {
+        const decision = await next();
+        const agent = exec.agent;
+        if (!agent)
+            return decision;
+        const content = decision.kind === "block"
+            ? decision.feedback
+            : decision.content ?? result.content;
+        const text = content.flatMap((block) => blockText(block, config.auditReasoning)).filter(Boolean).join("\n").trim();
+        if (!text)
+            return decision;
+        coordinator.observe(agent, {
+            eventSeq: Math.max(agent.session.seq, coordinator.pointers(agent).auditCursor + 1),
+            source: "tool_result",
+            text,
+        });
+        const additions = await coordinator.flushForPreStep(agent);
+        if (!additions.length)
+            return decision;
+        return {
+            ...decision,
+            additionalContexts: [...decision.additionalContexts ?? [], ...additions],
+        };
+    });
+    ctx.on("session/event", (session, event) => {
+        const agent = agentsBySession.get(session);
+        if (agent)
+            observeEvent(agent, event);
+    });
+    ctx.on("agent/pre-step", async (payload, next) => {
+        const decision = await next();
+        if (decision.kind === "reject")
+            return decision;
+        coordinator.setStepPhase(payload.agent, false, false);
+        const baseSeq = payload.agent.session.seq;
+        decision.messages.forEach((message, index) => {
+            if (!isOwnPluginMessage(message))
+                enqueueMessage(payload.agent, baseSeq + index, "pre_step", message);
+        });
+        if (!config.flushOnPreStep)
+            return decision;
+        const additions = await coordinator.flushForPreStep(payload.agent);
+        return additions.length
+            ? { kind: "enter", messages: [...decision.messages, ...additions] }
+            : decision;
+    });
+    ctx.on("agent/turn-stopping", async ({ agent }) => {
+        if (!config.flushOnTurnStopping)
+            return;
+        await coordinator.flush(agent, true);
+    });
+    ctx.effect(() => () => coordinator.dispose());
+    void api.getCatalog().then((catalog) => {
+        logger.info("terminology catalog ready: kb=%s revision=%d entries=%d", catalog.kb_version, catalog.catalog_revision, catalog.entries.length);
+    }).catch((error) => {
+        logger.warn("initial terminology catalog fetch failed; live events will retry: %s", error instanceof Error ? error.message : String(error));
+    });
+}
+export function messageText(message, auditReasoning = true) {
+    return message.content.flatMap((block) => blockText(block, auditReasoning)).filter(Boolean).join("\n").trim();
+}
+function blockText(block, auditReasoning) {
+    if (block.type === "text")
+        return [block.text];
+    // Match only a complete reasoning block committed with assistant/message.
+    // Streaming reasoning-delta chunks are lifecycle signals and never enter here.
+    if (block.type === "reasoning")
+        return auditReasoning ? [block.text] : [];
+    if (block.type === "tool-result")
+        return block.content.flatMap((item) => blockText(item, auditReasoning));
+    return [];
+}
+export { TerminologyApi } from "./api.js";
+export { TerminologyCoordinator } from "./coordinator.js";
+export { findCatalogMatches, normalizeMatchKey } from "./matcher.js";

package/dist/matcher.d.ts

@@ -0,0 +1,3 @@
+import type { CatalogEntry } from "./types.js";
+export declare function normalizeMatchKey(value: string): string;
+export declare function findCatalogMatches(text: string, entries: readonly CatalogEntry[]): CatalogEntry[];

package/dist/matcher.js

@@ -0,0 +1,22 @@
+export function normalizeMatchKey(value) {
+    return value.normalize("NFKC")
+        .toLocaleLowerCase("de")
+        .replace(/[‐‑‒–—―]/gu, "-")
+        .replace(/\s+/gu, " ")
+        .trim();
+}
+export function findCatalogMatches(text, entries) {
+    const normalized = normalizeMatchKey(text);
+    if (!normalized)
+        return [];
+    return entries.filter((entry) => containsNormalized(normalized, entry.match_key));
+}
+function containsNormalized(normalized, matchKey) {
+    if (!matchKey)
+        return false;
+    if (/^[\p{L}\p{N}-]+$/u.test(matchKey)) {
+        const escaped = matchKey.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        return new RegExp(`(^|[^\\p{L}\\p{N}])${escaped}($|[^\\p{L}\\p{N}])`, "u").test(normalized);
+    }
+    return normalized.includes(matchKey);
+}

package/dist/types.d.ts

@@ -0,0 +1,88 @@
+import type { UserMessage } from "@deepseek-ai/dsh-llm";
+export interface PluginConfig {
+    apiUrl: string;
+    apiKeyEnv: string;
+    queryIntervalMs: number;
+    catalogRefreshMs: number;
+    requestTimeoutMs: number;
+    auditToolArguments: boolean;
+    auditReasoning: boolean;
+    flushOnPreStep: boolean;
+    flushOnTurnStopping: boolean;
+}
+export interface CatalogEntry {
+    match_key: string;
+    display: string;
+    term_ids: string[];
+    rule_ids: string[];
+}
+export interface CatalogResponse {
+    kb_version: string;
+    catalog_revision: number;
+    generated_at: string;
+    entries: CatalogEntry[];
+    degraded?: boolean;
+    fallback_reason?: string;
+}
+export interface RuleRecord {
+    rule_id: string;
+    priority: "P0" | "P1";
+    trigger: string;
+    instruction: string;
+    bad_example: string;
+    good_example: string;
+}
+export interface TermDeltaRecord {
+    term_id: string;
+    source_term: string;
+    full_form: string;
+    preferred_zh: string;
+    preferred_en: string;
+    official_en: string;
+    status: "locked" | "contextual" | "pending" | "deprecated";
+    scope_type: "generic" | "school_specific" | "contextual";
+    school_ids: string[];
+    degree_level: string;
+    context_rule: string;
+    forbidden_translations: string[];
+}
+export interface ResolveResponse {
+    kb_version: string;
+    catalog_revision: number;
+    audit_through_seq?: number;
+    hits: Array<{
+        term_id: string;
+        matched_text: string;
+    }>;
+    term_delta: TermDeltaRecord[];
+    rule_delta: RuleRecord[];
+    unresolved: Array<{
+        matched_text: string;
+        reason: string;
+        candidate_term_ids: string[];
+    }>;
+    degraded?: boolean;
+    fallback_reason?: string;
+}
+export interface AuditSegment {
+    event_seq: number;
+    source: string;
+    text: string;
+    candidates?: string[];
+}
+export interface AgentPort {
+    readonly id: string;
+    readonly status: "idle" | "running";
+    readonly inbox: {
+        readonly nextStep: readonly UserMessage[];
+        remove(messageId: UserMessage["id"]): boolean;
+    };
+    inject(message: UserMessage): void;
+    steer(message: UserMessage): void;
+}
+export interface LoggerPort {
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@apollo-music/dsh-sidecar-terms",
+  "version": "0.1.0",
+  "description": "DeepSeek Harness sidecar plugin for incremental Apollo terminology and rule injection",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": ["dist", "README.md"],
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fde0-inc/apollo-terminology-knowledge-base.git",
+    "directory": "integrations/deepseek-harness"
+  },
+  "homepage": "https://github.com/fde0-inc/apollo-terminology-knowledge-base/tree/main/integrations/deepseek-harness",
+  "bugs": {
+    "url": "https://github.com/fde0-inc/apollo-terminology-knowledge-base/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "license": "UNLICENSED",
+  "keywords": [
+    "deepseek-harness",
+    "cordis",
+    "terminology",
+    "sidecar"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-agent": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-llm": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-session": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-tools": "0.1.0-rc.6",
+    "@deepseek-ai/schemastery": "^3.18.1"
+  }
+}