dsh-plugin-bridge 0.2.10 → 0.3.0

package/lib/migrate.js

@@ -1,13 +1,14 @@
 /**
  * 迁移编排：取材 → 压缩工人 → 目标会话。
  *
- * 只依赖注入进来的 `Rpc`，不碰 process / argv / 文件系统，所以可以对着一个
- * 假的 RPC（见 test/migrate.test.mjs）跑完整条链路而不烧任何 token。
+ * 只依赖注入进来的 `BridgeHost`，不碰 process / argv / 文件系统，所以可以对着
+ * 任意宿主 adapter（见 test/migrate.test.mjs）跑完整条链路而不烧任何 token。
  * CLI（`cli.ts`）与客户端 GUI 都消费这里的函数，保证「被验证的」和
  * 「被交付的」是同一条代码路径。
  */
 import { buildBridgeInstruction, buildBridgeKickoff, buildBridgeSource, appendVisualEvidence, collectVisualEvidence, detectLang, } from './compression.js';
 import { foldSessionEvents } from './fold.js';
+import { asBridgeHost, missingHostCapability, } from './host.js';
 import { RpcError, sleep } from './rpc.js';
 /** 工人会话优先使用的 preset（工具越少越省，也不会误动工作区）。 */
 const WORKER_PRESET_PREFERENCE = ['minimal', 'standard'];
@@ -21,11 +22,12 @@ const HISTORY_MAX_PAGES = 4;
  * `session.list` 的 v1 一次返回全部，`cursor` 是预留位；这里仍按 cursor 取完，
  * 免得上游哪天真的分页之后这里悄悄只看第一页。
  */
-export async function listSessions(rpc) {
+export async function listSessions(input) {
+    const host = asBridgeHost(input);
     const rows = [];
     let cursor;
     for (let page = 0; page < 20; page += 1) {
-        const res = await rpc('session.list', cursor === undefined ? {} : { cursor });
+        const res = await host.sessions.list(cursor === undefined ? {} : { cursor });
         rows.push(...(res.items ?? []));
         if (!res.nextCursor)
             break;
@@ -33,22 +35,24 @@ export async function listSessions(rpc) {
     }
     return rows;
 }
-export async function findSession(rpc, sessionId) {
-    return (await listSessions(rpc)).find((row) => row.sessionId === sessionId);
+export async function findSession(host, sessionId) {
+    return (await listSessions(host)).find((row) => row.sessionId === sessionId);
 }
 /** 找出会话所属工作区；找不到就返回 undefined（调用方退回用 cwd 建会话）。 */
-export async function findWorkspaceId(rpc, sessionId) {
-    const res = await rpc('workspace.list', {});
+export async function findWorkspaceId(input, sessionId) {
+    const host = asBridgeHost(input);
+    const res = await host.workspaces.list();
     return res.items?.find((ws) => ws.sessionIds?.includes(sessionId))?.workspaceId;
 }
 /** 可作为迁移目标的 preset（去掉 broken 的）。 */
-export async function listPresets(rpc) {
-    const res = await rpc('agentPreset.list', {});
+export async function listPresets(input) {
+    const host = asBridgeHost(input);
+    const res = await host.presets.list();
     return (res.presets ?? []).filter((preset) => preset.broken === undefined);
 }
 /** 新会话的落点：优先同工作区，否则同 cwd，再否则交给 host 默认。 */
-async function placement(rpc, source, sessionId) {
-    const workspaceId = await findWorkspaceId(rpc, sessionId).catch(() => undefined);
+async function placement(host, source, sessionId) {
+    const workspaceId = await findWorkspaceId(host, sessionId).catch(() => undefined);
     if (workspaceId)
         return { workspaceId };
     if (source?.cwd)
@@ -62,11 +66,12 @@ async function placement(rpc, source, sessionId) {
  * 里挑。挑不到就退回源会话当前模型——档位是省钱偏好，不该成为换 provider 的人
  * 装不上的理由。
  */
-export async function resolveWorkerModel(rpc, sessionId, tier, override = {}) {
+export async function resolveWorkerModel(input, sessionId, tier, override = {}) {
+    const host = asBridgeHost(input);
     if (override.provider && override.model) {
         return { provider: override.provider, model: override.model, reason: 'configured' };
     }
-    const models = await rpc('session.models', { sessionId });
+    const models = await host.sessions.models({ sessionId });
     const current = models.current;
     const fallback = {
         provider: override.provider ?? current?.provider ?? '',
@@ -86,8 +91,8 @@ export async function resolveWorkerModel(rpc, sessionId, tier, override = {}) {
     return fallback;
 }
 /** 压缩工人用哪个 preset：优先 minimal，其次 standard，再否则 host 默认。 */
-export async function resolveWorkerPreset(rpc) {
-    const presets = await listPresets(rpc).catch(() => []);
+export async function resolveWorkerPreset(input) {
+    const presets = await listPresets(input).catch(() => []);
     for (const wanted of WORKER_PRESET_PREFERENCE) {
         if (presets.some((preset) => preset.id === wanted))
             return wanted;
@@ -95,39 +100,51 @@ export async function resolveWorkerPreset(rpc) {
     return presets.find((preset) => preset.isDefault)?.id;
 }
 /**
- * 等一个会话回到空闲。
+ * 等一个会话的新一轮写入 `turn/end`。
  *
- * 旧实现是「先 sleep 2s，再看 running 是不是 false」——host 排队稍慢一点，
- * 第一次轮询就会把「还没开始」误判成「已经跑完」，取到的是上一轮的回答。
- * 这里先等它真的 running 起来（有宽限期），再等它落回 false。
+ * `session.list` 是全局列表，拿它每两秒轮询一个 worker 会把会话总量放大成
+ * O(会话数 × 轮询次数)。`session.history` 则只读目标会话；用 prompt 前的事件
+ * 水位隔开旧轮次后，`turn/start` / `turn/end` 也比易过期的 running 快照更可靠。
  */
-export async function waitIdle(rpc, sessionId, options = {}) {
+export async function waitIdle(input, sessionId, options = {}) {
+    const host = asBridgeHost(input);
     const pollMs = options.pollMs ?? 2000;
     const deadline = Date.now() + (options.timeoutMs ?? 360_000);
     const startBy = Date.now() + (options.startGraceMs ?? 25_000);
+    const afterSeq = options.afterSeq ?? 0;
     let started = false;
     while (Date.now() < deadline) {
         await sleep(pollMs);
-        const row = await findSession(rpc, sessionId).catch(() => undefined);
-        if (row?.running) {
+        const events = await tailSessionEvents(host, sessionId).catch(() => []);
+        const fresh = events.filter((event) => typeof event.seq === 'number' && event.seq > afterSeq);
+        if (fresh.some((event) => event.type === 'turn/start'))
             started = true;
-            continue;
-        }
-        if (started)
+        if (fresh.some((event) => event.type === 'turn/end'))
             return { idle: true, started: true };
-        if (Date.now() > startBy)
+        if (!started && Date.now() > startBy)
             return { idle: true, started: false };
     }
     return { idle: false, started };
 }
+/** 读取单个会话的尾页；不触发全局 session.list 扫描。 */
+async function tailSessionEvents(input, sessionId) {
+    const host = asBridgeHost(input);
+    const res = await host.sessions.history({ sessionId, maxMessages: 2 }, { timeoutMs: 60_000 });
+    return (res.events ?? []).map((entry) => entry.event);
+}
+async function latestSessionSeq(host, sessionId) {
+    const events = await tailSessionEvents(host, sessionId);
+    return events.reduce((max, event) => (typeof event.seq === 'number' && event.seq > max ? event.seq : max), 0);
+}
 /** 拉取并折叠会话历史（按需翻页）。 */
-export async function foldedHistory(rpc, sessionId, options = {}) {
+export async function foldedHistory(input, sessionId, options = {}) {
+    const host = asBridgeHost(input);
     const pageMessages = options.pageMessages ?? HISTORY_PAGE_MESSAGES;
     const maxPages = options.maxPages ?? HISTORY_MAX_PAGES;
     let events = [];
     let beforeSeq;
     for (let page = 0; page < maxPages; page += 1) {
-        const res = await rpc('session.history', { sessionId, maxMessages: pageMessages, ...(beforeSeq === undefined ? {} : { beforeSeq }) }, 60_000);
+        const res = await host.sessions.history({ sessionId, maxMessages: pageMessages, ...(beforeSeq === undefined ? {} : { beforeSeq }) }, { timeoutMs: 60_000 });
         const chunk = (res.events ?? []).map((entry) => entry.event);
         if (!chunk.length)
             break;
@@ -142,59 +159,62 @@ export async function foldedHistory(rpc, sessionId, options = {}) {
     return foldSessionEvents(events);
 }
 /** 会话里最后一条非空 assistant 文本。 */
-export async function lastAssistantText(rpc, sessionId) {
-    const messages = await foldedHistory(rpc, sessionId, { pageMessages: 20, maxPages: 1 });
+export async function lastAssistantText(host, sessionId) {
+    const messages = await foldedHistory(host, sessionId, { pageMessages: 20, maxPages: 1 });
     return [...messages].reverse().find((m) => m.role === 'assistant' && m.content.trim())?.content.trim() ?? '';
 }
 /** 生成交接摘要：取材 → 起临时工人 → 收摘要 → 归档工人。 */
-export async function previewMigration(rpc, options) {
+export async function previewMigration(input, options) {
+    const host = asBridgeHost(input);
     const progress = options.onProgress ?? (() => { });
-    const sourceSession = await findSession(rpc, options.sessionId);
+    const sourceSession = options.sourceSession ?? await findSession(host, options.sessionId);
     progress('拉取并折叠会话历史…');
-    const messages = await foldedHistory(rpc, options.sessionId);
+    const messages = await foldedHistory(host, options.sessionId);
     const source = buildBridgeSource(messages, { sourceCharBudget: options.sourceCharBudget });
     if (!source.text.trim()) {
         throw new RpcError('bridge.preview', 'empty-source', '这个会话还没有可迁移的内容（取材为空）。直接开一个新会话更省事。');
     }
     const lang = options.lang && options.lang !== 'auto' ? options.lang : detectLang(source.text);
     const tier = options.tier ?? 'pro';
-    const route = await resolveWorkerModel(rpc, options.sessionId, tier, options);
+    const route = await resolveWorkerModel(host, options.sessionId, tier, options);
     if (options.dryRun) {
         return { summary: '', source, lang, worker: { ...route }, capped: false, sourceSession };
     }
-    const preset = await resolveWorkerPreset(rpc);
-    const where = await placement(rpc, sourceSession, options.sessionId);
+    const preset = await resolveWorkerPreset(host);
+    const where = await placement(host, sourceSession, options.sessionId);
     progress(`起压缩工人（${preset ?? '默认 preset'} / ${route.model || '会话默认模型'}）…`);
-    const worker = await rpc('session.create', {
+    const worker = await host.sessions.create({
         ...where,
         ...(preset === undefined ? {} : { agentPreset: preset }),
     });
     let capped = false;
     try {
         if (route.provider && route.model) {
-            await rpc('session.selectModel', { sessionId: worker.sessionId, provider: route.provider, model: route.model })
+            await host.sessions.selectModel({ sessionId: worker.sessionId, provider: route.provider, model: route.model })
                 .catch((error) => {
                 // 选模型失败不该让整次迁移失败：工人用会话默认模型照样能写摘要。
                 progress(`选模型失败，改用默认模型（${error instanceof Error ? error.message : String(error)}）`);
             });
         }
         const instruction = buildBridgeInstruction(lang, { summaryCharBudget: options.summaryCharBudget });
-        await rpc('session.prompt', {
+        const workerBaselineSeq = await latestSessionSeq(host, worker.sessionId).catch(() => 0);
+        await host.sessions.prompt({
             sessionId: worker.sessionId,
             mode: 'queue',
             content: [{ type: 'text', text: `${instruction}${source.text}` }],
         });
         progress('等待摘要…');
-        const settled = await waitIdle(rpc, worker.sessionId, {
+        const settled = await waitIdle(host, worker.sessionId, {
             timeoutMs: options.workerTimeoutMs ?? 360_000,
+            afterSeq: workerBaselineSeq,
             ...(options.pollMs === undefined ? {} : { pollMs: options.pollMs, startGraceMs: options.pollMs * 6 }),
         });
         if (!settled.idle) {
             capped = true;
-            await rpc('session.cancel', { sessionId: worker.sessionId }).catch(() => undefined);
+            await host.sessions.cancel({ sessionId: worker.sessionId }).catch(() => undefined);
             await sleep(2500);
         }
-        const workerSummary = await lastAssistantText(rpc, worker.sessionId);
+        const workerSummary = await lastAssistantText(host, worker.sessionId);
         if (!workerSummary) {
             throw new RpcError('bridge.preview', 'worker-empty', '压缩工人没有产出摘要（可能是模型不可用或被取消）。');
         }
@@ -210,7 +230,7 @@ export async function previewMigration(rpc, options) {
     }
     finally {
         // 工人是一次性的：无论成败都归档，不在侧栏留垃圾。
-        await rpc('workspace.archiveSession', { sessionId: worker.sessionId }).catch(() => undefined);
+        await host.workspaces.archiveSession({ sessionId: worker.sessionId }).catch(() => undefined);
     }
 }
 /** 找出没有关联助手正文的图片引用；已有逐字视觉证据时默认不重复烧视觉 token。 */
@@ -232,14 +252,17 @@ function unresolvedImageRefs(messages) {
     }
     return { refs, missing };
 }
-async function readPromptImages(rpc, sourceSessionId, refs) {
+async function readPromptImages(host, sourceSessionId, refs) {
+    const readAttachment = host.sessions.attachment;
+    if (readAttachment === undefined)
+        throw missingHostCapability('session attachment reading');
     return Promise.all(refs.map(async (ref) => {
-        const stored = await rpc('session.attachment', {
+        const stored = await readAttachment({
             sessionId: sourceSessionId,
             attachmentId: ref.attachmentId,
         });
         if (!stored.data || typeof stored.data !== 'string') {
-            throw new RpcError('session.attachment', 'empty-image', `附件 ${ref.attachmentId} 没有返回图片字节。`);
+            throw new RpcError('bridge.host', 'empty-image', `附件 ${ref.attachmentId} 没有返回图片字节。`);
         }
         const attachment = stored.attachment ?? ref;
         return {
@@ -253,9 +276,9 @@ async function readPromptImages(rpc, sourceSessionId, refs) {
 function imageFallbackAllowed(error) {
     if (!(error instanceof RpcError))
         return false;
-    if (error.method === 'session.attachment')
+    if (error.code === 'unavailable' || error.code === 'empty-image')
         return true;
-    if (error.method !== 'session.prompt' || error.code !== 'attachment-error')
+    if (error.code !== 'attachment-error')
         return false;
     const reason = error.details && typeof error.details === 'object' && 'reason' in error.details
         ? String(error.details.reason)
@@ -272,19 +295,20 @@ function imageFallbackAllowed(error) {
  * 摘要能被模型看见依赖 goal-round-driver 把它渲染成 `<goal_round>` 提示，
  * 或模型主动调 `get_goal`。所以默认把摘要同时放进首轮提示：任何组装下都成立。
  */
-export async function executeMigration(rpc, options) {
+export async function executeMigration(input, options) {
+    const host = asBridgeHost(input);
     const progress = options.onProgress ?? (() => { });
     const warnings = [];
     const inject = options.inject ?? 'both';
     const lang = options.lang ?? detectLang(options.summary);
-    const summary = options.summary.trim();
-    if (!summary)
+    const summary = options.summary;
+    if (!summary.trim())
         throw new RpcError('bridge.migrate', 'empty-summary', '摘要为空，拒绝迁移。');
-    const sourceSession = await findSession(rpc, options.sessionId);
-    const where = await placement(rpc, sourceSession, options.sessionId);
+    const sourceSession = options.sourceSession ?? await findSession(host, options.sessionId);
+    const where = await placement(host, sourceSession, options.sessionId);
     let sourceModel;
     try {
-        const models = await rpc('session.models', { sessionId: options.sessionId });
+        const models = await host.sessions.models({ sessionId: options.sessionId });
         const current = models.current;
         if (typeof current?.provider === 'string' && current.provider
             && typeof current.model === 'string' && current.model) {
@@ -301,7 +325,7 @@ export async function executeMigration(rpc, options) {
         warnings.push(`读取源会话模型失败，目标将使用 host 默认模型：${error instanceof Error ? error.message : String(error)}`);
     }
     progress(`在 ${options.to} 模式下新建会话…`);
-    const created = await rpc('session.create', {
+    const created = await host.sessions.create({
         ...where,
         agentPreset: options.to,
     });
@@ -312,7 +336,7 @@ export async function executeMigration(rpc, options) {
     let modelTransferred = false;
     if (sourceModel) {
         try {
-            await rpc('session.selectModel', { sessionId: created.sessionId, ...sourceModel });
+            await host.sessions.selectModel({ sessionId: created.sessionId, ...sourceModel });
             modelTransferred = true;
         }
         catch (error) {
@@ -322,7 +346,7 @@ export async function executeMigration(rpc, options) {
     let titled = false;
     if (options.title) {
         try {
-            await rpc('session.rename', { sessionId: created.sessionId, title: options.title });
+            await host.sessions.rename({ sessionId: created.sessionId, title: options.title });
             titled = true;
         }
         catch (error) {
@@ -336,14 +360,14 @@ export async function executeMigration(rpc, options) {
     let imagesSent = 0;
     if (inject === 'goal' || inject === 'both') {
         try {
-            const createdGoal = await rpc('goal.create', {
+            const createdGoal = await host.goals.create({
                 sessionId: created.sessionId,
                 objective: summary,
                 maxGoalRounds: options.goalRounds ?? 1,
             });
             goalCreated = true;
             try {
-                await rpc('goal.pause', { sessionId: created.sessionId, ref: createdGoal.ref });
+                await host.goals.pause({ sessionId: created.sessionId, ref: createdGoal.ref });
                 goalPaused = true;
             }
             catch (error) {
@@ -352,13 +376,16 @@ export async function executeMigration(rpc, options) {
                 safeToKickoff = false;
                 let goalCleared = false;
                 try {
-                    await rpc('goal.clear', { sessionId: created.sessionId, ref: createdGoal.ref });
+                    const clearGoal = host.goals.clear;
+                    if (clearGoal === undefined)
+                        throw missingHostCapability('goal clearing');
+                    await clearGoal({ sessionId: created.sessionId, ref: createdGoal.ref });
                     goalCleared = true;
                 }
                 catch (clearError) {
                     warnings.push(`清除未暂停的交接目标失败，已继续取消目标会话；请保持目标会话关闭并手动检查：${clearError instanceof Error ? clearError.message : String(clearError)}`);
                 }
-                await rpc('session.cancel', { sessionId: created.sessionId }).catch(() => undefined);
+                await host.sessions.cancel({ sessionId: created.sessionId }).catch(() => undefined);
                 warnings.push(goalCleared
                     ? `暂停交接目标失败，已清除目标并取消自动启动；请打开目标会话检查后手动继续：${error instanceof Error ? error.message : String(error)}`
                     : `暂停交接目标失败，已取消自动启动但无法确认目标已清除；请打开目标会话检查后手动继续：${error instanceof Error ? error.message : String(error)}`);
@@ -376,7 +403,7 @@ export async function executeMigration(rpc, options) {
         progress('发送首轮交接指令…');
         let unresolved = { refs: [], missing: 0 };
         try {
-            unresolved = unresolvedImageRefs(await foldedHistory(rpc, options.sessionId));
+            unresolved = unresolvedImageRefs(await foldedHistory(host, options.sessionId));
         }
         catch (error) {
             warnings.push(`读取图片状态失败，已按纯文本交接：${error instanceof Error ? error.message : String(error)}`);
@@ -384,33 +411,50 @@ export async function executeMigration(rpc, options) {
         if (unresolved.missing > 0) {
             warnings.push(`有 ${unresolved.missing} 张未解析图片缺少可复用的持久附件引用；目标会话必须回源会话核验。`);
         }
+        let uncertainImagePromptFailure = false;
         if (unresolved.refs.length) {
             try {
-                const images = await readPromptImages(rpc, options.sessionId, unresolved.refs);
+                const images = await readPromptImages(host, options.sessionId, unresolved.refs);
                 const transferNote = lang === 'en'
                     ? 'Bridge transfer note: the unresolved source images listed above are attached to this kickoff. Inspect them directly; do not infer details that are not visible.'
                     : 'Bridge 搬运说明：上文列出的未解析源图片已附在本次 kickoff 中。请直接检查原图，不得推断看不清的细节。';
-                await rpc('session.prompt', {
+                await host.sessions.prompt({
                     sessionId: created.sessionId,
                     mode: 'queue',
                     content: [...images, { type: 'text', text: `${baseText}\n\n${transferNote}` }],
                 });
                 imagesSent = images.length;
+                kickoffSent = true;
             }
             catch (error) {
-                if (!imageFallbackAllowed(error))
-                    throw error;
-                warnings.push(`目标模型或 host 不能接收原图，已使用逐字视觉证据/未解析提示降级：${error instanceof Error ? error.message : String(error)}`);
+                if (imageFallbackAllowed(error)) {
+                    warnings.push(`目标模型或 host 不能接收原图，已使用逐字视觉证据/未解析提示降级：${error instanceof Error ? error.message : String(error)}`);
+                }
+                else {
+                    // 目标已经存在且 goal 已暂停。对不确定是否送达的 prompt 不能盲目重试，
+                    // 否则可能让模型收到两份 kickoff；把原目标交还给用户手动检查更安全。
+                    uncertainImagePromptFailure = true;
+                    warnings.push(lang === 'en'
+                        ? `The target session was created, but its image kickoff could not be confirmed. Open that target and continue manually; Bridge did not retry an ambiguously delivered prompt: ${error instanceof Error ? error.message : String(error)}`
+                        : `目标会话已创建，但带图 kickoff 是否送达无法确认。请打开这个目标手动检查并继续；Bridge 没有盲目重试可能已送达的提示：${error instanceof Error ? error.message : String(error)}`);
+                }
             }
         }
-        if (imagesSent === 0) {
-            await rpc('session.prompt', {
-                sessionId: created.sessionId,
-                mode: 'queue',
-                content: [{ type: 'text', text: baseText }],
-            });
+        if (imagesSent === 0 && !uncertainImagePromptFailure) {
+            try {
+                await host.sessions.prompt({
+                    sessionId: created.sessionId,
+                    mode: 'queue',
+                    content: [{ type: 'text', text: baseText }],
+                });
+                kickoffSent = true;
+            }
+            catch (error) {
+                warnings.push(lang === 'en'
+                    ? `The target session was created, but its kickoff could not be confirmed. Open that target and continue manually; Bridge did not create another session: ${error instanceof Error ? error.message : String(error)}`
+                    : `目标会话已创建，但 kickoff 是否送达无法确认。请打开这个目标手动检查并继续；Bridge 没有再创建一个会话：${error instanceof Error ? error.message : String(error)}`);
+            }
         }
-        kickoffSent = true;
     }
     return {
         sessionId: created.sessionId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-bridge",
-  "version": "0.2.10",
+  "version": "0.3.0",
   "description": "Previewable cross-preset session migration for DeepSeek Harness with bounded, fixed-schema handoffs",
   "type": "module",
   "main": "lib/index.js",
@@ -11,12 +11,15 @@
     "reports/v0.2.3-e2e-2026-08-20T13-19-13-924Z.raw.json",
     "reports/v0.2.3-e2e-report.md",
     "reports/v0.2.6-rc11-vision-report.md",
+    "reports/native-workbench-2026-08-25.md",
+    "reports/native-workbench-2026-08-25.raw.json",
     "cordis.patch.yml",
     "README.md",
     "README.zh.md"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.json && npm run build:client",
+    "build:client": "tsdown --config tsdown.config.ts",
     "build:check": "npm run build && git diff --exit-code -- lib",
     "typecheck": "tsc -p tsconfig.check.json",
     "prepack": "npm run build",
@@ -41,20 +44,50 @@
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-api-remotes",
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-ui-conversation"
+      ],
+      "platform": "web"
     }
   },
   "engines": {
     "node": ">=22"
   },
   "peerDependencies": {
-    "@deepseek-ai/cordis": "^4.0.1"
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-api-remotes": "^0.1.0-rc.7 || ^0.1.1-rc.1",
+    "@deepseek-ai/dsh-client-runtime": "^0.1.0-rc.7 || ^0.1.1-rc.1",
+    "@deepseek-ai/dsh-client-ui-conversation": "^0.1.0-rc.7 || ^0.1.1-rc.1",
+    "@deepseek-ai/dsh-client-ui-primitives": "^0.1.0-rc.7 || ^0.1.1-rc.1",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.1.0-rc.7 || ^0.1.1-rc.1",
+    "react": "^18.2.0"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/dsh-api-remotes": { "optional": true },
+    "@deepseek-ai/dsh-client-runtime": { "optional": true },
+    "@deepseek-ai/dsh-client-ui-conversation": { "optional": true },
+    "@deepseek-ai/dsh-client-ui-primitives": { "optional": true },
+    "@deepseek-ai/dsh-client-ui-slots": { "optional": true },
+    "react": { "optional": true }
   },
   "dependencies": {
     "@deepseek-ai/schemastery": "^3.18.1"
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "4.0.1",
+    "@deepseek-ai/dsh-api-remotes": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-client-runtime": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-conversation": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-primitives": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.1.1-rc.2",
     "@types/node": "^26.2.0",
+    "@types/react": "~18.3.1",
+    "react": "^18.3.1",
+    "tsdown": "^0.22.14",
     "typescript": "^7.0.2"
   },
   "publishConfig": {
@@ -88,6 +121,10 @@
       "types": "./lib/migrate.d.ts",
       "default": "./lib/migrate.js"
     },
+    "./host": {
+      "types": "./lib/host.d.ts",
+      "default": "./lib/host.js"
+    },
     "./rpc": {
       "types": "./lib/rpc.d.ts",
       "default": "./lib/rpc.js"
@@ -100,6 +137,14 @@
       "types": "./lib/command.d.ts",
       "default": "./lib/command.js"
     },
+    "./client": {
+      "types": "./lib/client.d.ts",
+      "default": "./lib/client.js"
+    },
+    "./client-contract": {
+      "types": "./lib/client-contract.d.ts",
+      "default": "./lib/client-contract.js"
+    },
     "./cordis.patch.yml": "./cordis.patch.yml",
     "./package.json": "./package.json"
   }

package/reports/native-workbench-2026-08-25.md

@@ -0,0 +1,30 @@
+# Native WebUI workbench acceptance · 2026-08-25
+
+Environment: isolated official `@deepseek-ai/dsh@0.1.1-rc.2` Web profile, locally packed Bridge `0.2.11` plus the current PR changes. The source, worker, and target sessions were synthetic and isolated from the user's normal DSH home.
+
+## What was exercised
+
+- the client half loaded through the official `dsh.client` module graph and occupied `conversation.chat.commandview`;
+- `/bridge --doctor` rendered through the native card and reported 13/13 host capabilities;
+- the running row showed immediate elapsed-time feedback without mutating the source;
+- completed Markdown rendered through the official primitive, a complete JSON edit rendered as a keyboard-accessible tree, and the textarea round-tripped user changes;
+- the reviewed payload was accepted by the host command without being recorded in command input;
+- the created goal was paused, the first target turn restated the handoff, and the client automatically opened the target session.
+
+## Fixed repeat gate
+
+Each run carried the same five low-collision facts: port `8118`, PostgreSQL, MongoDB forbidden, `src/orders/router.ts`, and “idempotency tests only.”
+
+| Run | Route | Preview facts | Target facts | Worker time | Target LLM time | Paused | Auto-open |
+|---|---|---:|---:|---:|---:|---:|---:|
+| R1 | standard → code | 5/5 | 5/5 | 12.846 s | 7.807 s | yes | yes |
+| R2 | minimal → code | 5/5 | 5/5 | 9.713 s | 6.175 s | yes | yes |
+| R3 | minimal → code | 5/5 | 5/5 | 7.421 s | 5.772 s | yes | yes |
+
+R1 additionally changed `8118` to `8118（用户在 WebUI 校对）` inside the native editor; the exact marker appeared in both the stored target goal and the first target response.
+
+The token counters and per-run records are in [`native-workbench-2026-08-25.raw.json`](native-workbench-2026-08-25.raw.json).
+
+## Boundary
+
+This is a three-run fixed release gate, not a latency distribution or population-level reliability claim. Worker and target latency, token use, and phrasing remain model-, preset-, cache-, and provider-dependent. Automated fake-host tests cover failure and payload bounds without spending tokens; this report covers the installed official-WebUI path that those tests cannot prove.

package/reports/native-workbench-2026-08-25.raw.json

@@ -0,0 +1,34 @@
+{
+  "date": "2026-08-25",
+  "dshVersion": "0.1.1-rc.2",
+  "bridgePackageVersion": "0.2.11",
+  "environment": "isolated official dsh web profile",
+  "workerModel": "deepseek-v4-flash",
+  "facts": ["8118", "PostgreSQL", "MongoDB forbidden", "src/orders/router.ts", "idempotency tests only"],
+  "runs": [
+    {
+      "id": "R1", "from": "standard", "to": "code",
+      "previewFacts": 5, "targetFacts": 5,
+      "workerMs": 12846, "targetMs": 7807,
+      "editedMarkerPreserved": true, "targetPaused": true, "autoOpened": true,
+      "workerTokens": { "uncachedInput": 931, "output": 1112, "cacheRead": 1024 },
+      "targetTokens": { "uncachedInput": 10415, "output": 436, "cacheRead": 0 }
+    },
+    {
+      "id": "R2", "from": "minimal", "to": "code",
+      "previewFacts": 5, "targetFacts": 5,
+      "workerMs": 9713, "targetMs": 6175,
+      "targetPaused": true, "autoOpened": true,
+      "workerTokens": { "uncachedInput": 518, "output": 771, "cacheRead": 1024 },
+      "targetTokens": { "uncachedInput": 9670, "output": 278, "cacheRead": 640 }
+    },
+    {
+      "id": "R3", "from": "minimal", "to": "code",
+      "previewFacts": 5, "targetFacts": 5,
+      "workerMs": 7421, "targetMs": 5772,
+      "targetPaused": true, "autoOpened": true,
+      "workerTokens": { "uncachedInput": 131, "output": 615, "cacheRead": 1408 },
+      "targetTokens": { "uncachedInput": 1622, "output": 290, "cacheRead": 8704 }
+    }
+  ]
+}