@twinsearth/w2m-dsh-plugin 2.1.11 → 2.2.1

package/.claude-plugin/marketplace.json

@@ -5,14 +5,14 @@
   },
   "metadata": {
     "description": "The w2m fleet plugins: one account, many machines, any of Windows, macOS or Linux.",
-    "version": "2.1.11"
+    "version": "2.2.1"
   },
   "plugins": [
     {
       "name": "w2m-fleet",
       "source": "./",
       "description": "Read fleet state and dispatch commands across the machines registered to one account. Read-only MCP surface: the five exposed tools cannot change anything.",
-      "version": "2.1.11",
+      "version": "2.2.1",
       "author": {
         "name": "TwinsEarth"
       },
@@ -26,5 +26,5 @@
       ]
     }
   ],
-  "version": "2.1.11"
+  "version": "2.2.1"
 }

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "w2m-fleet",
   "description": "Drive the same project on online Windows, macOS and Linux machines from one account: read fleet state, dispatch commands and read results. The MCP surface is deliberately read-only.",
-  "version": "2.1.11",
+  "version": "2.2.1",
   "author": {
     "name": "TwinsEarth"
   },

package/CHANGELOG.md

@@ -7,6 +7,24 @@ All notable changes to this project are documented here.
 - `w2m_intent`: structured intents mapped onto allow-listed commands; unknown actions, parameters and types
   are refused by name (the fleet does not invent commands).
 
+## [2.2.1] - 2026-11-01
+
+- Fleet identity is now per-account **home**-first. Each machine records the fleet key it actually joined under `fleet-home.json` beside `device.json`; switching back to an account returns to that account’s previous fleet instead of deriving a new one. This is the “whoever leaves returns by themselves” rule: a first appearance of account B may join B’s account fleet, but an existing home for A is never rewritten by B, and no other machine is moved.
+- `fleetKeyPolicy` is now `home` by default. `account` keeps the v2.2.0 always-follow-the-account behaviour as an opt-in; `config` remains the explicit operator pin. An invalid policy is a startup error naming the setting, not a silent default.
+- A corrupt or unreadable `fleet-home.json` is reported and blocks `home` policy instead of silently creating a new fleet; `account` policy may continue without the history. The file is written atomically with mode 0600 (ACL protection on Windows).
+- Upgrading a paired 2.2.0 machine with no home to 2.2.1 keeps it in its current fleet instead of deriving the account key; an actual account switch is still allowed to make its first join, and that first join is remembered.
+- leet-home.json` now also records the last account code, so a restart can tell `same account, no home yet` (stay put) from a real account switch (first join allowed).
+- Composer target control: selecting a machine now writes a visible `@machine` token into the draft after the host accepts the selection. Switching targets replaces the previous token, and selecting All machines removes it; names containing whitespace use `@"machine name"`. A refused host write reopens the menu with the host’s reason; an editor rejection is shown instead of leaving a stale token.
+
+- Settings page: new `编队绑定` section for machines that must return to an old fleet. It previews the `fleet_id` derived from a pasted key, requires explicit confirmation, then writes an independent `fleet-config.json` (0600) with a timestamped backup and rollback; `cordis.patch.yml` is never modified. The file takes precedence over the profile's `fleetKey`/`fleetKeyPolicy` at startup, and the raw key is never returned by the route.
+- Tests: fleet-config storage/backup/corruption and the preview/save route, including an explicit assertion that the profile patch is untouched.
+## [2.2.0] - 2026-11-01
+
+- Fleet binding policy: `fleetKeyPolicy: account` is the new default. A configured `fleetKey` is a fallback while the signed-in account is authoritative, so switching DeepSeek accounts moves the machine without editing every profile. Set `fleetKeyPolicy: config` to keep the old explicit-pin behaviour.
+- `w2m_status` now reads `device.json` through the `DSH_HOME/xclient` fallback when `stateDir` is unset; it no longer reports `paired: false` / `FLEET_UNPAIRED` on a working machine. The reported fleet is compared against the key the stack actually resolved.
+- Includes the v2.1.10 `spawnSync.status` capture fix and the v2.1.11 profile-refresh fix for a switched account.
+- Breaking: an explicit `fleetKey` no longer pins the fleet by default; add `fleetKeyPolicy: config` to opt out.
+
 ## [2.1.11] - 2026-11-01
 
 - Account switch: refresh the account profile when `getDeviceIdentity()` has no userId. After a DeepSeek account switch the host clears its cached profile, so the identity read returns no userId until someone calls `getProfile()`; the plugin then derived no new fleet key and kept the previous account's token. It now fetches the profile once, derives the new key, detects the fleet mismatch and re-pairs. This is the remaining half of the v2.1.10 account-switch fix.

package/README.md

@@ -92,7 +92,7 @@ w2m-mcp --help
 # 复制进你自己的 codex/mcp-servers.toml
 [mcp_servers.w2m]
 command = "npx"
-args = ["-y", "@twinsearth/w2m-dsh-plugin@2.1.11", "w2m-mcp"]
+args = ["-y", "@twinsearth/w2m-dsh-plugin@2.2.1", "w2m-mcp"]
 ```
 
 ### 5. 验证过的 release tarball（离线）

package/codex/mcp-servers.toml

@@ -12,6 +12,6 @@
 
 [mcp_servers.w2m-fleet]
 command = "npx"
-args = ["-y", "-p", "@twinsearth/w2m-dsh-plugin@2.1.11", "w2m-mcp"]
+args = ["-y", "-p", "@twinsearth/w2m-dsh-plugin@2.2.1", "w2m-mcp"]
 startup_timeout_sec = 20
 tool_timeout_sec = 60

package/docs/acceptance/2.2.0/ACCOUNT-SWITCH-POLICY-2200.json

@@ -0,0 +1,21 @@
+{
+  "version": "2.2.0",
+  "case": "ACCOUNT-SWITCH-POLICY-2200",
+  "kind": "positive",
+  "machines": [
+    "1bef9935-8c13-4dd9-9043-4e025320723f"
+  ],
+  "executed_at": "2026-10-31T20:06:14.655Z",
+  "executor": "lead",
+  "task_id": "account-switch-policy-2200-1793477174656",
+  "requirement": "A DeepSeek account switch must move a machine without per-machine fleetKey edits, while w2m_status must use the same device identity fallback as the other tools",
+  "result": {
+    "outcome": "ok",
+    "assertions": {
+      "policy": "fleetKeyPolicy defaults account; configured key is fallback; config opts out",
+      "status": "w2m_status reads DSH_HOME/xclient device.json when stateDir is unset",
+      "select": "selectFleetKey account/config/no-account tests pass",
+      "account": "profile refresh and fleet mismatch re-pair from 2.1.11"
+    }
+  }
+}

package/docs/acceptance/2.2.1/RELEASE-2210.json

@@ -0,0 +1,31 @@
+{
+  "version": "2.2.1",
+  "case": "RELEASE-2210",
+  "kind": "positive",
+  "machines": [
+    "b53a37f4-1464-4512-9259-33a7df091e3e"
+  ],
+  "executed_at": "2026-11-01T03:05:23.452Z",
+  "executor": "lead",
+  "task_id": "pre-release-2210-1793511923452",
+  "requirement": "v2.2.1: fleet membership returns to the per-account home after an account switch, a first appearance of a new account may join its fleet without moving other machines, and the settings page can pin an old fleet key without editing cordis.patch.yml",
+  "commands": [
+    ["node", "--test", "--test-force-exit", "test/fleet-home.test.mjs", "test/fleet-binding.test.mjs"],
+    ["node", "--test", "--test-force-exit", "test/fleet-config.test.mjs", "test/fleet-config-route.test.mjs"],
+    ["node", "--test", "--test-force-exit", "test/tools.test.mjs"],
+    ["node", "--test", "--test-force-exit", "test/client-bundle.test.mjs"],
+    ["node", "--test", "--test-force-exit", "test/loader-entry.test.mjs"]
+  ],
+  "result": {
+    "outcome": "ok",
+    "assertions": {
+      "fleet_home": "test/fleet-home.test.mjs 6/6: A first join, B first join, B->A returns A's home, account policy does not overwrite home, config pin wins, corrupt home blocks a new fleet, upgrade with an existing token stays put",
+      "fleet_config": "test/fleet-config.test.mjs 4/4 and test/fleet-config-route.test.mjs 3/3: preview does not write, mismatch is shown before saving, save writes fleet-config.json with a backup, a wrong expected fleet_id is refused, and cordis.patch.yml is untouched",
+      "tools": "test/tools.test.mjs 141/141, including w2m_status reading the settings-page pin without printing the key",
+      "bundle": "test/client-bundle.test.mjs 34/34; the 编队绑定 settings section is registered and target @mention tests remain green",
+      "loader": "test/loader-entry.test.mjs 10/10 against the packed 2.2.1 tarball in the real DSH Loader",
+      "lint": "eslint 0 errors; layer-check clean",
+      "scope": "local code, tests and packed artifact only; the release tag is pushed separately; no machine profile was edited by the tests"
+    }
+  }
+}

package/lib/client.js

@@ -103,6 +103,7 @@ const PLUGIN_UPDATE_ROUTE = '/api/w2m/plugin-update';
         costAll: '本次会话的派发会送到所有在线机器',
         costOne: '本次会话的派发会送到 {name}',
         unconfirmed: '（未确认在线）',
+        mentionFailed: '目标已切换，但输入框未能同步 @ 标记；请稍后重新选择该机器',
         targetLabel: '目标机器：{name}',
         unreachable: '无法连接插件',
         routeMissing: '这个 Harness 没有提供插件目标路由',
@@ -176,6 +177,7 @@ const PLUGIN_UPDATE_ROUTE = '/api/w2m/plugin-update';
         costAll: 'Work from this session goes to every online machine',
         costOne: 'Work from this session goes to {name}',
         unconfirmed: ' (not confirmed online)',
+        mentionFailed: 'the target changed, but the composer could not add the @ handle; pick the machine again in a moment',
         targetLabel: 'target machine: {name}',
         unreachable: 'the plugin could not be reached',
         routeMissing: 'this host does not serve the W2M target route',
@@ -1748,7 +1750,336 @@ function UpdateSettingsSection() {
   ]);
 }
 
-function TargetSelect({ sessionId, locked: _locked, t }) {
+    /**
+     * The `@machine` token the target control writes into the composer.
+     *
+     * This is a *visible handle*, not the dispatch decision: the host-side selection store remains
+     * the source of truth, and `w2m_run` reads it from the host process. The token exists so the
+     * operator can see which machine the next turn is aimed at after the menu closes.
+     *
+     * A name that is not a single safe word is quoted, because DSH's own `@` trigger runs to the
+     * next whitespace. A name containing a quote cannot be represented safely and yields null:
+     * the selection still works, it simply gets no token.
+     *
+     * @param {string|null|undefined} name The machine's display name.
+     * @returns {string|null} `@name`, `@"name with spaces"`, or null.
+     */
+    function targetTokenForName(name) {
+      if (typeof name !== 'string') return null;
+      const trimmed = name.trim();
+      if (trimmed === '' || /[\r\n"]/.test(trimmed)) return null;
+      return /^[A-Za-z0-9_-]+$/.test(trimmed) ? `@${trimmed}` : `@"${trimmed}"`;
+    }
+
+    /** Occurrence offsets are clipboard offsets; sort them so both maps walk one order. */
+    function sortedOccurrences(occurrences) {
+      return (Array.isArray(occurrences) ? occurrences : [])
+        .filter((entry) => entry !== null && typeof entry === 'object'
+          && Number.isInteger(entry.offset) && Number.isInteger(entry.length) && entry.length > 0)
+        .slice()
+        .sort((left, right) => left.offset - right.offset);
+    }
+
+    /**
+     * Clipboard offset → editor (detect) offset.
+     *
+     * A reference chip is one U+FFFC in the editor but its whole clipboard text in the draft, so
+     * the two coordinate spaces diverge after every chip. Positions inside a chip are clamped to
+     * its editor position; a token boundary never lands there.
+     */
+    function clipboardToDetect(offset, occurrences) {
+      let shift = 0;
+      for (const occurrence of sortedOccurrences(occurrences)) {
+        if (offset <= occurrence.offset) break;
+        if (offset < occurrence.offset + occurrence.length) return occurrence.offset - shift + 1;
+        shift += occurrence.length - 1;
+      }
+      return offset - shift;
+    }
+
+    /** Editor (detect) offset → clipboard offset; the inverse of {@link clipboardToDetect}. */
+    function detectToClipboard(offset, occurrences) {
+      let shift = 0;
+      for (const occurrence of sortedOccurrences(occurrences)) {
+        const start = occurrence.offset - shift;
+        if (offset <= start) break;
+        if (offset < start + 1) return occurrence.offset;
+        shift += occurrence.length - 1;
+      }
+      return offset + shift;
+    }
+
+    /** Find a token in the draft, requiring a word boundary on both sides. */
+    function targetTokenSpan(draft, token) {
+      if (typeof draft !== 'string' || typeof token !== 'string' || token === '') return null;
+      let from = 0;
+      while (from <= draft.length) {
+        const start = draft.indexOf(token, from);
+        if (start < 0) return null;
+        const before = start === 0 ? '' : draft.charAt(start - 1);
+        const after = draft.charAt(start + token.length);
+        const beforeOk = start === 0 || /\s/.test(before);
+        const afterOk = after === '' || /\s/.test(after) || /[.,;:!?，。；：！？、]/.test(after);
+        if (beforeOk && afterOk) return { start, end: start + token.length };
+        from = start + 1;
+      }
+      return null;
+    }
+
+    /**
+     * The editor span that removes one token without leaving a double word gap.
+     *
+     * Letting a token go and leaving its separating space turns "@alpha run" into " run", which is
+     * visibly not the draft the operator typed. Only one ASCII space is eaten, and a newline is
+     * never eaten: the plugin owns the token, not the paragraph around it.
+     */
+    function targetTokenRemoval(draft, span, occurrences) {
+      let clipboardEnd = span.end;
+      if (draft.charAt(clipboardEnd) === ' ') clipboardEnd += 1;
+      return {
+        start: clipboardToDetect(span.start, occurrences),
+        end: clipboardToDetect(clipboardEnd, occurrences),
+      };
+    }
+
+    /**
+     * Plan the one editor edit that keeps the visible token in step with a target change.
+     *
+     * Rules (all deliberately conservative):
+     *   · switching A → B replaces the old `@A` instead of leaving two targets in the draft;
+     *   · the new token is only inserted when the host accepted the selection;
+     *   · clearing the selection removes only the token this plugin inserted;
+     *   · an existing `@B` is never duplicated;
+     *   · a name that cannot be represented as a token is left alone rather than guessed.
+     *
+     * @returns {{kind: 'none'|'present'|'remove'|'replace'|'insert', text?: string,
+     *   start?: number, end?: number, reason?: string}}
+     */
+    function planTargetMention(input = {}) {
+      const draft = typeof input.draft === 'string' ? input.draft : '';
+      const occurrences = sortedOccurrences(input.occurrences);
+      const caret = input.caret !== null && typeof input.caret === 'object' ? input.caret : {};
+      const nextToken = targetTokenForName(input.nextName);
+      const previousToken = targetTokenForName(input.previousName);
+      const previousSpan = previousToken === null ? null : targetTokenSpan(draft, previousToken);
+
+      if (nextToken === null) {
+        if (previousSpan === null) return { kind: previousToken === null ? 'none' : 'present', reason: 'no-token' };
+        return {
+          kind: 'remove',
+          ...targetTokenRemoval(draft, previousSpan, occurrences),
+          draftRev: Number.isInteger(caret.draftRev) ? caret.draftRev : 0,
+        };
+      }
+
+      const nextSpan = targetTokenSpan(draft, nextToken);
+      if (nextSpan !== null) {
+        if (previousSpan !== null && previousToken !== nextToken) {
+          return {
+            kind: 'remove',
+            ...targetTokenRemoval(draft, previousSpan, occurrences),
+            draftRev: Number.isInteger(caret.draftRev) ? caret.draftRev : 0,
+          };
+        }
+        return { kind: 'present' };
+      }
+
+      if (previousSpan !== null) {
+        return {
+          kind: 'replace',
+          text: nextToken,
+          start: clipboardToDetect(previousSpan.start, occurrences),
+          end: clipboardToDetect(previousSpan.end, occurrences),
+          draftRev: Number.isInteger(caret.draftRev) ? caret.draftRev : 0,
+        };
+      }
+
+      const start = Number.isInteger(caret.start) ? caret.start : 0;
+      const end = Number.isInteger(caret.end) ? caret.end : start;
+      // Inserting at a non-collapsed selection must not consume what the operator selected:
+      // the selection is where their caret is, not text this control owns. Anchor at its end.
+      const at = end;
+      const clipboardAt = detectToClipboard(at, occurrences);
+      const lead = clipboardAt > 0 && !/\s/.test(draft.charAt(clipboardAt - 1)) ? ' ' : '';
+      const tail = /\s/.test(draft.charAt(clipboardAt)) ? '' : ' ';
+      return {
+        kind: 'insert',
+        text: lead + nextToken + tail,
+        start: at,
+        end: at,
+        draftRev: Number.isInteger(caret.draftRev) ? caret.draftRev : 0,
+      };
+    }
+
+    /** Put the caret back in the composer after the menu closes; best effort, never fatal. */
+    function focusComposer() {
+      if (typeof document === 'undefined') return;
+      try {
+        const node = document.querySelector('[data-composer-input]');
+        if (node !== null && typeof node.focus === 'function') node.focus({ preventScroll: true });
+      } catch { /* a detached or re-rendered editor is not an error */ }
+    }
+
+    /** A composition without the input seat keeps the control working, minus the token edit. */
+    function useNoComposerInput() {
+      return null;
+    }
+
+    /** Stable selector: the whole input snapshot, never a fresh derived object. */
+    function selectComposerInput(snapshot) {
+      return snapshot;
+    }
+
+    /**
+     * v2.2.1: the settings-page fleet pin.
+     *
+     * The operator pastes an old fleet key, sees the fleet id it derives, compares that with the
+     * expected id, and only then saves. The host route writes an independent `fleet-config.json`
+     * with a backup; this component never edits `cordis.patch.yml` and never displays the key back.
+     */
+    function FleetConfigSection() {
+      const [state, setState] = React.useState(null);
+      const [keyInput, setKeyInput] = React.useState('');
+      const [expectedId, setExpectedId] = React.useState('');
+      const [preview, setPreview] = React.useState(null);
+      const [confirmed, setConfirmed] = React.useState(false);
+      const [error, setError] = React.useState(null);
+      const [busy, setBusy] = React.useState(false);
+      const [saved, setSaved] = React.useState(null);
+
+      const call = async (init) => {
+        try {
+          const response = await fetch('/api/w2m/fleet-config', {
+            credentials: 'same-origin',
+            headers: { accept: 'application/json', ...(init?.body === undefined ? {} : { 'content-type': 'application/json' }) },
+            ...init,
+          });
+          let body = null;
+          try { body = await response.json(); } catch { body = null; }
+          if (response.status === 404) return { ok: false, routeMissing: true, error: 'this host does not serve the fleet-config route' };
+          if (response.ok !== true || body?.ok === false) {
+            return { ok: false, error: body?.error ?? body?.code ?? `HTTP ${response.status}`, body };
+          }
+          return { ok: true, body };
+        } catch (err) {
+          return { ok: false, error: err instanceof Error ? err.message : String(err) };
+        }
+      };
+
+      const load = React.useCallback(async () => {
+        const result = await call({ method: 'GET' });
+        if (result.ok) setState(result.body);
+        else setError(result.routeMissing ? '当前 DSH 没有编队绑定路由（插件版本过旧或未挂载）' : (result.error ?? '读取失败'));
+      }, []);
+      React.useEffect(() => { load(); }, [load]);
+
+      const previewKey = async () => {
+        const key = keyInput.trim();
+        if (key === '') return;
+        setBusy(true);
+        setError(null);
+        setSaved(null);
+        setConfirmed(false);
+        try {
+          const result = await call({ method: 'POST', body: JSON.stringify({ action: 'preview', fleet_key: key, expected_fleet_id: expectedId.trim() }) });
+          if (!result.ok) { setPreview(null); setError(result.error ?? '无法计算 fleet_id'); return; }
+          setPreview(result.body);
+        } finally { setBusy(false); }
+      };
+
+      const save = async () => {
+        const key = keyInput.trim();
+        if (key === '' || preview === null || confirmed !== true) return;
+        setBusy(true);
+        setError(null);
+        try {
+          const result = await call({
+            method: 'POST',
+            body: JSON.stringify({ action: 'save', fleet_key: key, expected_fleet_id: preview.fleet_id }),
+          });
+          if (!result.ok) { setError(result.error ?? '保存失败'); return; }
+          setSaved(result.body);
+          setKeyInput('');
+          setPreview(null);
+          setConfirmed(false);
+          await load();
+        } finally { setBusy(false); }
+      };
+
+      const expectedMismatch = preview !== null && expectedId.trim() !== ''
+        && String(preview.fleet_id).toLowerCase() !== expectedId.trim().toLowerCase();
+      const mono = { fontFamily: 'ui-monospace, SFMono-Regular, Menlo, Consolas, monospace', wordBreak: 'break-all' };
+      return h('div', { className: 'w2mGpw_admin' }, [
+        h('div', { key: 'head', className: 'w2mGpw_adminHead' }, [
+          h('h1', { key: 'h', className: 'w2mGpw_adminTitle' }, '编队绑定'),
+          h('div', { key: 'sub', className: 'w2mGpw_adminSub' },
+            '把本机固定到指定编队。保存到独立的 fleet-config.json（0600），不改 cordis.patch.yml；保存后重启 DSH 才生效。'),
+        ]),
+        error === null ? null : h('div', { key: 'err', className: 'w2mGpw_adminNote' }, error),
+        h('div', { key: 'current', className: 'w2mGpw_adminCard' }, [
+          h('div', { key: 's', className: 'w2mGpw_adminSub' }, state === null
+            ? '读取中…'
+            : state.configured === true
+              ? `已配置 · policy ${String(state.policy ?? '?')} · 指纹 ${String(state.fingerprint ?? '').slice(0, 12)}`
+              : '未配置：当前按 fleetKeyPolicy 的默认策略绑定'),
+          state?.fleet_id ? h('div', { key: 'id', style: mono }, 'fleet_id: ' + state.fleet_id) : null,
+          state?.path ? h('div', { key: 'p', className: 'w2mGpw_adminSub' }, '文件：' + state.path) : null,
+        ]),
+        h('div', { key: 'form', className: 'w2mGpw_adminCard' }, [
+          h('div', { key: 'row', className: 'w2mGpw_adminToolbar' }, [
+            h('input', {
+              key: 'k',
+              className: 'w2mGpw_adminInput',
+              type: 'password',
+              value: keyInput,
+              placeholder: '旧 fleet key（保存后只显示指纹，不回显）',
+              onChange: (event) => { setKeyInput(event.target.value); setPreview(null); setConfirmed(false); },
+            }),
+            h('button', { key: 'c', type: 'button', className: 'w2mGpw_adminBtn', disabled: busy || keyInput.trim() === '', onClick: previewKey }, '计算 fleet_id'),
+          ]),
+          h('div', { key: 'row2', className: 'w2mGpw_adminToolbar', style: { marginTop: '8px' } }, [
+            h('input', {
+              key: 'e',
+              className: 'w2mGpw_adminInput',
+              value: expectedId,
+              placeholder: '期望的 fleet_id（可选，例如 004945ed…）',
+              onChange: (event) => { setExpectedId(event.target.value); setConfirmed(false); },
+            }),
+          ]),
+          preview === null ? null : h('div', { key: 'preview', style: { marginTop: '12px' } }, [
+            h('div', { key: 'l', className: 'w2mGpw_adminSub' }, '这个 key 算出的 fleet_id：'),
+            h('div', { key: 'id', style: { ...mono, margin: '4px 0 8px' } }, String(preview.fleet_id)),
+            expectedMismatch
+              ? h('div', { key: 'bad', className: 'w2mGpw_adminNote' }, '与期望值不一致，不能保存。请核对 key 或期望值。')
+              : h('label', { key: 'ok', className: 'w2mGpw_adminSub', style: { display: 'flex', gap: '8px', alignItems: 'center' } }, [
+                  h('input', {
+                    key: 'c',
+                    type: 'checkbox',
+                    checked: confirmed,
+                    disabled: expectedMismatch,
+                    onChange: (event) => setConfirmed(event.target.checked),
+                  }),
+                  h('span', { key: 't' }, '我确认这是目标编队，保存并固定'),
+                ]),
+            h('button', {
+              key: 'save',
+              type: 'button',
+              className: 'w2mGpw_adminBtn',
+              style: { marginTop: '8px' },
+              disabled: busy || confirmed !== true || expectedMismatch,
+              onClick: save,
+            }, '保存并固定到该编队'),
+          ]),
+          saved === null ? null : h('div', { key: 'saved', className: 'w2mGpw_adminNote' }, [
+            h('div', { key: 'a' }, '已保存。重启 DSH 后生效；本页不会自动重启。'),
+            h('div', { key: 'b', style: mono }, 'fleet_id: ' + String(saved.fleet_id ?? '')),
+            saved.backup ? h('div', { key: 'c' }, '备份：' + saved.backup) : null,
+          ]),
+        ]),
+      ]);
+    }
+
+    function TargetSelect({ sessionId, locked: _locked, t, inputActions, useInput }) {
       const [open, setOpen] = React.useState(false);
       // v1.5.1: relay folding. The snapshot carries the pool; when it holds more than three nodes
       // the menu shows a summary and this toggle reveals the folded ones.
@@ -1756,11 +2087,29 @@ function TargetSelect({ sessionId, locked: _locked, t }) {
       const [reloadSeq, setReloadSeq] = React.useState(0);
       const [state, setState] = React.useState(null);
       const [error, setError] = React.useState(null);
+      // A write/edit refusal is not a fleet-read failure: the menu is closed when it happens, so
+      // keeping it beside `error` (which a successful read clears) is what makes it survive the
+      // reopen that shows it to the operator.
+      const [notice, setNotice] = React.useState(null);
       const [busy, setBusy] = React.useState(false);
       const anchorRef = React.useRef(null);
       const menuRef = React.useRef(null);
       const [placement, setPlacement] = React.useState(null);
 
+      // v2.3.0: the target control also writes a visible `@machine` token. `inputActions` and
+      // `useInput` are standard session props (dsh-client-ui-conversation provides them to every
+      // session slot); a host that does not carry them still gets the selector, just no token.
+      const useComposerInput = typeof useInput === 'function' ? useInput : useNoComposerInput;
+      const input = useComposerInput(selectComposerInput);
+      const inputRef = React.useRef(input);
+      inputRef.current = input;
+      // Session switches are per mount in the shell, but a write can still land after the prop
+      // changed under a reused component. The ref reads the current value at resolve time; the
+      // sequence makes the last click win when two writes are in flight.
+      const sessionRef = React.useRef(sessionId);
+      sessionRef.current = sessionId;
+      const writeSeq = React.useRef(0);
+
       // The host half is the source of truth, so every read replaces the mirror rather than merging
       // into it: a stale "online" must not outlive the answer that disproved it.
       React.useEffect(() => {
@@ -1832,7 +2181,7 @@ function TargetSelect({ sessionId, locked: _locked, t }) {
       const machines = Array.isArray(state?.machines) ? state.machines : [];
       // v1.5.1: the relay pool the host probed, already folded. `null` means a single-relay host.
       const relayFold = state?.relays ?? null;
-      const problem = error ?? fleetProblem(state, t);
+      const problem = notice ?? error ?? fleetProblem(state, t);
       const disabled = typeof sessionId !== 'string' || sessionId === '';
       const label = state === null ? (provisionalLabel(state) ?? t('machine')) : labelOf(state, t);
       const selectedMachine = machines.find((machine) => machine.machine_id === chosen) ?? null;
@@ -1846,21 +2195,92 @@ function TargetSelect({ sessionId, locked: _locked, t }) {
         ? t('costAll')
         : `${t('costOne', { name: label })}${selectedOnline === true ? '' : t('unconfirmed')}`);
 
+      /**
+       * Apply the one editor edit that mirrors a target change.
+       *
+       * Ordering matters: the host write happens first, so a token is never left claiming a target
+       * the host refused. The edit is best effort — a composer that is submitting, or a host
+       * without `inputActions`, keeps the selection and simply loses the visible handle.
+       */
+      const applyTargetMention = (nextName, previousName) => {
+        if (inputActions === null || typeof inputActions !== 'object'
+          || typeof inputActions.insertText !== 'function'
+          || typeof inputActions.captureInsertion !== 'function') {
+          focusComposer();
+          return;
+        }
+        const capture = inputActions.captureInsertion();
+        if (capture === null || typeof capture !== 'object') {
+          focusComposer();
+          return;
+        }
+        const current = inputRef.current ?? {};
+        // `captureInsertion()` is the editor's current revision; `inputRef.current` is the last
+        // published snapshot. If they disagree, the draft these offsets were computed from is not
+        // the draft the editor holds, and `draftRev` would let a stale offset through.
+        if (Number.isInteger(current.draftRev) && current.draftRev !== capture.draftRev) {
+          focusComposer();
+          return;
+        }
+        const plan = planTargetMention({
+          draft: typeof current.draft === 'string' ? current.draft : '',
+          occurrences: current.occurrences,
+          caret: capture,
+          nextName,
+          previousName,
+        });
+        if (plan.kind === 'insert' || plan.kind === 'replace' || plan.kind === 'remove') {
+          const text = plan.kind === 'remove' ? '' : plan.text;
+          const applied = inputActions.insertText(text, {
+            start: plan.start,
+            end: plan.end,
+            draftRev: capture.draftRev,
+          });
+          if (applied !== true) {
+            setNotice(t('mentionFailed'));
+            setOpen(true);
+          } else {
+            setNotice(null);
+          }
+        } else {
+          setNotice(null);
+        }
+        focusComposer();
+      };
+
       const choose = (machineId, machineName) => {
         setOpen(false);
-        if (machineId === chosen) return;
+        const previousName = selectedMachine?.name ?? state?.selected?.name ?? null;
+        if (machineId === chosen) {
+          // Clicking the current target restores a token the operator deleted, but never turns
+          // the click into a destructive "clear" gesture: clearing is the All-machines row.
+          setNotice(null);
+          applyTargetMention(machineId === null ? null : previousName, null);
+          return;
+        }
+        const seq = (writeSeq.current += 1);
+        const at = sessionId;
         setBusy(true);
         writeSelection(sessionId, machineId, machineName).then((result) => {
+          if (seq !== writeSeq.current) return; // a later click owns the answer
+          if (at !== sessionRef.current) return; // the session changed while the write was in flight
           setBusy(false);
           if (result.ok) {
             setState(result.state);
             setError(null);
+            setNotice(null);
+            if (machineId === null) {
+              applyTargetMention(null, previousName);
+              return;
+            }
+            applyTargetMention(result.state?.selected?.name ?? machineName ?? null, previousName);
             return;
           }
           // The write is refused for a reason the operator can act on (the machine went away, the
-          // fleet could not be read), so it is shown where they are looking rather than swallowed.
-          setError(result.error);
-          setReloadSeq((seq) => seq + 1);
+          // fleet could not be read). Reopen the menu so `notice` is actually in front of them.
+          setNotice(result.error);
+          setOpen(true);
+          setReloadSeq((reload) => reload + 1);
         });
       };
 
@@ -2848,6 +3268,20 @@ const CHAT_EMOJIS = CHAT_COMMANDS;
         } catch (error) {
           console.error('@twinsearth/w2m-dsh-plugin: the GPW settings tab was not mounted', error);
         }
+        // v2.2.1: the supported alternative to editing cordis.patch.yml. The section is its own
+        // settings card so an operator can find "where do I put the old fleet key?" without
+        // touching a profile file.
+        try {
+          slots.inject('settings.section', () => slots.register({
+            name: 'settings.section',
+            id: 'w2m-fleet',
+            order: 11,
+            label: () => '编队绑定',
+            inject: () => ({ t }),
+          }, FleetConfigSection));
+        } catch (error) {
+          console.error('@twinsearth/w2m-dsh-plugin: the fleet-binding settings section was not mounted', error);
+        }
         // v1.9.4: the update controls belong on the plugin's own page (same page as Uninstall),
         // not only in the global settings list.
         try {
@@ -3008,6 +3442,8 @@ const CHAT_EMOJIS = CHAT_COMMANDS;
     exports.apply = apply;
     exports.inject = inject;
     exports.TargetSelect = TargetSelect;
+    exports.targetTokenForName = targetTokenForName;
+    exports.planTargetMention = planTargetMention;
     exports.GpwLauncher = GpwLauncher;
     exports.GpwPrompt = GpwPrompt;
       exports.FleetChat = FleetChat;