dsh-remote-vs 0.9.2 → 0.10.0

package/lib/index.js

@@ -4006,7 +4006,7 @@ const Config = z.object({
 		"off",
 		"shadow",
 		"enforce"
-	]).default("off").volatile(),
+	]).default("enforce").volatile(),
 	gitTimeoutMs: z.number().step(1).min(MIN_TIMEOUT_MS).max(MAX_TIMEOUT_MS).default(DEFAULT_GIT_TIMEOUT_MS).volatile(),
 	readTimeoutMs: z.number().step(1).min(MIN_TIMEOUT_MS).max(MAX_TIMEOUT_MS).default(DEFAULT_READ_TIMEOUT_MS).volatile()
 });
@@ -4063,7 +4063,7 @@ function apply(ctx, config) {
 	const worlds = new RemoteWorlds(ctx, {
 		store,
 		pool,
-		mode: () => readField(config?.routingMode, "off")
+		mode: () => readField(config?.routingMode, "enforce")
 	});
 	ctx.provide("remoteWorlds", worlds);
 	ctx.effect(() => () => {

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

@@ -95,7 +95,11 @@ interface InputSnapshot {
     draft: string;
     draftRev?: number;
     occurrences?: readonly OccurrenceLike[];
-    phase?: 'plain' | 'adjudicating' | 'claimed' | 'submitting';
+    /**
+     * Host submission plane. `sending` exists since DSH 0.2.2-alpha.2: an ordinary
+     * message the host has not accepted yet — the editor is read-only there too.
+     */
+    phase?: 'plain' | 'adjudicating' | 'claimed' | 'submitting' | 'sending';
     claim?: {
         readonly token: string;
     };

package/lib/types/client/scm/HistoryPanel.d.ts

@@ -7,6 +7,11 @@
  * repository shows the newest GIT_LOG_MAX commits and is filtered client-side.
  * The docstring here used to promise scroll-triggered paging that does not
  * exist, which is worse than no comment: a reader trusts it.
+ *
+ * Each repository's last answer is kept in memory (`./panel-cache.ts`), so a
+ * switch back to a workspace repaints its commit list at once and the log is
+ * re-read behind it — the tab used to blank on every switch, and worse, kept the
+ * PREVIOUS repository's rows until the new log arrived.
  */
 import { type ReactNode } from 'react';
 export declare function HistoryPanel(): ReactNode;

package/lib/types/client/scm/actions.d.ts

@@ -16,6 +16,31 @@ export declare class GitOpError extends Error {
 export declare function joinRemote(dir: string, rel: string): string;
 /** The repository that encloses a workspace directory (undefined when none). */
 export declare function resolveRepoRoot(alias: string, workspaceRoot: string): Promise<string | undefined>;
+/**
+ * The same probe, telling "not a repository" apart from "the probe failed".
+ *
+ * `git rev-parse --show-toplevel` exits non-zero BOTH when the directory is not
+ * inside a work tree and for every way a remote command can fail (host gone,
+ * budget blown, sshd refusing, no answer at all). `resolveRepoRoot` folds the two
+ * into `undefined`, which is right for the workspace wizard — there "unknown" and
+ * "none" both mean "nothing to offer". The SCM panel cannot take that shortcut:
+ * treating a failed probe as "no repository" writes an EMPTY snapshot over the
+ * cached change list and tells the user their workspace has no git repository.
+ * That is exactly the blank state the snapshot cache exists to prevent, so this
+ * variant asks a command that KEEPS the answer (`repoProbeDetailCommand`: exit
+ * code + merged streams, `LC_ALL=C`) and reports the failure to the caller.
+ */
+export type RepoRootProbe = {
+    kind: 'repo';
+    root: string;
+} | {
+    kind: 'none';
+} | {
+    kind: 'failed';
+    error: string;
+};
+/** The repository root, or WHY the probe could not answer. */
+export declare function probeRepoRoot(alias: string, workspaceRoot: string): Promise<RepoRootProbe>;
 /** Repositories under a workspace root (the workspace itself sorts first). */
 export declare function findRepos(alias: string, workspaceRoot: string): Promise<string[]>;
 /** Every changed path plus the ignored half. */

package/lib/types/client/scm/git-cache.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Last-read git state, remembered per workspace AND per repository directory.
+ *
+ * The complaint this module answers: switching between two remote workspaces
+ * blanked the source-control panel. The store dropped `status` / `head` /
+ * `repoRoot` on the switch and started a full `git status` again — minutes of
+ * "Loading…" on a large repository — even though BOTH workspaces had just been
+ * read, so the very data the panel needed was already in memory. It simply had
+ * no home: the store keeps one git slice, describing whatever is on screen.
+ *
+ * A snapshot is that home. It holds everything the panel paints from, keyed by
+ * the binding id AND the workspace-relative directory git ran in, because one
+ * workspace can carry several repositories and their states must never
+ * overwrite each other (the repo picker switches between them). The store
+ * hydrates a snapshot the moment a workspace is selected — in the same frame as
+ * the dropdown change — and refreshes it in the background; the read replaces
+ * the snapshot and repaints only when it is still the current binding's answer.
+ *
+ * MEMORY ONLY, on purpose: a `-u normal -z --ignored=matching` status of a
+ * monorepo is hundreds of kilobytes, and after a page reload it would describe
+ * a tree that may have moved on. The cache is an accelerator for switching, not
+ * a second source of truth — every value in it was read by a real command.
+ */
+import type { GitStatusDetail } from '../../protocol.ts';
+import type { DirExpansions } from './untracked-dirs.ts';
+/**
+ * Branch header, structurally identical to the store's `HeadInfo`.
+ *
+ * Declared here instead of imported from `store.tsx` so this module stays a
+ * standalone leaf: `store` imports it, and a type-only back-import would pull
+ * the whole store into the module graph of every gate that touches the cache.
+ */
+export interface GitHead {
+    branch: string;
+    detached: boolean;
+    ahead: number;
+    behind: number;
+}
+/** Everything one git read answered, as the panels need it. */
+export interface GitSnapshot {
+    /** Enclosing repository root, or undefined when the directory is no repo. */
+    repoRoot: string | undefined;
+    /** Workspace-relative directory git ran in (the settled one). */
+    repoSubdir: string;
+    status: GitStatusDetail;
+    head: GitHead | undefined;
+    /** git answered "not a repository" — a fact, not a failure. */
+    repoMissing: boolean;
+    /** Expanded untracked directories, repository-relative. */
+    untrackedDirs: DirExpansions;
+    /** `Date.now()` when the read that produced this snapshot finished. */
+    at: number;
+}
+/** Cache key for one (workspace, repository directory) pair. */
+export declare function gitCacheKey(bindingId: string, repoSubdir: string): string;
+/** Split a cache key back into its two halves (undefined when it is not one). */
+export declare function parseGitCacheKey(key: string): {
+    bindingId: string;
+    repoSubdir: string;
+} | undefined;
+/** The cached read for one (workspace, repository directory), if any. */
+export declare function readGitSnapshot(key: string): GitSnapshot | undefined;
+/**
+ * Remember one read.
+ *
+ * Called even when the read is no longer the binding on screen: the walk has
+ * already been paid for, and caching it is what makes the NEXT switch back
+ * instant instead of another minutes-long wait.
+ *
+ * An answer OLDER than the one already cached is dropped. Two reads of one
+ * workspace can overlap when the repo picker changes the directory mid-read (the
+ * settled directory is a second key, see the store's `readGit`), and the older
+ * walk may finish last — letting it win would hand the user a change list that
+ * predates the one already shown.
+ */
+export declare function writeGitSnapshot(key: string, snapshot: GitSnapshot): void;
+/** Drop every snapshot whose workspace left the binding table. */
+export declare function retainGitSnapshots(bindingIds: ReadonlySet<string>): void;
+/**
+ * Write a locally-known status into a cached snapshot.
+ *
+ * The plotted stage/unstage move is applied to the store's status WITHOUT a
+ * repository-wide read (see `applyLocalStage`). Without this write-through the
+ * cache would keep the pre-click list, so switching away and back would flip
+ * the row back — the panel would show a change the user already staged.
+ * A different `repoRoot` means the snapshot is not that repository: refusing is
+ * what keeps one workspace's rows out of another's cache.
+ */
+export declare function patchCachedGitStatus(key: string, repoRoot: string | undefined, status: GitStatusDetail): void;
+/** Same write-through for the expanded untracked directories. */
+export declare function patchCachedUntrackedDirs(key: string, repoRoot: string | undefined, dirs: DirExpansions): void;
+/** Test hook: forget every snapshot (the cache gate drives this module alone). */
+export declare function clearGitSnapshots(): void;

package/lib/types/client/scm/panel-cache.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Per-repository caches for the two views that live beside the change list:
+ * the source-control panel's side lists (stash / branches / remotes) and the
+ * history tab's commit log.
+ *
+ * Same reasoning as `git-cache.ts`, one level down: the git status snapshot
+ * already makes the change list paint instantly when a workspace is selected
+ * again, and these caches stop the second wave of blanks. The extras are three
+ * more git commands per repository switch; the log is up to 200 commits (`git
+ * log` on a deep monorepo is not free). Both are read-only views of state the
+ * host already answered — keeping the last answer costs nothing and is what the
+ * panels show while their background re-read runs.
+ *
+ * MEMORY ONLY, same contract as the git snapshots, and every entry is replaced
+ * by a real read; nothing is ever synthesised here.
+ */
+import type { GitBranch, GitCommit, GitRemote, GitStash } from '../../protocol.ts';
+/** Stash / branch / remote lists of one repository (one panel refresh). */
+export interface ScmExtrasSnapshot {
+    stashes: GitStash[];
+    branches: GitBranch[];
+    remotes: GitRemote[];
+    /** `Date.now()` when the read finished. */
+    at: number;
+}
+/** The history tab's commit list of one repository. */
+export interface HistorySnapshot {
+    commits: GitCommit[];
+    /** `Date.now()` when the read finished. */
+    at: number;
+}
+/** Cache key of one repository, as the git panel addresses it: alias + root. */
+export declare function repoCacheKey(alias: string, repoRoot: string): string;
+/** The cached side lists of one repository, if it was read before. */
+export declare function readScmExtras(key: string): ScmExtrasSnapshot | undefined;
+/** Remember one repository's side lists. */
+export declare function writeScmExtras(key: string, snapshot: ScmExtrasSnapshot): void;
+/** The cached commit log of one repository, if it was read before. */
+export declare function readHistorySnapshot(key: string): HistorySnapshot | undefined;
+/** Remember one repository's commit log. */
+export declare function writeHistorySnapshot(key: string, snapshot: HistorySnapshot): void;
+/** Test hook: forget both caches (the panel caches carry no other state). */
+export declare function clearPanelCaches(): void;

package/lib/types/client/scm/read-queue.d.ts

@@ -0,0 +1,74 @@
+/**
+ * One remote read at a time, per key — with two honest contracts.
+ *
+ * Why this exists
+ * ---------------
+ * Git reads are expensive on a large repository: `loadStatusDetail` walks the
+ * whole index and worktree (minutes on the AOSP monorepo), and several surfaces
+ * can ask for one at the same moment — the workspace dropdown, the session
+ * follow, the panel's ⟳, and every write made through the plugin. Until now each
+ * caller simply started its own command and the newest one won the paint, which
+ * meant two concurrent walks of the same tree and a panel that could not tell
+ * which answer was current.
+ *
+ * The queue replaces that with:
+ *
+ * - `join`  — "show me a read of this key". A read already in flight is shared:
+ *             starting a second one would only duplicate the same walk, so a
+ *             workspace switch costs nothing when the previous read of that
+ *             workspace is still running.
+ * - `fresh` — "the answer must describe the state as of NOW" (the ⟳ button, and
+ *             every write: a save, a commit, a stage verb). It never shares a
+ *             read that started before the call: it waits for the running one to
+ *             settle and then starts its own. Two `fresh` callers that arrive
+ *             during the same read share the SINGLE follow-up read, because the
+ *             second one can see that the follow-up started after its own call.
+ *
+ * Reads for DIFFERENT keys run in parallel: two workspaces are two repositories,
+ * and making one wait for the other would make a switch feel dead. Nothing here
+ * paints anything — the caller decides what its answer may overwrite — so the
+ * queue carries no store/React knowledge and is directly testable.
+ */
+/** How a caller relates to a read that is already in flight. */
+export type ReadMode = 'join' | 'fresh';
+export declare class ReadQueue {
+    private readonly onChange?;
+    /** In-flight reads by key (insertion order is irrelevant here). */
+    private readonly flights;
+    private nextId;
+    /**
+     * @param onChange - called whenever a read starts or settles, so the owner can
+     *   derive a "busy" flag from `inflightKeys()` without polling.
+     */
+    constructor(onChange?: (() => void) | undefined);
+    /** The keys with a read in flight (a caller derives its busy state from this). */
+    inflightKeys(): string[];
+    /** True while ONE key has a read in flight. */
+    isBusy(key: string): boolean;
+    /**
+     * Run `read` for `key`, honouring `mode`.
+     *
+     * The returned promise settles with this key's answer: a rejection comes from
+     * the read the caller ended up waiting on (its own, or the one it joined).
+     * `read` must be equivalent for every caller that passes the same key — the
+     * queue keeps only the FIRST caller's closure, because a joined read cannot
+     * carry a second closure.
+     *
+     * @param settleMs - hard settle deadline for a read THIS call starts (`0` =
+     *   unbounded). A joined read keeps the deadline it was started with: its
+     *   caller already decided how long that read may take.
+     */
+    run<T>(key: string, read: () => Promise<T>, mode?: ReadMode, settleMs?: number): Promise<T>;
+    /**
+     * `fresh` while a read is in flight: wait for it, then read once more.
+     *
+     * The follow-up is NOT started from here unconditionally, or two `fresh`
+     * callers that arrived during the same read would each start one (two
+     * concurrent walks, exactly what this class exists to prevent). The second
+     * caller instead finds a flight whose id is newer than the one it waited on —
+     * a read that started after its own call — and shares it.
+     */
+    private after;
+    /** Register a flight and run `read`; a synchronous throw becomes a rejection. */
+    private start;
+}

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

@@ -149,6 +149,8 @@ export interface ExplorerValue {
     head: HeadInfo | undefined;
     gitBusy: boolean;
     gitError: string | undefined;
+    /** The painted git slice is a cached one; a background refresh is running. */
+    gitCached: boolean;
     /** Effective per-git-command budget (ms), for the loading hint. */
     gitDeadlineMs: number;
     tabs: EditorTab[];
@@ -199,7 +201,16 @@ export interface ExplorerValue {
     /** Repositories found under the workspace root, as workspace-relative dirs. */
     discoverRepos: () => Promise<string[]>;
     refreshAll: () => void;
-    refreshGit: () => Promise<void>;
+    /**
+     * Re-read git for the binding on screen.
+     *
+     * `join` shares a read that is already in flight — the right contract for an
+     * automatic refresh, since a second walk of the same repository answers
+     * exactly the same question. `fresh` (the default) waits for a running read
+     * and then reads again: the answer must include whatever the caller just
+     * wrote.
+     */
+    refreshGit: (mode?: 'join' | 'fresh') => Promise<void>;
     afterWrite: () => Promise<void>;
     /**
      * Stage / unstage paths: the row moves at once, and ONE path-limited status
@@ -394,8 +405,25 @@ export declare function selectedWorkspaceId(): string;
 export declare function setRepoSubdir(subdir: string): Promise<void>;
 /** Repositories found under the workspace root (workspace-relative, root first). */
 export declare function discoverRepos(): Promise<string[]>;
-/** Re-read git status for the current binding. */
-export declare function refreshGit(): Promise<void>;
+/**
+ * Re-read git for the binding on screen.
+ *
+ * Reads go through `scm/read-queue.ts`, keyed by (binding, repository directory):
+ * `join` shares a read that is already in flight — an automatic refresh has no
+ * reason to duplicate a walk — while `fresh` waits for it and then reads again,
+ * because the caller just wrote something and the answer must include it. Either
+ * mode never runs two walks of the same repository at once, which is what lets a
+ * background refresh and the ⟳ button coexist instead of racing.
+ *
+ * The answer is cached under the key the read STARTED with (even when the user
+ * has already switched away: the walk is paid for either way, and the cache is
+ * what makes the next visit instant) and repaints only while it is still that
+ * binding's latest read.
+ *
+ * @param mode - `fresh` (default) never reuses a read that started before the
+ *   call; `join` shares a running one (workspace switches, bootstrap).
+ */
+export declare function refreshGit(mode?: 'join' | 'fresh'): Promise<void>;
 /** Refresh everything a working-tree change can invalidate. */
 export declare function afterWrite(): Promise<void>;
 /** The repository the SCM panel is pointed at, or undefined when none. */
@@ -403,6 +431,25 @@ export declare function scmTarget(): {
     alias: string;
     root: string;
 } | undefined;
+/**
+ * Read-only view of the git slice, for callers that do not render.
+ *
+ * The UI reads the same values through `useExplorer()`; this getter exists for
+ * the local gates, which drive this module in node with nothing mounted (they
+ * need to observe the switch, the cached flag and what a failed read left
+ * behind). It hands out primitives only, so no caller can mutate the store
+ * through it.
+ */
+export declare function gitState(): {
+    workspaceId: string;
+    repoRoot: string | undefined;
+    repoSubdir: string;
+    changes: number;
+    gitBusy: boolean;
+    gitCached: boolean;
+    gitError: string | undefined;
+    repoMissing: boolean;
+};
 /**
  * Move paths between the index and the worktree halves of the LOCAL status
  * model — the optimistic update, its rollback, and the correction the probe
@@ -446,6 +493,22 @@ export declare function stageOptimistic(paths: readonly string[], staged: boolea
  * @param dirPath - the directory row's repo-relative path (with its `/`).
  */
 export declare function toggleUntrackedDir(dirPath: string): Promise<void>;
+/**
+ * Hard settle deadline for ONE queued git read (`scm/read-queue.ts`).
+ *
+ * A read that never settles would keep its key reserved forever: later `join`
+ * calls reuse the dead promise, `fresh` callers wait for it, and the busy flag
+ * stays up — one hung host call would freeze that key for the rest of the page
+ * (the pre-cache code could always re-read, so this is the one regression a
+ * shared flight introduces). The bound is generous on purpose: the status read
+ * issues its probe and then its two loaders SEQUENTIALLY, so twice the configured
+ * git budget plus slack is "stuck", not "slow".
+ *
+ * Exported because the panels own their own queues (SCM side lists, history log)
+ * and must pass the same bound — a queue without one is a permanent lock waiting
+ * for a host hiccup.
+ */
+export declare function gitReadSettleMs(): number;
 /** Open (or focus) a remote file in the editor tab strip. */
 export declare function openFile(fullPath: string, options?: {
     line?: number;

package/lib/types/git-ops.d.ts

@@ -15,6 +15,25 @@ export declare function assertRemoteName(name: string): string;
 export declare function assertRemoteUrl(url: string): string;
 /** Resolve the enclosing repository root (fails outside a work tree). */
 export declare function repoProbeCommand(workdir: string): string;
+/**
+ * Repository probe that keeps the ANSWER (exit code + both streams) on stdout.
+ *
+ * `repoProbeCommand` throws the exit code and stderr away — everything that is
+ * not a root line reads as "nothing". That is fine for the workspace wizard
+ * ("nothing to offer") but not for the SCM panel, where "this is not a
+ * repository" and "git could not answer" are DIFFERENT states: the first is a
+ * fact that may be cached, the second must keep the last known change list and
+ * report the reason. So this command always exits 0 and prints
+ *
+ *     RVS_RC=<git exit code>
+ *     <everything git wrote, stderr merged>
+ *
+ * `LC_ALL=C` pins git's wording (the client matches `not a git repository`; a
+ * localized host would otherwise read as a failure), and merging the streams is
+ * what makes that message survive — git writes it to stderr, which the plain
+ * probe discards.
+ */
+export declare function repoProbeDetailCommand(workdir: string): string;
 /** Discover repositories under a workspace root (depth-capped). */
 export declare function repoDiscoveryCommand(root: string): string;
 /**
@@ -143,6 +162,25 @@ export declare function initCommand(workdir: string): string;
 export declare function applyPatchCommand(workdir: string, patchPath: string, mode: 'stage' | 'unstage' | 'revert'): string;
 /** Enclosing repository root from `rev-parse --show-toplevel`. */
 export declare function parseRepoRoot(stdout: string): string | undefined;
+/** One strict probe's answer (see `repoProbeDetailCommand`). */
+export type RepoProbeAnswer = {
+    kind: 'repo';
+    root: string;
+} | {
+    kind: 'none';
+} | {
+    kind: 'failed';
+    error: string;
+};
+/**
+ * Parse `repoProbeDetailCommand`'s output into the three states the panel needs.
+ *
+ * "not a git repository" is matched on git's own message rather than on the exit
+ * code: `rev-parse` exits 128 for that AND for a directory it cannot enter, so
+ * the code alone cannot separate the two. The message is guaranteed English by
+ * the command's `LC_ALL=C`.
+ */
+export declare function parseRepoProbe(stdout: string): RepoProbeAnswer;
 /** Repository dirs found under a workspace root. */
 export declare function parseRepoDiscovery(stdout: string): string[];
 /**

package/lib/types/index.d.ts

@@ -39,6 +39,11 @@ export interface Config {
     /**
      * P2 transparent-routing kill-switch: off = pure local passthrough;
      * shadow = log remote decisions but execute locally; enforce = route.
+     *
+     * The DEFAULT is `enforce`: the plugin exists to execute remote workspaces
+     * remotely, and a fresh profile that silently kept executing locally was the
+     * most common "why is nothing remote" report. `off`/`shadow` stay available as
+     * explicit opt-outs for debugging and for hosts that must stay local.
      */
     routingMode?: RoutingMode;
     /** Per-command timeout for git work on a remote host (ms). */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-remote-vs",
   "description": "VSCode-style remote development for DSH: SSH host manager (key/password), helper deploy pipeline with version check, remote file explorer + editor + terminal in dsh-better-sidebar.",
-  "version": "0.9.2",
+  "version": "0.10.0",
   "icon": "icon.svg",
   "keywords": [
     "dsh",
@@ -59,7 +59,7 @@
     "./locale/*.json": "./locale/*.json"
   },
   "engines": {
-    "dsh": ">=0.2.1-alpha.3 <0.3.0"
+    "dsh": ">=0.2.2-alpha.2 <0.3.0"
   },
   "dsh": {
     "bundle": {
@@ -122,7 +122,7 @@
     "@codemirror/view": "^6.43.14",
     "@deepseek-ai/dsh-fs-ssh": "0.2.1-rc.2",
     "@deepseek-ai/dsh-ssh": "0.2.1-rc.2",
-    "@deepseek-ai/schemastery": "3.18.5",
+    "@deepseek-ai/schemastery": "3.18.6-alpha.1",
     "@lezer/highlight": "1.2.3",
     "@xterm/addon-fit": "^0.11.0",
     "@xterm/xterm": "^6.0.0",
@@ -130,44 +130,44 @@
     "zod": "4.4.3"
   },
   "peerDependencies": {
-    "@deepseek-ai/cordis": "^4.0.5-alpha.2",
-    "@deepseek-ai/dsh-agent-preset": "^0.2.1-rc.2",
-    "@deepseek-ai/dsh-bash-local": "^0.2.1-rc.2",
-    "@deepseek-ai/dsh-file-reference": "^0.2.1-rc.2",
-    "@deepseek-ai/dsh-fs": "^0.2.1-rc.2",
-    "@deepseek-ai/dsh-shell": "^0.2.1-rc.2",
-    "@deepseek-ai/dsh-spill": "^0.2.1-rc.2",
-    "@deepseek-ai/dsh-subprocess": "^0.2.1-rc.2",
-    "@deepseek-ai/dsh-tools": "^0.2.1-rc.2",
+    "@deepseek-ai/cordis": "^4.0.6-alpha.1",
+    "@deepseek-ai/dsh-agent-preset": "^0.2.2-alpha.2",
+    "@deepseek-ai/dsh-bash-local": "^0.2.2-alpha.2",
+    "@deepseek-ai/dsh-file-reference": "^0.2.2-alpha.2",
+    "@deepseek-ai/dsh-fs": "^0.2.2-alpha.2",
+    "@deepseek-ai/dsh-shell": "^0.2.2-alpha.2",
+    "@deepseek-ai/dsh-spill": "^0.2.2-alpha.2",
+    "@deepseek-ai/dsh-subprocess": "^0.2.2-alpha.2",
+    "@deepseek-ai/dsh-tools": "^0.2.2-alpha.2",
     "react": "^18.2.0",
     "react-dom": "^18.2.0"
   },
   "devDependencies": {
-    "@deepseek-ai/cordis": "^4.0.4",
-    "@deepseek-ai/dsh-agent": "0.2.1-rc.2",
-    "@deepseek-ai/dsh-agent-preset-registry": "0.2.1-rc.2",
-    "@deepseek-ai/dsh-api-remotes": "0.2.1-rc.2",
-    "@deepseek-ai/dsh-bash-local": "0.2.1-rc.2",
-    "@deepseek-ai/dsh-client-locale": "0.2.1-rc.2",
-    "@deepseek-ai/dsh-client-ui-renderer": "0.2.1-rc.2",
-    "@deepseek-ai/dsh-client-ui-settings": "0.2.1-rc.2",
-    "@deepseek-ai/dsh-client-ui-sidebar-right": "0.2.1-rc.2",
-    "@deepseek-ai/dsh-client-ui-slots": "0.2.1-rc.2",
-    "@deepseek-ai/dsh-client-ui-workspace": "0.2.1-rc.2",
-    "@deepseek-ai/dsh-file-reference": "0.2.1-rc.2",
-    "@deepseek-ai/dsh-fs": "0.2.1-rc.2",
-    "@deepseek-ai/dsh-host-directory-picker": "0.2.1-rc.2",
-    "@deepseek-ai/dsh-host-webserver": "0.2.1-rc.2",
-    "@deepseek-ai/dsh-llm": "0.2.1-rc.2",
-    "@deepseek-ai/dsh-sandbox": "0.2.1-rc.2",
-    "@deepseek-ai/dsh-session": "0.2.1-rc.2",
-    "@deepseek-ai/dsh-shell": "0.2.1-rc.2",
-    "@deepseek-ai/dsh-spill": "0.2.1-rc.2",
-    "@deepseek-ai/dsh-subprocess": "0.2.1-rc.2",
-    "@deepseek-ai/dsh-system-prompt": "0.2.1-rc.2",
-    "@deepseek-ai/dsh-tools": "0.2.1-rc.2",
-    "@deepseek-ai/dsh-working-directory": "0.2.1-rc.2",
-    "@deepseek-ai/dsh-workspace": "0.2.1-rc.2",
+    "@deepseek-ai/cordis": "^4.0.6-alpha.1",
+    "@deepseek-ai/dsh-agent": "0.2.2-alpha.2",
+    "@deepseek-ai/dsh-agent-preset-registry": "0.2.2-alpha.2",
+    "@deepseek-ai/dsh-api-remotes": "0.2.2-alpha.2",
+    "@deepseek-ai/dsh-bash-local": "0.2.2-alpha.2",
+    "@deepseek-ai/dsh-client-locale": "0.2.2-alpha.2",
+    "@deepseek-ai/dsh-client-ui-renderer": "0.2.2-alpha.2",
+    "@deepseek-ai/dsh-client-ui-settings": "0.2.2-alpha.2",
+    "@deepseek-ai/dsh-client-ui-sidebar-right": "0.2.2-alpha.2",
+    "@deepseek-ai/dsh-client-ui-slots": "0.2.2-alpha.2",
+    "@deepseek-ai/dsh-client-ui-workspace": "0.2.2-alpha.2",
+    "@deepseek-ai/dsh-file-reference": "0.2.2-alpha.2",
+    "@deepseek-ai/dsh-fs": "0.2.2-alpha.2",
+    "@deepseek-ai/dsh-host-directory-picker": "0.2.2-alpha.2",
+    "@deepseek-ai/dsh-host-webserver": "0.2.2-alpha.2",
+    "@deepseek-ai/dsh-llm": "0.2.2-alpha.2",
+    "@deepseek-ai/dsh-sandbox": "0.2.2-alpha.2",
+    "@deepseek-ai/dsh-session": "0.2.2-alpha.2",
+    "@deepseek-ai/dsh-shell": "0.2.2-alpha.2",
+    "@deepseek-ai/dsh-spill": "0.2.2-alpha.2",
+    "@deepseek-ai/dsh-subprocess": "0.2.2-alpha.2",
+    "@deepseek-ai/dsh-system-prompt": "0.2.2-alpha.2",
+    "@deepseek-ai/dsh-tools": "0.2.2-alpha.2",
+    "@deepseek-ai/dsh-working-directory": "0.2.2-alpha.2",
+    "@deepseek-ai/dsh-workspace": "0.2.2-alpha.2",
     "@types/node": "^22.20.0",
     "@types/react": "~18.3.1",
     "@types/react-dom": "^18.3.5",

package/src/client/SettingsHosts.tsx

@@ -22,7 +22,8 @@ import { Notice, Row, hairline, optionStyle, selectStyle } from './ui.tsx'
 export function SettingsHostsSection(_props: SettingsSectionOwnerProps): ReactNode {
   const [t] = useState(() => makeT(detectLang()))
   const [hosts, setHosts] = useState<RemoteHostSummary[]>([])
-  const [mode, setMode] = useState<'off' | 'shadow' | 'enforce'>('off')
+  /** Pre-load placeholder; matches the plugin's default (nforce) until the host answers. */
+  const [mode, setMode] = useState<'off' | 'shadow' | 'enforce'>('enforce')
   const [version, setVersion] = useState('')
   const [saving, setSaving] = useState(false)
   const [error, setError] = useState<string | undefined>(undefined)

package/src/client/composer.ts

@@ -100,7 +100,11 @@ interface InputSnapshot {
   draft: string
   draftRev?: number
   occurrences?: readonly OccurrenceLike[]
-  phase?: 'plain' | 'adjudicating' | 'claimed' | 'submitting'
+  /**
+   * Host submission plane. `sending` exists since DSH 0.2.2-alpha.2: an ordinary
+   * message the host has not accepted yet — the editor is read-only there too.
+   */
+  phase?: 'plain' | 'adjudicating' | 'claimed' | 'submitting' | 'sending'
   claim?: { readonly token: string }
 }
 
@@ -295,7 +299,7 @@ export function insertDraftReference(
     const { actx, input } = resolved
     const snapshot = input.state.getSnapshot()
     if (input.insertReference === undefined || snapshot.draftRev === undefined) return false
-    if (snapshot.phase === 'adjudicating' || snapshot.phase === 'submitting') return false
+    if (snapshot.phase === 'adjudicating' || snapshot.phase === 'submitting' || snapshot.phase === 'sending') return false
     before = snapshot.draftRev
     const at = appendOffset(snapshot)
     if (at === undefined) return false
@@ -346,6 +350,11 @@ export function appendToDraft(ctx: Context, sessionId: string, text: string): bo
     const { actx, input } = resolved
     const snapshot = input.state.getSnapshot()
     const draft = snapshot.draft
+    // The host makes the editor read-only on every submission plane: a slash
+    // command being checked, a claimed command running, and (since DSH
+    // 0.2.2-alpha.2) an ordinary message waiting for the host to accept it.
+    // Writing there would either be refused or land after the send snapshot.
+    if (snapshot.phase === 'adjudicating' || snapshot.phase === 'submitting' || snapshot.phase === 'sending') return false
     if ((snapshot.occurrences ?? []).length > 0 || snapshot.phase === 'claimed') {
       const at = appendOffset(snapshot)
       if (snapshot.draftRev === undefined || at === undefined) {