dsh-plugin-bridge 0.2.11 → 0.3.1

package/lib/migrate.d.ts

@@ -1,59 +1,38 @@
 /**
  * 迁移编排：取材 → 压缩工人 → 目标会话。
  *
- * 只依赖注入进来的 `Rpc`，不碰 process / argv / 文件系统，所以可以对着一个
- * 假的 RPC（见 test/migrate.test.mjs）跑完整条链路而不烧任何 token。
+ * 只依赖注入进来的 `BridgeHost`，不碰 process / argv / 文件系统，所以可以对着
+ * 任意宿主 adapter（见 test/migrate.test.mjs）跑完整条链路而不烧任何 token。
  * CLI（`cli.ts`）与客户端 GUI 都消费这里的函数，保证「被验证的」和
  * 「被交付的」是同一条代码路径。
  */
 import { type BridgeSource } from './compression.ts';
-import { type Rpc } from './rpc.ts';
+import { type BridgeHostInput, type ModelSelection, type PresetRow, type SessionRow } from './host.ts';
 import type { ChatMessage } from './types.ts';
+export type { ModelSelection, PresetRow, SessionRow } from './host.ts';
 export type ModelTier = 'flash' | 'current' | 'pro';
 export type InjectMode = 'goal' | 'prompt' | 'both';
 export type Lang = 'zh' | 'en' | 'auto';
-export interface SessionRow {
-    sessionId: string;
-    running?: boolean;
-    blank?: boolean;
-    cwd?: string;
-    agentPreset?: string;
-    parentSessionId?: string;
-    projections?: {
-        values?: Record<string, unknown>;
-    };
-}
-export interface PresetRow {
-    id: string;
-    trust?: 'system' | 'user';
-    isDefault?: boolean;
-    name?: string;
-    description?: string;
-    broken?: string;
-}
 export interface ModelRoute {
     provider: string;
     model: string;
     /** 为什么选中它：configured / follow-session / tier:<tier> / fallback-current。 */
     reason: string;
 }
-export interface ModelSelection {
-    provider: string;
-    model: string;
-    reasoningEffort?: string;
-}
 /**
  * 列出全部会话。
  *
  * `session.list` 的 v1 一次返回全部，`cursor` 是预留位；这里仍按 cursor 取完，
  * 免得上游哪天真的分页之后这里悄悄只看第一页。
  */
-export declare function listSessions(rpc: Rpc): Promise<SessionRow[]>;
-export declare function findSession(rpc: Rpc, sessionId: string): Promise<SessionRow | undefined>;
+export declare function listSessions(input: BridgeHostInput): Promise<SessionRow[]>;
+export declare function findSession(host: BridgeHostInput, sessionId: string): Promise<SessionRow | undefined>;
 /** 找出会话所属工作区；找不到就返回 undefined（调用方退回用 cwd 建会话）。 */
-export declare function findWorkspaceId(rpc: Rpc, sessionId: string): Promise<string | undefined>;
+export declare function findWorkspaceId(input: BridgeHostInput, sessionId: string): Promise<string | undefined>;
 /** 可作为迁移目标的 preset（去掉 broken 的）。 */
-export declare function listPresets(rpc: Rpc): Promise<PresetRow[]>;
+export declare function listPresets(input: BridgeHostInput): Promise<PresetRow[]>;
+/** Map the one upstream internal rename without making either generation mandatory. */
+export declare function resolvePresetTarget(requested: string, presets: readonly PresetRow[]): string;
 /**
  * 选压缩工人的模型。
  *
@@ -61,12 +40,12 @@ export declare function listPresets(rpc: Rpc): Promise<PresetRow[]>;
  * 里挑。挑不到就退回源会话当前模型——档位是省钱偏好，不该成为换 provider 的人
  * 装不上的理由。
  */
-export declare function resolveWorkerModel(rpc: Rpc, sessionId: string, tier: ModelTier, override?: {
+export declare function resolveWorkerModel(input: BridgeHostInput, sessionId: string, tier: ModelTier, override?: {
     provider?: string;
     model?: string;
 }): Promise<ModelRoute>;
 /** 压缩工人用哪个 preset：优先 minimal，其次 standard，再否则 host 默认。 */
-export declare function resolveWorkerPreset(rpc: Rpc): Promise<string | undefined>;
+export declare function resolveWorkerPreset(input: BridgeHostInput): Promise<string | undefined>;
 export interface WaitOptions {
     timeoutMs?: number;
     /** 等待新 `turn/start` 的宽限期；超过仍未出现就按未启动处理。 */
@@ -82,17 +61,17 @@ export interface WaitOptions {
  * O(会话数 × 轮询次数)。`session.history` 则只读目标会话；用 prompt 前的事件
  * 水位隔开旧轮次后，`turn/start` / `turn/end` 也比易过期的 running 快照更可靠。
  */
-export declare function waitIdle(rpc: Rpc, sessionId: string, options?: WaitOptions): Promise<{
+export declare function waitIdle(input: BridgeHostInput, sessionId: string, options?: WaitOptions): Promise<{
     idle: boolean;
     started: boolean;
 }>;
 /** 拉取并折叠会话历史（按需翻页）。 */
-export declare function foldedHistory(rpc: Rpc, sessionId: string, options?: {
+export declare function foldedHistory(input: BridgeHostInput, sessionId: string, options?: {
     pageMessages?: number;
     maxPages?: number;
 }): Promise<ChatMessage[]>;
 /** 会话里最后一条非空 assistant 文本。 */
-export declare function lastAssistantText(rpc: Rpc, sessionId: string): Promise<string>;
+export declare function lastAssistantText(host: BridgeHostInput, sessionId: string): Promise<string>;
 export interface PreviewOptions {
     sessionId: string;
     /** 同一命令已经读取过的源会话行，避免重复扫描全局列表。 */
@@ -126,7 +105,7 @@ export interface PreviewResult {
     sourceSession: SessionRow | undefined;
 }
 /** 生成交接摘要：取材 → 起临时工人 → 收摘要 → 归档工人。 */
-export declare function previewMigration(rpc: Rpc, options: PreviewOptions): Promise<PreviewResult>;
+export declare function previewMigration(input: BridgeHostInput, options: PreviewOptions): Promise<PreviewResult>;
 export interface MigrateOptions {
     sessionId: string;
     /** 同一流程已经读取过的源会话行，避免重复扫描全局列表。 */
@@ -175,7 +154,7 @@ export interface MigrateResult {
  * 摘要能被模型看见依赖 goal-round-driver 把它渲染成 `<goal_round>` 提示，
  * 或模型主动调 `get_goal`。所以默认把摘要同时放进首轮提示：任何组装下都成立。
  */
-export declare function executeMigration(rpc: Rpc, options: MigrateOptions): Promise<MigrateResult>;
+export declare function executeMigration(input: BridgeHostInput, options: MigrateOptions): Promise<MigrateResult>;
 /** 默认标题：让新会话在侧栏里一眼看得出来源。 */
 export declare function migratedTitle(sourceTitle: string | undefined, to: string): string;
 /** 从 session.list 行里尽力取出标题（projection 形状随部署而异）。 */

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,34 @@ 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);
 }
+/** Map the one upstream internal rename without making either generation mandatory. */
+export function resolvePresetTarget(requested, presets) {
+    if (presets.some(preset => preset.id === requested))
+        return requested;
+    if (requested === 'code' && presets.some(preset => preset.id === 'ptc'))
+        return 'ptc';
+    if (requested === 'ptc' && presets.some(preset => preset.id === 'code'))
+        return 'code';
+    return requested;
+}
 /** 新会话的落点：优先同工作区，否则同 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 +76,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 +101,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;
@@ -101,7 +116,8 @@ export async function resolveWorkerPreset(rpc) {
  * 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);
@@ -109,7 +125,7 @@ export async function waitIdle(rpc, sessionId, options = {}) {
     let started = false;
     while (Date.now() < deadline) {
         await sleep(pollMs);
-        const events = await tailSessionEvents(rpc, sessionId).catch(() => []);
+        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;
@@ -121,22 +137,24 @@ export async function waitIdle(rpc, sessionId, options = {}) {
     return { idle: false, started };
 }
 /** 读取单个会话的尾页；不触发全局 session.list 扫描。 */
-async function tailSessionEvents(rpc, sessionId) {
-    const res = await rpc('session.history', { sessionId, maxMessages: 2 }, 60_000);
+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(rpc, sessionId) {
-    const events = await tailSessionEvents(rpc, sessionId);
+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;
@@ -151,61 +169,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 = options.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 });
-        const workerBaselineSeq = await latestSessionSeq(rpc, worker.sessionId).catch(() => 0);
-        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', '压缩工人没有产出摘要（可能是模型不可用或被取消）。');
         }
@@ -221,7 +240,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。 */
@@ -243,14 +262,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 {
@@ -264,9 +286,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' && error.code !== 'session/attachment-invalid')
         return false;
     const reason = error.details && typeof error.details === 'object' && 'reason' in error.details
         ? String(error.details.reason)
@@ -283,19 +305,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 = options.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) {
@@ -312,7 +335,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,
     });
@@ -323,7 +346,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) {
@@ -333,7 +356,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) {
@@ -347,14 +370,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) {
@@ -363,13 +386,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)}`);
@@ -387,7 +413,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)}`);
@@ -395,33 +421,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,