@deepseek-harness-tui/dsh-tui 0.12.0 → 0.14.0

package/lib/types/dsh-adapter/channel/ide-selection.d.ts

@@ -33,16 +33,7 @@ export declare function buildSelectionBlock(selection: ChannelSelection, content
  * protocol-1 fallback.
  */
 export declare function attachIdeSelection(blocks: MentionExpansion['blocks'], cwd: string, selection: ChannelSelection | undefined, fs: MentionFs | undefined): Promise<SelectionAttachment | undefined>;
-/**
- * Derive the transcript indicator from the DURABLE user-message content:
- * the `<attached-file path="…" selection count="N">` block the submit path
- * appended is part of the persisted event, so a replayed session can rebuild
- * the "Selected N lines from <file>" line even though the in-memory
- * message-id → attachment map starts empty (maintainer review round 3: the
- * session log is the source of truth — the indicator must not depend on
- * process-local state).
- */
-export declare function replaySelectionAttachment(content: readonly unknown[] | undefined): SelectionAttachment | undefined;
+export { replaySelectionAttachment } from '../../channel/selection-record.js';
 /**
  * Bounded map from a submitted message id → what its selection attached.
  * The delivery path remembers at submit; the transcript projection reads it

package/lib/types/dsh-adapter/channel/ide-selection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ide-selection.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/ide-selection.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAA;AAEhG,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAuB7D;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEvD;AAyCD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,gBAAgB,EAC3B,OAAO,EAAE,MAAM,GACd;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAc7C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,gBAAgB,CAAC,QAAQ,CAAC,EAClC,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,gBAAgB,GAAG,SAAS,EACvC,EAAE,EAAE,SAAS,GAAG,SAAS,GACxB,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC,CAoC1C;AAED;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,SAAS,OAAO,EAAE,GAAG,SAAS,GACtC,mBAAmB,GAAG,SAAS,CA8BjC;AAED;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,IAAI;IAC5C,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,mBAAmB,GAAG,IAAI,CAAA;IAC5D,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS,CAAA;CACzD,CAeA"}
+{"version":3,"file":"ide-selection.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/ide-selection.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAA;AAEhG,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAuB7D;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEvD;AAyCD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,gBAAgB,EAC3B,OAAO,EAAE,MAAM,GACd;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAc7C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,gBAAgB,CAAC,QAAQ,CAAC,EAClC,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,gBAAgB,GAAG,SAAS,EACvC,EAAE,EAAE,SAAS,GAAG,SAAS,GACxB,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC,CAoC1C;AAKD,OAAO,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAA;AAE7E;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,IAAI;IAC5C,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,mBAAmB,GAAG,IAAI,CAAA;IAC5D,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS,CAAA;CACzD,CAeA"}

package/lib/types/dsh-adapter/channel/ide-selection.js

@@ -153,52 +153,10 @@ export async function attachIdeSelection(blocks, cwd, selection, fs) {
         return undefined;
     }
 }
-/**
- * Derive the transcript indicator from the DURABLE user-message content:
- * the `<attached-file path="…" selection count="N">` block the submit path
- * appended is part of the persisted event, so a replayed session can rebuild
- * the "Selected N lines from <file>" line even though the in-memory
- * message-id → attachment map starts empty (maintainer review round 3: the
- * session log is the source of truth — the indicator must not depend on
- * process-local state).
- */
-export function replaySelectionAttachment(content) {
-    if (content === undefined)
-        return undefined;
-    for (const block of content) {
-        if (block === null || typeof block !== 'object')
-            continue;
-        const text = block.text;
-        if (block.type !== 'text' || typeof text !== 'string')
-            continue;
-        const opened = /^<attached-file path="([^"]+)" selection(?: count="(\d+)")?>\n/.exec(text);
-        if (opened === null)
-            continue;
-        let closed = text.slice(opened[0].length);
-        if (closed.endsWith('</attached-file>'))
-            closed = closed.slice(0, -'</attached-file>'.length);
-        // The builder writes `body\n</attached-file>` — strip the newline the
-        // close tag rode on, or every body counts one phantom line.
-        if (closed.endsWith('\n'))
-            closed = closed.slice(0, -1);
-        const lines = closed.split('\n').length;
-        // `count` is authoritative when present (the builder always writes it).
-        // Blocks persisted before it existed fall back to the old tail heuristic,
-        // which misreads a body whose last line is literally the truncation marker.
-        const counted = opened[2] === undefined ? undefined : Number(opened[2]);
-        return {
-            lines: counted ?? (closed.endsWith('\n[… truncated]') ? lines - 1 : lines),
-            // Reverse escapeSnippetAttr so the replayed indicator shows the path
-            // exactly as the live one did (`&` first so entities are not re-baked).
-            path: opened[1]
-                .replace(/&lt;/g, '<')
-                .replace(/&gt;/g, '>')
-                .replace(/&quot;/g, '"')
-                .replace(/&amp;/g, '&'),
-        };
-    }
-    return undefined;
-}
+// The durable-content replay of the indicator is a pure parse of the block
+// this module builds, shared with the backend-neutral projector
+// (src/channel/selection-record.ts); re-exported for existing importers.
+export { replaySelectionAttachment } from '../../channel/selection-record.js';
 /**
  * Bounded map from a submitted message id → what its selection attached.
  * The delivery path remembers at submit; the transcript projection reads it

package/lib/types/dsh-adapter/channel/input-actions.d.ts

@@ -1,13 +1,36 @@
-/** Input actions own cancellation/requeue convergence, not session binding. */
-import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { AgentSession } from '../../agent/session.js';
 import type { ChannelState, ComposerImageRef } from './types.js';
 export interface InputConvergence {
     cancelInFlight: boolean;
     interruptSeq: number;
+    /** Cause of the abort currently converging, written by whoever fires the
+     *  cancel and read to decide whether a queued-input drop is still needed
+     *  (a 'user' cancel kept the backend queue; an 'interrupt' drops it). */
+    cancelCause?: 'user' | 'interrupt';
+    /** True while an interrupt cancel's receipt has not settled yet: rows
+     *  docked in that window sit outside the receipt's queue snapshot. */
+    interruptReceiptPending?: boolean;
+    /** The docked-row ids parked while the current receipt was in flight.
+     *  Its snapshot predates them, so it cannot vouch for their backend
+     *  copies; they are un-docked (with the unconfirmed notice) when it
+     *  settles. Owned by the pending request; undefined when none is. */
+    uncoveredDockIds?: string[];
+    /** Docked-row ids whose vouching interrupt receipt has not settled yet.
+     *  They still render as docked, but edit / re-send / swap are held: a
+     *  late failed/unknown/still_queued answer can only revoke rows still on
+     *  the pending list, so anything already delivered, edited out or
+     *  swapped under a new id would double with the backend copy that
+     *  receipt says may still run. A confirmed receipt graduates its rows;
+     *  every other answer revokes them. Owned by the pending request;
+     *  undefined when none is. */
+    provisionalDockIds?: string[];
 }
-export declare function createInputActions(getState: () => Pick<ChannelState, 'agentId' | 'pending' | 'cancelPending' | 'emit' | 'notify'>, getAgent: () => Agent, owner: {
+export declare function createInputActions(getState: () => Pick<ChannelState, 'agentId' | 'pending' | 'cancelPending' | 'emit' | 'notify' | 'backendCapabilities'>, getSession: () => AgentSession, owner: {
     assertActive(): void;
 }, input: InputConvergence, composer: {
     includeLegacyImageRefs(text: string, images: readonly ComposerImageRef[]): readonly ComposerImageRef[];
-}, dispatchUserText: (text: string, placement: 'steer' | 'followup', images?: readonly ComposerImageRef[]) => void, runLocalCommand: (command: string, includeInContext: boolean) => Promise<void>): Pick<ChannelState, 'submit' | 'steer' | 'removePending' | 'cancel' | 'interruptAndDeliver'>;
+}, dispatchUserText: (text: string, placement: 'steer' | 'followup', images?: readonly ComposerImageRef[]) => void, runLocalCommand: (command: string, includeInContext: boolean) => Promise<void>, 
+/** Move the used session to the front of the `/resume` MRU (DSH session
+ *  history); a backend whose sessions that list cannot open passes a no-op. */
+touch?: (sessionId: string) => void): Pick<ChannelState, 'submit' | 'steer' | 'removePending' | 'cancel' | 'interruptAndDeliver' | 'interruptAndDock' | 'deliverDocked' | 'swapDockedForDraft'>;
 //# sourceMappingURL=input-actions.d.ts.map

package/lib/types/dsh-adapter/channel/input-actions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"input-actions.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/input-actions.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAA;AAInD,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAsB,MAAM,YAAY,CAAA;AAEpF,MAAM,WAAW,gBAAgB;IAAG,cAAc,EAAE,OAAO,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE;AACnF,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,IAAI,CAAC,YAAY,EAAE,SAAS,GAAG,SAAS,GAAG,eAAe,GAAG,MAAM,GAAG,QAAQ,CAAC,EAC/F,QAAQ,EAAE,MAAM,KAAK,EACrB,KAAK,EAAE;IAAE,YAAY,IAAI,IAAI,CAAA;CAAE,EAC/B,KAAK,EAAE,gBAAgB,EACvB,QAAQ,EAAE;IAAE,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,gBAAgB,EAAE,GAAG,SAAS,gBAAgB,EAAE,CAAA;CAAE,EACpH,gBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,GAAG,UAAU,EAAE,MAAM,CAAC,EAAE,SAAS,gBAAgB,EAAE,KAAK,IAAI,EAC/G,eAAe,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,GAC7E,IAAI,CAAC,YAAY,EAAE,QAAQ,GAAG,OAAO,GAAG,eAAe,GAAG,QAAQ,GAAG,qBAAqB,CAAC,CAgI7F"}
+{"version":3,"file":"input-actions.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/input-actions.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAiB,MAAM,wBAAwB,CAAA;AAGzE,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAsB,MAAM,YAAY,CAAA;AAEpF,MAAM,WAAW,gBAAgB;IAC/B,cAAc,EAAE,OAAO,CAAA;IACvB,YAAY,EAAE,MAAM,CAAA;IACpB;;6EAEyE;IACzE,WAAW,CAAC,EAAE,MAAM,GAAG,WAAW,CAAA;IAClC;0EACsE;IACtE,uBAAuB,CAAC,EAAE,OAAO,CAAA;IACjC;;;yEAGqE;IACrE,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC3B;;;;;;;kCAO8B;IAC9B,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC9B;AACD,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,IAAI,CAAC,YAAY,EAAE,SAAS,GAAG,SAAS,GAAG,eAAe,GAAG,MAAM,GAAG,QAAQ,GAAG,qBAAqB,CAAC,EACvH,UAAU,EAAE,MAAM,YAAY,EAC9B,KAAK,EAAE;IAAE,YAAY,IAAI,IAAI,CAAA;CAAE,EAC/B,KAAK,EAAE,gBAAgB,EACvB,QAAQ,EAAE;IAAE,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,gBAAgB,EAAE,GAAG,SAAS,gBAAgB,EAAE,CAAA;CAAE,EACpH,gBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,GAAG,UAAU,EAAE,MAAM,CAAC,EAAE,SAAS,gBAAgB,EAAE,KAAK,IAAI,EAC/G,eAAe,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC;AAC9E;+EAC+E;AAC/E,KAAK,GAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAmB,GAChD,IAAI,CAAC,YAAY,EAAE,QAAQ,GAAG,OAAO,GAAG,eAAe,GAAG,QAAQ,GAAG,qBAAqB,GAAG,kBAAkB,GAAG,eAAe,GAAG,oBAAoB,CAAC,CAyU3J"}

package/lib/types/dsh-adapter/channel/input-actions.js

@@ -1,7 +1,11 @@
-import { MessageId } from '@deepseek-ai/dsh-llm';
+/** Input actions own cancellation/requeue convergence, not session binding. */
+import { randomUUID } from 'node:crypto';
 import { t } from '../../i18n.js';
 import { touchSession } from '../../sessionHistory.js';
-export function createInputActions(getState, getAgent, owner, input, composer, dispatchUserText, runLocalCommand) {
+export function createInputActions(getState, getSession, owner, input, composer, dispatchUserText, runLocalCommand, 
+/** Move the used session to the front of the `/resume` MRU (DSH session
+ *  history); a backend whose sessions that list cannot open passes a no-op. */
+touch = touchSession) {
     return {
         submit(text, images = []) {
             owner.assertActive();
@@ -30,7 +34,7 @@ export function createInputActions(getState, getAgent, owner, input, composer, d
             }
             // The current session is being used — move it to the MRU front
             // (/resume sorts by last-used).
-            touchSession(state.agentId);
+            touch(state.agentId);
             dispatchUserText(trimmed, 'followup', submittedImages);
         },
         /** Steer a message into the RUNNING turn (Codex/pi semantics): it is
@@ -42,7 +46,7 @@ export function createInputActions(getState, getAgent, owner, input, composer, d
             const trimmed = text.trim();
             if (!trimmed)
                 return;
-            touchSession(state.agentId);
+            touch(state.agentId);
             // Same tui/input decision pass as submit; the delivery re-validates
             // the live agent after the await. Official dsh-agent rc.6: steer() is
             // synchronous void — the message enters the next-step inbox; a
@@ -56,17 +60,30 @@ export function createInputActions(getState, getAgent, owner, input, composer, d
         removePending(id) {
             owner.assertActive();
             const state = getState();
-            const agent = getAgent();
+            const session = getSession();
             const index = state.pending.findIndex(item => item.id === id);
             if (index === -1)
                 return false;
-            // Official dsh-agent rc.6: withdrawal goes through the agent's inbox
-            // projection — `Inbox.remove(messageId)` durably records the
-            // cancellation (an `agent/inbox/spliced` session event) and publishes
-            // `agent/inbox/discarded`, which retires the preview. Refuse when the
-            // message was already claimed (remove returns false) so the UI never
-            // pretends a ghost send was pulled back.
-            if (!agent.inbox.remove(MessageId(id)))
+            // A docked preview is a channel-side asset: the backend dropped its
+            // queued copy with the aborted turn, so pulling it back is purely
+            // local and works on every backend, including backends without
+            // pending-message withdrawal; the gate below only governs live queue items.
+            if (state.pending[index].docked === true) {
+                // A dock the pending receipt has not vouched for is view-only:
+                // its backend copy may still run, so editing the row out now would
+                // strand a copy the late revocation can no longer reach. The caller
+                // keeps the row queued and says it cannot be retracted.
+                if (input.provisionalDockIds?.includes(id) === true)
+                    return false;
+                state.pending = state.pending.filter(item => item.id !== id);
+                state.emit();
+                return true;
+            }
+            const retraction = session.capabilities.pendingRetraction;
+            if (retraction === undefined)
+                return false;
+            const removed = retraction.remove(id);
+            if (!removed)
                 return false;
             state.pending = state.pending.filter(item => item.id !== id);
             state.emit();
@@ -75,7 +92,7 @@ export function createInputActions(getState, getAgent, owner, input, composer, d
         cancel() {
             owner.assertActive();
             const state = getState();
-            const agent = getAgent();
+            const session = getSession();
             // Keep the staged queue: an interrupt aborts the running turn but the
             // queued/steered messages are delivered as the next turn (web parity).
             // Cancellation converges asynchronously; ignore a repeated Esc/Ctrl+C
@@ -84,13 +101,201 @@ export function createInputActions(getState, getAgent, owner, input, composer, d
             if (input.cancelInFlight)
                 return;
             input.cancelInFlight = true;
+            input.cancelCause = 'user';
             state.cancelPending = true;
-            agent.cancel({ kind: 'user' }, { keepInbox: true });
+            void session.cancel('user');
+        },
+        /** Esc with queued input while a turn runs (Claude Code parity: "Press
+         *  up to select a queued message to edit, or Enter to send them now"):
+         *  the abort drops the backend's queued copies and the channel parks its
+         *  previews as a dock, which nothing re-delivers until the user sends it
+         *  (⏎ / deliverDocked) or retracts items (Alt+↑ / the ↑ editor).
+         *  Docking assumes the backend dropped its copies, so only a confirmed
+         *  cancel receipt keeps the dock (minus the ids it says it kept); an
+         *  unknown or failed receipt, and rows docked after the request fired,
+         *  un-dock with a notice so the still-live backend copy is not sent
+         *  twice. Returns the count docked; 0 means nothing new was parked
+         *  (already-docked rows stay put; the caller may still plain-cancel). */
+        interruptAndDock() {
+            owner.assertActive();
+            const state = getState();
+            const session = getSession();
+            const dockable = state.pending.filter(item => item.docked !== true);
+            const dockedNow = dockable.map(item => item.id);
+            if (dockable.length > 0) {
+                // Mark before the cancel fires: the discard events the backend's
+                // queue drop produces must not delete the previews (binding-feed
+                // keeps `docked` rows alive on discard; the dock owns them now).
+                state.pending = state.pending.map(item => item.docked === true ? item : { ...item, docked: true });
+                state.emit();
+            }
+            state.cancelPending = true;
+            if (input.cancelInFlight && input.cancelCause === 'interrupt' && input.interruptReceiptPending === true) {
+                // The in-flight receipt's queue snapshot predates these rows: it
+                // cannot vouch for their backend copies. They join its uncovered
+                // set and are un-docked when it settles rather than riding a
+                // receipt that never saw them.
+                input.uncoveredDockIds?.push(...dockedNow);
+                // They are provisional dock rows for exactly the same reason (the
+                // receipt cannot vouch for them yet): view-only until it settles.
+                // Mutate, never replace: settle() clears this exact array.
+                if (input.provisionalDockIds === undefined)
+                    input.provisionalDockIds = [...dockedNow];
+                else
+                    input.provisionalDockIds.push(...dockedNow);
+                return dockable.length;
+            }
+            // A 'user' cancel already converging kept the backend queue
+            // (keepInbox); docking over it must still drop that queue or the
+            // parked previews would double with the backend's own next-turn run.
+            // An 'interrupt' abort whose receipt already settled is no longer
+            // dropping anything: the new rows need their own request.
+            input.cancelInFlight = true;
+            input.cancelCause = 'interrupt';
+            input.interruptReceiptPending = true;
+            const uncovered = [];
+            input.uncoveredDockIds = uncovered;
+            // Every row this request parks is provisional until its receipt
+            // vouches for it: the batch that fired the request (the receipt's
+            // own snapshot covers it) and every later joiner above alike.
+            // Rows an earlier request still holds stay held: that receipt can be
+            // outlived by this request (the aborted turn ended before it came
+            // back), and this one's later queue snapshot vouches for them too.
+            const provisional = [...input.provisionalDockIds ?? [], ...dockedNow];
+            input.provisionalDockIds = provisional;
+            let settled = false;
+            const settle = (outcome, stillQueued) => {
+                if (settled)
+                    return;
+                settled = true;
+                // A newer request owns the bookkeeping once it replaced ours.
+                if (input.uncoveredDockIds === uncovered) {
+                    input.uncoveredDockIds = undefined;
+                    input.interruptReceiptPending = false;
+                }
+                if (input.provisionalDockIds === provisional)
+                    input.provisionalDockIds = undefined;
+                // The channel moved to another session: its dock and its queue are
+                // not the ones this receipt speaks about.
+                if (getSession() !== session)
+                    return;
+                // Every docked row this receipt cannot confirm dropped: the ids the
+                // backend says it kept, plus every row docked after the request
+                // fired (outside its snapshot). Those copies are still live: their
+                // previews go back to the normal claim/discard retirement and the
+                // dock never offers a second send on top of them. Only a confirmed
+                // answer graduates the provisional rows; any other verdict un-docks
+                // them too, so nothing keeps edit/re-send rights a late revocation
+                // could no longer reach.
+                const revoke = new Set([...stillQueued, ...uncovered]);
+                if (outcome !== 'confirmed')
+                    for (const id of provisional)
+                        revoke.add(id);
+                // A newer request that carried our rows over holds them no longer
+                // than this answer needs.
+                const held = input.provisionalDockIds;
+                if (outcome === 'confirmed' && held !== undefined && held !== provisional) {
+                    for (const id of provisional) {
+                        const index = held.indexOf(id);
+                        if (index !== -1 && !revoke.has(id))
+                            held.splice(index, 1);
+                    }
+                }
+                if (revoke.size > 0) {
+                    let undocked = false;
+                    state.pending = state.pending.map(item => {
+                        if (item.docked !== true || !revoke.has(item.id))
+                            return item;
+                        undocked = true;
+                        return { ...item, docked: undefined };
+                    });
+                    if (undocked)
+                        state.emit();
+                }
+                // The unconfirmed legs are loud: a failed or answerless interrupt
+                // must not leave a success-shaped dock (or a silently failed Esc).
+                const notice = outcome === 'failed' ? t('interrupt-failed')
+                    : revoke.size === 0 ? undefined
+                        : t('interrupt-unconfirmed');
+                if (notice !== undefined)
+                    state.notify(notice, { color: 'warning', timeoutMs: 6000 });
+            };
+            void session.cancel('interrupt')
+                .then(receipt => { settle(receipt.outcome, receipt.stillQueued); })
+                // A backend that breaks the receipt contract by throwing gets the
+                // same revocation; the catch must not keep the dock.
+                .catch(() => { settle('failed', dockedNow); });
+            return dockable.length;
+        },
+        /** Send every docked message now (⏎ on an empty draft, or the clickable
+         *  dock hint): FIFO through the same dispatch chain a typed submit uses,
+         *  exactly once; the docked rows leave first and their deliveries
+         *  enqueue fresh pending previews. Rows still awaiting their interrupt
+         *  receipt are held (their backend copies may yet run) and stay parked,
+         *  with a notice, until the receipt confirms. Returns the count sent. */
+        deliverDocked() {
+            owner.assertActive();
+            const state = getState();
+            const held = (id) => input.provisionalDockIds?.includes(id) === true;
+            const docked = state.pending.filter(item => item.docked === true);
+            if (docked.length === 0)
+                return 0;
+            // Provisional rows are always the newest dock batches, so the confirmed
+            // remainder is a FIFO prefix; holding the tail never reorders anyone.
+            const ready = docked.filter(item => !held(item.id));
+            if (ready.length < docked.length) {
+                state.notify(t('input-dock-confirming', { n: docked.length - ready.length }), { color: 'warning', timeoutMs: 4000 });
+            }
+            if (ready.length === 0)
+                return 0;
+            state.pending = state.pending.filter(item => item.docked !== true || held(item.id));
+            state.emit();
+            for (const entry of ready) {
+                touch(state.agentId);
+                dispatchUserText(entry.text, 'followup', entry.images);
+            }
+            return ready.length;
+        },
+        /**
+         * Lossless swap: retract the docked row `id` and park the live draft
+         * (text + staged images) at the pending tail as a new docked row, in one
+         * queue write; nothing sends. The draft's id is prefixed and purely
+         * local: the backend never saw this text, so no inbox event can match
+         * it, and the row stays out of the in-flight interrupt receipt's
+         * uncovered set (that fence is for rows the backend may still hold).
+         * False when `id` is no longer docked (the receipt un-docked it, a claim
+         * retired it, another editor took it) or while an unsettled interrupt
+         * receipt holds it: the caller keeps its draft and says so.
+         */
+        swapDockedForDraft(id, draft) {
+            owner.assertActive();
+            const state = getState();
+            const index = state.pending.findIndex(item => item.id === id);
+            if (index === -1 || state.pending[index].docked !== true)
+                return false;
+            // The clicked row's backend copy may still run while its receipt
+            // is in flight; swapping its text into the composer now would hand
+            // the user a second copy the late revocation cannot reach.
+            if (input.provisionalDockIds?.includes(id) === true)
+                return false;
+            // A docked retract is purely local on every backend (see removePending).
+            state.pending = [
+                ...state.pending.filter(item => item.id !== id),
+                {
+                    id: `dock-swap-${randomUUID()}`,
+                    text: draft.text,
+                    images: [...(draft.images ?? [])],
+                    placement: 'followup',
+                    docked: true,
+                },
+            ];
+            state.emit();
+            return true;
         },
         interruptAndDeliver(inputs) {
             owner.assertActive();
             const state = getState();
-            const agent = getAgent();
+            const session = getSession();
             const queued = inputs
                 .map(input => typeof input === 'string'
                 ? { text: input.trim(), images: [] }
@@ -98,7 +303,7 @@ export function createInputActions(getState, getAgent, owner, input, composer, d
                 .filter(input => input.text !== '');
             if (queued.length === 0)
                 return 0;
-            // No keepInbox: the parked copies are dropped (their discard events
+            // An `interrupt` cancel drops the parked copies (their discard events
             // retire the preview), then each message is re-queued as a fresh
             // followup. dsh-agent's cancel-convergence wake latch accepts this
             // wake immediately after cancel and starts it once the aborted turn
@@ -106,9 +311,12 @@ export function createInputActions(getState, getAgent, owner, input, composer, d
             // replacement work and may never settle. If cancellation is already
             // in flight, keep the existing abort and still replace the pending
             // interrupt delivery; fake/embedded agents may not emit turn/end.
-            if (!input.cancelInFlight) {
+            // (Exception: an in-flight 'user' cancel kept the backend queue, so
+            // drop it now or the re-queue below would double with its own run.)
+            if (!input.cancelInFlight || input.cancelCause === 'user') {
                 input.cancelInFlight = true;
-                agent.cancel({ kind: 'user' });
+                input.cancelCause = 'interrupt';
+                void session.cancel('interrupt');
             }
             state.cancelPending = true;
             const token = ++input.interruptSeq;
@@ -117,8 +325,19 @@ export function createInputActions(getState, getAgent, owner, input, composer, d
                 // double-deliver: only the latest request's re-queue runs.
                 if (input.interruptSeq !== token)
                     return;
-                for (const entry of queued) {
-                    touchSession(state.agentId);
+                // The dock's rows ride this batch too: take them off the pending
+                // list first (their re-deliveries enqueue fresh previews), ahead
+                // of the given inputs, since docked rows are the oldest texts (FIFO).
+                // Rows still awaiting their receipt stay parked for the verdict:
+                // their backend copies may still run.
+                const heldHere = (id) => input.provisionalDockIds?.includes(id) === true;
+                const docked = state.pending.filter(item => item.docked === true && !heldHere(item.id));
+                if (docked.length > 0) {
+                    state.pending = state.pending.filter(item => item.docked !== true || heldHere(item.id));
+                    state.emit();
+                }
+                for (const entry of [...docked, ...queued]) {
+                    touch(state.agentId);
                     // Same tui/input decision pass as a typed submit: Ctrl+Enter must
                     // not bypass a plugin's cancel/transform policy, and re-queued
                     // texts keep submission order through the one FIFO chain.
@@ -130,6 +349,6 @@ export function createInputActions(getState, getAgent, owner, input, composer, d
             // token survives, so the user's text is never sent twice.
             queueMicrotask(deliver);
             return queued.length;
-        }
+        },
     };
 }

package/lib/types/dsh-adapter/channel/input-delivery.d.ts

@@ -1,34 +1,62 @@
 import type { Context } from '@deepseek-ai/cordis';
-import type { Agent } from '@deepseek-ai/dsh-agent';
 import { type UserMessage } from '@deepseek-ai/dsh-llm';
+import type { AgentSession } from '../../agent/session.js';
 import { type ComposerImages } from './composer-images.js';
+import type { LocalImageStore } from './core/local-images.js';
 import type { ChannelOwner } from './owner.js';
-import type { ChannelSelection, SelectionAttachment } from '../../adapter/ports/channel-view.js';
+import type { AttachedContext, ChannelSelection, SelectionAttachment } from '../../adapter/ports/channel-view.js';
 import type { ChannelImageBlock, ChannelState, ComposerImageRef, MentionAttachments, MentionFs, PendingMessage, StagedImageInput } from './types.js';
 /** One submission's enqueue-time world: the session it was typed in, the
  *  services that resolve its references, and the capabilities live then. */
-interface UserTextOrigin {
-    readonly agent: Agent;
+export interface UserTextOrigin {
+    readonly session: AgentSession;
     readonly agentId: string;
     readonly generation: number;
     readonly cwd: string;
     readonly fs: MentionFs | undefined;
     readonly attachments: MentionAttachments | undefined;
+    /** The in-memory image store when the session takes images itself: the
+     *  staged references resolve to its facades for `submit`. */
+    readonly localImages?: LocalImageStore;
     readonly stagedImages: ReadonlyMap<string, ChannelImageBlock['attachment']>;
     /** Live editor selection AT ENQUEUE (undefined = none). Captured here so a
      *  selection made while the FIFO or mention expansion parks the delivery
      *  can never attach to this message. */
     readonly selection: ChannelSelection | undefined;
+    /** "Send to Chat" contexts AT ENQUEUE, already taken off the channel (see
+     *  `consumeAttachedContexts`): the same one-shot rule as the selection, and
+     *  the reason a chip can never ride along with a second submission. */
+    readonly attachedContexts: readonly AttachedContext[];
 }
 /** Input FIFO, staged attachments and decision notice timers share one lifetime. */
 export declare function createInputDelivery(ctx: Context, owner: ChannelOwner, binding: {
-    readonly agent: Agent;
+    readonly session: AgentSession;
 }, state: () => Pick<ChannelState, 'cwd' | 'agentId' | 'agentBindingGeneration'>, notify: ChannelState['notify'], trackPending: (message: {
     id: string;
     text: string;
     images?: readonly ComposerImageRef[];
-}, placement: PendingMessage['placement']) => void, untrackPending: (id: string) => void, composer: ComposerImages, selection: () => ChannelSelection | undefined, rememberSelection: (messageId: string, info: SelectionAttachment) => void): {
+}, placement: PendingMessage['placement']) => void, untrackPending: (id: string) => void, composer: ComposerImages, selection: () => ChannelSelection | undefined, rememberSelection: (messageId: string, info: SelectionAttachment) => void, 
+/** The fs surface to use when the host mounts no `fs` service (a non-DSH
+ *  composition reads the local disk); absent = no fallback. */
+fallbackFs?: () => MentionFs | undefined, 
+/** The in-memory image store of a session that takes images itself (the
+ *  `images` capability); absent / undefined = the DSH attachments service. */
+localImages?: () => LocalImageStore | undefined, 
+/**
+ * Take-and-clear the staged "Send to Chat" contexts for the submission being
+ * enqueued (side-panel §6.7). Optional so a bare embedder/fixture that owns
+ * only the decision seam stays constructible; with it absent the origin
+ * simply carries no contexts.
+ */
+consumeAttachedContexts?: () => readonly AttachedContext[]): {
     dispatchUserText: (text: string, placement: PendingMessage["placement"], images?: readonly ComposerImageRef[], attach?: UserMessage) => void;
+    /** Inputs dispatched so far, and whether any is still in the FIFO (a
+     *  parked decision, an `@` read, an IDE-selection read). */
+    activity: () => {
+        readonly dispatched: number;
+        readonly unsettled: boolean;
+        readonly parked?: string;
+    };
     deliverUserText: (text: string, placement: PendingMessage["placement"], images?: readonly ComposerImageRef[], attach?: UserMessage) => void;
     claimAttachments: (messages: readonly UserMessage[]) => UserMessage[];
     retireAttachment: (messageId: string) => void;
@@ -38,5 +66,4 @@ export declare function createInputDelivery(ctx: Context, owner: ChannelOwner, b
     stagedImages: () => ReadonlyMap<string, ChannelImageBlock["attachment"]>;
     composer: ComposerImages;
 };
-export {};
 //# sourceMappingURL=input-delivery.d.ts.map

package/lib/types/dsh-adapter/channel/input-delivery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"input-delivery.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/input-delivery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAA;AACnD,OAAO,EAAqB,KAAK,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAI1E,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,sBAAsB,CAAA;AAK7B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAA;AAChG,OAAO,KAAK,EACV,iBAAiB,EACjB,YAAY,EACZ,gBAAgB,EAChB,kBAAkB,EAClB,SAAS,EACT,cAAc,EACd,gBAAgB,EACjB,MAAM,YAAY,CAAA;AAEnB;4EAC4E;AAC5E,UAAU,cAAc;IACtB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,EAAE,EAAE,SAAS,GAAG,SAAS,CAAA;IAClC,QAAQ,CAAC,WAAW,EAAE,kBAAkB,GAAG,SAAS,CAAA;IACpD,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,YAAY,CAAC,CAAC,CAAA;IAC3E;;4CAEwC;IACxC,QAAQ,CAAC,SAAS,EAAE,gBAAgB,GAAG,SAAS,CAAA;CACjD;AAED,oFAAoF;AACpF,wBAAgB,mBAAmB,CAClC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE;IAAE,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;CAAE,EACrE,KAAK,EAAE,MAAM,IAAI,CAAC,YAAY,EAAE,KAAK,GAAG,SAAS,GAAG,wBAAwB,CAAC,EAC7E,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,EAC9B,YAAY,EAAE,CAAC,OAAO,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,SAAS,gBAAgB,EAAE,CAAA;CAAE,EAAE,SAAS,EAAE,cAAc,CAAC,WAAW,CAAC,KAAK,IAAI,EAC3I,cAAc,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,EACpC,QAAQ,EAAE,cAAc,EACxB,SAAS,EAAE,MAAM,gBAAgB,GAAG,SAAS,EAC7C,iBAAiB,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,mBAAmB,KAAK,IAAI;6BAkRhE,MAAM,aACD,cAAc,CAAC,WAAW,CAAC,WAC9B,SAAS,gBAAgB,EAAE,WAC1B,WAAW,KACnB,IAAI;4BAcC,MAAM,aACD,cAAc,CAAC,WAAW,CAAC,WAC9B,SAAS,gBAAgB,EAAE,WAC1B,WAAW,KACnB,IAAI;iCAlR6B,SAAS,WAAW,EAAE,KAAG,WAAW,EAAE;kCAarC,MAAM,KAAG,IAAI;0BAuIrB,CAAC,QAAQ,MAAM,WAAW,OAAO,CAAC,CAAC,CAAC,WAAW,cAAc,KAAG,OAAO,CAAC,CAAC,CAAC;6BAkIzE,IAAI;wBAaZ,gBAAgB,KAAG,OAAO,CAAC,MAAM,CAAC;wBACpC,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,YAAY,CAAC,CAAC;;EAGzE"}
+{"version":3,"file":"input-delivery.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/input-delivery.ts"],"names":[],"mappings":"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"}