@nomix-ai/nomix-harness 0.2.4 → 0.2.6

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;
     /**

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

@@ -43,8 +43,23 @@ export class InputHub {
             inputTriggers: () => this.controller(actx),
             popup: () => this.popup(actx),
             queue: queueReadFaceOf(session),
-            defaultSink: (text, imageIds, mode) => { this.sink(session, text, imageIds, mode); },
+            defaultSink: (text, imageIds, mode, signal) => this.sink(session, text, imageIds, mode, signal),
             steerQueue: () => { void this.steerQueue(session, shell); },
+            commandImages: {
+                serialize: ids => this.conversation().serializeDraftImages(ids),
+                // Asymmetric with serialize on purpose: release settles AFTER the
+                // submit RPC, where session teardown may already have unloaded the
+                // conversation service (the same tolerance as the scope disposer
+                // above); leaked preview URLs then die with the document.
+                release: (ids) => {
+                    const conversation = this.rootCtx.get('conversation');
+                    for (const imageId of ids)
+                        conversation?.releaseDraftImage(imageId);
+                },
+                unsupportedNotice: token => this.t('command.imagesUnsupported', {
+                    command: token.trim().replace(/^\//u, ''),
+                }),
+            },
         });
         this.shells.set(id, shell);
         // The one teardown axis: listeners, shell, and map entries all ride the
@@ -54,7 +69,7 @@ export class InputHub {
                 actx.on('slash/input-begin-command', req => shell.beginCommand(req.claim, req.span) ? true : undefined),
                 actx.on('slash/input-insert-reference', req => shell.insertReference(req.reference, req.span) ? true : undefined),
                 actx.on('slash/input-consume-token', req => shell.consumeToken(req.guard) ? true : undefined),
-                actx.on('slash/input-insert-text', req => shell.insertText(req.text, req.span) ? true : undefined),
+                actx.on('slash/input-insert-text', req => shell.insertText(req.text, req.span, req.continue === true) ? true : undefined),
             ];
             return () => {
                 for (const off of offs)
@@ -108,25 +123,12 @@ export class InputHub {
      * 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).
      */
-    sink(session, text, imageIds, mode) {
+    sink(session, text, imageIds, mode, signal) {
         if (text === '' && imageIds.length === 0)
-            return;
-        const shell = this.shells.get(session.sessionId);
-        // Commit, not an editable clear: undo must not resurrect sent content.
-        shell?.commitSend(imageIds);
-        void this.conversation().sendSession(session, text, imageIds, mode).catch(() => {
-            if (this.shells.get(session.sessionId) === shell) {
-                shell?.restoreImages(imageIds);
-                if (shell?.snapshot.draft === '')
-                    shell.setDraft(text);
-                return;
-            }
-            const conversation = this.rootCtx.get('conversation');
-            for (const id of imageIds)
-                conversation?.releaseDraftImage(id);
-        });
+            return Promise.resolve({ kind: 'success' });
+        return this.conversation().sendSession(session, text, imageIds, mode, signal);
     }
     /**
      * Steer every still-pending queued message into the running turn, in FIFO

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

@@ -1,11 +1,33 @@
+/**
+ * InputMachine: the pure per-session input state machine.
+ * Events in, effects out; zero React / DOM / cordis / ambient
+ * clock. Package-private — the SessionInput shell is the only caller and the
+ * sole executor of the returned effects.
+ *
+ * Draft truth: the draft string holds each reference's complete inline display
+ * text; the occurrence table carries identity, range, and the owner's cached projections. Every
+ * draft mutation is one transaction — draft edit, occurrence reconciliation,
+ * and undo-log push are atomic inside dispatch() — and bumps draftRev, which
+ * is what lets span CAS reduce to a revision-equality check: equal rev ⟹
+ * identical draft ⟹ identical span content. Callers observe mutation success
+ * as a draftRev advance (begin-command / insert-ref / consume-token /
+ * paste-upgrade all answer their bail events this way).
+ */
+import type { ReferenceInsert } from '../../../../../client-ui-input-trigger/lib/client.js';
 import type { InputEffect, InputEvent, InputMachineOptions, InputState } from './contract.ts';
-/** The object-replacement character backing every chip occurrence in the draft. */
+/** Legacy fixed-width object replacement character rejected from pasted text. */
 export declare const PLACEHOLDER = "\uFFFC";
 /**
- * Expand the draft's placeholders into their occurrences' clipboard text
- * (the persistence mirror and clipboard both write this
- * projection — U+FFFC never leaves the machine). Table order is offset
- * order, so one linear walk pairs placeholders with entries.
+ * Build the inline draft text whose leading marker is decorated as the
+ * reference icon in the backdrop.
+ * @param reference - reference insertion with its cached display projection.
+ * @returns display text with one marker glyph followed by the complete label.
+ */
+export declare function referenceDraftText(reference: Pick<ReferenceInsert, 'label'>): string;
+/**
+ * Expand the draft's reference ranges into their occurrences' clipboard text
+ * for persistence and clipboard projection. Table order is offset order, so
+ * one linear walk pairs ranges with entries.
  * @param state - published input state.
  * @returns the plain-text projection of the draft.
  */
@@ -50,9 +72,9 @@ export declare class InputMachine {
     private pushTxn;
     /**
      * Reconcile the occurrence table with one edit (old-draft coordinates):
-     * entries past the range shift by the length delta; entries whose
-     * placeholder sits inside the replaced range go away whole (a
-     * deletion/replacement intersecting a placeholder acts on the whole chip).
+     * entries past the range shift by the length delta; an edit that intersects
+     * a reference range removes its structured occurrence and leaves the edited
+     * characters as ordinary draft text.
      */
     private reconcile;
     /** Claimed integrity watch: any mutation that breaks the token prefix releases the claim. */
@@ -67,10 +89,10 @@ export declare class InputMachine {
     private onBeginCommand;
     private onInsertRef;
     /**
-     * Shared chip-insertion transaction: replace [span) with one placeholder
+     * Shared reference-insertion transaction: replace [span) with one inline
      * occurrence (insert-ref and paste-upgrade both land here). A separating
-     * space follows the chip unless one is already next.
-     * @returns the inserted length (placeholder plus optional gap).
+     * space follows the reference unless one is already next.
+     * @returns the inserted length (display text plus optional gap).
      */
     private replaceSpanWithChip;
     /**
@@ -88,7 +110,7 @@ export declare class InputMachine {
     private onUndo;
     private onRedo;
     /**
-     * Paste as one transaction: the text (U+FFFC-sanitized) replaces the
+     * Paste as one transaction: the text (reference-placeholder-sanitized) replaces the
      * selection; hot-snapshot sync matches componentize inside the SAME
      * transaction (one undo returns to pre-paste); a match attempt opens for
      * the async remainder while the phase still accepts reference mutations.
@@ -106,8 +128,7 @@ export declare class InputMachine {
     private onAdjudicated;
     private onAdjudicationFailed;
     private onSubmitSettled;
-    /** Ordinary send accepted: clear as a commit (no undo unit; sent content
-     *  must not be resurrectable — same discipline as submit-settled success). */
+    /** Cut undo state after an accepted image-only send. */
     private onSendCommitted;
     private onRelease;
 }