dsh-client-auto-continue 0.7.4 → 0.8.0

package/lib/types/client/bridge.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Host status bridge, browser side.
+ *
+ * Subscribes to the host engine's `/api/auto-continue-bridge` SSE stream:
+ * notifications (shown via the browser Notification API, action buttons POST
+ * to `/api/auto-continue-action`) and runtime state (today's stats and the
+ * paused-sessions list) consumed by the settings card's live panels.
+ */
+/** 今日统计视图(与 host 引擎的 DayStats 对应)。 */
+export interface DayStatsView {
+    date: string;
+    sent: number;
+    skipped: number;
+    recovered: number;
+    failed: number;
+    gaveUp: number;
+    looped: number;
+    byCode: Record<string, number>;
+}
+/** 已暂停会话视图。 */
+export interface PausedSessionView {
+    sessionId: string;
+    until: number;
+}
+/** 当前桥状态里的已暂停会话(卡片面板用)。 */
+export declare function pausedSessions(): PausedSessionView[];
+/** 当前桥状态里的今日统计(卡片面板用)。 */
+export declare function readTodayStats(): DayStatsView;
+/** 清零今日统计(经动作端点交给 host 引擎执行)。 */
+export declare function resetTodayStats(): void;
+/** 解除某个会话的暂停(经动作端点交给 host 引擎执行)。 */
+export declare function unpauseSession(sessionId: string): void;
+/** 订阅桥状态变化(卡片面板刷新用)。 */
+export declare function subscribeBridge(listener: () => void): () => void;
+/**
+ * 启动桥订阅(带断线重连), 返回停止函数。
+ * 由 client apply 的 ctx.effect 持有。
+ */
+export declare function startBridge(): () => void;

package/lib/types/client/engine.d.ts

@@ -229,8 +229,13 @@ export declare class AutoContinueRunner {
     private buildContinueText;
     /** 上一步工具调用的护栏状态(实时路径, 由 mux 帧维护)。 */
     private currentGuard;
-    /** 会话标题缓存(来自 session.list 投影, {sessionTitle} 占位符用)。 */
-    private readonly titles;
+    /**
+     * 宿主权威兜底: 历史里最后一条事件是否就是同一文本的 user 消息。
+     * 是 = 它还在排队未被处理, 不应再叠加发送; 否(回合结束等其他事件)= 放行。
+     * 查询失败时返回 false(放行, 本地防线仍在)。
+     */
+    private hostHasPendingSameText;
+    /** 会话标题缓存(来自 session.list 投影, {sessionTitle} 占位符用)。 */ private readonly titles;
     /** 查一次 session.list, 顺带缓存该会话的标题。 */
     private fetchSessionInfo;
     private runningViaList;

package/lib/types/client/index.d.ts

@@ -1,20 +1,16 @@
 /**
- * Auto-continue plugin, browser half.
+ * Auto-continue plugin, browser half (thin shell).
  *
- * - Runs the auto-continue engine over the live mux + host event streams.
- * - Registers the `auto-continue` settings card into the plugin-configuration
- *   section (`settings.plugin.item`), editing the same namespace the engine
- *   reads — every behavior knob is configurable from the GUI.
+ * Since 0.8.0 the auto-continue ENGINE runs inside the host process (single
+ * instance — see src/host/engine.ts), so this half only:
+ * - registers the `auto-continue` settings card (`settings.plugin.item`),
+ * - subscribes to the host status bridge (SSE) and shows browser
+ *   notifications with action buttons (Resume now / Pause 1h) via the bridge
+ *   action endpoint,
+ * - feeds the card's stats / paused-sessions panels from the bridge state.
  */
 import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client';
-import type { ConnectionHandle } from '@deepseek-ai/dsh-client-connection/client';
 import { type SettingsCardKey } from './locales.ts';
-/** 客户端根上下文的 connection 服务(由 dsh-client-connection 挂载)。 */
-declare module '@deepseek-ai/cordis' {
-    interface Context {
-        connection: ConnectionHandle;
-    }
-}
 declare module '@deepseek-ai/dsh-client-ui-slots' {
     interface LocaleNamespaceMap {
         /** auto-continue settings-card copy. */
@@ -23,9 +19,10 @@ declare module '@deepseek-ai/dsh-client-ui-slots' {
 }
 /** Services required by this plugin. */
 export declare const inject: string[];
-export { fillTemplate, pauseSession, pausedSessions, readTodayStats, resetTodayStats, sessionPauseUntil, unpauseSession, } from './engine.ts';
+export { pausedSessions, readTodayStats, resetTodayStats, unpauseSession, } from './bridge.ts';
 /**
- * Plugin body: mount the engine and the settings card.
+ * Plugin body: settings card + host status bridge (notifications, stats,
+ * paused sessions).
  * @param ctx - client root context.
  */
 export declare function apply(ctx: ClientContext): void;

package/lib/types/host/engine.d.ts

@@ -0,0 +1,258 @@
+/**
+ * Auto-continue engine — host half core (single instance).
+ *
+ * Runs inside the dsh host process, so there is exactly ONE engine regardless
+ * of how many browser tabs are open — the multi-tab duplicate-send class of
+ * bugs (issue #13) cannot exist by construction. Listens to the session event
+ * firehose (`session/event`), sends through the agent registry
+ * (`agent.followup`), cancels through `agent.cancel`, and reads configuration
+ * from the settings service.
+ *
+ * All behavior is driven by the `auto-continue` settings namespace (see the
+ * plugin's settings card); every knob below is user-configurable there.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+/** The `auto-continue` settings section (all fields optional on the wire; the host schema carries defaults). */
+export interface AutoContinueSettings {
+    /** Text automatically sent after an interruption. */
+    continueText?: string;
+    /** Text sent when the output token ceiling is reached (same placeholders as `continueText`). */
+    continueTextMaxTokens?: string;
+    /** Idempotency guard: inspect the last tool call before resuming and steer the model. */
+    guardTools?: boolean;
+    /** Guard text appended when the last tool call has no confirmed result (it may have partially executed). */
+    guardPendingText?: string;
+    /** Guard text appended when the last tool call completed successfully (don't rerun it). */
+    guardDoneText?: string;
+    /** Grace period after an interruption before auto-sending (ms). */
+    graceMs?: number;
+    /** Minimum interval between two auto-continues per session (ms). */
+    cooldownMs?: number;
+    /** Max consecutive auto-continues per session before stopping. */
+    maxConsecutive?: number;
+    /** Scan recently interrupted sessions on page load / reconnect. */
+    scanOnBoot?: boolean;
+    /** Max sessions the scan checks (most recently updated). */
+    scanLimit?: number;
+    /** Scan only considers interruptions inside this window (ms). */
+    freshMs?: number;
+    /** Delay before scanning after a reconnect (ms). */
+    reconnectScanDelayMs?: number;
+    /** SSE reconnect backoff (ms). */
+    reconnectBackoffMs?: number;
+    /** Log `[auto-continue]` lines to the browser console. */
+    verbose?: boolean;
+    /** Classify failures: auto-continue transient errors only; permanent ones (auth/balance/model) are skipped and notified. */
+    classify?: boolean;
+    /** Cooldown multiplier per consecutive failure (adaptive backoff). */
+    backoffFactor?: number;
+    /** Cap on the effective backoff interval (ms). */
+    backoffMaxMs?: number;
+    /** Show browser notifications for auto-continue events. */
+    notify?: boolean;
+    /** Globally pause auto-continue: no live or scan send, queued pending sends cancelled. */
+    paused?: boolean;
+    /** Loop guard: detect a running turn spinning in place (short talk without tools, or the same tool repeating) and restart it. */
+    loopGuard?: boolean;
+    /** A model message shorter than this many chars counts as a "short sentence" (loop signal). */
+    loopShortChars?: number;
+    /** Consecutive short sentences within this window (ms) with no tool call in between trip the loop guard. */
+    loopWindowMs?: number;
+    /** Consecutive short sentences trip the loop guard. */
+    loopShortCount?: number;
+    /** Consecutive identical tool calls with identical arguments AND identical results trip the loop guard. */
+    loopToolRepeat?: number;
+    /** Consecutive identical short sentences trip the loop guard (strongest spinning signal). */
+    loopRepeatText?: number;
+    /** Text sent after the loop guard cancels and restarts a turn (supports {tool}). */
+    loopText?: string;
+}
+/** Fully resolved configuration (built-in defaults + user overrides). */
+export type AutoContinueConfig = Required<AutoContinueSettings>;
+/** Built-in defaults — must match the host schema defaults in src/index.ts. */
+export declare const DEFAULT_CONFIG: AutoContinueConfig;
+/** Resolve a (possibly partial / not-yet-loaded) settings section to a full config. */
+export declare function resolveConfig(section: AutoContinueSettings | undefined): AutoContinueConfig;
+/** 一次回合失败的机器可读事实(turn/end error 的 LlmFailure 载荷)。 */
+export interface FailureFacts {
+    /** 稳定机器路由码(如 UPSTREAM、RATE_LIMIT_EXCEEDED、INVALID_API_KEY)。 */
+    code: string;
+    /** 人类可读的失败描述。 */
+    message: string;
+    /** 供应商 HTTP 状态码(可用时)。 */
+    status?: number;
+}
+/**
+ * 错误分类: 该失败是否值得自动继续。
+ * 永久性失败(认证/余额/模型不存在/上下文超限等)重试也不会成功, 应跳过并通知用户;
+ * 其余(网络、超时、5xx、429 等)视为临时性失败, 允许自动恢复。
+ */
+export declare function isTransientFailure(failure: FailureFacts): boolean;
+/**
+ * host/agent-error 消息分类: 仅明确属于网络/传输类的临时错误才自动继续。
+ * 其余(序列化失败、配置/宿主内部错误等)视为永久性——重试无益, 且用户停止导致的
+ * 序列化失败(如 Windows 下 abort 的 DOMException reason)绝不能自动续跑。
+ */
+export declare function isTransientAgentError(message: string): boolean;
+/** 通知上的一个操作按钮(action 标识 + 显示文案)。 */
+export interface NotifyAction {
+    /** 稳定动作标识, 点击时经 onAction 回调传出。 */
+    action: string;
+    /** 按钮显示文案。 */
+    title: string;
+}
+/** 通知的可选行为: 操作按钮列表与点击回调。 */
+export interface NotifyOptions {
+    actions?: NotifyAction[];
+    onAction?: (action: string) => void;
+}
+/** 模板填充所需的上下文(全部可选, 缺失的占位符填为空串)。 */
+export interface TemplateContext {
+    /** 失败事实(错误码/消息/HTTP 状态), 对应 {code}/{message}/{status}。 */
+    facts?: FailureFacts;
+    /** 失败前最后一次工具调用的名称, 对应 {tool}。 */
+    tool?: string;
+    /** 失败回合的编号, 对应 {turn}。 */
+    turn?: number;
+    /** 连续失败次数(含本次), 对应 {errorCount}。 */
+    errorCount?: number;
+    /** 会话标题(来自 session.list 投影, 可用时), 对应 {sessionTitle}。 */
+    sessionTitle?: string;
+    /** 自失败发生以来的毫秒数, 对应 {elapsed}。 */
+    elapsedMs?: number;
+    /** 上一步工具结果摘要(截断), 对应 {result}(护栏模板用)。 */
+    result?: string;
+}
+/** 用失败事实与回合信息填充 continueText 模板占位符({code}/{message}/{status}/{tool}/{turn}/{errorCount}/{sessionTitle}/{elapsed}/{result})。 */
+export declare function fillTemplate(template: string, ctx: TemplateContext): string;
+/** 上一步工具调用的判定结果: 是否已确认完成, 以及文本摘要。 */
+export interface ToolResultFacts {
+    /** 工具是否成功完成(内部失败或 isError 视为未成功)。 */
+    ok: boolean;
+    /** 工具输出的文本摘要(截断)。 */
+    excerpt: string;
+}
+/** 自适应退避: 同一会话连续失败时的有效冷却间隔。 */
+export declare function effectiveCooldown(consecutive: number, base: number, factor: number, max: number): number;
+/** 一天的自动继续统计(host 单实例内存态)。 */
+export interface DayStats {
+    /** 本地日期 YYYY-MM-DD。 */
+    date: string;
+    /** 自动发送次数。 */
+    sent: number;
+    /** 因永久性错误跳过的次数。 */
+    skipped: number;
+    /** 发送后回合成功完成(恢复成功)的次数。 */
+    recovered: number;
+    /** 发送后再次失败的次数。 */
+    failed: number;
+    /** 达到连续上限而停止的次数(按停止事件计)。 */
+    gaveUp: number;
+    /** loop guard 打断并重启回合的次数。 */
+    looped: number;
+    /** 按错误码计数的失败分布。 */
+    byCode: Record<string, number>;
+}
+/** 通知桥事件: host 引擎产生, browser 侧订阅展示(Notification / 动作按钮)。 */
+export interface HostNotice {
+    /** 稳定标识(供 browser 去重)。 */
+    id: string;
+    title: string;
+    body: string;
+    /** 会话 id(通知按钮「立即续跑 / 暂停该会话」作用于它)。 */
+    sessionId?: SessionId;
+    actions: NotifyAction[];
+    /** 产生时间。 */
+    at: number;
+}
+/** 插件主体: 一条 mux 流 + 一条 host 流 + 启动/重连扫描。 */
+export declare class AutoContinueRunner {
+    private readonly ctx;
+    private readonly getConfig;
+    private readonly states;
+    private readonly pauseUntil;
+    private dayStats;
+    private readonly notices;
+    private readonly noticeListeners;
+    private readonly stateListeners;
+    private disposed;
+    /**
+     * @param ctx - host plugin context (agents registry, session events, settings).
+     * @param getConfig - read the current resolved configuration (settings service).
+     */
+    constructor(ctx: Context, getConfig: () => AutoContinueConfig);
+    private log;
+    /** 对外(状态桥): 今日统计快照。 */
+    todayStats(): DayStats;
+    /** 对外(状态桥): 当前生效的会话级暂停列表。 */
+    activePauses(): {
+        sessionId: SessionId;
+        until: number;
+    }[];
+    /** 对外(状态桥): 订阅通知事件(SSE 端点推送)。 */
+    subscribeNotices(listener: () => void): () => void;
+    /** 对外(状态桥): 订阅运行时状态变化(统计/暂停列表)。 */
+    subscribeState(listener: () => void): () => void;
+    private emitState;
+    /** 对外(状态桥): 消费待展示的通知。 */
+    drainNotices(): HostNotice[];
+    /** 通知动作(browser 通知按钮回传): 立即续跑 / 暂停该会话 / 解除暂停 / 清零统计。 */
+    handleNoticeAction(sessionId: SessionId | undefined, action: string): void;
+    dispose(): void;
+    private state;
+    /**
+     * 事件入口(host 单实例): 预处理工具调用/结果/模型消息(护栏与循环信号),
+     * 然后交给回合状态机。
+     */
+    private onHostEvent;
+    /** 从 assistant/message 事件提取纯文本。 */
+    private assistantText;
+    private onAssistantMessage;
+    /** 两个循环信号的公共检查; 命中且本回合未打断过则打断。 */
+    private checkLoop;
+    /**
+     * 打断运行中的回合: cancel(带来源标记)+ 进冷却。
+     * 随后的 turn/end aborted 会因 loopCancelled 走「可恢复中断」路径,
+     * 用 loopText 重启回合——不会与用户手动停止混淆。
+     */
+    private interruptLoop;
+    private onSessionEvent;
+    private onTurnFailure;
+    /** 通知操作按钮与回调(「立即续跑」/「暂停该会话 1 小时」)。 */
+    private notifyOptions;
+    private onNotifyAction;
+    /** 内存统计(host 单实例): 按今日桶累计。 */
+    private bumpStat;
+    /** 通知桥: 产生一条通知事件, SSE 端点推给 browser 侧展示。 */
+    private notify;
+    /** 恢复结果记账: 自动发送后窗口内的回合结束, 判定恢复成功或失败。 */
+    private noteRecovery;
+    /** 立即为该会话发送一次自动继续(无视冷却与连续上限; 由通知按钮触发)。 */
+    resumeNow(sessionId: SessionId): Promise<void>;
+    /** 本会话当前生效的冷却间隔(自适应退避)。 */
+    private cooldownFor;
+    private schedule;
+    private cancelPending;
+    private fire;
+    /**
+     * 组装本次续跑消息: 模板填充 + 幂等护栏。
+     * 护栏依据上一步工具调用的执行状态附加指引, 防止重跑副作用操作:
+     * - 结果未确认(可能已部分执行)→ 提示先确认状态、不要重复执行
+     * - 已确认成功 → 提示已完成、不要重复执行
+     * - 已失败 → 不加护栏(重试工具本来就是目的)
+     */
+    private buildContinueText;
+    /** 上一步工具调用的护栏状态(实时路径, 由 mux 帧维护)。 */
+    private currentGuard;
+    private bootScanLoop;
+    /** 反复尝试扫描, 直到成功(宿主就绪)或达到次数上限。 */
+    private scanLoop;
+    /**
+     * 扫描最近中断过的会话: 最后回合以非人为原因结束, 且其后没有新回合或用户消息。
+     * @returns 是否成功完成一次扫描(宿主就绪)。
+     */
+    private scanInterrupted;
+    /** 从历史事件恢复上一步工具调用状态(扫描路径的幂等护栏)。 */
+    private applyGuardFromEvents;
+}

package/lib/types/index.d.ts

@@ -1,7 +1,13 @@
 /**
- * Host half of the auto-continue plugin: registers the `auto-continue`
- * settings namespace so the browser half's settings card can edit it and the
- * engine can read it. No other host-side behavior.
+ * Host half of the auto-continue plugin.
+ *
+ * - Registers the `auto-continue` settings namespace (the browser half's
+ *   settings card edits it; the host engine reads it).
+ * - Runs the single-instance auto-continue engine: listens to the session
+ *   event firehose, sends via `agent.followup`, cancels via `agent.cancel`.
+ * - Serves a status bridge the browser half subscribes to: notifications and
+ *   runtime state (stats / pauses), plus an action endpoint for notification
+ *   buttons.
  */
 import type { Context } from '@deepseek-ai/cordis';
 import z from '@deepseek-ai/schemastery';
@@ -116,8 +122,8 @@ export declare const AutoContinueSchema: z<Schemastery.ObjectS<{
     loopText: z<string, string>;
 }>>;
 /**
- * Plugin body: register the settings namespace when a settings provider is
- * composed. Changes apply live — the browser half observes the scope.
+ * Plugin body: register the settings namespace, start the single-instance
+ * engine, and serve the status bridge.
  * @param ctx - host plugin context.
  */
 export declare function apply(ctx: Context): void;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-client-auto-continue",
   "description": "DSH Web UI plugin: automatically sends \"继续\" (continue) when a request is interrupted by network errors or other non-human causes",
-  "version": "0.7.4",
+  "version": "0.8.0",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -47,7 +47,7 @@
     "build": "node build.mjs && tsc -p tsconfig.build.json",
     "watch": "node build.mjs --watch",
     "typecheck": "tsc --noEmit",
-    "test": "node tests/simulate.mjs",
+    "test": "node tests/simulate-host.mjs",
     "prepack": "npm run build"
   },
   "keywords": [
@@ -76,7 +76,8 @@
     "@deepseek-ai/dsh-client-ui-slots": "^0.1.0-rc.7",
     "@deepseek-ai/dsh-session": "^0.1.0-rc.7",
     "@deepseek-ai/dsh-settings": "^0.1.0-rc.7",
-    "@deepseek-ai/schemastery": "^3.18.1"
+    "@deepseek-ai/schemastery": "^3.18.1",
+    "@types/node": "^22.0.0"
   },
   "license": "MIT",
   "peerDependencies": {

package/src/client/bridge.ts

@@ -0,0 +1,202 @@
+/**
+ * Host status bridge, browser side.
+ *
+ * Subscribes to the host engine's `/api/auto-continue-bridge` SSE stream:
+ * notifications (shown via the browser Notification API, action buttons POST
+ * to `/api/auto-continue-action`) and runtime state (today's stats and the
+ * paused-sessions list) consumed by the settings card's live panels.
+ */
+
+/** 今日统计视图(与 host 引擎的 DayStats 对应)。 */
+export interface DayStatsView {
+  date: string;
+  sent: number;
+  skipped: number;
+  recovered: number;
+  failed: number;
+  gaveUp: number;
+  looped: number;
+  byCode: Record<string, number>;
+}
+
+/** 已暂停会话视图。 */
+export interface PausedSessionView {
+  sessionId: string;
+  until: number;
+}
+
+interface BridgeState {
+  stats: DayStatsView;
+  paused: PausedSessionView[];
+}
+
+interface BridgeNotice {
+  id: string;
+  title: string;
+  body: string;
+  sessionId?: string;
+  actions: { action: string; title: string }[];
+  at: number;
+}
+
+const EMPTY_STATS: DayStatsView = {
+  date: '',
+  sent: 0,
+  skipped: 0,
+  recovered: 0,
+  failed: 0,
+  gaveUp: 0,
+  looped: 0,
+  byCode: {},
+};
+
+let state: BridgeState = { stats: EMPTY_STATS, paused: [] };
+const listeners = new Set<() => void>();
+
+/** 当前桥状态里的已暂停会话(卡片面板用)。 */
+export function pausedSessions(): PausedSessionView[] {
+  return state.paused;
+}
+
+/** 当前桥状态里的今日统计(卡片面板用)。 */
+export function readTodayStats(): DayStatsView {
+  return state.stats;
+}
+
+/** 清零今日统计(经动作端点交给 host 引擎执行)。 */
+export function resetTodayStats(): void {
+  void postAction({ action: 'reset-stats' });
+}
+
+/** 解除某个会话的暂停(经动作端点交给 host 引擎执行)。 */
+export function unpauseSession(sessionId: string): void {
+  void postAction({ action: 'unpause', sessionId });
+}
+
+/** 订阅桥状态变化(卡片面板刷新用)。 */
+export function subscribeBridge(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
+/** 通知按钮动作回传 host(立即续跑 / 暂停该会话 1 小时 / 解除暂停 / 清零统计)。 */
+async function postAction(payload: { action: string; sessionId?: string }): Promise<void> {
+  try {
+    await fetch('/api/auto-continue-action', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify(payload),
+    });
+  } catch {
+    /* host 不可达时静默 */
+  }
+}
+
+function handleEvent(event: { type: string; notice?: BridgeNotice; stats?: DayStatsView; paused?: PausedSessionView[] }): void {
+  if (event.type === 'state') {
+    state = {
+      stats: event.stats ?? EMPTY_STATS,
+      paused: event.paused ?? [],
+    };
+    for (const listener of listeners) listener();
+  } else if (event.type === 'notice' && event.notice !== undefined) {
+    showNotification(event.notice);
+  }
+}
+
+/** 浏览器通知: 展示 host 通知并挂动作按钮。 */
+function showNotification(notice: BridgeNotice): void {
+  try {
+    const N = (globalThis as { Notification?: unknown }).Notification as
+      | (new (t: string, o: { body: string; actions?: { action: string; title: string }[] }) => unknown)
+      | undefined;
+    if (typeof N === 'undefined') return;
+    const permission = (N as unknown as { permission?: string }).permission;
+    const create = (): void => {
+      const instance = new N(notice.title, {
+        body: notice.body,
+        ...(notice.actions.length > 0 ? { actions: notice.actions } : {}),
+      });
+      const target = instance as {
+        onclick?: (() => void) | null;
+        onaction?: ((event: { action: string }) => void) | null;
+      };
+      target.onclick = () => {
+        try {
+          (globalThis as { focus?: () => void }).focus?.();
+        } catch {
+          /* ignore */
+        }
+      };
+      target.onaction = (event) => {
+        if (notice.sessionId !== undefined) {
+          void postAction({ action: event.action, sessionId: notice.sessionId });
+        }
+      };
+    };
+    if (permission === 'granted') {
+      create();
+    } else if (permission === 'default') {
+      void (N as unknown as { requestPermission?: () => Promise<string> }).requestPermission?.()
+        .then((result) => {
+          if (result === 'granted') create();
+        })
+        .catch(() => {});
+    }
+  } catch {
+    /* 通知失败不影响核心逻辑 */
+  }
+}
+
+/**
+ * 启动桥订阅(带断线重连), 返回停止函数。
+ * 由 client apply 的 ctx.effect 持有。
+ */
+export function startBridge(): () => void {
+  let stopped = false;
+  let controller: AbortController | undefined;
+
+  const loop = async (): Promise<void> => {
+    while (!stopped) {
+      controller = new AbortController();
+      try {
+        const response = await fetch('/api/auto-continue-bridge', { signal: controller.signal });
+        if (!response.ok || response.body === null) throw new Error(`bridge HTTP ${response.status}`);
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        for (;;) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          let idx = buffer.indexOf('\n\n');
+          while (idx !== -1) {
+            const chunk = buffer.slice(0, idx);
+            buffer = buffer.slice(idx + 2);
+            for (const line of chunk.split('\n')) {
+              if (line.startsWith('data: ')) {
+                try {
+                  handleEvent(JSON.parse(line.slice(6)) as Parameters<typeof handleEvent>[0]);
+                } catch {
+                  /* 忽略坏帧 */
+                }
+              }
+            }
+            idx = buffer.indexOf('\n\n');
+          }
+        }
+      } catch {
+        /* 断线: 退避重连 */
+      }
+      if (!stopped) await new Promise((resolve) => setTimeout(resolve, 3000));
+    }
+  };
+  void loop();
+
+  return () => {
+    stopped = true;
+    controller?.abort();
+  };
+}