@deepseek-harness-tui/dsh-tui 0.10.0 → 0.10.2

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

@@ -0,0 +1,135 @@
+import { MessageId } from '@deepseek-ai/dsh-llm';
+import { t } from '../../i18n.js';
+import { touchSession } from '../../sessionHistory.js';
+export function createInputActions(getState, getAgent, owner, input, composer, dispatchUserText, runLocalCommand) {
+    return {
+        submit(text, images = []) {
+            owner.assertActive();
+            const state = getState();
+            const trimmed = text.trim();
+            if (!trimmed)
+                return;
+            const submittedImages = composer.includeLegacyImageRefs(trimmed, images);
+            // Non-UI callers do not pass through PromptInput's admission guard.
+            // Shell routes have no image grammar: reject loudly before spawning
+            // anything rather than silently ignoring the supplied capabilities.
+            if (submittedImages.length > 0 && trimmed.startsWith('!')) {
+                state.notify(t('shell-images-unsupported'), { color: 'warning', timeoutMs: 4000 });
+                return;
+            }
+            // Local shell mode: `!cmd` runs locally and only shows the output;
+            // `!!cmd` additionally sends the output to the model as a user
+            // message wrapped in `<bash-stdout>`.
+            if (trimmed.startsWith('!!')) {
+                void runLocalCommand(trimmed.slice(2).trim(), true);
+                return;
+            }
+            if (trimmed.startsWith('!')) {
+                void runLocalCommand(trimmed.slice(1).trim(), false);
+                return;
+            }
+            // The current session is being used — move it to the MRU front
+            // (/resume sorts by last-used).
+            touchSession(state.agentId);
+            dispatchUserText(trimmed, 'followup', submittedImages);
+        },
+        /** Steer a message into the RUNNING turn (Codex/pi semantics): it is
+         *  injected at the next step boundary of the current turn and the agent
+         *  continues without stopping — faster than followup, never an abort. */
+        steer(text, images = []) {
+            owner.assertActive();
+            const state = getState();
+            const trimmed = text.trim();
+            if (!trimmed)
+                return;
+            touchSession(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
+            // rejected step leaves it parked for the next wake, and the inbox
+            // events retire the preview (claimed → turn boundary, discarded →
+            // cancel).
+            dispatchUserText(trimmed, 'steer', images);
+        },
+        /** Pull a pending message back out of the inbox (Alt+Up): it returns to
+         *  the input for editing instead of being delivered. */
+        removePending(id) {
+            owner.assertActive();
+            const state = getState();
+            const agent = getAgent();
+            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)))
+                return false;
+            state.pending = state.pending.filter(item => item.id !== id);
+            state.emit();
+            return true;
+        },
+        cancel() {
+            owner.assertActive();
+            const state = getState();
+            const agent = getAgent();
+            // 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
+            // until the aborted turn has produced its terminal event. `cancelPending`
+            // mirrors that window for the UI, where a repeated press force-exits.
+            if (input.cancelInFlight)
+                return;
+            input.cancelInFlight = true;
+            state.cancelPending = true;
+            agent.cancel({ kind: 'user' }, { keepInbox: true });
+        },
+        interruptAndDeliver(inputs) {
+            owner.assertActive();
+            const state = getState();
+            const agent = getAgent();
+            const queued = inputs
+                .map(input => typeof input === 'string'
+                ? { text: input.trim(), images: [] }
+                : { text: input.text.trim(), images: [...(input.images ?? [])] })
+                .filter(input => input.text !== '');
+            if (queued.length === 0)
+                return 0;
+            // No keepInbox: the parked copies are dropped (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
+            // retires; waiting for whenIdle is unsafe because it also follows
+            // 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) {
+                input.cancelInFlight = true;
+                agent.cancel({ kind: 'user' });
+            }
+            state.cancelPending = true;
+            const token = ++input.interruptSeq;
+            const deliver = () => {
+                // A second interrupt while the abort is still settling must not
+                // double-deliver: only the latest request's re-queue runs.
+                if (input.interruptSeq !== token)
+                    return;
+                for (const entry of queued) {
+                    touchSession(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.
+                    dispatchUserText(entry.text, 'followup', entry.images);
+                }
+            };
+            // Let cancel finish its synchronous inbox bookkeeping before waking.
+            // A microtask also coalesces two same-tick interrupts: only the latest
+            // 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

@@ -0,0 +1,37 @@
+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 ComposerImages } from './composer-images.js';
+import type { ChannelOwner } from './owner.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;
+    readonly agentId: string;
+    readonly generation: number;
+    readonly cwd: string;
+    readonly fs: MentionFs | undefined;
+    readonly attachments: MentionAttachments | undefined;
+    readonly stagedImages: ReadonlyMap<string, ChannelImageBlock['attachment']>;
+}
+/** Input FIFO, staged attachments and decision notice timers share one lifetime. */
+export declare function createInputDelivery(ctx: Context, owner: ChannelOwner, binding: {
+    readonly agent: Agent;
+}, 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): {
+    dispatchUserText: (text: string, placement: PendingMessage["placement"], images?: readonly ComposerImageRef[], attach?: UserMessage) => void;
+    deliverUserText: (text: string, placement: PendingMessage["placement"], images?: readonly ComposerImageRef[], attach?: UserMessage) => void;
+    claimAttachments: (messages: readonly UserMessage[]) => UserMessage[];
+    retireAttachment: (messageId: string) => void;
+    withDecisionPending: <T>(name: string, pending: Promise<T>, origin?: UserTextOrigin) => Promise<T>;
+    clearStagedImages: () => void;
+    stageImage: (input: StagedImageInput) => Promise<string>;
+    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

@@ -0,0 +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;AAI7B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAC9C,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;CAC5E;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;6BA4Qf,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;iCA5Q6B,SAAS,WAAW,EAAE,KAAG,WAAW,EAAE;kCAarC,MAAM,KAAG,IAAI;0BAiIrB,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"}

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

@@ -0,0 +1,305 @@
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { t } from '../../i18n.js';
+import { logForDebugging } from '../../utils/debug.js';
+import { dispatchTuiDecision } from '../extension-events.js';
+import { firstStaleComposerToken, formatMissingReference, orderedComposerImages, } from './composer-images.js';
+import { expandComposerMentions } from './composer-mentions.js';
+import { normalizeInputDecision } from './decisions.js';
+import { mentionAttachments, mentionFs } from './mentions.js';
+/** Input FIFO, staged attachments and decision notice timers share one lifetime. */
+export function createInputDelivery(ctx, owner, binding, state, notify, trackPending, untrackPending, composer) {
+    /**
+     * `@` file mentions (issue #15): expansion reads files asynchronously, so
+     * every user-text delivery (submit / steer / interrupt-requeue) funnels
+     * through this chain to keep the send order FIFO.
+     */
+    let inputChain = Promise.resolve();
+    /**
+     * Attached-context registry (issue #842): `deliverUserText(..., attach)`
+     * records the model-facing companion message under the DELIVERED user
+     * message's id. The resident `agent/pre-step` listener below claims an entry
+     * exactly once — on the step that admits its user message — and appends it
+     * AFTER `next()`'s batch, the same shape and order as dsh-tool-skill's
+     * gesture boundary. The map is emptied on claim, on inbox discard and on
+     * channel release (owner.own below).
+     */
+    const attachedByMessageId = new Map();
+    /** Claim the batch's registered attachments, deleting each entry so a later
+     *  step can never append it a second time. */
+    const claimAttachments = (messages) => {
+        if (attachedByMessageId.size === 0)
+            return [];
+        const attached = [];
+        for (const message of messages) {
+            const context = attachedByMessageId.get(message.id);
+            if (context === undefined)
+                continue;
+            attachedByMessageId.delete(message.id);
+            attached.push(context);
+        }
+        return attached;
+    };
+    /** Drop an attachment whose user message will never be claimed (inbox discard). */
+    const retireAttachment = (messageId) => {
+        attachedByMessageId.delete(messageId);
+    };
+    /**
+     * Resident `agent/pre-step` listener (D3/D4): `await next()` lets every
+     * later transform run first; the waterfall applies AFTER-next transforms in
+     * registration order, so registering at channel construction keeps this
+     * append LAST (范例: presets/liangshen/instruction-hint.mjs). A rejected
+     * step never claims — no context message without its admitted user line —
+     * and a released owner returns the decision untouched. One `owner.own`
+     * lifetime covers both the subscription and the whole registry (D5).
+     */
+    const disposePreStep = ctx.on('agent/pre-step', async (_payload, next) => {
+        const decision = await next();
+        if (decision.kind === 'reject')
+            return decision;
+        if (!owner.current())
+            return decision;
+        const attached = claimAttachments(decision.messages);
+        if (attached.length === 0)
+            return decision;
+        return { ...decision, messages: [...decision.messages, ...attached] };
+    });
+    owner.own(() => {
+        disposePreStep();
+        attachedByMessageId.clear();
+    });
+    /** D-6 fence: the submission belongs to the session it was typed in. */
+    const current = (origin) => owner.current() && binding.agent === origin.agent && state().agentBindingGeneration === origin.generation;
+    /** D-6: bind the submission to the session it was typed in AT ENQUEUE
+     *  TIME. The FIFO chain may park this task behind a slow predecessor
+     *  while the user /new's away — capturing the agent at run time would
+     *  adopt the NEW session as this text's origin and deliver the old
+     *  conversation's words into it. */
+    const captureOrigin = () => ({
+        agent: binding.agent,
+        agentId: state().agentId,
+        generation: state().agentBindingGeneration,
+        cwd: state().cwd,
+        fs: mentionFs(ctx),
+        attachments: mentionAttachments(ctx),
+        stagedImages: composer.snapshot(),
+    });
+    /**
+     * Expand the text's `@` mentions and deliver ONE user message: the typed
+     * text stays the first content block (the transcript bubble renders it —
+     * never the file dump) and each resolved reference appends a model-facing
+     * attachment block. The pending preview tracks the typed text.
+     */
+    const deliverUserText = async (text, placement, images, origin, attach) => {
+        const orderedImages = orderedComposerImages(text, images, origin.stagedImages);
+        // A `[Image #N]` placeholder whose staging was evicted (FIFO cap) or
+        // whose draft capability was lost (history/rewind/session switch) would
+        // otherwise ship as plain text with no image attached — warn loudly,
+        // deliver unchanged (the text is the user's; rewriting is worse).
+        const stale = firstStaleComposerToken(text, orderedImages);
+        if (stale !== undefined) {
+            notify(t('input-image-token-stale', { token: stale }), { color: 'warning', timeoutMs: 5000 });
+        }
+        const expansion = await expandComposerMentions(origin.fs, origin.cwd, text, origin.attachments, orderedImages);
+        // Mention reads can park for arbitrary I/O. A session switch during that
+        // await invalidates the whole submission; neither the old nor the new
+        // agent may receive a message assembled for a different conversation.
+        if (!current(origin)) {
+            notify(t('ext-stale-dropped'), { color: 'warning', timeoutMs: 4000 });
+            return;
+        }
+        const message = createUserMessage({
+            content: expansion.blocks,
+            source: { kind: 'user' },
+        });
+        // The message is real from here on: remember its attached context BEFORE
+        // the agent call so the pre-step listener can find it (D6). A throwing
+        // followup/steer rolls both the pending preview and this entry back.
+        if (attach !== undefined)
+            attachedByMessageId.set(message.id, attach);
+        // Track BEFORE the agent call: a synchronous throw inside
+        // followup/steer rolls the preview back; otherwise the inbox events
+        // retire it once the message is claimed or discarded.
+        trackPending({ id: message.id, text, images }, placement);
+        try {
+            if (placement === 'steer')
+                origin.agent.steer(message);
+            else
+                origin.agent.followup(message);
+        }
+        catch (error) {
+            if (attach !== undefined)
+                attachedByMessageId.delete(message.id);
+            untrackPending(message.id);
+            throw error;
+        }
+        if (expansion.attached.length > 0) {
+            notify(t('mentions-attached', { count: expansion.attached.length }), { timeoutMs: 2500 });
+        }
+        if (expansion.missing.length > 0) {
+            notify(t('mentions-missing', { paths: expansion.missing.map(formatMissingReference).join(' ') }), {
+                color: 'warning',
+                timeoutMs: 4000,
+            });
+        }
+    };
+    /**
+     * RFC 0005 D-8: a flow parked on a plugin decision must be user-observable.
+     * Decisions normally resolve in milliseconds, so the notice only fires
+     * once the wait crosses a threshold — a slow plugin (e.g. one showing a
+     * managed dialog) then explains the pause instead of looking like the TUI
+     * ate the input.
+     */
+    const DECISION_PENDING_MS = 400;
+    /**
+     * Session-scoped ledger of live pending-decision indicators. A session
+     * replacement must cancel the notice timer and dismiss an already-visible
+     * sticky notice even when the plugin's decision promise never settles; the
+     * owner-scoped release alone would keep it up until channel teardown, and a
+     * timer firing after the switch would raise the notice into the session that
+     * replaced the one which parked the input (review finding: stale decision
+     * notices were no longer dismissed or suppressed on session change).
+     */
+    const pendingDecisionCleanups = new Set();
+    const withDecisionPending = (name, pending, origin) => {
+        let dismiss;
+        let timer;
+        const cleanup = () => {
+            if (timer !== undefined) {
+                clearTimeout(timer);
+                timer = undefined;
+            }
+            const raised = dismiss;
+            dismiss = undefined;
+            raised?.();
+            pendingDecisionCleanups.delete(cleanup);
+        };
+        timer = setTimeout(() => {
+            // Sticky (timeoutMs 0), D-8: the indicator must cover the WHOLE wait —
+            // an auto-expiring notice would vanish after ~4s while the decision,
+            // the delivery and every queued FIFO task behind them stay parked,
+            // leaving the user with no sign the flow is still waiting. It comes
+            // down only when the decision settles (finally below); a decision
+            // that never settles keeps its indicator up, which is the truthful
+            // state.
+            // A notice must never be raised for a session that has already been
+            // replaced: the switch drains this ledger, and the origin fence covers
+            // a timer that fires before that drain lands.
+            if (origin !== undefined && !current(origin)) {
+                cleanup();
+                return;
+            }
+            if (!owner.current())
+                return;
+            dismiss = notify(t('ext-decision-pending', { event: name }), { timeoutMs: 0 });
+        }, DECISION_PENDING_MS);
+        pendingDecisionCleanups.add(cleanup);
+        // Both exits are covered: a fast decision clears the timer before it
+        // fires; a slow one dismisses the indicator it raised. The owner release
+        // keeps the channel-teardown path working on top of the session drain.
+        const release = owner.own(cleanup);
+        return pending.finally(release);
+    };
+    /**
+     * The `tui/input` decision event (pi's `input` seam): the FIRST plugin
+     * returning a valid decision wins — transform the text, mark it handled,
+     * or cancel it. No listeners (or only crashing/malformed ones) means
+     * delivery proceeds unchanged, so a broken plugin can never wedge the
+     * input path — and can never skip a later veto listener either
+     * (dispatchTuiDecision isolates crashes and normalizes returns per
+     * listener instead of bailing on the first object).
+     *
+     * Decision AND delivery enter one FIFO chain in submission order: a slow
+     * listener on A parks A's delivery AND any later submissions behind it —
+     * without the chain, B's decision could resolve first and the model would
+     * receive B before A. Each submission binds its origin agent AT ENQUEUE,
+     * so a session switch landing before OR during its decision drops the
+     * stale text with a notice instead of sending the old conversation's
+     * words to the new session.
+     */
+    const runUserTextDecision = async (text, placement, images, origin, attach) => {
+        // Stale detection compares the AGENT REFERENCE, not the id: session ids
+        // are reusable (A → /new → /resume A lands back on the same id with a
+        // fresh agent), so an id check has an ABA hole. Both origin values are
+        // ENQUEUE-time captures (see dispatchUserText): a decision parked behind
+        // a slow predecessor must still be judged against the session its text
+        // was typed in, not whichever session is live when it finally runs.
+        const dropIfStale = () => {
+            if (current(origin))
+                return false;
+            notify(t('ext-stale-dropped'), { color: 'warning', timeoutMs: 4000 });
+            return true;
+        };
+        // A follower can wait behind an older slow decision while /new replaces
+        // the session. Do not even expose that stale text to plugins.
+        if (dropIfStale())
+            return;
+        const decision = await withDecisionPending('tui/input', dispatchTuiDecision(ctx, 'tui/input', {
+            text,
+            delivery: placement === 'steer' ? 'steer' : 'followup',
+            sessionId: origin.agentId,
+            cwd: origin.cwd,
+        }, normalizeInputDecision), origin);
+        // Staleness wins over cancel/handled: an old plugin result must neither
+        // toast into nor claim input from the replacement session.
+        if (dropIfStale())
+            return;
+        if (decision !== undefined) {
+            // Both intercepts toast — a bare {cancel}/{handled} must not make the
+            // typed line vanish silently (the host-localized fallback mirrors the
+            // other decision events' ext-action-cancelled handling).
+            if ('cancel' in decision) {
+                notify(decision.reason ?? t('ext-action-cancelled'), { color: 'warning', timeoutMs: 4000 });
+                return;
+            }
+            if ('handled' in decision) {
+                notify(decision.notice ?? t('ext-action-handled'), { timeoutMs: 4000 });
+                return;
+            }
+            text = decision.text.trim();
+        }
+        try {
+            await deliverUserText(text, placement, images, origin, attach);
+        }
+        catch (error) {
+            // The FIFO must survive a failed expansion/send: surface it, then let
+            // the next input proceed through the settled inputChain.
+            const message = error instanceof Error ? error.message : String(error);
+            logForDebugging(`submit: delivery failed (${message})`);
+            notify(t('send-failed', { err: message }), { color: 'error' });
+        }
+    };
+    const dispatchUserText = (text, placement, images = [], attach) => {
+        const origin = captureOrigin();
+        const capturedImages = composer.captureDraftImages(text, images);
+        inputChain = inputChain.then(() => runUserTextDecision(text, placement, capturedImages, origin, attach)).catch((error) => {
+            // The chain must survive a failed decision: log, then continue with
+            // the next queued submission.
+            ctx.logger.warn('dsh-tui: tui/input dispatch failed: %o', error);
+        });
+    };
+    /** Public companion for callers that own a line but not a draft (skill
+     *  registrations): same decision pass and FIFO as a typed submit. The
+     *  optional `attach` is registered by `deliverUserText` only once its user
+     *  message is real, then appended at the end of that message's step batch. */
+    const deliverUserTextNow = (text, placement, images = [], attach) => dispatchUserText(text, placement, images, attach);
+    /** Main's `clearStagedImages`: revoke capabilities AND release the FIFO so
+     *  a task parked on the replaced session cannot wedge the new one, and drop
+     *  every pending-decision indicator owned by the session being replaced. */
+    const clearStagedImages = () => {
+        composer.clearStagedImages();
+        inputChain = Promise.resolve();
+        for (const cleanup of [...pendingDecisionCleanups])
+            cleanup();
+    };
+    return {
+        dispatchUserText,
+        deliverUserText: deliverUserTextNow,
+        claimAttachments,
+        retireAttachment,
+        withDecisionPending,
+        clearStagedImages,
+        stageImage: (input) => composer.stageImage(input),
+        stagedImages: () => composer.snapshot(),
+        composer,
+    };
+}

package/lib/types/dsh-adapter/channel/job-projection.d.ts

@@ -0,0 +1,28 @@
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import { BackgroundJobStore, type JobsRuntime } from '../jobs.js';
+import type { ChannelOwner } from './owner.js';
+import type { ChannelState, JobControl } from './types.js';
+/**
+ * Current-binding background-job projection. The registry can publish every
+ * owner's changes, so callbacks must prove their attachment and Channel owner
+ * are still current before they read a service or mutate projected rows.
+ */
+export declare function createJobProjection(getState: () => Pick<ChannelState, 'backgroundJobs' | 'rows' | 'emit'>, deps: {
+    owner: Pick<ChannelOwner, 'current' | 'own'>;
+    notify(text: string, options?: {
+        color?: 'success' | 'error' | 'warning';
+        timeoutMs?: number;
+    }): unknown;
+    rowIds: {
+        value: number;
+    };
+    agent(): Agent;
+    steer(text: string): void;
+}): {
+    store: BackgroundJobStore;
+    control: JobControl;
+    attach: (jobs: JobsRuntime | undefined, ownService?: (dispose: () => void) => void) => void;
+    dropRows: () => void;
+    reset: () => void;
+};
+//# sourceMappingURL=job-projection.d.ts.map

package/lib/types/dsh-adapter/channel/job-projection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-projection.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/job-projection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAA;AAGnD,OAAO,EAAE,kBAAkB,EAAqB,KAAK,WAAW,EAAE,MAAM,YAAY,CAAA;AACpF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAW,UAAU,EAAE,MAAM,YAAY,CAAA;AAEnE;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,MAAM,IAAI,CAAC,YAAY,EAAE,gBAAgB,GAAG,MAAM,GAAG,MAAM,CAAC,EACtE,IAAI,EAAE;IACJ,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,SAAS,GAAG,KAAK,CAAC,CAAA;IAC5C,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAA;IACxG,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;IACzB,KAAK,IAAI,KAAK,CAAA;IACd,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;CAC1B;;;mBA4EqB,WAAW,GAAG,SAAS,eAAe,CAAC,OAAO,EAAE,MAAM,IAAI,KAAK,IAAI,KAAG,IAAI;oBAwD3E,IAAI;iBACP,IAAI;EAGvB"}

package/lib/types/dsh-adapter/channel/job-projection.js

@@ -0,0 +1,150 @@
+import { markChannelReadDirty } from '../../adapter/channel/read-view.js';
+import { t } from '../../i18n.js';
+import { BackgroundJobStore, formatJobDuration } from '../jobs.js';
+/**
+ * Current-binding background-job projection. The registry can publish every
+ * owner's changes, so callbacks must prove their attachment and Channel owner
+ * are still current before they read a service or mutate projected rows.
+ */
+export function createJobProjection(getState, deps) {
+    const jobRowsByJobId = new Map();
+    let jobsRuntime;
+    let detachActive;
+    let attachmentToken;
+    let attachmentCurrent = () => false;
+    const syncRows = () => {
+        if (!attachmentCurrent())
+            return;
+        const state = getState();
+        state.backgroundJobs = store.snapshot();
+        for (const job of state.backgroundJobs) {
+            let row = jobRowsByJobId.get(job.id);
+            if (!row) {
+                row = { id: deps.rowIds.value++, kind: 'job', text: job.label, job: undefined };
+                jobRowsByJobId.set(job.id, row);
+                state.rows.push(row);
+            }
+            row.job = {
+                id: job.id,
+                kind: job.kind,
+                label: job.label,
+                status: job.status,
+                ...(job.detail === undefined ? {} : { detail: job.detail }),
+                startedAt: job.startedAt,
+                ...(job.finishedAt === undefined ? {} : { finishedAt: job.finishedAt }),
+                outputLines: job.outputLines,
+            };
+            row.text = job.label;
+            markChannelReadDirty(row);
+            markChannelReadDirty(state.rows);
+        }
+    };
+    const store = new BackgroundJobStore({
+        onSettled(job) {
+            deps.notify(t(job.status === 'completed' ? 'jobs-toast-completed' : job.status === 'failed' ? 'jobs-toast-failed' : 'jobs-toast-killed', {
+                id: job.id,
+                label: job.label,
+                duration: formatJobDuration(job),
+                detail: job.detail ?? '',
+            }), { color: job.status === 'completed' ? 'success' : job.status === 'failed' ? 'error' : 'warning', timeoutMs: 6000 });
+        },
+        onChanged() {
+            if (!attachmentCurrent())
+                return;
+            syncRows();
+            if (attachmentCurrent())
+                getState().emit();
+        },
+    });
+    const control = {
+        kill(id) {
+            const jobs = jobsRuntime;
+            if (!jobs?.kill)
+                return false;
+            const job = store.get(id);
+            try {
+                jobs.kill(id, deps.agent(), 'dsh-tui /jobs panel');
+            }
+            catch {
+                return false;
+            }
+            if (job !== undefined && (job.status === 'running' || job.status === 'stopping')) {
+                deps.steer(t('jobs-steer-killed', { id, label: job.label }));
+            }
+            return true;
+        },
+    };
+    /**
+     * Each service attachment has one idempotent disposer, dual-owned by the
+     * Channel and (when injected) the service context. Reattachment revokes the
+     * prior token before the replacement may synchronously publish.
+     */
+    const attach = (jobs, ownService) => {
+        if (jobs === undefined)
+            return;
+        detachActive?.();
+        jobsRuntime = jobs;
+        const token = Symbol('jobs-attachment');
+        let detached = false;
+        let detach;
+        const current = () => !detached && attachmentToken === token && detachActive === detach && jobsRuntime === jobs && deps.owner.current();
+        const refresh = () => {
+            // Check before list(): retained callbacks must not touch a revoked or
+            // replaced service, nor invoke any store/row work after owner disposal.
+            if (!current())
+                return;
+            try {
+                const snapshot = jobs.list(deps.agent());
+                if (!current())
+                    return;
+                store.replace(snapshot);
+            }
+            catch { /* optional service is disposing */ }
+        };
+        // Publish the attachment identity before subscription: registries are
+        // allowed to synchronously deliver their current snapshot from on*().
+        // Every registration below is transactional because a second on*() can
+        // throw after the first one successfully subscribed.
+        const disposers = [];
+        let releaseOwner;
+        detach = () => {
+            if (detached)
+                return;
+            detached = true;
+            if (detachActive === detach) {
+                detachActive = undefined;
+                attachmentToken = undefined;
+                attachmentCurrent = () => false;
+            }
+            if (jobsRuntime === jobs)
+                jobsRuntime = undefined;
+            for (const dispose of disposers.splice(0))
+                dispose?.();
+            // A service-context detach happens before channel teardown on remount;
+            // release its Channel owner entry now rather than retaining one cleanup
+            // per remount until the entire channel exits.
+            const release = releaseOwner;
+            releaseOwner = undefined;
+            release?.();
+        };
+        detachActive = detach;
+        attachmentToken = token;
+        attachmentCurrent = current;
+        try {
+            if (typeof jobs.onJobsChanged === 'function')
+                disposers.push(jobs.onJobsChanged(refresh));
+            if (typeof jobs.onJobDone === 'function')
+                disposers.push(jobs.onJobDone(refresh));
+            releaseOwner = deps.owner.own(detach);
+            ownService?.(detach);
+            refresh();
+        }
+        catch (error) {
+            detach();
+            throw error;
+        }
+    };
+    const dropRows = () => { jobRowsByJobId.clear(); };
+    const reset = () => { dropRows(); store.reset(); };
+    return { store, control, attach, dropRows, reset };
+}