dsh-remote 0.8.7 → 0.8.8

package/README.zh.md

@@ -70,6 +70,9 @@ dsh plugin add dsh-remote            # 添加 bundle
 ## 快速上手
 
 1. **加一台机器** —— 设置 → 远程工作区 → 填 host/port/user + 密码或 key →（可选）设为当前。
+   > **保存 ≠ 激活（v0.8.8+）**：保存的机器只是备用连接，不会自动进入任何 session 的
+   > remote context。只有「设为当前」（或 Agent 显式调用 `rw_connect`）才激活当前机器；
+   > 「取消设为当前」可回到 `active remote = none`。
 2. **选工作区** —— 点侧边栏/会话的 **Add workspace**：
    - **本机** → 系统文件夹选择（或输入本地路径）→ 本地工作区。
    - **远程** → 选机器 → 浏览到远程目录（或输入 `/path`）→ 「设为远程工作区」⇒ 创建并收养一个本地镜像工作区。
@@ -80,6 +83,12 @@ dsh plugin add dsh-remote            # 添加 bundle
    - `rw_exec(command, cwd?)` —— 在远程执行命令（默认在工作区目录）
    - `rw_sync` / `rw_push` —— 拉取/推送本地镜像 <-> 远程
 
+> **Remote context 是 session 级的（v0.8.8+）**：system prompt 只会在**当前 session 的
+> cwd 位于某个远程 mirror 内**（即你把远程目录选成了这个 session 的工作区）时注入
+> 「Remote workspace」段落；普通本地 session 不注入、侧边栏「远程文件」也不显示任何
+> 机器默认目录，模型不会主动调用 `rw_*`。混合访问（本地 + 远程同屏比较）请通过显式
+> 选择远程工作区进行。
+
 ## 可选：CLI 默认机
 
 可在 `cordis.patch.yml` 提供默认机：

package/lib/client.js

@@ -204,6 +204,9 @@ window.__ModuleLoader__.load({
         }).then((r) => { refresh(); clearForm(); setMsg(form.id ? '已保存更新' : '已添加 — 可设为当前') }).catch((e) => setErr(String((e && e.message) || e))).finally(() => setBusy(false))
       }
       const useNow = (id) => { setBusy(true); api('POST', '/dsh-remote/current', { id }).then((r) => { setCurrentId(r.currentId); setMsg('已切换为当前远程机') }).catch((e) => setErr(String((e && e.message) || e))).finally(() => setBusy(false)) }
+      // Issue #13: "active remote = none" — saved machines stay, but no machine
+      // is current, so local sessions are never dragged into a remote context.
+      const clearCurrent = () => { setBusy(true); api('POST', '/dsh-remote/current', { id: '' }).then((r) => { setCurrentId(''); setMsg('已取消当前远程机 — 本地会话不再自动使用远程上下文') }).catch((e) => setErr(String((e && e.message) || e))).finally(() => setBusy(false)) }
       const del = (id) => { if (window.confirm('确定删除这台机器？')) { api('POST', '/dsh-remote/machines', { action: 'delete', id }).then(refresh).then(() => setMsg('已删除')).catch((e) => setErr(String((e && e.message) || e))) } }
 
       const importSsh = () => {
@@ -261,6 +264,11 @@ window.__ModuleLoader__.load({
                 React.createElement('button', { style: buttonS, onClick: () => del(m.id) }, '删除'),
                 React.createElement('button', { style: { ...buttonS, padding: '6px 10px', whiteSpace: 'nowrap' }, onClick: () => useNow(m.id), disabled: m.id === currentId }, '设为当前')))
             : React.createElement('div', { style: { opacity: 0.6, fontSize: 12 } }, '还没有机器。在下方添加。'),
+          currentId
+            ? React.createElement('div', { style: { display: 'flex', gap: 8, alignItems: 'center', paddingTop: 6, fontSize: 12, color: T.ok } },
+                '当前远程机：' + ((machines.find((m) => m.id === currentId) || {}).name || currentId),
+                React.createElement('button', { style: { ...buttonS, padding: '2px 8px', fontSize: 12, marginLeft: 'auto' }, onClick: clearCurrent }, '取消设为当前（active remote = none）'))
+            : React.createElement('div', { style: { paddingTop: 6, fontSize: 12, opacity: 0.6 } }, '当前没有活动远程机：保存的机器只是备用连接，不会自动进入会话上下文（本地会话不受影响）。'),
           ),
         React.createElement('div', { style: boxS },
           React.createElement('div', { style: { display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: 6 } },
@@ -830,10 +838,12 @@ window.__ModuleLoader__.load({
       return api('GET', '/dsh-remote/status').catch(() => null)
     }
 
-    // Resolve the remote path this session should show: prefer the session's
-    // own cwd (a remote mirror dir) mapped through /dsh-remote/resolve-mirror;
-    // fall back to the machine workspace when the session has no cwd or the
-    // host side has no mirror match.
+    // Resolve the remote path this session shows. Issue #13: the ONLY source
+    // of truth is the session's own cwd mapped through /dsh-remote/resolve-
+    // mirror — a cwd outside any mirror dir means "this session is NOT a
+    // remote session", and the sidebar must NOT fall back to the machine
+    // workspace (that made an unrelated saved machine leak into local
+    // sessions).
     function resolveSessionRemote(sessionId) {
       if (!sessionId) return Promise.resolve('')
       // 1) Prefer the client-side session list cwd (mirror dir under
@@ -969,7 +979,10 @@ window.__ModuleLoader__.load({
         resolveRoot().then((r) => {
           fetchRemoteStatus().then((s) => {
             setStatus(s)
-            applyRoot(r || (s && s.workspace) || '')
+            // Issue #13: NEVER fall back to the machine-level workspace here —
+            // a session whose cwd is not a mirror is a LOCAL session and shows
+            // the "no remote workspace" empty state instead.
+            applyRoot(r || '')
           })
         })
       }, [scopeCwd, sessionId])
@@ -1087,15 +1100,15 @@ window.__ModuleLoader__.load({
           }, '新建目录'),
           React.createElement('button', { style: { ...buttonS, padding: '3px 8px', fontSize: 12 }, onClick: () => setPicker(true) }, '…'),
         ),
-        status && status.workspace
+        status && status.workspace && root
           ? React.createElement('div', { style: { fontSize: 11, opacity: 0.7, padding: '4px 8px', wordBreak: 'break-all' } }, '远程工作区: ' + root + (status.host ? '  (' + status.username + '@' + status.host + ')' : ''))
-          : React.createElement('div', { style: { fontSize: 11, opacity: 0.7, padding: '4px 8px' } }, '未设置远程工作区'),
+          : React.createElement('div', { style: { fontSize: 11, opacity: 0.7, padding: '4px 8px' } }, root ? '未设置远程工作区' : '当前会话未使用远程工作区'),
         picker ? React.createElement('div', { style: { padding: 8 } }, React.createElement(DirPicker, {
           open: true, busy: false, onPicked: () => { setPicker(false); refreshStatus() }, onCancel: () => setPicker(false),
         })) : null,
         React.createElement('div', { style: { flex: 1, overflowY: 'auto', minHeight: 0, padding: '2px 0' } },
           !root
-            ? React.createElement('div', { style: { opacity: 0.6, padding: 12, fontSize: 13 } }, '选择或设置一个远程工作区')
+            ? React.createElement('div', { style: { opacity: 0.6, padding: 12, fontSize: 13 } }, '当前会话是本地工作区，未使用远程文件。\n\n如需访问远程，可在设置页将某台机器「设为当前」，再用上方「…」选择远程工作区。')
             : React.createElement('div', { key: root },
                 React.createElement('div', {
                   role: 'button', tabIndex: 0,
@@ -1243,6 +1256,10 @@ window.__ModuleLoader__.load({
         if (!snap || !snap.sessionId) return
         if (autoOpenedFor.has(snap.sessionId)) return
         const sessionId = snap.sessionId
+        // Issue #13: only auto-open the Remote Files tab for sessions that are
+        // genuinely remote (cwd inside a mirror). A plain local session must
+        // not get a remote tab popped open by a machine that happens to be
+        // saved as "current".
         resolveSessionRemote(sessionId).then((remotePath) => {
           if (!remotePath || autoOpenedFor.has(sessionId)) return
           autoOpenedFor.add(sessionId)

package/lib/index.js

@@ -42,6 +42,7 @@ import { searchTree } from './search.js'
 import { TaskManager } from './tasks.js'
 import { ForwardManager } from './forwards.js'
 import { selfDir, readVersion, gtVersion, fetchLatestVersion, applyUpdate, persistUpdateMode, readUpdateMode } from './update.js'
+import { loadMachines as _loadMachines, saveMachines as _saveMachines, sanitizeMachine as _sanitizeMachine, applyMachine as _applyMachine, machineId as _machineId } from './registry.js'
 
 const { Client } = ssh2
 
@@ -220,6 +221,9 @@ function migrateLegacyData() {
 }
 
 // ── persistent multi-machine registry ─────────────────────────────────────
+// Pure registry logic lives in lib/registry.js (unit-tested): saved machines
+// are STANDBY connections; only an explicit "set current" activates one.
+// (issue #13 — Saved Connections != Active Remote Context)
 const MACHINES_FILE = 'machines.json'
 const machinesFile = () => path.join(remoteWorkspacesRoot(), MACHINES_FILE)
 const secretsDir = () => path.join(remoteWorkspacesRoot(), '.secrets')
@@ -227,40 +231,11 @@ const forwardsFile = () => path.join(remoteWorkspacesRoot(), 'forwards.json')
 const auditFile = () => path.join(remoteWorkspacesRoot(), 'audit.log')
 const ignoreFile = () => path.join(remoteWorkspacesRoot(), '.dsh-remote-ignore')
 
-function loadMachines() {
-  try {
-    const j = JSON.parse(readFileSync(machinesFile(), 'utf8'))
-    if (Array.isArray(j.list)) return { list: j.list, currentId: j.currentId || (j.list[0] && j.list[0].id) || null }
-  } catch {}
-  return { list: [], currentId: null }
-}
-function saveMachines(list, currentId) {
-  try { mkdirSync(path.dirname(machinesFile()), { recursive: true }) } catch {}
-  writeFileSync(machinesFile(), JSON.stringify({ list, currentId }, null, 2))
-}
-function sanitizeMachine(m) {
-  if (!m) return m
-  const { password, proxy, ...rest } = m
-  const out = { ...rest, passwordSet: !!(m.password && m.password.length) }
-  if (proxy) out.proxy = { ...proxy, password: proxy.password ? '' : undefined, passwordSet: !!(proxy.password && proxy.password.length) }
-  return out
-}
-/** Apply a machine's fields onto the live config object (pool + tools read it). */
-function applyMachine(config, m) {
-  if (!m) return
-  config.host = m.host
-  config.port = Number(m.port) || 22
-  config.username = m.username || ''
-  config.password = m.password || ''
-  config.privateKeyPath = m.privateKeyPath || ''
-  config.passphrase = m.passphrase || ''
-  config.workspace = m.workspace || (config.workspace || '')
-  if (m.hostKeyMode) config.hostKeyMode = m.hostKeyMode
-  if (typeof m.useAgent === 'boolean') config.useAgent = m.useAgent
-  if (typeof m.keyboardInteractive === 'boolean') config.keyboardInteractive = m.keyboardInteractive
-  config.proxy = m.proxy && m.proxy.host ? m.proxy : undefined
-}
-function machineId() { return 'm-' + Date.now().toString(36) + '-' + Math.random().toString(36).slice(2, 6) }
+const loadMachines = () => _loadMachines(machinesFile())
+const saveMachines = (list, currentId, keepCurrentKey) => _saveMachines(machinesFile(), list, currentId, keepCurrentKey)
+const sanitizeMachine = _sanitizeMachine
+const applyMachine = _applyMachine
+const machineId = _machineId
 
 // ── host-key registry (TOFU) ──────────────────────────────────────────────
 const KNOWN_HOSTS_FILE = 'known_hosts.json'
@@ -753,6 +728,15 @@ export async function apply(ctx, config) {
   }
 
   const setCurrent = async (id) => {
+    if (!id) {
+      // Explicit "active remote = none": saved machines stay in the registry
+      // (issue #13) but nothing is bound to the pool anymore.
+      store.currentId = null
+      ephemeral = null
+      saveMachines(machines, null)
+      await clearActiveMachine()
+      return true
+    }
     const i = machineIndex(id)
     if (i < 0) return false
     store.currentId = id
@@ -762,10 +746,41 @@ export async function apply(ctx, config) {
     return true
   }
 
-  // If no stored current, adopt a CLI-provided default as the active machine.
+  /** Unbind the pool + live config from any machine: the plugin starts in a
+   * pure "no remote context" state (issue #13). The host stays configured for
+   * tool fallback, but no machine workspace leaks into this session. */
+  const clearActiveMachine = async () => {
+    ephemeral = null
+    if (!config.host) return
+    // Clear host + workspace directly (applyMachine keeps the old workspace
+    // when the incoming value is empty — it must not be used for a full reset).
+    config.host = ''
+    config.port = 22
+    config.username = ''
+    config.password = ''
+    config.workspace = ''
+    pool.setTarget({ host: '', port: 22, username: '', workspace: '' })
+    // Also stop any auto-push watcher bound to the old machine workspace.
+    // (autoPushWatchers is declared later; read it lazily to avoid TDZ.)
+    if (typeof autoPushWatchers !== 'undefined' && autoPushWatchers) {
+      for (const [, entry] of autoPushWatchers) {
+        if (!entry) continue
+        try { entry.watcher && entry.watcher.close() } catch {}
+        if (entry.timer) clearTimeout(entry.timer)
+      }
+      autoPushWatchers.clear()
+    }
+  }
+
+  // If no stored current, adopt a CLI-provided default as the active machine —
+  // UNLESS the user explicitly cleared the current machine (currentId: null in
+  // the registry = "active remote = none", issue #13). A registry that exists
+  // with currentId null must stay inert; only a fresh/absent registry lets the
+  // config host serve as the bootstrap default.
   {
     const cur = currentMachine()
-    if (cur && cur.host && !store.currentId) applyMachine(config, cur)
+    const registryExplicitNone = store.explicitNone
+    if (cur && cur.host && !store.currentId && !registryExplicitNone) applyMachine(config, cur)
   }
 
   /** Persist the active workspace on the machine the pool is actually bound to
@@ -980,9 +995,61 @@ export async function apply(ctx, config) {
 
   // ── remote workspace state ────────────────────────────────────────────────
   const wsPath = () => (config.workspace || '').trim()
+  /** Map a LOCAL path to the remote path its mirror represents ('' when the
+   *  path is not inside any dsh-remote mirror). Shared by the resolve-mirror
+   *  route, the session-aware system-prompt injection, and status(). */
+  const resolveMirrorForLocal = (local) => {
+    const root = remoteWorkspacesRoot()
+    const norm = (p) => path.resolve(String(p || '')).replace(/[\\/]+$/, '') || ''
+    let matched = ''
+    let matchedRemote = ''
+    if (local && existsSync(root)) {
+      const base = norm(local)
+      for (const hostDir of readdirSync(root)) {
+        const hostPath = path.join(root, hostDir)
+        if (!statSync(hostPath, { throwIfNoEntry: false })?.isDirectory?.()) continue
+        for (const mirrorDir of readdirSync(hostPath)) {
+          const metaPath = path.join(hostPath, mirrorDir, '.dsh-remote-meta.json')
+          if (!existsSync(metaPath)) continue
+          try {
+            const meta = JSON.parse(readFileSync(metaPath, 'utf8'))
+            const mirrorAbs = norm(path.join(hostPath, mirrorDir))
+            if (mirrorAbs === base || base.startsWith(mirrorAbs + path.sep) || base.startsWith(mirrorAbs + '/')) {
+              if (mirrorAbs.length > matched.length) {
+                matched = mirrorAbs
+                matchedRemote = String(meta.remotePath || '')
+              }
+            }
+          } catch { /* skip unparsable meta */ }
+        }
+      }
+    }
+    return { mirrorDir: matched || null, remotePath: matchedRemote || '' }
+  }
   if (config.autoPush && wsPath()) {
     startAutoPush(mirrorDirFor(wsPath(), config.host, config.username, config.port))
   }
+  /** The remote path the CURRENT agent session is really bound to, or '' when
+   *  the session is a plain local one. Walks the mirror registry (host side
+   *  copy of the resolve-mirror logic) so status / prompt / sidebar agree.
+   *  `sessionId` narrows to one session; without it the first live session's
+   *  cwd is used (best effort — status is informational, the per-session
+   *  resolve-mirror endpoint is authoritative). */
+  const sessionRemotePath = (sessionId) => {
+    let cwd = ''
+    try {
+      const sessions = ctx && typeof ctx.get === 'function' ? ctx.get('sessions') : null
+      if (sessions && typeof sessions.get === 'function' && sessionId) {
+        const s = sessions.get(sessionId)
+        if (s && s.header && s.header.cwd) cwd = String(s.header.cwd)
+      } else if (sessions && typeof sessions.list === 'function') {
+        const s = sessions.list()[0]
+        if (s && s.header && s.header.cwd) cwd = String(s.header.cwd)
+      }
+    } catch { /* sessions service unavailable */ }
+    if (!cwd) return ''
+    return resolveMirrorForLocal(cwd).remotePath
+  }
   const status = () => ({
     host: config.host,
     port: config.port,
@@ -992,6 +1059,11 @@ export async function apply(ctx, config) {
     localMirror: wsPath() ? mirrorDirFor(wsPath(), config.host, config.username, config.port) : '',
     currentId: store.currentId || null,
     activeSource: ephemeral ? 'ephemeral' : (store.currentId ? 'machine' : (config.host ? 'config' : 'none')),
+    // Issue #13: whether THIS session is in remote mode (cwd inside a mirror).
+    // `none`/`local` means the plugin is present but no remote context is
+    // active — saved machines stay standby-only.
+    sessionMode: sessionRemotePath() ? 'remote' : (store.currentId ? 'standby' : 'local'),
+    sessionRemotePath: sessionRemotePath(),
     machines: machines.map(sanitizeMachine),
     hostKeyMode: config.hostKeyMode === 'verify' || config.hostKeyMode === 'off' ? config.hostKeyMode : 'accept-new',
     hostKeyKnown: config.host ? isHostKeyKnown(config.host, config.port) : false,
@@ -1015,15 +1087,16 @@ export async function apply(ctx, config) {
     defineTool({
       name: 'rw_info',
       description:
-        'Show the remote environment: host/user/port, connection health, current remote workspace path, active port forwards. Call this first to orient, or when an rw_* call fails to check connectivity.',
+        'Show the remote environment: host/user/port, connection health, current remote workspace path, active port forwards. Call this first to orient, or when an rw_* call fails to check connectivity. Note: remote context is session-scoped — a saved machine only becomes active when you explicitly rw_connect to it (issue #13).',
       parameters: {},
       output: textOut,
       async execute() {
         const s = status()
         const lines = [
           `Remote host: ${s.username || '<user>'}@${s.host || '<host>'}:${s.port}${s.activeSource !== 'machine' ? ` (source: ${s.activeSource})` : ''}`,
-          `Current remote workspace: ${s.workspace || '(none — call rw_pick_workspace to set one)'}`,
+          `Current remote workspace: ${s.workspace || '(none — call rw_connect then rw_pick_workspace to set one)'}`,
           `Local mirror: ${s.localMirror || '(none)'}`,
+          `Session remote context: ${s.sessionRemotePath ? s.sessionRemotePath : '(this session is LOCAL — no remote workspace bound)'}`,
           `Connected: ${s.connected ? 'yes' : 'no'}`,
           `Active forwards: ${s.forwards.filter((f) => f.active).length} / ${s.forwards.length}`,
           `Host key: ${s.hostKeyKnown ? 'trusted' : 'not yet trusted'} (mode=${s.hostKeyMode})`,
@@ -1689,19 +1762,30 @@ export async function apply(ctx, config) {
     ctx.tools.register(t)
   }
 
-  // ── system-prompt injection: the current remote workspace ─────────────────
+  // ── system-prompt injection: session-aware remote workspace ──────────────
+  // Issue #13: remote context must be SESSION-scoped, not machine-global.
+  // The section text is evaluated per assembly with the current agent's
+  // session; it is injected ONLY when that session's cwd actually maps to a
+  // dsh-remote mirror (i.e. the user picked a remote workspace as the session
+  // workspace). A plain local session gets no remote section — saved machines
+  // never leak their workspace into an unrelated local session's prompt.
+  // (resolveMirrorForLocal is defined above, next to wsPath.)
   ctx.systemPrompt.section({
     name: 'dsh-remote',
     order: 88,
-    text: () => {
-      const w = wsPath()
-      if (!w || !config.host) return ''
+    text: (promptContext) => {
+      const agent = promptContext && promptContext.agent
+      const session = agent && agent.session
+      const cwd = session && session.header && session.header.cwd
+      if (!cwd) return '' // no session cwd → nothing to map → stay quiet
+      const { remotePath } = resolveMirrorForLocal(cwd)
+      if (!remotePath) return '' // this session is NOT a remote session (issue #13)
       const fwd = forwards.list().filter((f) => f.active).map((f) => `${f.direction}:127.0.0.1:${f.listenPort}→${f.targetHost}:${f.targetPort}`)
       let extra = ''
       if (fwd.length) extra = `\nActive port forwards: ${fwd.join(', ')}`
       return (
         '## Remote workspace\n' +
-        `Current remote workspace: ${config.username}@${config.host}:${w}\n` +
+        `Current remote workspace: ${config.username || 'user'}@${config.host}:${remotePath}\n` +
         'Use the rw_* tools (rw_list_dir / rw_read_file / rw_write_file / rw_edit / rw_exec / rw_search / rw_sync / rw_push) to inspect and act on files on the remote host. Treat this directory as the working root for this task.' +
         extra
       )
@@ -1852,15 +1936,23 @@ export async function apply(ctx, config) {
       kind: 'exact',
       path: '/dsh-remote/status',
       handler: async (req, res) => {
-        if (req.method === 'GET') return sendJson(res, 200, status())
+        if (req.method === 'GET') {
+          const q = new URL(req.url, 'http://localhost').searchParams
+          const sessionId = q.get('sessionId') ? decodeURIComponent(q.get('sessionId')) : ''
+          // Per-session remote context (issue #13): when a sessionId is given,
+          // sessionMode reflects THAT session's cwd, not the machine default.
+          return sendJson(res, 200, sessionId ? { ...status(), sessionMode: sessionRemotePath(sessionId) ? 'remote' : 'local', sessionRemotePath: sessionRemotePath(sessionId) } : status())
+        }
         sendJson(res, 405, { error: 'method not allowed' })
       },
     },
     {
       // Map a LOCAL path (typically a session cwd that sits inside a remote
       // mirror dir) to the remote path it mirrors, by reading each mirror
-      // dir's .dsh-remote-meta.json. Falls back to the machine workspace so
-      // the sidebar still shows something sensible for non-mirror cwds.
+      // dir's .dsh-remote-meta.json. NO machine-workspace fallback (issue #13):
+      // a session whose cwd is not inside any mirror is a pure LOCAL session —
+      // the sidebar must show "no remote workspace", never another machine's
+      // remembered default.
       // Accepts either ?local=<abs path> or ?sessionId=<id> (resolved via
       // the host sessions service header.cwd).
       kind: 'exact',
@@ -1909,7 +2001,6 @@ export async function apply(ctx, config) {
               } catch { /* session log scan failed */ }
             }
           }
-          const remote = status().workspace || ''
           const root = remoteWorkspacesRoot()
           const norm = (p) => path.resolve(String(p || '')).replace(/[\\/]+$/, '') || ''
           let matched = ''
@@ -1936,8 +2027,16 @@ export async function apply(ctx, config) {
               }
             }
           }
-          const remotePath = matchedRemote || remote
-          return sendJson(res, 200, { local, remotePath, mirrorDir: matched || null, fallback: !matchedRemote, resolvedVia })
+          // Issue #13: a non-mirror session is LOCAL — remotePath stays empty.
+          const remotePath = matchedRemote || ''
+          return sendJson(res, 200, {
+            local, remotePath, mirrorDir: matched || null,
+            // `fallback:true` now means "this session is NOT a remote session"
+            // (used to mean "fell back to machine workspace").
+            fallback: !matchedRemote,
+            mode: matchedRemote ? 'remote' : 'local',
+            resolvedVia,
+          })
         } catch (err) {
           return sendJson(res, 500, { error: String((err && err.message) || err) })
         }
@@ -2347,9 +2446,13 @@ export async function apply(ctx, config) {
                 rec.password = prev.password
               }
               if (i >= 0) machines[i] = rec; else machines.push(rec)
-              if (!store.currentId) store.currentId = id
-              saveMachines(machines, store.currentId)
-              if (store.currentId === id) await applyActiveMachine()
+              // Issue #13: saving a machine must NOT make it the active
+              // remote context. `currentId` stays untouched on add/update —
+              // only an explicit "设为当前" (or rw_connect) activates one.
+              // keepCurrentKey:false leaves the stored `currentId` byte-for-byte
+              // alone, so a fresh registry stays "no choice yet" (not an
+              // explicit none) and a previously-cleared registry stays cleared.
+              saveMachines(machines, store.currentId, false)
               return sendJson(res, 200, { ok: true, machine: sanitizeMachine(rec), machines: machines.map(sanitizeMachine), currentId: store.currentId })
             }
             if (action === 'delete') {
@@ -2360,9 +2463,17 @@ export async function apply(ctx, config) {
                 await deleteSecret(m.id, secretsDir()).catch(() => {})
               }
               machines.splice(i, 1)
-              if (store.currentId === body.id) store.currentId = machines[0] ? machines[0].id : null
-              saveMachines(machines, store.currentId)
-              if (store.currentId) await applyActiveMachine()
+              const wasCurrent = store.currentId === m.id
+              if (wasCurrent) {
+                // Issue #13: deleting the current machine leaves NO active
+                // remote context (never auto-promote a sibling — that would
+                // make an unrelated machine leak into the session again).
+                store.currentId = null
+                saveMachines(machines, null)
+                await clearActiveMachine()
+              } else {
+                saveMachines(machines, store.currentId)
+              }
               return sendJson(res, 200, { ok: true, machines: machines.map(sanitizeMachine), currentId: store.currentId })
             }
             return sendJson(res, 400, { ok: false, error: 'unknown action' })
@@ -2422,7 +2533,14 @@ export async function apply(ctx, config) {
         if (req.method !== 'POST') return sendJson(res, 405, { ok: false, error: 'method not allowed' })
         try {
           const body = JSON.parse((await readBody(req)) || '{}')
-          const okSet = await setCurrent(String(body.id || ''))
+          const id = String(body.id || '').trim()
+          // Issue #13: an empty id is an explicit "active remote = none" —
+          // saved machines stay in the registry but nothing is current.
+          if (!id) {
+            await setCurrent('')
+            return sendJson(res, 200, { ok: true, currentId: null, ...status() })
+          }
+          const okSet = await setCurrent(id)
           if (!okSet) return sendJson(res, 404, { ok: false, error: 'machine not found' })
           return sendJson(res, 200, { ok: true, ...status() })
         } catch (err) {

package/lib/registry.js

@@ -0,0 +1,89 @@
+// Machine-registry pure logic for dsh-remote.
+//
+// Issue #13: a SAVED machine is only a standby connection — it must never
+// silently become the "active remote context" of every session. The registry
+// therefore keeps `currentId` as an EXPLICIT user choice:
+//   • loadMachines never falls back to the first saved machine,
+//   • a stale currentId (machine deleted meanwhile) resolves to null,
+//   • add/update never auto-activate; only an explicit "set current" does,
+//   • deleting the current machine leaves NO current (no auto-promotion).
+// Keeping this logic in one module makes the guarantee unit-testable and
+// shared between the HTTP routes and the tools (rw_connect).
+
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs'
+import path from 'node:path'
+
+/** Load { list, currentId, explicitNone } from the registry file. */
+export function loadMachines(file) {
+  try {
+    const j = JSON.parse(readFileSync(file, 'utf8'))
+    if (Array.isArray(j.list)) {
+      const list = j.list
+      // Explicit choice only — no fallback to the first machine, no activation
+      // of a stale/deleted id (issue #13).
+      const currentId = j.currentId && list.some((m) => m.id === j.currentId) ? j.currentId : null
+      // A persisted `currentId: null` is a deliberate "active remote = none"
+      // (the user cleared the current machine). It must survive restarts so a
+      // config-level default host cannot silently reactivate a context the user
+      // explicitly turned off. `explicitNone` is true when the file carries an
+      // explicit null (vs. a fresh file where currentId is simply absent).
+      const explicitNone = Object.prototype.hasOwnProperty.call(j, 'currentId') && j.currentId == null
+      return { list, currentId, explicitNone }
+    }
+  } catch {}
+  return { list: [], currentId: null, explicitNone: false }
+}
+
+/** Persist { list, currentId }. `currentId` may be null → active remote = none.
+ *  Pass `keepCurrentKey: false` (add/update a machine without touching the
+ *  current selection) to PRESERVE whatever `currentId` the file already holds
+ *  — so merely saving a machine never flips a fresh registry into "explicit
+ *  none", nor clears an explicit choice. When no previous file exists the
+ *  `currentId` key is omitted entirely (fresh registry = "no choice yet"). */
+export function saveMachines(file, list, currentId, keepCurrentKey = true) {
+  try { mkdirSync(path.dirname(file), { recursive: true }) } catch {}
+  let stored = currentId
+  let hasStored = keepCurrentKey
+  if (!keepCurrentKey) {
+    try {
+      const prev = JSON.parse(readFileSync(file, 'utf8'))
+      if (prev && Object.prototype.hasOwnProperty.call(prev, 'currentId')) {
+        stored = prev.currentId
+        hasStored = true
+      }
+    } catch { /* no previous file → omit the key */ }
+  }
+  const payload = { list }
+  if (hasStored) payload.currentId = stored
+  writeFileSync(file, JSON.stringify(payload, null, 2))
+}
+
+/** Strip secrets before sending a machine to the client. */
+export function sanitizeMachine(m) {
+  if (!m) return m
+  const { password, proxy, ...rest } = m
+  const out = { ...rest, passwordSet: !!(m.password && m.password.length) }
+  if (proxy) out.proxy = { ...proxy, password: proxy.password ? '' : undefined, passwordSet: !!(proxy.password && proxy.password.length) }
+  return out
+}
+
+/** Apply a machine's fields onto the live config object (pool + tools read it). */
+export function applyMachine(config, m) {
+  if (!m) return
+  config.host = m.host
+  config.port = Number(m.port) || 22
+  config.username = m.username || ''
+  config.password = m.password || ''
+  config.privateKeyPath = m.privateKeyPath || ''
+  config.passphrase = m.passphrase || ''
+  config.workspace = m.workspace || (config.workspace || '')
+  if (m.hostKeyMode) config.hostKeyMode = m.hostKeyMode
+  if (typeof m.useAgent === 'boolean') config.useAgent = m.useAgent
+  if (typeof m.keyboardInteractive === 'boolean') config.keyboardInteractive = m.keyboardInteractive
+  config.proxy = m.proxy && m.proxy.host ? m.proxy : undefined
+}
+
+/** Mint a fresh machine id. */
+export function machineId() {
+  return 'm-' + Date.now().toString(36) + '-' + Math.random().toString(36).slice(2, 6)
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-remote",
-  "version": "0.8.7",
+  "version": "0.8.8",
   "description": "Remote-work assistant for DeepSeek Harness: connect SSH (password/key/agent/keyboard-interactive/proxy jump), pick a remote workspace, operate on it with 21 rw_* tools (incl. rw_edit/rw_stat/rw_mkdir/rw_remove/rw_move/rw_forward), conflict-aware mirror sync, port forwarding, side-bar remote file editing, audit log, keychain passwords.",
   "license": "MIT",
   "author": "flymysql <flyphp@outlook.com>",