dsh-restart-continue 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LISHUANGXI1412
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,90 @@
-# Temporary Holding Version
+# dsh-restart-continue
+
+让 DSH 里的 Agent 自己重启 DSH Desktop，并在新进程启动后**自动回到同一个会话继续对话**。
+
+> npm 包名：`dsh-restart-continue`（`dsh-restart` 已被他人占用，源码目录仍为 `E:\dsh的工作区\dsh-restart`）。
+
+## 解决的问题
+
+装插件、改配置、换原生依赖之后，DSH 经常需要重启才能生效。原来的流程是：
+
+1. Agent 说“需要重启”；
+2. 用户手动重启；
+3. 用户回到会话，再补一句“继续”。
+
+这个插件把 1→3 串起来：Agent 调一次工具，重启完成后插件自己往会话里投递一条续聊指令，Agent 接着干。**全程没有确认弹窗、不需要点任何东西。**
+
+## 工作方式
+
+```
+工具调用 dsh_restart
+   │  ① 拒绝：其他对话有 turn 正在运行（重启会打断它们）
+   │  ② 写 hand-off 文件 ~/.dsh/restart/continuation.json
+   │  ③ 挂一个一次性 agent/status 监听
+   ▼
+本轮结束（Agent 进入 idle）
+   │  ④ 再次检查：这期间有没有别的对话开始跑
+   │  ⑤ flush 当前会话，保证最终消息落盘
+   │  ⑥ 写 launch.vbs（UTF-16LE + BOM）并启动 wscript.exe
+   ▼
+wscript（GUI 子系统，无控制台）
+   └→ WScript.Shell.Run(..., 0, False) 隐藏启动 PowerShell worker
+        ├─ 清掉 ELECTRON_RUN_AS_NODE（否则新进程变成 Node 模式秒退）
+        ├─ 优雅 taskkill 主进程（WM_CLOSE）
+        ├─ closeToTray 只隐藏窗口 → forcing：先 kill Host，再 kill 主进程
+        └─ 用原始命令行重新启动 DSH NEXT.exe
+   ▼
+新进程启动，插件读到 hand-off 文件
+   │  ⑦ 校验：记录早于本次启动 + 10 分钟内 + 尝试次数 < 3 + 同 Profile
+   │  ⑧ 用 sessionController.prompt(..., mode: 'queue') 投递续聊消息
+   ▼
+原会话恢复上下文，开一轮新 turn 继续工作
+```
+
+几个刻意的设计：
+
+- **不用桌面壳的重启确认框**：`desktopActions.requestRestart()` 会弹 Electron 原生对话框，而且默认按钮是「取消」。静默重启走“优雅关闭 + 重新拉起”，窗口会关掉再打开，约 3~8 秒。
+- **为什么是 wscript 而不是直接 spawn PowerShell**：Node 用 `detached: true` 启动 PowerShell 会在执行脚本前静默退出；普通子进程又会跟着父控制台一起被销毁。`wscript` 是无控制台的 GUI 宿主，配合 `WScript.Shell.Run(cmd, 0, False)` 能拉起一个独立、隐藏、继承正确用户环境的 worker。
+- **VBS 必须 UTF-16LE + BOM**：否则 `WScript` 按 ANSI 读，`C:\Users\木\...` 这类中文路径会被读坏。
+- **必须清 `ELECTRON_RUN_AS_NODE`**：桌面壳用 Node 模式启动 Host，会把 `ELECTRON_RUN_AS_NODE=1` 注入 Host 环境；worker 继承后若原样传给 App，Electron 会以纯 Node 运行、没有脚本参数就立即退出（表现为“拉起后秒退、什么都没发生”）。
+- **等本轮结束再重启**：tool result 和最终回复先落盘，重启不会吞掉它们。
+- **其他对话在跑就拒绝**：调度时检查一次，真正触发前再检查一次；有别的 Agent 正在跑 turn 就放弃重启（只记日志，不强制）。
+- **只认“比本次启动更早”的记录**：10 分钟过期、最多跨启动重试 3 次，避免复活旧会话或陷入重启循环。
+- **续聊走公开审计路径**：消息以普通 user message 出现在对话里，头部标注 `[DSH 自动重启 · 已完成]`。
+- **插件 dispose 不删 hand-off 文件**：Host 关闭时插件会被卸载，只有 `cancel` 或成功续聊后才删。
+
+## 安装
+
+```powershell
+plugin_manager install_bundle E:\dsh的工作区\dsh-restart
+```
+
+插件改代码后：在 Settings → Plugins 里把它关掉再打开即可热重载（不必重启 Host）。
+
+## 用法
+
+```json
+{ "action": "restart", "reason": "plugin 已升级", "prompt": "重启后继续验收 Settings 面板" }
+```
+
+- `action: restart`（默认）：预约重启。
+- `action: status`：只读，报告重启能力（`silent-app-relaunch` / `desktop-confirm` / `unsupported`）、正在跑的对话、挂起请求、hand-off 路径。
+- `action: cancel`：撤销挂起的请求（同时删掉 hand-off 文件）。
+
+Agent 侧约定：调用完工具后**正常结束本轮**，不要在本轮里等重启。
+
+## 限制
+
+- **静默重启仅 Windows**：靠 `taskkill`（WM_CLOSE）+ 重新拉起实现。macOS/Linux 会退回桌面壳的 `requestRestart()`，那一步需要用户确认。
+- **重启 = 整个 App 退出再启动**：窗口会关掉；正在跑的**其他**对话会被拒绝保护，但已经打开的其他会话页面会一起重载。
+- **10 分钟有效窗口**：超时后不会续聊（会话本身不受影响）。
+- **续聊是 user message**：会以用户消息出现在对话里。
+- **`closeToTray` 开启时**：优雅关闭会变成隐藏窗口，助手等 12 秒后强制结束进程再拉起。
+
+## 验证状态
+
+- 单元测试：`node --test`，18 项全过（状态过期、启动先后、重试与放弃、续聊文本、运行中对话守卫）。
+- `dsh_restart action=status` 在 DSH Desktop 返回 `silentRelaunch: true`、`mode: "silent-app-relaunch"`。
+- **端到端实测通过**（2026-11-15 18:28）：Agent 调用工具 → 本轮结束后窗口自动关闭 → worker 重新拉起 App（`relaunch.log`：`clearing ELECTRON_RUN_AS_NODE=1` → `graceful quit timed out; forcing` → `relaunch attempt 1 pid=24700` → `done started=True`）→ 新 Host 启动 → 同一会话自动注入续聊消息并继续。
+- **守卫实测**：另起一个子会话跑长任务时，`status.runningAgents` 列出它，`action=restart` 返回 `ok:false` 并给出 `running` 列表，不重启。
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.

package/cordis.patch.yml

@@ -0,0 +1,3 @@
+- insert:
+    - id: dsh-restart-continue
+      name: dsh-restart-continue

package/icon.svg

@@ -0,0 +1,12 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64" role="img" aria-label="Restart and continue">
+  <defs>
+    <linearGradient id="g" x1="8" y1="8" x2="56" y2="56" gradientUnits="userSpaceOnUse">
+      <stop offset="0" stop-color="#3b82f6"/>
+      <stop offset="1" stop-color="#6366f1"/>
+    </linearGradient>
+  </defs>
+  <rect x="2" y="2" width="60" height="60" rx="16" fill="url(#g)"/>
+  <path d="M22 22h14a10 10 0 0 1 10 10v2a10 10 0 0 1-10 10H26" fill="none" stroke="#ffffff" stroke-width="4" stroke-linecap="round"/>
+  <path d="M27 16l-7 6 7 6" fill="none" stroke="#ffffff" stroke-width="4" stroke-linecap="round" stroke-linejoin="round"/>
+  <path d="M40 30h8M44 26v8" stroke="#bfdbfe" stroke-width="3" stroke-linecap="round"/>
+</svg>

package/index.js

@@ -0,0 +1,447 @@
+/**
+ * dsh-restart — let an agent restart DSH Desktop and continue the same
+ * conversation after the new process boots.
+ *
+ * Restarting is silent on Windows: a detached helper closes the Electron main
+ * process gracefully (the same path as the window close button) and starts the
+ * same executable again. The continuation is a durable hand-off file consumed by
+ * the next Host boot, so it survives the process replacement.
+ */
+import { randomUUID } from 'node:crypto'
+import { basename } from 'node:path'
+import {
+  STATE_VERSION,
+  appendLog,
+  bootTime,
+  clearState,
+  isResumable,
+  readState,
+  statePath,
+  writeState,
+} from './lib/state.js'
+import { deliverContinuation } from './lib/continuation.js'
+import { otherRunningAgents } from './lib/guard.js'
+import { canRelaunchSilently, requestAppRelaunch } from './lib/relaunch.js'
+
+export const name = 'dsh-restart-continue'
+export const inject = ['tools']
+
+/** How long a scheduled request may wait for the Agent to go idle before it expires. */
+const SCHEDULE_MAX_WAIT_MS = 30 * 60 * 1000
+
+/** Delay after boot before the continuation prompt is admitted. */
+const CONTINUATION_DELAY_MS = 1500
+
+function json(value) {
+  return JSON.stringify(value, null, 2)
+}
+
+/**
+ * Ask the session store to persist everything appended so far. The restart that
+ * follows may terminate the process without the shell's graceful shutdown, so
+ * the final assistant message must already be durable.
+ * @param {object} ctx - plugin context.
+ * @param {string} sessionId - session to flush.
+ * @returns {Promise<void>} resolves after the flush settles or times out.
+ */
+async function flushSession(ctx, sessionId) {
+  const sessions = ctx.get('sessions')
+  if (typeof sessions?.flush !== 'function') return
+  let session
+  try {
+    session = sessions.get?.(sessionId)
+  } catch {}
+  if (session === undefined) return
+  let timer
+  try {
+    await Promise.race([
+      sessions.flush(session),
+      new Promise((resolve) => {
+        timer = setTimeout(resolve, 3000)
+        timer.unref?.()
+      }),
+    ])
+  } finally {
+    if (timer !== undefined) clearTimeout(timer)
+  }
+}
+
+function textOutput() {
+  return {
+    schema: { type: 'string' },
+    render: (_args, value) => [{ type: 'text', text: String(value) }],
+  }
+}
+
+/**
+ * Best-effort name of the Profile this Host booted, used only to avoid replaying
+ * a hand-off into a different Profile. The Desktop Host runs with the Profile
+ * directory as its cwd and does not export DSH_PROFILE.
+ * @returns {string | undefined} profile name when it can be derived.
+ */
+function currentProfile() {
+  const configured = process.env.DSH_PROFILE?.trim()
+  if (configured) return configured
+  try {
+    return basename(process.cwd())
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Owns the single pending restart request for this Host process.
+ */
+class RestartScheduler {
+  /**
+   * @param {object} ctx - plugin context.
+   * @param {{ later: Function, log?: Function }} deps - timer helper and logger.
+   */
+  constructor(ctx, deps) {
+    this.ctx = ctx
+    this.later = deps.later
+    this.log = deps.log ?? appendLog
+    this.pending = undefined
+    this.disposeStatusListener = undefined
+    this.expiryTimer = undefined
+  }
+
+  /** @returns {{ silentRelaunch: boolean, desktopShell: boolean, mode: string }} restart capabilities. */
+  capabilities() {
+    const silentRelaunch = canRelaunchSilently()
+    const desktopShell = typeof this.ctx.get('desktopActions')?.requestRestart === 'function'
+    return {
+      silentRelaunch,
+      desktopShell,
+      mode: silentRelaunch ? 'silent-app-relaunch' : desktopShell ? 'desktop-confirm' : 'unsupported',
+    }
+  }
+
+  /** @returns {boolean} whether this Host can restart itself at all. */
+  canRestart() {
+    return this.capabilities().mode !== 'unsupported'
+  }
+
+  /**
+   * @param {unknown} callerId - Agent that asked for the restart.
+   * @returns {Array<{ id: string, status: string }>} other Agents that are mid-turn.
+   */
+  runningOthers(callerId) {
+    const agents = this.ctx.get('agents')
+    let list = []
+    try {
+      list = agents?.list?.() ?? []
+    } catch {}
+    return otherRunningAgents(list, callerId)
+  }
+
+  /**
+   * Persist a request and arm the one-shot idle listener.
+   * @param {{ sessionId: string, cwd?: string, prompt?: string, reason?: string }} request - caller intent.
+   * @returns {object} the stored record.
+   */
+  schedule(request) {
+    this.cancel()
+    const state = {
+      version: STATE_VERSION,
+      token: randomUUID(),
+      sessionId: String(request.sessionId),
+      cwd: typeof request.cwd === 'string' ? request.cwd : undefined,
+      profile: currentProfile(),
+      prompt: typeof request.prompt === 'string' ? request.prompt : undefined,
+      reason: typeof request.reason === 'string' ? request.reason : undefined,
+      createdAt: Date.now(),
+      attempts: 0,
+    }
+    writeState(state)
+    this.pending = state
+    this.log({ event: 'restart.scheduled', sessionId: state.sessionId })
+
+    this.disposeStatusListener = this.ctx.on('agent/status', (payload) => {
+      if (payload?.status !== 'idle') return
+      if (String(payload.agent?.id) !== state.sessionId) return
+      void this.fire()
+    })
+
+    // Never keep a request alive forever when the Agent never reaches idle.
+    this.expiryTimer = this.later(() => {
+      if (this.pending?.token !== state.token) return
+      this.log({ event: 'restart.expired', sessionId: state.sessionId })
+      this.cancel()
+    }, SCHEDULE_MAX_WAIT_MS)
+
+    return state
+  }
+
+  /** Drop the pending request and its durable record (user cancellation). */
+  cancel() {
+    this.disposeInMemory()
+    if (readState() !== undefined) clearState()
+  }
+
+  /** Release listeners and timers without touching the hand-off file (plugin disposal). */
+  dispose() {
+    this.disposeInMemory()
+  }
+
+  disposeInMemory() {
+    this.pending = undefined
+    if (this.disposeStatusListener !== undefined) {
+      this.disposeStatusListener()
+      this.disposeStatusListener = undefined
+    }
+    if (this.expiryTimer !== undefined) {
+      clearTimeout(this.expiryTimer)
+      this.expiryTimer = undefined
+    }
+  }
+
+  /**
+   * Perform the restart once the Agent is idle.
+   * @returns {Promise<void>} resolves after the request is handed off (or rejected).
+   */
+  async fire() {
+    const pending = this.pending
+    if (pending === undefined) return
+    this.disposeInMemory()
+
+    const stored = readState()
+    if (stored === undefined || stored.token !== pending.token) return
+
+    // Re-check at the last moment: another conversation may have started a turn
+    // between the tool call and this idle edge.
+    const running = this.runningOthers(pending.sessionId)
+    if (running.length > 0) {
+      this.log({ event: 'restart.blocked', sessionId: pending.sessionId, running: running.map((agent) => agent.id) })
+      clearState()
+      return
+    }
+
+    writeState({ ...stored, turnEndedAt: Date.now() })
+    await flushSession(this.ctx, pending.sessionId)
+
+    if (canRelaunchSilently()) {
+      try {
+        const result = await requestAppRelaunch()
+        if (result.ok) {
+          this.log({ event: 'relaunch.spawned', sessionId: pending.sessionId, launcher: result.launcher })
+        } else {
+          this.log({
+            event: 'relaunch.failed',
+            sessionId: pending.sessionId,
+            code: result.code,
+            error: result.error ?? 'launcher did not start',
+          })
+          clearState()
+        }
+      } catch (error) {
+        this.log({
+          event: 'relaunch.failed',
+          error: error instanceof Error ? error.message : String(error),
+        })
+        clearState()
+      }
+      return
+    }
+
+    // Non-Windows fallback: the Desktop's own restart request, which is confirmed
+    // through the shell's native dialog.
+    const actions = this.ctx.get('desktopActions')
+    if (typeof actions?.requestRestart !== 'function') {
+      this.log({ event: 'restart.unsupported' })
+      clearState()
+      return
+    }
+    try {
+      await actions.requestRestart()
+      this.log({ event: 'restart.requested', sessionId: pending.sessionId })
+    } catch (error) {
+      this.log({
+        event: 'restart.request-failed',
+        error: error instanceof Error ? error.message : String(error),
+      })
+      clearState()
+    }
+  }
+}
+
+/**
+ * Compose the Host plugin.
+ * @param {object} ctx - plugin context.
+ */
+export function apply(ctx) {
+  const lifetime = new AbortController()
+  const timers = new Set()
+
+  const later = (fn, ms) => {
+    const timer = setTimeout(() => {
+      timers.delete(timer)
+      fn()
+    }, ms)
+    timer.unref?.()
+    timers.add(timer)
+    return timer
+  }
+
+  const scheduler = new RestartScheduler(ctx, { later })
+
+  ctx.tools.register({
+    name: 'dsh_restart',
+    description:
+      'Restart DSH Desktop and resume this same conversation automatically after the new process boots. ' +
+      'On Windows this is silent: a detached helper closes the app gracefully and starts it again, so no dialog ' +
+      'and no click are involved. The restart is deferred until this turn ends, so the current tool result and ' +
+      'final message are never lost; after the new app boots, a continuation prompt is injected into this exact ' +
+      'session. It refuses while another conversation is mid-turn, because a restart would interrupt it. ' +
+      'action="status" reports capabilities, running conversations, and any pending request; action="cancel" drops ' +
+      'a pending request.',
+    parameters: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          enum: ['restart', 'status', 'cancel'],
+          description: 'restart (default) schedules the restart; status is read-only; cancel drops the pending request.',
+        },
+        prompt: {
+          type: 'string',
+          description:
+            'What the resumed turn should continue doing. Omit to continue the unfinished work of this conversation.',
+        },
+        reason: {
+          type: 'string',
+          description: 'Short human-readable reason recorded in the continuation message and the plugin log.',
+        },
+      },
+    },
+    output: textOutput(),
+    timeoutMs: 15000,
+    isConcurrencySafe: () => false,
+    async execute(args, exec) {
+      const action = typeof args?.action === 'string' ? args.action : 'restart'
+
+      if (action === 'status') {
+        const pending = readState()
+        return json({
+          ok: true,
+          action,
+          host: {
+            pid: process.pid,
+            parentPid: process.ppid,
+            startedAt: new Date(bootTime()).toISOString(),
+            profile: currentProfile() ?? null,
+            cwd: process.cwd(),
+            dshHome: process.env.DSH_HOME ?? null,
+          },
+          capabilities: {
+            ...scheduler.capabilities(),
+            sessionPrompt: typeof ctx.get('sessionController')?.prompt === 'function',
+          },
+          runningAgents: scheduler.runningOthers(exec?.agent?.id),
+          stateFile: statePath(),
+          pending: pending ?? null,
+        })
+      }
+
+      if (action === 'cancel') {
+        const pending = readState()
+        scheduler.cancel()
+        return json({
+          ok: true,
+          action,
+          cancelled: pending !== null && pending !== undefined,
+          pending: null,
+        })
+      }
+
+      const agent = exec?.agent
+      if (agent === undefined || agent === null) {
+        return json({
+          ok: false,
+          error: 'dsh_restart must run inside an Agent turn; no calling Agent is available.',
+        })
+      }
+      const capabilities = scheduler.capabilities()
+      if (capabilities.mode === 'unsupported') {
+        return json({
+          ok: false,
+          error:
+            'This Host cannot restart itself: no silent relaunch is available on this platform and the Desktop shell ' +
+            'exposes no restart capability. dsh_restart needs DSH Desktop on Windows.',
+        })
+      }
+
+      const running = scheduler.runningOthers(agent.id)
+      if (running.length > 0) {
+        return json({
+          ok: false,
+          error:
+            `Refusing to restart: ${running.length} other conversation(s) are running a turn. ` +
+            'A restart replaces the whole app process and would interrupt them.',
+          running,
+          suggestion:
+            'Wait for those turns to finish (or cancel them), then call dsh_restart again. action="status" shows them.',
+        })
+      }
+
+      const state = scheduler.schedule({
+        sessionId: agent.id,
+        cwd: agent.session?.header?.cwd,
+        prompt: typeof args?.prompt === 'string' ? args.prompt : undefined,
+        reason: typeof args?.reason === 'string' ? args.reason : undefined,
+      })
+
+      return json({
+        ok: true,
+        action,
+        scheduled: true,
+        mode: capabilities.mode,
+        sessionId: state.sessionId,
+        stateFile: statePath(),
+        restartAt: 'when this turn ends (the Agent reaches idle)',
+        continuation:
+          'After the new process boots, this plugin reopens the session and injects a continuation prompt. ' +
+          'Finish the current turn normally instead of waiting for the restart inside the turn.',
+        guard:
+          'The restart is re-checked at fire time; if another conversation starts a turn meanwhile it is skipped, not forced.',
+        note:
+          'The request expires in 10 minutes and never replays an older conversation.',
+      })
+    },
+  })
+
+  // A previous Host may have handed off a continuation to this boot.
+  const pending = readState()
+  if (pending !== undefined) {
+    const profile = currentProfile()
+    const foreignProfile =
+      typeof pending.profile === 'string' && profile !== undefined && pending.profile !== profile
+    if (foreignProfile || !isResumable(pending)) {
+      clearState()
+      appendLog({
+        event: 'state.discarded',
+        sessionId: pending?.sessionId,
+        expired: !foreignProfile,
+        foreignProfile,
+        expectedProfile: pending?.profile,
+        profile,
+      })
+    } else {
+      const accepted = { ...pending, attempts: (pending.attempts ?? 0) + 1, resumedAt: Date.now() }
+      try {
+        writeState(accepted)
+      } catch {}
+      appendLog({ event: 'state.accepted', sessionId: accepted.sessionId, attempts: accepted.attempts })
+      later(() => {
+        void deliverContinuation(ctx, accepted, { signal: lifetime.signal })
+      }, CONTINUATION_DELAY_MS)
+    }
+  }
+
+  ctx.effect(() => () => {
+    lifetime.abort()
+    for (const timer of timers) clearTimeout(timer)
+    timers.clear()
+    scheduler.dispose()
+  })
+}

package/lib/continuation.js

@@ -0,0 +1,140 @@
+/**
+ * Turn a pending restart record into one continuation prompt.
+ *
+ * Runs right after a Host boot. The session is resumed through
+ * `ctx.sessionController.prompt`, the same admission path a Web client uses,
+ * so the model sees a normal user turn with the full durable history.
+ */
+import { randomUUID } from 'node:crypto'
+import {
+  STATE_MAX_ATTEMPTS,
+  appendLog,
+  clearState,
+  continuationText,
+  readState,
+  writeState,
+} from './state.js'
+
+const DEFAULT_RETRY_MS = [0, 3000, 8000, 15000]
+
+/**
+ * Sleep for a fixed delay while remaining cancellable.
+ * @param {number} ms - delay.
+ * @param {AbortSignal} [signal] - plugin lifetime.
+ * @returns {Promise<boolean>} false when the lifetime ended first.
+ */
+function sleep(ms, signal) {
+  if (ms <= 0) return Promise.resolve(!signal?.aborted)
+  return new Promise((resolve) => {
+    if (signal?.aborted) return resolve(false)
+    const timer = setTimeout(() => {
+      signal?.removeEventListener('abort', onAbort)
+      resolve(!signal?.aborted)
+    }, ms)
+    timer.unref?.()
+    function onAbort() {
+      clearTimeout(timer)
+      resolve(false)
+    }
+    signal?.addEventListener('abort', onAbort, { once: true })
+  })
+}
+
+/**
+ * Resolve one Host service, waiting for late composition.
+ * @param {import('@deepseek-ai/cordis').Context} ctx - plugin context.
+ * @param {string} name - service key.
+ * @param {number} timeoutMs - upper bound.
+ * @param {AbortSignal} [signal] - plugin lifetime.
+ * @returns {Promise<any | undefined>} the service, or undefined on timeout.
+ */
+async function waitForService(ctx, name, timeoutMs, signal) {
+  const deadline = Date.now() + timeoutMs
+  for (;;) {
+    if (signal?.aborted) return undefined
+    if (ctx.get(name) !== undefined) return ctx.get(name)
+    if (Date.now() >= deadline) return undefined
+    if (!(await sleep(250, signal))) return undefined
+  }
+}
+
+/**
+ * Deliver the continuation prompt, retrying transient failures in this boot.
+ * @param {import('@deepseek-ai/cordis').Context} ctx - plugin context.
+ * @param {object} state - the pending record read at boot.
+ * @param {object} [options] - test seams.
+ * @param {AbortSignal} [options.signal] - plugin lifetime.
+ * @param {number[]} [options.retryMs] - delay before each attempt.
+ * @param {boolean} [options.waitForService] - whether to await `sessionController` first.
+ * @param {Function} [options.log] - diagnostic sink.
+ * @returns {Promise<{ ok: boolean, reason?: string, error?: string }>} outcome.
+ */
+export async function deliverContinuation(ctx, state, options = {}) {
+  const {
+    signal,
+    retryMs = DEFAULT_RETRY_MS,
+    waitForService: awaitService = true,
+    log = appendLog,
+  } = options
+
+  if (awaitService) await waitForService(ctx, 'sessionController', 20000, signal)
+
+  let lastError = ''
+  for (let attempt = 0; attempt < retryMs.length; attempt += 1) {
+    if (attempt > 0 && !(await sleep(retryMs[attempt], signal))) {
+      return { ok: false, reason: 'disposed' }
+    }
+    if (signal?.aborted) return { ok: false, reason: 'disposed' }
+
+    // Another code path may have consumed or replaced the request meanwhile.
+    const latest = readState()
+    if (!latest || latest.token !== state.token) {
+      return { ok: false, reason: 'state-changed' }
+    }
+
+    const controller = ctx.get('sessionController')
+    if (controller?.prompt === undefined) {
+      lastError = 'sessionController.prompt is unavailable'
+      log({ event: 'continuation.service-missing' })
+      continue
+    }
+
+    try {
+      const text = continuationText(latest)
+      await controller.prompt(
+        {
+          requestId: `restart-${randomUUID()}`,
+          sessionId: latest.sessionId,
+          mode: 'queue',
+          content: [{ type: 'text', text }],
+        },
+        AbortSignal.timeout(120000),
+      )
+      clearState()
+      log({ event: 'continuation.sent', sessionId: latest.sessionId, attempt })
+      return { ok: true }
+    } catch (error) {
+      lastError = error instanceof Error ? error.message : String(error)
+      log({
+        event: 'continuation.failed',
+        sessionId: latest.sessionId,
+        attempt,
+        error: lastError,
+      })
+    }
+  }
+
+  // Leave a record of the failure for the next boot or for the user to inspect,
+  // but stop retrying once this request has exhausted its budget.
+  const attempts = (state.attempts ?? 0) + 1
+  if (attempts >= STATE_MAX_ATTEMPTS) {
+    clearState()
+    log({ event: 'continuation.abandoned', sessionId: state.sessionId, attempts, error: lastError })
+    return { ok: false, reason: 'abandoned', error: lastError }
+  }
+  try {
+    writeState({ ...state, attempts })
+  } catch {}
+  log({ event: 'continuation.retry-later', sessionId: state.sessionId, attempts, error: lastError })
+  return { ok: false, reason: 'retry-later', error: lastError }
+}

package/lib/guard.js

@@ -0,0 +1,20 @@
+/**
+ * Refuse to restart while another conversation is mid-turn.
+ *
+ * A restart replaces the whole app process, so any other Agent with an active
+ * driver would lose its turn. Idle Agents are fine: nothing is executing.
+ */
+
+/**
+ * @param {Array<{ id: unknown, status?: string }> | undefined} agents - live agents.
+ * @param {unknown} callerId - the Agent that asked for the restart.
+ * @returns {Array<{ id: string, status: string }>} running agents other than the caller.
+ */
+export function otherRunningAgents(agents, callerId) {
+  const caller = String(callerId ?? '')
+  return (agents ?? [])
+    .filter((agent) => agent !== undefined && agent !== null)
+    .filter((agent) => String(agent.id) !== caller)
+    .filter((agent) => agent.status === 'running')
+    .map((agent) => ({ id: String(agent.id), status: 'running' }))
+}

package/lib/relaunch.js

@@ -0,0 +1,248 @@
+/**
+ * Silent Desktop relaunch.
+ *
+ * The Host cannot ask the Electron shell to restart without the shell's own
+ * native confirmation dialog, and that dialog defaults to "Cancel". Instead a
+ * helper closes the Electron main process gracefully (WM_CLOSE, the same path as
+ * the window close button) and starts the same executable again.
+ *
+ * Launch chain, and why it is shaped this way:
+ *   Host -> wscript.exe launch.vbs (GUI subsystem: no console) -> powershell worker
+ *
+ * A `detached` PowerShell spawned straight from Node exits before running the
+ * script, and a plain child dies with its parent's console. `WScript.Shell.Run`
+ * with a hidden window starts the worker with its own console and the Host's
+ * environment, and it survives the wscript launcher exiting immediately.
+ */
+import { spawn } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+import { stateDir } from './state.js'
+
+/** Absolute path to Windows PowerShell, independent of PATH. */
+export function powershellPath() {
+  const root = process.env.SystemRoot ?? 'C:\\Windows'
+  return path.join(root, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe')
+}
+
+/** Absolute path to the Windows Script Host (GUI subsystem, no console). */
+export function wscriptPath() {
+  const root = process.env.SystemRoot ?? 'C:\\Windows'
+  return path.join(root, 'System32', 'wscript.exe')
+}
+
+export function relaunchScriptPath() {
+  return path.join(stateDir(), 'relaunch.ps1')
+}
+
+export function relaunchLauncherPath() {
+  return path.join(stateDir(), 'launch.vbs')
+}
+
+export function relaunchLogPath() {
+  return path.join(stateDir(), 'relaunch.log')
+}
+
+/** The helper script; kept as one literal so a packaged bundle needs no extra files. */
+function helperSource() {
+  return `param(
+  [int]$ParentPid,
+  [int]$HostPid,
+  [string]$ExePath,
+  [string]$LogPath
+)
+function Write-Log([string]$Message) {
+  try { Add-Content -LiteralPath $LogPath -Value ((Get-Date).ToString('o') + ' ' + $Message) } catch {}
+}
+function Get-OriginalArguments([int]$TargetId, [string]$Executable) {
+  try {
+    $info = Get-CimInstance Win32_Process -Filter "ProcessId=$TargetId"
+    $line = $info.CommandLine
+    if ([string]::IsNullOrWhiteSpace($line)) { return '' }
+    if ($line.StartsWith('"')) {
+      $end = $line.IndexOf('"', 1)
+      if ($end -gt 0) { return $line.Substring($end + 1).Trim() }
+      return ''
+    }
+    if ($line.StartsWith($Executable, [System.StringComparison]::OrdinalIgnoreCase)) {
+      return $line.Substring($Executable.Length).Trim()
+    }
+    $space = $line.IndexOf(' ')
+    if ($space -gt 0) { return $line.Substring($space + 1).Trim() }
+    return ''
+  } catch {
+    Write-Log ("command-line read failed: " + $_.Exception.Message)
+    return ''
+  }
+}
+Write-Log ("helper start parent=" + $ParentPid + " host=" + $HostPid + " exe=" + $ExePath)
+# The Desktop starts its Host in Electron's Node mode, so this worker inherited
+# ELECTRON_RUN_AS_NODE=1. If the relaunched app inherits it too, Electron runs as
+# plain Node with no script, reads EOF on stdin, and exits before any window.
+if (Test-Path Env:ELECTRON_RUN_AS_NODE) {
+  Write-Log ("clearing ELECTRON_RUN_AS_NODE=" + $env:ELECTRON_RUN_AS_NODE)
+  Remove-Item Env:ELECTRON_RUN_AS_NODE -ErrorAction SilentlyContinue
+}
+$appArguments = Get-OriginalArguments -TargetId $ParentPid -Executable $ExePath
+Write-Log ("original arguments: [" + $appArguments + "]")
+Start-Sleep -Milliseconds 900
+$graceful = $false
+try { $null = & taskkill.exe /PID $ParentPid 2>&1 } catch { Write-Log ("taskkill error: " + $_.Exception.Message) }
+$deadline = (Get-Date).AddSeconds(4)
+while ((Get-Date) -lt $deadline) {
+  if (-not (Get-Process -Id $ParentPid -ErrorAction SilentlyContinue)) { $graceful = $true; break }
+  Start-Sleep -Milliseconds 250
+}
+if (-not $graceful) {
+  # close-to-tray keeps the app alive on WM_CLOSE; stop the Host first, then the
+  # shell. Never use /T here: this worker may be a descendant of the Host.
+  Write-Log 'graceful quit timed out; forcing'
+  if ($HostPid -gt 0 -and $HostPid -ne $PID) {
+    try { $null = & taskkill.exe /PID $HostPid /F 2>&1 } catch { Write-Log ("host kill error: " + $_.Exception.Message) }
+    Start-Sleep -Milliseconds 400
+  }
+  try { $null = & taskkill.exe /PID $ParentPid /F 2>&1 } catch { Write-Log ("force kill error: " + $_.Exception.Message) }
+  Start-Sleep -Seconds 2
+}
+Start-Sleep -Milliseconds 1200
+function Find-AppProcess([string]$Path) {
+  try {
+    return @(Get-CimInstance Win32_Process | Where-Object { $_.ExecutablePath -eq $Path })
+  } catch {
+    return @()
+  }
+}
+$started = $false
+for ($attempt = 1; $attempt -le 2 -and -not $started; $attempt++) {
+  if ((Find-AppProcess $ExePath).Count -gt 0) { $started = $true; break }
+  try {
+    $psi = New-Object System.Diagnostics.ProcessStartInfo
+    $psi.FileName = $ExePath
+    $psi.Arguments = $appArguments
+    $psi.WorkingDirectory = (Split-Path -Parent $ExePath)
+    $psi.UseShellExecute = $true
+    $psi.WindowStyle = [System.Diagnostics.ProcessWindowStyle]::Normal
+    $process = [System.Diagnostics.Process]::Start($psi)
+    Write-Log ("relaunch attempt " + $attempt + " pid=" + $process.Id)
+    Start-Sleep -Seconds 4
+    if (-not $process.HasExited) { $started = $true }
+    else {
+      try { Write-Log ("attempt " + $attempt + " exited code=" + $process.ExitCode) } catch {}
+      $started = (Find-AppProcess $ExePath).Count -gt 0
+    }
+  } catch {
+    Write-Log ("relaunch attempt " + $attempt + " failed: " + $_.Exception.Message)
+  }
+  if (-not $started) { Start-Sleep -Seconds 2 }
+}
+if (-not $started) {
+  # Last resort: the shell association launch, which does not inherit this
+  # process's console or window state.
+  Write-Log 'fallback: explorer launch'
+  try { $null = & explorer.exe $ExePath } catch { Write-Log ("explorer launch failed: " + $_.Exception.Message) }
+  Start-Sleep -Seconds 5
+  $started = (Find-AppProcess $ExePath).Count -gt 0
+  Write-Log ("fallback started=" + $started)
+}
+Write-Log ("done started=" + $started)
+`
+}
+
+/**
+ * Write the worker script to disk and return its path.
+ * @returns {string} absolute script path.
+ */
+export function writeRelaunchScript() {
+  const script = relaunchScriptPath()
+  fs.mkdirSync(path.dirname(script), { recursive: true })
+  fs.writeFileSync(script, helperSource(), 'utf8')
+  return script
+}
+
+/**
+ * Quote one command-line token so Windows/PowerShell parses it as one argument.
+ * @param {string} value - raw token.
+ * @returns {string} quoted token.
+ */
+function quote(value) {
+  return `"${String(value).replaceAll('"', '\\"')}"`
+}
+
+/**
+ * Write the VBS launcher that starts the worker hidden and detached.
+ * @param {string} script - worker script path.
+ * @param {string} log - worker log path.
+ * @param {{ parentPid?: number, hostPid?: number, exePath?: string }} [overrides] - test seams.
+ * @returns {string} launcher path.
+ */
+export function writeRelaunchLauncher(script, log, overrides = {}) {
+  const parentPid = overrides.parentPid ?? process.ppid
+  const hostPid = overrides.hostPid ?? process.pid
+  const exePath = overrides.exePath ?? process.execPath
+  const worker = [
+    quote(powershellPath()),
+    '-NoProfile',
+    '-ExecutionPolicy',
+    'Bypass',
+    '-WindowStyle',
+    'Hidden',
+    '-File',
+    quote(script),
+    '-ParentPid',
+    String(parentPid),
+    '-HostPid',
+    String(hostPid),
+    '-ExePath',
+    quote(exePath),
+    '-LogPath',
+    quote(log),
+  ].join(' ')
+  const vbs = [
+    'Set shell = CreateObject("WScript.Shell")',
+    `shell.Run "${worker.replaceAll('"', '""')}", 0, False`,
+    '',
+  ].join('\r\n')
+  const launcher = relaunchLauncherPath()
+  fs.mkdirSync(path.dirname(launcher), { recursive: true })
+  // Windows Script Host reads .vbs as ANSI unless a BOM marks UTF-16; the home
+  // path may contain non-ASCII characters, so always write UTF-16LE + BOM.
+  const body = Buffer.from(vbs, 'utf16le')
+  fs.writeFileSync(launcher, Buffer.concat([Buffer.from([0xff, 0xfe]), body]))
+  return launcher
+}
+
+/**
+ * Start the launcher and wait for it to hand off (wscript exits immediately).
+ * @param {number} timeoutMs - upper bound for the launcher itself.
+ * @returns {Promise<{ ok: boolean, code: number | null, launcher: string }>} launch result.
+ */
+export function requestAppRelaunch(timeoutMs = 8000) {
+  const script = writeRelaunchScript()
+  const log = relaunchLogPath()
+  const launcher = writeRelaunchLauncher(script, log)
+  const child = spawn(wscriptPath(), [launcher], { stdio: 'ignore', windowsHide: true })
+  return new Promise((resolve) => {
+    let settled = false
+    const finish = (result) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      resolve(result)
+    }
+    const timer = setTimeout(() => finish({ ok: true, code: null, launcher }), timeoutMs)
+    timer.unref?.()
+    child.on('error', (error) => finish({ ok: false, code: null, launcher, error: error.message }))
+    child.on('exit', (code) => finish({ ok: code === 0, code, launcher }))
+  })
+}
+
+/** @returns {boolean} whether this Host can relaunch the Desktop silently. */
+export function canRelaunchSilently() {
+  if (process.platform !== 'win32') return false
+  if (!Number.isInteger(process.ppid) || process.ppid <= 0) return false
+  try {
+    return fs.existsSync(process.execPath) && fs.existsSync(wscriptPath())
+  } catch {
+    return false
+  }
+}

package/lib/state.js

@@ -0,0 +1,132 @@
+/**
+ * Durable restart hand-off state.
+ *
+ * The Host process that schedules a restart writes one JSON record before it
+ * exits. The next Host boot reads it and turns it into a continuation prompt.
+ * Everything here is synchronous small-file IO: it runs at most once per boot.
+ */
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+/** Bump when the on-disk shape changes incompatibly. */
+export const STATE_VERSION = 1
+
+/** A request older than this is stale and must not revive an old conversation. */
+export const STATE_MAX_AGE_MS = 10 * 60 * 1000
+
+/** Boot attempts allowed inside one request before we stop trying. */
+export const STATE_MAX_ATTEMPTS = 3
+
+/** Resolve the DSH data directory; the desktop Host sets DSH_HOME explicitly. */
+export function dshHome() {
+  const configured = process.env.DSH_HOME?.trim()
+  return configured && configured.length > 0 ? configured : path.join(os.homedir(), '.dsh')
+}
+
+export function stateDir() {
+  return path.join(dshHome(), 'restart')
+}
+
+export function statePath() {
+  return path.join(stateDir(), 'continuation.json')
+}
+
+export function logPath() {
+  return path.join(stateDir(), 'log.jsonl')
+}
+
+/**
+ * Read the pending record.
+ * @param {string} [file] - override for tests.
+ * @returns {object | undefined} parsed record, or undefined when absent/invalid.
+ */
+export function readState(file = statePath()) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'))
+    return parsed && typeof parsed === 'object' ? parsed : undefined
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Replace the pending record atomically.
+ * @param {object} state - complete record.
+ * @param {string} [file] - override for tests.
+ */
+export function writeState(state, file = statePath()) {
+  fs.mkdirSync(path.dirname(file), { recursive: true })
+  const temp = `${file}.${process.pid}.tmp`
+  fs.writeFileSync(temp, JSON.stringify(state, null, 2))
+  fs.renameSync(temp, file)
+}
+
+/**
+ * Remove the pending record; absence is not an error.
+ * @param {string} [file] - override for tests.
+ */
+export function clearState(file = statePath()) {
+  try {
+    fs.unlinkSync(file)
+  } catch {}
+}
+
+/**
+ * Append one diagnostic line. Logging must never break the restart path.
+ * @param {object} entry - fields merged into the line.
+ * @param {string} [file] - override for tests.
+ */
+export function appendLog(entry, file = logPath()) {
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true })
+    fs.appendFileSync(file, `${JSON.stringify({ time: new Date().toISOString(), ...entry })}\n`)
+  } catch {}
+}
+
+/** Wall-clock time at which this process started. */
+export function bootTime() {
+  return Date.now() - Math.round(process.uptime() * 1000)
+}
+
+/**
+ * Whether a record belongs to a restart this boot can serve.
+ * @param {object | undefined} state - candidate record.
+ * @param {{ now?: number, boot?: number }} [clock] - injectable clock for tests.
+ * @returns {boolean} true when the record is fresh and predates this boot.
+ */
+export function isResumable(state, clock = {}) {
+  const now = clock.now ?? Date.now()
+  const boot = clock.boot ?? bootTime()
+  if (!state || typeof state !== 'object') return false
+  if (state.version !== STATE_VERSION) return false
+  if (typeof state.sessionId !== 'string' || state.sessionId.length === 0) return false
+  if (typeof state.createdAt !== 'number' || !Number.isFinite(state.createdAt)) return false
+  // The request must have been written by an earlier process: a record that
+  // appears after this boot cannot describe a restart this boot is finishing.
+  if (state.createdAt > boot) return false
+  if (now - state.createdAt > STATE_MAX_AGE_MS) return false
+  if ((state.attempts ?? 0) >= STATE_MAX_ATTEMPTS) return false
+  return true
+}
+
+/**
+ * Build the user-visible continuation text injected into the resumed session.
+ * @param {object} state - pending record.
+ * @returns {string} prompt text.
+ */
+export function continuationText(state) {
+  const when = new Date(state.turnEndedAt ?? state.createdAt)
+  const stamp = Number.isNaN(when.getTime()) ? 'unknown time' : when.toLocaleString('zh-CN')
+  const reason = typeof state.reason === 'string' && state.reason.trim().length > 0 ? `重启原因：${state.reason.trim()}\n` : ''
+  const instruction =
+    typeof state.prompt === 'string' && state.prompt.trim().length > 0
+      ? state.prompt.trim()
+      : '继续上一次会话中未完成的工作。'
+  return [
+    '[DSH 自动重启 · 已完成]',
+    `宿主进程已于 ${stamp} 重启，当前会话（${state.sessionId}）已恢复，之前的对话上下文仍然可用。`,
+    reason + `继续指令：${instruction}`,
+    '请直接从上次停下的位置继续，不要重复已完成的步骤或重新开始任务；先用一句话说明接下来要做什么，然后继续执行。',
+  ].join('\n')
+}

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Restart and continue",
+    "description": "Restart DSH Desktop from an agent tool and resume the same conversation automatically."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "重启并续聊",
+    "description": "让 Agent 主动重启 DSH Desktop，并在新进程启动后自动恢复同一会话继续工作。"
+  }
+}

package/package.json

@@ -1,6 +1,52 @@
 {
   "name": "dsh-restart-continue",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Restart DSH Desktop from an agent tool and resume the same conversation automatically.",
+  "type": "module",
+  "main": "index.js",
+  "license": "MIT",
+  "author": "LISHUANGXI1412",
+  "homepage": "https://github.com/LISHUANGXI1412/dsh-restart-continue",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/LISHUANGXI1412/dsh-restart-continue"
+  },
+  "bugs": {
+    "url": "https://github.com/LISHUANGXI1412/dsh-restart-continue/issues"
+  },
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "restart",
+    "resume",
+    "session"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "exports": {
+    ".": "./index.js",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg"
+  },
+  "files": [
+    "index.js",
+    "lib/",
+    "cordis.patch.yml",
+    "locale/*.json",
+    "icon.svg",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  }
+}