@nomix-ai/nomix-harness 0.2.5 → 0.2.6

package/dist/kernel/client-ui-conversation/lib/types/client/input/contract.d.ts

@@ -29,7 +29,7 @@ export interface SessionInput extends InputTarget {
     setDraft(text: string): void;
     /** Append ordered browser-owned image ids; busy admission phases refuse. */
     addImages(ids: readonly DraftAttachmentId[]): boolean;
-    /** Remove one browser-owned image id. */
+    /** Remove one browser-owned image id; busy admission phases refuse. */
     removeImage(id: DraftAttachmentId): void;
     /** Drop ids whose browser-owned objects no longer exist. */
     pruneImages(ids: readonly DraftAttachmentId[]): void;
@@ -67,7 +67,7 @@ export interface InputActions {
     setDraft(text: string): void;
     /** Append ordered browser-owned image ids; busy admission phases refuse. */
     addImages(ids: readonly DraftAttachmentId[]): boolean;
-    /** Remove one browser-owned image id. */
+    /** Remove one browser-owned image id; busy admission phases refuse. */
     removeImage(id: DraftAttachmentId): void;
     /** Drop ids whose browser-owned objects no longer exist. */
     pruneImages(ids: readonly DraftAttachmentId[]): void;
@@ -134,9 +134,9 @@ export interface EditRange extends EditSelection {
     readonly insertedLength: number;
 }
 /**
- * One reference chip occurrence, backing exactly one U+FFFC placeholder in
- * the draft. Identity is occurrenceId — same-named
- * references stay independently addressable. label/clipboardText are the
+ * One reference occurrence backed by its complete inline display text in the
+ * draft. Identity is occurrenceId — same-named
+ * references stay independently addressable. label/appearance/clipboardText are the
  * owner's insert-time projections, cached so the chip survives owner loss
  * (invalid flips instead of dropping the occurrence).
  */
@@ -147,10 +147,14 @@ export interface Occurrence {
     readonly source: string;
     /** Owner-scoped reference id. */
     readonly ref: string;
-    /** Placeholder offset in the draft; the occurrence occupies exactly [offset, offset+1). */
+    /** Display-text offset in the draft. */
     readonly offset: number;
-    /** Chip display label (insert-time cache). */
+    /** Display-text length; the occurrence occupies exactly [offset, offset+length). */
+    readonly length: number;
+    /** Inline display label (insert-time cache). */
     readonly label: string;
+    /** Optional domain glyph (insert-time cache). */
+    readonly appearance?: ReferenceInsert['appearance'];
     /** Clipboard / persistence projection, e.g. `/name` (insert-time cache, never the model form). */
     readonly clipboardText: string;
     /** Owner-resolution failure flag: chip renders invalid; serialization must fail. */
@@ -198,8 +202,9 @@ export interface InputState {
     readonly claim?: {
         readonly token: string;
         readonly hint?: string;
+        readonly images?: boolean;
     };
-    /** Chip occurrence table, sorted by offset (one U+FFFC per entry). */
+    /** Reference occurrence table, sorted by offset. */
     readonly occurrences: readonly Occurrence[];
     /** Live paste-match attempt (absent when no paste is matchable). */
     readonly paste?: PasteAttemptState;
@@ -215,7 +220,7 @@ export interface InputState {
 export interface SubmitAttempt {
     readonly seq: number;
     readonly signal: AbortSignal;
-    /** Draft at enter time; rollback restores it only while the live draft still equals it. */
+    /** Draft at enter time; settlement clears it only after acceptance. */
     readonly draftSnapshot: string;
     /** Default-message delivery intent retained while slash adjudication is pending. */
     readonly mode: InputSubmitMode;
@@ -237,7 +242,7 @@ export type InputEvent =
     readonly claim: CommandClaim;
     readonly span: TokenSpan;
 }
-/** Place one U+FFFC at the span and mint the occurrence (scoped insert-reference event payload). */
+/** Place one inline reference at the span and mint the occurrence (scoped insert-reference event payload). */
  | {
     readonly type: 'insert-ref';
     readonly reference: ReferenceInsert;
@@ -298,10 +303,7 @@ export type InputEvent =
     readonly outcome?: SubmitOutcome;
     readonly message?: string;
 }
-/**
- * An ordinary (default-sink) send was accepted: clear the draft as a COMMIT —
- * undo must not resurrect sent content (mirrors submit-settled's success arm).
- */
+/** Commit an image-only send whose empty draft did not need an attempt. */
  | {
     readonly type: 'send-committed';
 } | {
@@ -323,6 +325,7 @@ export type InputEffect = {
     readonly args: string;
 } | {
     readonly type: 'default-sink';
+    readonly attempt: SubmitAttempt;
     readonly draft: string;
     readonly mode: InputSubmitMode;
 } | {

package/dist/kernel/client-ui-conversation/lib/types/client/input/decorations.d.ts

@@ -1,6 +1,6 @@
 /**
- * Draft decoration pure core (chips render from the occurrence
- * table at placeholder offsets; the claim token renders as a mirror-layer
+ * Draft decoration pure core (references render from occurrence ranges; the
+ * claim token renders as a mirror-layer
  * highlight, the claim hint as ghost text). Zero React — the skeleton renders
  * the instructions; tests drive this directly.
  */
@@ -10,13 +10,19 @@ export interface TokenRange {
     readonly start: number;
     readonly end: number;
 }
-/** One chip render instruction: the placeholder at `offset` draws as `label`. */
+/** One structured inline-reference render instruction. */
 export interface ChipRender {
     /** Stable render key (same-labeled chips stay independent). */
     readonly occurrenceId: number;
-    /** Placeholder offset in the draft (the chip occupies [offset, offset+1)). */
+    /** Display-text offset in the draft. */
     readonly offset: number;
+    /** Display-text length in the draft. */
+    readonly length: number;
+    /** Exact inline text whose native glyph metrics determine layout. */
+    readonly text: string;
     readonly label: string;
+    /** Optional domain glyph beside the label. */
+    readonly appearance?: 'session' | 'file' | 'folder';
     /** Owner-resolution failure styling bit. */
     readonly invalid: boolean;
 }
@@ -31,6 +37,8 @@ export interface TextRefRange {
     readonly start: number;
     readonly end: number;
     readonly trigger: '/' | '@';
+    /** Optional icon domain for syntax-recognizable plain references. */
+    readonly appearance?: 'folder';
 }
 /** Decoration product: claim token range + chip instructions + text-ref ranges + the ghost hint. */
 export interface DraftDecorations {
@@ -38,7 +46,7 @@ export interface DraftDecorations {
     readonly token: TokenRange | null;
     /** Chip render instructions in draft order (occurrence table is offset-sorted). */
     readonly chips: readonly ChipRender[];
-    /** Scan-derived plain-text reference ranges (empty without a lexicon). */
+    /** Scan-derived lexicon tokens and syntax-recognizable folder ranges. */
     readonly textRefs: readonly TextRefRange[];
     /** Ghost hint shown while the claim's args are blank; null otherwise. */
     readonly hint: string | null;

package/dist/kernel/client-ui-conversation/lib/types/client/input/decorations.js

@@ -1,5 +1,6 @@
 /** Token matcher: a trigger char at line start or after whitespace, then a word-ish name (never crosses \n). */
 const TEXT_REF_RE = /(^|\s)([/@])([\w-]+)/g;
+const FOLDER_REF_RE = /(^|\s)(@(?:"[^"\n]*\/|[^\s"]+\/))/g;
 /**
  * Scan the draft for plain-text reference tokens against the hot lexicons.
  * Word-boundary discipline: the trigger must sit at the draft
@@ -10,20 +11,32 @@ const TEXT_REF_RE = /(^|\s)([/@])([\w-]+)/g;
  * @returns matched ranges in draft order.
  */
 export function scanTextRefs(draft, lexicon) {
-    if (lexicon.size === 0 || draft === '')
+    if (draft === '')
         return [];
     const out = [];
-    TEXT_REF_RE.lastIndex = 0;
-    let m;
-    while ((m = TEXT_REF_RE.exec(draft)) !== null) {
-        const trigger = m[2];
-        const name = m[3] ?? '';
-        if (lexicon.get(trigger)?.includes(name)) {
-            const start = m.index + (m[1]?.length ?? 0);
-            out.push({ start, end: start + 1 + name.length, trigger });
+    if (lexicon.size > 0) {
+        TEXT_REF_RE.lastIndex = 0;
+        let m;
+        while ((m = TEXT_REF_RE.exec(draft)) !== null) {
+            const trigger = m[2];
+            const name = m[3] ?? '';
+            if (lexicon.get(trigger)?.includes(name)) {
+                const start = m.index + (m[1]?.length ?? 0);
+                out.push({ start, end: start + 1 + name.length, trigger });
+            }
         }
     }
-    return out;
+    FOLDER_REF_RE.lastIndex = 0;
+    let folder;
+    while ((folder = FOLDER_REF_RE.exec(draft)) !== null) {
+        const token = folder[2] ?? '';
+        const start = folder.index + (folder[1]?.length ?? 0);
+        const end = start + token.length;
+        if (!out.some(range => range.start < end && range.end > start)) {
+            out.push({ start, end, trigger: '@', appearance: 'folder' });
+        }
+    }
+    return out.sort((left, right) => left.start - right.start);
 }
 /** The empty lexicon (default: zero text-ref decorations, old call sites unchanged). */
 const EMPTY_LEXICON = new Map();
@@ -41,7 +54,10 @@ export function deriveDecorations(state, lexicon = EMPTY_LEXICON) {
     const chips = occurrences.map(o => ({
         occurrenceId: o.occurrenceId,
         offset: o.offset,
+        length: o.length,
+        text: draft.slice(o.offset, o.offset + o.length),
         label: o.label,
+        ...o.appearance === undefined ? {} : { appearance: o.appearance },
         invalid: o.invalid === true,
     }));
     const hint = claimActive && claim.hint !== undefined && draft.slice(claim.token.length).trim() === ''

package/dist/kernel/client-ui-conversation/lib/types/client/input/facade.d.ts

@@ -7,7 +7,7 @@
  * event listeners onto it.
  */
 import type { ClientContext, ObservableSnapshot, SnapshotStore } from '../../../../../client-runtime/lib/client.js';
-import type { ArbitrateKey, ArbitrateOutcome, CommandClaim, ConsumeTokenRequest, ReferenceInsert, InputTriggerController, TokenSpan } from '../../../../../client-ui-input-trigger/lib/client.js';
+import type { ArbitrateKey, ArbitrateOutcome, CommandClaim, ConsumeTokenRequest, ReferenceInsert, InputTriggerController, SubmitImageAttachment, SubmitOutcome, TokenSpan } from '../../../../../client-ui-input-trigger/lib/client.js';
 import type { DraftAttachmentId, EditRange, EditSelection, InputActions, InputNotice, InputState, PasteComponent, QueuedMessage, SessionInput } from './contract.ts';
 import type { InputSubmitMode } from '../contract/composer-submission.ts';
 /** Popup face the shell needs (dismissal only; typed structurally to avoid a value import). */
@@ -35,7 +35,16 @@ export interface SessionInputDeps {
      */
     steerQueue?: (() => void) | undefined;
     /** The plain-message sink (send choreography / materialize fork — the hub owns it). */
-    defaultSink(text: string, imageIds: readonly DraftAttachmentId[], mode: InputSubmitMode): void;
+    defaultSink(text: string, imageIds: readonly DraftAttachmentId[], mode: InputSubmitMode, signal: AbortSignal): Promise<SubmitOutcome>;
+    /** Command-plane image plumbing (the hub owns the conversation face and the copy). */
+    commandImages: {
+        /** Resolve ordered draft ids to wire payloads without sending them; rejects when an id no longer resolves. */
+        serialize(ids: readonly DraftAttachmentId[]): Promise<readonly SubmitImageAttachment[]>;
+        /** Free consumed draft images after a successful command submit. */
+        release(ids: readonly DraftAttachmentId[]): void;
+        /** Localized composer notice for a claimed command that does not accept images. */
+        unsupportedNotice(token: string): string;
+    };
 }
 /**
  * The per-session input facade: scoped-event application verbs +
@@ -45,16 +54,18 @@ export declare class SessionInputShell implements SessionInput {
     private readonly deps;
     /** Published machine state + queue overlay (the InputZone currency source). */
     readonly state: SnapshotStore<InputState>;
-    /** Latest surfaced notice (null after clear); the wiring renders it beside the error strip. */
+    /** Latest surfaced notice (null after clear); the bar renders errors as banners and information inline. */
     readonly notices: SnapshotStore<InputNotice | null>;
     /** The public provide-channel action face (one stable identity per session). */
     readonly actions: InputActions;
     private readonly core;
     private noticeSeq;
-    private lastDraft;
+    private lastMirroredDraft;
     private imageIds;
+    /** One image-only send at a time: Enter during the Host round-trip is a no-op. */
+    private imageSendInFlight;
     private disposed;
-    /** Draft persistence mirror (chat store write; receives the clipboard projection, never raw placeholders). */
+    /** Draft persistence mirror (chat store write; receives the clipboard projection, never display-only ranges). */
     private mirrorFn;
     constructor(deps: SessionInputDeps);
     /**
@@ -66,18 +77,17 @@ export declare class SessionInputShell implements SessionInput {
     setDraft(text: string, editRange?: EditRange): void;
     /** Append ordered image ids unless an admission transaction is locked. */
     addImages(ids: readonly DraftAttachmentId[]): boolean;
-    /** Remove one image id from this draft. */
+    /**
+     * Remove one image id from this draft. Busy admission phases refuse, like
+     * {@link addImages}: a removal landing while a command submit serializes
+     * would otherwise vanish from the rail yet still ride the in-flight send.
+     */
     removeImage(id: DraftAttachmentId): void;
     /**
      * Keep only image ids that still resolve in the browser attachment registry.
      * @param available - live registry ids.
      */
     pruneImages(available: readonly DraftAttachmentId[]): void;
-    /**
-     * Restore a failed attempt before any images added after its admission.
-     * @param ids - failed attempt image ids.
-     */
-    restoreImages(ids: readonly DraftAttachmentId[]): void;
     /**
      * Clear the draft as a successful-send commit: no undo unit is recorded and
      * the undo history is cut, so Ctrl/Cmd-Z cannot resurrect sent content
@@ -175,9 +185,11 @@ export declare class SessionInputShell implements SessionInput {
      * a scan-derived decoration, never state.
      * @param text - the plain reference text to splice in (e.g. `/name `).
      * @param span - pick-time span snapshot (draftRev CAS).
+     * @param keepCompleting - re-track at the caret after the splice so an open
+     * token (a directory pick's trailing slash) reopens the menu.
      * @returns whether the text was applied.
      */
-    insertText(text: string, span: TokenSpan): boolean;
+    insertText(text: string, span: TokenSpan, keepCompleting?: boolean): boolean;
     /**
      * Surface a notice from outside the machine (detached command results).
      * @param level - severity tier.
@@ -201,15 +213,23 @@ export declare class SessionInputShell implements SessionInput {
     private execute;
     /**
      * Prompt serialization before the sink: expand each
-     * placeholder to its owner's model form via the session controller's
+     * inline reference range to its owner's model form via the session controller's
      * codec routing. Owner missing / serialize failure / disposal blocks the
      * send — notice + draft and chips retained, never a silent downgrade to
      * the clipboard text. Chip-free drafts skip the async detour.
      */
     private sinkSerialized;
+    /** Settle one admission attempt; successful sends consume only their captured images. */
+    private settleSubmit;
     /** Enter adjudication: poll the session controller; failure = notice + draft retained (never a silent downgrade). */
     private adjudicate;
-    /** The submit transaction: claim.submit against the session scope; ok maps from the outcome kind. */
+    /**
+     * The submit transaction: claim.submit against the session scope; ok maps
+     * from the outcome kind. An accepting claim receives the serialized draft
+     * images, which are cleared and released only on a success outcome; a
+     * failure (serialize, transport, or handler error) keeps draft and images
+     * for correction.
+     */
     private beginSubmit;
     /** Late-settlement guard: superseded attempts and disposed facades drop silently. */
     private dead;

package/dist/kernel/client-ui-conversation/lib/types/client/input/facade.js

@@ -1,5 +1,5 @@
 import { createSnapshotStore } from '../../../../../client-runtime/lib/client.js';
-import { InputMachine } from "./machine.js";
+import { InputMachine, projectClipboard } from "./machine.js";
 /** Guard tier from the machine phase. */
 function guardOf(phase) {
     switch (phase) {
@@ -19,7 +19,7 @@ export class SessionInputShell {
     deps;
     /** Published machine state + queue overlay (the InputZone currency source). */
     state;
-    /** Latest surfaced notice (null after clear); the wiring renders it beside the error strip. */
+    /** Latest surfaced notice (null after clear); the bar renders errors as banners and information inline. */
     notices = createSnapshotStore(null);
     /** The public provide-channel action face (one stable identity per session). */
     actions = {
@@ -33,10 +33,12 @@ export class SessionInputShell {
     // production (the machine's no-clock default is a constant for pure tests).
     core = new InputMachine({ now: () => Date.now() });
     noticeSeq = 0;
-    lastDraft = '';
+    lastMirroredDraft = '';
     imageIds = [];
+    /** One image-only send at a time: Enter during the Host round-trip is a no-op. */
+    imageSendInFlight = false;
     disposed = false;
-    /** Draft persistence mirror (chat store write; receives the clipboard projection, never raw placeholders). */
+    /** Draft persistence mirror (chat store write; receives the clipboard projection, never display-only ranges). */
     mirrorFn;
     constructor(deps) {
         this.deps = deps;
@@ -63,8 +65,14 @@ export class SessionInputShell {
         this.publish();
         return true;
     }
-    /** Remove one image id from this draft. */
+    /**
+     * Remove one image id from this draft. Busy admission phases refuse, like
+     * {@link addImages}: a removal landing while a command submit serializes
+     * would otherwise vanish from the rail yet still ride the in-flight send.
+     */
     removeImage(id) {
+        if (this.snapshot.phase === 'adjudicating' || this.snapshot.phase === 'submitting')
+            return;
         const next = this.imageIds.filter(candidate => candidate !== id);
         if (next.length === this.imageIds.length)
             return;
@@ -83,15 +91,6 @@ export class SessionInputShell {
         this.imageIds = next;
         this.publish();
     }
-    /**
-     * Restore a failed attempt before any images added after its admission.
-     * @param ids - failed attempt image ids.
-     */
-    restoreImages(ids) {
-        const current = new Set(this.imageIds);
-        this.imageIds = [...ids.filter(id => !current.has(id)), ...this.imageIds];
-        this.publish();
-    }
     /**
      * Clear the draft as a successful-send commit: no undo unit is recorded and
      * the undo history is cut, so Ctrl/Cmd-Z cannot resurrect sent content
@@ -138,8 +137,32 @@ export class SessionInputShell {
      */
     submit(mode = 'queue') {
         if (this.snapshot.draft.trim() === '' && this.imageIds.length > 0) {
-            if (this.snapshot.phase === 'plain')
-                this.deps.defaultSink('', [...this.imageIds], mode);
+            if (this.snapshot.phase === 'plain' && !this.imageSendInFlight) {
+                const imageIds = [...this.imageIds];
+                this.imageSendInFlight = true;
+                void this.deps.defaultSink('', imageIds, mode, new AbortController().signal).then((outcome) => {
+                    this.imageSendInFlight = false;
+                    if (this.disposed)
+                        return;
+                    if (outcome.kind === 'success')
+                        this.commitSend(imageIds);
+                    else if (outcome.text !== undefined)
+                        this.notify('error', outcome.text);
+                }, (error) => {
+                    this.imageSendInFlight = false;
+                    if (!this.disposed)
+                        this.notify('error', error instanceof Error ? error.message : String(error));
+                });
+            }
+            return;
+        }
+        // Claimed pre-gate: a claim that does not declare image acceptance never
+        // submits while images are attached — one notice, everything retained.
+        // Enter-time adjudication applies the same policy for unclaimed lines
+        // inside the command source itself.
+        const before = this.snapshot;
+        if (before.phase === 'claimed' && this.imageIds.length > 0 && before.claim?.images !== true) {
+            this.notify('error', this.deps.commandImages.unsupportedNotice(before.claim?.token ?? before.draft));
             return;
         }
         this.run(this.core.dispatch({ type: 'enter', mode }));
@@ -262,14 +285,22 @@ export class SessionInputShell {
      * a scan-derived decoration, never state.
      * @param text - the plain reference text to splice in (e.g. `/name `).
      * @param span - pick-time span snapshot (draftRev CAS).
+     * @param keepCompleting - re-track at the caret after the splice so an open
+     * token (a directory pick's trailing slash) reopens the menu.
      * @returns whether the text was applied.
      */
-    insertText(text, span) {
+    insertText(text, span, keepCompleting = false) {
         const snapshot = this.core.state;
         if (span.draftRev !== snapshot.draftRev)
             return false;
         const draft = snapshot.draft;
         this.setDraft(draft.slice(0, span.start) + text + draft.slice(span.end));
+        if (keepCompleting) {
+            // Machine-driven draft replacement never passes through onChange, so
+            // re-track at the caret inside the still-open token (see space()).
+            const next = this.snapshot;
+            this.deps.inputTriggers?.()?.track(next.draft, span.start + text.length, { tier: guardOf(next.phase) }, next.draftRev);
+        }
         return true;
     }
     /**
@@ -328,7 +359,7 @@ export class SessionInputShell {
                 return;
             }
             case 'default-sink': {
-                this.sinkSerialized(fx.draft, fx.mode);
+                this.sinkSerialized(fx.attempt, fx.draft, fx.mode);
                 return;
             }
             default:
@@ -337,16 +368,16 @@ export class SessionInputShell {
     }
     /**
      * Prompt serialization before the sink: expand each
-     * placeholder to its owner's model form via the session controller's
+     * inline reference range to its owner's model form via the session controller's
      * codec routing. Owner missing / serialize failure / disposal blocks the
      * send — notice + draft and chips retained, never a silent downgrade to
      * the clipboard text. Chip-free drafts skip the async detour.
      */
-    sinkSerialized(draft, mode) {
+    sinkSerialized(attempt, draft, mode) {
         const imageIds = [...this.imageIds];
         const occurrences = this.core.state.occurrences;
         if (occurrences.length === 0) {
-            this.deps.defaultSink(draft.trim(), imageIds, mode);
+            this.settleSubmit(attempt, this.deps.defaultSink(draft.trim(), imageIds, mode, attempt.signal), imageIds);
             return;
         }
         const inputTriggers = this.deps.inputTriggers?.();
@@ -354,26 +385,56 @@ export class SessionInputShell {
         void Promise.all(occurrences.map(async (o) => {
             if (inputTriggers === undefined)
                 throw new Error(`no serializer for reference source "${o.source}"`);
-            return { offset: o.offset, text: await inputTriggers.serializeReference(o.source, o.ref, controller.signal) };
+            return {
+                offset: o.offset,
+                length: o.length,
+                text: await inputTriggers.serializeReference(o.source, o.ref, controller.signal),
+            };
         })).then((parts) => {
             if (this.disposed)
                 return;
-            // Splice model forms over their placeholders (offsets are draft-time;
+            // Splice model forms over their display ranges (offsets are draft-time;
             // parts arrive offset-sorted since the table is).
             let out = '';
             let cursor = 0;
             for (const part of parts) {
                 out += draft.slice(cursor, part.offset) + part.text;
-                cursor = part.offset + 1;
+                cursor = part.offset + part.length;
             }
             out += draft.slice(cursor);
-            this.deps.defaultSink(out.trim(), imageIds, mode);
+            this.settleSubmit(attempt, this.deps.defaultSink(out.trim(), imageIds, mode, attempt.signal), imageIds);
         }, (error) => {
             controller.abort();
-            if (this.disposed)
+            if (this.dead(attempt))
                 return;
             const message = error instanceof Error ? error.message : String(error);
-            this.notify('error', message);
+            this.run(this.core.dispatch({ type: 'submit-settled', attempt, ok: false, message }));
+        });
+    }
+    /** Settle one admission attempt; successful sends consume only their captured images. */
+    settleSubmit(attempt, pending, imageIds = []) {
+        pending.then((outcome) => {
+            if (this.dead(attempt))
+                return;
+            if (outcome.kind === 'success' && imageIds.length > 0) {
+                const submitted = new Set(imageIds);
+                this.imageIds = this.imageIds.filter(id => !submitted.has(id));
+            }
+            this.run(this.core.dispatch({
+                type: 'submit-settled',
+                attempt,
+                ok: outcome.kind === 'success',
+                outcome,
+            }));
+        }, (error) => {
+            if (this.dead(attempt))
+                return;
+            this.run(this.core.dispatch({
+                type: 'submit-settled',
+                attempt,
+                ok: false,
+                message: error instanceof Error ? error.message : String(error),
+            }));
         });
     }
     /** Enter adjudication: poll the session controller; failure = notice + draft retained (never a silent downgrade). */
@@ -384,7 +445,7 @@ export class SessionInputShell {
             this.run(this.core.dispatch({ type: 'adjudicated', attempt, outcome: undefined }));
             return;
         }
-        inputTriggers.adjudicate(draft.trim(), attempt.signal).then((outcome) => {
+        inputTriggers.adjudicate(draft.trim(), attempt.signal, { images: this.imageIds.length }).then((outcome) => {
             if (this.dead(attempt))
                 return;
             this.run(this.core.dispatch({ type: 'adjudicated', attempt, outcome }));
@@ -395,15 +456,35 @@ export class SessionInputShell {
             this.run(this.core.dispatch({ type: 'adjudication-failed', attempt, message }));
         });
     }
-    /** The submit transaction: claim.submit against the session scope; ok maps from the outcome kind. */
+    /**
+     * The submit transaction: claim.submit against the session scope; ok maps
+     * from the outcome kind. An accepting claim receives the serialized draft
+     * images, which are cleared and released only on a success outcome; a
+     * failure (serialize, transport, or handler error) keeps draft and images
+     * for correction.
+     */
     beginSubmit(attempt, claim, args) {
+        const imageIds = claim.images === true ? [...this.imageIds] : [];
         Promise.resolve()
-            .then(() => claim.submit(args, this.deps.actx))
-            .then((outcome) => {
+            .then(async () => {
+            const images = imageIds.length > 0 ? await this.deps.commandImages.serialize(imageIds) : [];
+            // Serialization may outlive the attempt (large files, session
+            // teardown); a dead attempt must not reach the Host executor.
             if (this.dead(attempt))
+                return undefined;
+            return claim.submit(args, this.deps.actx, images);
+        })
+            .then((outcome) => {
+            if (outcome === undefined || this.dead(attempt))
                 return;
+            if (outcome.kind === 'success' && imageIds.length > 0) {
+                const submitted = new Set(imageIds);
+                this.imageIds = this.imageIds.filter(id => !submitted.has(id));
+                this.deps.commandImages.release(imageIds);
+            }
             this.run(this.core.dispatch({
                 type: 'submit-settled', attempt, ok: outcome.kind === 'success', outcome,
+                ...(outcome.kind === 'error' && outcome.text === undefined ? { message: 'command failed' } : {}),
             }));
         }, (error) => {
             if (this.dead(attempt))
@@ -423,9 +504,10 @@ export class SessionInputShell {
     publish() {
         const next = this.compose();
         this.state.set(next);
-        if (next.draft !== this.lastDraft) {
-            this.lastDraft = next.draft;
-            this.mirrorFn?.(next.draft);
+        const mirroredDraft = projectClipboard(next);
+        if (mirroredDraft !== this.lastMirroredDraft) {
+            this.lastMirroredDraft = mirroredDraft;
+            this.mirrorFn?.(mirroredDraft);
         }
     }
 }

package/dist/kernel/client-ui-conversation/lib/types/client/input/hub.d.ts

@@ -64,7 +64,7 @@ export declare class InputHub implements SessionInputResolver {
      * Default sink: optimistic clear + prompt. The session is always a real
      * host entity (materialized when its workspace was picked), so there is
      * exactly one path; a failed first prompt is an ordinary prompt failure
-     * (error strip via promptError, draft restored only while untouched).
+     * (banner via promptError, draft restored only while untouched).
      */
     private sink;
     /**