@volter/supercode-frontend-vscode 0.1.53 → 0.1.55

package/README.md

@@ -400,14 +400,35 @@ running response is replayed through `activeResponseCallback`, with each pending
 request drawn once from the snapshot and later events followed by sequence.
 An idle runtime with a pending request also keeps this callback open until the
 request is resolved. Standalone requests use the explicit runtime-history marker
-instead of reopening an earlier answer. Managed conversations save their native
-identity before sending input, as well as when a turn ends.
-Stop is observed during the save and checked before input, including a lease
+instead of reopening an earlier answer. A new conversation sends its first input
+before trying to save its native identity: the harness creates its transcript
+from that input. Identity saves run after input acceptance, retry with later
+native events until one succeeds, and finish at the end of a turn. A successful
+host save acknowledges that exact runtime connection, native id and catalogue
+identity; completion skips another save while all three still match. A reload
+or replacement connection must obtain its own acknowledgement. Completion
+refreshes the host before that comparison; a changed/cleared binding or failed
+refresh invalidates the local acknowledgement and retains the save attempt.
+After reload,
+the exact runtime's user history/events recover that save obligation; restored
+snapshots, later events and response completion retry through the same host
+checks without sending input. A busy state or standalone request alone does
+not establish submitted input. A failed save
+does not resend input or abort a running turn. An unbound conversation whose
+final save fails says the prompt was submitted, and tells the person to keep Chat
+open and avoid repeating the prompt.
+Stop is observed throughout the turn and checked before input, including a lease
 renewal retry. Retained request/decision records with no originating replay
 prompt appear in a separate runtime-history turn.
 The [reload investigation](../../docs/evidence/chat-pending-approval-reload-2026-10-08.md)
 separates the retained first-user failure from this source change; a live
 candidate reload and approval click remain unmeasured.
+The [first-input regression investigation](../../docs/evidence/chat-first-input-binding-2026-10-08.md)
+records the 0.1.52 binding-order failure, the correction and its outstanding
+product reading.
+The [identity-save investigation](../../docs/evidence/chat-identity-save-acknowledgement-2026-10-08.md)
+names the repeated host lookup removed at completion; candidate latency and
+real-editor qualification remain open.
 
 The pinned Code-OSS host needs a resource-scoping repair in its input-state change
 routing: stock code broadcasts changes to all input states of a provider. The

package/dist/extension.js

@@ -422,6 +422,92 @@ export async function activate(context) {
     // them, so they open as what they are: attachments, shown as their runtime
     // reports them, and never taken for the conversation the host manages.
     const attachedIds = new Set();
+    // A request handler can disappear on reload. Recover this obligation from
+    // the exact runtime's user history/events when its connection is reattached.
+    const identitySaves = new WeakMap();
+    const identitySave = (connection) => {
+        let save = identitySaves.get(connection);
+        if (!save) {
+            save = { submitted: false, remembered: false, again: false, warned: false };
+            identitySaves.set(connection, save);
+        }
+        save.submitted ||= connection.session.history.some(message => message.role === 'user')
+            || connection.session.replay.some(event => event.kind === 'user_message');
+        return save;
+    };
+    const identitySaved = (connection, nativeId) => {
+        const save = identitySave(connection);
+        save.remembered = true;
+        const identity = controls?.state.sessions.find(session => session.id === connection.id)?.identity;
+        // Only a successful host save acknowledges this runtime/native-id pair.
+        // A restored catalogue identity alone is not a save receipt for a new connection.
+        save.acknowledged = identity ? { nativeId, identity } : undefined;
+    };
+    const rememberIdentity = (connection, submitted = false) => {
+        const save = identitySave(connection);
+        save.submitted ||= submitted;
+        const entry = controls?.state.sessions.find(session => session.id === connection.id);
+        const nativeId = connection.session.descriptor?.session_id;
+        if (!save.submitted || !controls || !entry || attachedIds.has(connection.id) || !nativeId)
+            return;
+        save.remembered ||= Boolean(entry.identity);
+        if (save.remembered)
+            return;
+        save.again = true;
+        if (save.pending)
+            return;
+        save.pending = (async () => {
+            do {
+                save.again = false;
+                try {
+                    await controls.remember(connection.id, nativeId);
+                    identitySaved(connection, nativeId);
+                }
+                catch (error) {
+                    log.warn(`Could not yet save conversation identity: ${String(error)}`);
+                }
+            } while (save.again && !save.remembered);
+        })().finally(() => { save.pending = undefined; });
+    };
+    const finishIdentitySave = async (connection, onlySubmitted = false) => {
+        const save = identitySave(connection);
+        if (onlySubmitted && !save.submitted)
+            return;
+        if (!controls || attachedIds.has(connection.id))
+            return;
+        await save.pending;
+        // The host may have cleared a binding since its last lifecycle reply.
+        // Read it before treating a local acknowledgement as satisfied.
+        const refreshed = await controls.refresh().then(() => true, error => {
+            log.warn(`Could not refresh chat identity: ${String(error)}`);
+            return false;
+        });
+        const nativeId = connection.session.descriptor?.session_id;
+        const identity = controls.state.sessions.find(session => session.id === connection.id)?.identity;
+        const acknowledged = save.acknowledged;
+        const satisfied = Boolean(refreshed && nativeId && acknowledged
+            && acknowledged.nativeId === nativeId && acknowledged.identity === identity);
+        if (!satisfied) {
+            save.acknowledged = undefined;
+            save.remembered = false;
+        }
+        if (nativeId && !satisfied)
+            await controls.remember(connection.id, nativeId).then(() => {
+                identitySaved(connection, nativeId);
+            }, error => {
+                log.warn(`Could not save conversation identity: ${String(error)}`);
+                if (save.submitted && !save.remembered && !save.warned
+                    && !controls.state.sessions.find(session => session.id === connection.id)?.identity) {
+                    save.warned = true;
+                    void vscode.window.showWarningMessage('Your prompt was submitted, but Chat could not save this conversation for reopening. Keep this chat open; do not send the prompt again.');
+                }
+            });
+        controlsChanged.fire();
+    };
+    context.subscriptions.push(frontends.onDidChange(() => {
+        for (const connection of frontends.all)
+            rememberIdentity(connection);
+    }));
     const savedAttachments = new Map(context.workspaceState.get('supercode.externalAttachments', [])
         .map(entry => [entry.connectionId, entry]));
     const restoringAttachments = new Map();
@@ -1030,6 +1116,8 @@ export async function activate(context) {
         effective: (entry) => controls && entry.id === controls.state.activeSession ? controls.state.effective ?? null : draftEffective(entry.selection),
         bindings: boundId,
         watchApprovals: (connection, stream, token) => watchApprovals(connection, stream, token, () => approvalFor(connection.id)),
+        rememberIdentity,
+        finishIdentitySave: (connection) => finishIdentitySave(connection, true),
     };
     context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.activateSession', async (resource) => { await connectionFor(vscode.Uri.parse(resource)); }));
     // A background task the chat named (sayTasks in runTurnInto), stopped through the harness's own control.
@@ -1343,12 +1431,9 @@ export async function activate(context) {
         const unwatchTasks = connection.session.onChange(sayTasks);
         let completed = false;
         try {
-            // Observe Stop throughout the save, then check the token before input.
-            // A cancellation while this idle runtime saves cannot be handled by an
-            // interrupt alone: there is no running turn to interrupt yet.
-            if (controls && !attachedIds.has(connection.id) && connection.session.descriptor?.session_id) {
-                await controls.remember(connection.id, connection.session.descriptor.session_id);
-            }
+            // A new harness transcript is created by input, so binding its identity
+            // cannot be a prerequisite for that input. Retry the host save as native
+            // events arrive; no save refusal submits input again or aborts its turn.
             throwIfCancelled();
             await connection.session.runTurn(prompt, (event) => {
                 // A turn the person stopped is marked stopped by VS Code itself; only an interruption from elsewhere is said.
@@ -1356,19 +1441,17 @@ export async function activate(context) {
                     return;
                 writeProjected(stream, projectEvent(event, projection), granted, state);
                 watch.sweep();
-            }, { throwIfCancelled });
+                rememberIdentity(connection);
+            }, { throwIfCancelled, onSubmitted: () => {
+                    rememberIdentity(connection, true);
+                } });
             completed = true;
         }
         finally {
             unwatchTasks();
             watch.dispose();
             cancellation.dispose();
-            if (controls && !attachedIds.has(connection.id)) {
-                if (connection.session.descriptor?.session_id)
-                    await controls.remember(connection.id, connection.session.descriptor.session_id).catch(error => log.warn(`Could not save conversation identity: ${String(error)}`));
-                await controls.refresh().catch(error => log.warn(`Could not refresh chat identity: ${String(error)}`));
-                controlsChanged.fire();
-            }
+            await finishIdentitySave(connection);
         }
         // The model the turn ran on: what the harness's own replies name (the host watches them), else what the
         // runtime reports; and the effort it ran at (host `effective`).
@@ -2073,6 +2156,9 @@ function registerSessions(context, frontends, participant, granted, handler, his
                 canRespond: Boolean(connection.session.descriptor?.actions.respond && connection.session.permissions.has('approve')),
             }, projectHistory(canonicalHistory, granted, pendingToolNames));
             const live = connection.session.descriptor?.turn_state === 'busy' || connection.session.pendingRequests.size > 0;
+            controls?.rememberIdentity(connection);
+            if (!live)
+                void controls?.finishIdentitySave(connection);
             const activeParts = [];
             if (live) {
                 // Standalone requests have no user turn. Give their live response
@@ -2132,6 +2218,7 @@ function registerSessions(context, frontends, participant, granted, handler, his
                                 canRespond: Boolean(connection.session.descriptor?.actions.respond && connection.session.permissions.has('approve')),
                             }), granted, state);
                             watch?.sweep();
+                            controls?.rememberIdentity(connection);
                             await observeActiveResponse(connection.session, token, (event) => {
                                 writeProjected(stream, projectEvent(event, {
                                     connectionId: connection.id,
@@ -2139,11 +2226,13 @@ function registerSessions(context, frontends, participant, granted, handler, his
                                     canRespond: Boolean(connection.session.descriptor?.actions.respond && connection.session.permissions.has('approve')),
                                 }), granted, state);
                                 watch?.sweep();
+                                controls?.rememberIdentity(connection);
                             }, () => { connection.viewReady = true; }, renderedCursor);
                         }
                         finally {
                             connection.viewReady = connection.session.descriptor?.turn_state !== 'busy' && !connection.session.pendingRequests.size;
                             watch?.dispose();
+                            await controls?.finishIdentitySave(connection);
                         }
                     }
                     : undefined,

package/dist/session.d.ts

@@ -161,10 +161,13 @@ export declare class VscodeFrontendSession {
      * Submit one prompt and feed every event of the resulting turn to `onEvent`,
      * resolving when the runtime reports the turn finished. The subscription is
      * registered BEFORE the prompt is sent, so no early delta is lost.
+     * `onSubmitted` observes the input RPC's successful return, not transcript
+     * persistence or turn completion; it runs once, after any lease retry.
      */
     runTurn(prompt: string, onEvent: (event: FrontendEvent) => void, options?: {
         onCancel?: (cancel: () => void) => void;
         throwIfCancelled?: () => void;
+        onSubmitted?: () => void;
     }): Promise<FrontendEvent | null>;
     private require;
     private notify;

package/dist/session.js

@@ -428,6 +428,8 @@ export class VscodeFrontendSession {
      * Submit one prompt and feed every event of the resulting turn to `onEvent`,
      * resolving when the runtime reports the turn finished. The subscription is
      * registered BEFORE the prompt is sent, so no early delta is lost.
+     * `onSubmitted` observes the input RPC's successful return, not transcript
+     * persistence or turn completion; it runs once, after any lease retry.
      */
     async runTurn(prompt, onEvent, options = {}) {
         let settle;
@@ -480,6 +482,8 @@ export class VscodeFrontendSession {
         });
         try {
             await this.submit(prompt, options.throwIfCancelled);
+            // Acceptance can precede the harness's first durable transcript record.
+            options.onSubmitted?.();
             return await finished;
         }
         finally {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@volter/supercode-frontend-vscode",
   "displayName": "Volter Harness",
-  "version": "0.1.53",
+  "version": "0.1.55",
   "type": "module",
   "description": "VS Code chat-view frontend for an existing Volter Harness SDK runtime",
   "publisher": "volter-ai-dev",