@volter/supercode-frontend-vscode 0.1.51 → 0.1.53

package/README.md

@@ -393,6 +393,22 @@ are read only for backwards compatibility.
 Restored response cancellation interrupts the runtime and waits for acknowledgement.
 Session-list updates consistently prioritize pending input over busy status.
 
+Reload restoration joins the runtime's canonical history to events after its
+`history_cursor`. A separately loaded native transcript is a fallback when the
+runtime has no user history; it never replaces the live event tail. The final
+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
+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 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
 Volter overlay guards this fix with a native regression test. The former legacy

package/dist/extension.js

@@ -10,7 +10,7 @@ import { readCredentialFile } from './credential.js';
 import { grantedProposals, PROPOSAL_EFFECTS, REQUESTED_PROPOSALS } from './proposals.js';
 import { observeActiveResponse, sessionStatus } from './native-session.js';
 import { RequestNotPendingError, VscodeFrontendSession } from './session.js';
-import { acceptedDecisions, opaqueText, projectEvent, projectPendingRequests, projectHistory, projectReplayTurns, resolveParts, resolutionSentence, typedAnswer, } from './view.js';
+import { acceptedDecisions, opaqueText, projectEvent, projectPendingRequests, projectHistory, projectReplayTurns, HISTORY_MARKER_PROMPT, resolveParts, resolutionSentence, typedAnswer, } from './view.js';
 const SESSION_SCHEME = 'supercode';
 /** The harnesses whose model and reasoning effort a new chat can set (the host passes them to the CLI). */
 const CONFIGURABLE_HARNESSES = ['claude-code', 'codex'];
@@ -979,7 +979,9 @@ export async function activate(context) {
             // A new draft's harness, not the previous runtime, owns its offered modes.
             const harness = resource ? controls?.state.sessions.find(session => session.id === id)?.selection.harness : draftSelection()?.harness;
             const canApprove = resource ? (active ? canAnswer(active) : ['claude-code', 'codex'].includes(harness ?? ''))
-                : (harness ? ['claude-code', 'codex'].includes(harness) : newChatDefault() === 'autoApprove' || ['claude-code', 'codex'].includes(controls?.state.selection.harness ?? ''));
+                : (harness ? ['claude-code', 'codex'].includes(harness)
+                    // the default harness decides; only with none known does the new-chat default stand in for it
+                    : controls?.state.selection.harness ? ['claude-code', 'codex'].includes(controls.state.selection.harness) : newChatDefault() === 'autoApprove');
             // An unbound input is a new chat, not the active conversation left behind it.
             const selectedPermission = resource ? currentOptions(resource).permissions : permission ?? newChatDefault();
             const permissionItems = [{ id: 'ask', name: canApprove ? 'Ask for approval' : 'Harness permissions', description: canApprove ? 'Show each approval requested by the harness.' : 'Approval controls are unavailable for this harness.' },
@@ -1067,8 +1069,9 @@ export async function activate(context) {
             await revealManaged();
     }));
     context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.configure', async (supplied) => {
+        // with a new chat's draft open, a permission chosen is the draft's, never the conversation behind it
         if (supplied?.permissions) {
-            const id = controls?.state.activeSession;
+            const id = activeDraft() ? undefined : controls?.state.activeSession;
             if (id)
                 choosePermission(id, turnPermission(supplied.permissions));
             else
@@ -1295,6 +1298,11 @@ export async function activate(context) {
             } };
     };
     const runTurnInto = async (connection, prompt, stream, token, approval) => {
+        const throwIfCancelled = () => {
+            if (token.isCancellationRequested)
+                throw new vscode.CancellationError();
+        };
+        throwIfCancelled();
         if (approval() === 'autoApprove' && !canAnswer(connection)) {
             throw new Error('This harness does not support automatic approval through Chat. Select Harness permissions.');
         }
@@ -1335,13 +1343,20 @@ 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);
+            }
+            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.
                 if (event.kind === 'turn_interrupted' && token.isCancellationRequested)
                     return;
                 writeProjected(stream, projectEvent(event, projection), granted, state);
                 watch.sweep();
-            });
+            }, { throwIfCancelled });
             completed = true;
         }
         finally {
@@ -2026,12 +2041,16 @@ function registerSessions(context, frontends, participant, granted, handler, his
             // canonical transcript, replayed as turns.
             const history = [];
             const authorId = historyParticipant(connection);
-            // A hosted harness runtime has no canonical ChatMessage history —
-            // `HostedHarnessRuntime::attach` returns an empty one and puts the
-            // conversation in `replay`. Read whichever the runtime actually
-            // filled, or a resumed session opens blank beside the person's own
-            // conversation.
-            const canonicalHistory = connection.persistedHistory?.length ? connection.persistedHistory : connection.session.history;
+            // History and replay are one runtime snapshot, joined by its cursor.
+            // A host's separately loaded native transcript has no replay cursor;
+            // selecting it instead hid every turn started since the runtime was
+            // created. Keep it only as a fallback when no runtime user history is
+            // available, rather than trying to align equal-looking prompt text.
+            const runtimeHistory = connection.session.history;
+            const replay = connection.session.replay.filter(event => event.sequence > connection.session.historyCursor);
+            const hasRuntimeHistory = runtimeHistory.length > 0 || replay.some(event => event.kind === 'user_message');
+            const usingSavedHistory = !hasRuntimeHistory && Boolean(connection.persistedHistory?.length);
+            const canonicalHistory = usingSavedHistory ? connection.persistedHistory : runtimeHistory;
             const pendingToolNames = new Set();
             if (connection.session.descriptor?.turn_state === 'busy') {
                 for (const request of connection.session.pendingRequests.values()) {
@@ -2043,14 +2062,44 @@ function registerSessions(context, frontends, participant, granted, handler, his
                         pendingToolNames.add(name);
                 }
             }
-            const projected = canonicalHistory.length > 0
-                ? projectHistory(canonicalHistory, granted, pendingToolNames)
-                : projectReplayTurns(connection.session.replay, granted, {
-                    connectionId: connection.id,
-                    pendingRequest: (id) => connection.session.pendingRequests.get(id) ?? connection.session.resolvedRequests.get(id),
-                    canRespond: connection.session.descriptor?.actions.respond !== false,
-                });
-            if (connection.historyTruncated)
+            const projected = projectReplayTurns(replay.filter(event => {
+                if (event.kind !== 'request')
+                    return true;
+                const payload = event.payload;
+                return !payload?.request || !connection.session.pendingRequests.has(payload.request.id);
+            }), granted, {
+                connectionId: connection.id,
+                pendingRequest: (id) => connection.session.pendingRequests.get(id) ?? connection.session.resolvedRequests.get(id),
+                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;
+            const activeParts = [];
+            if (live) {
+                // Standalone requests have no user turn. Give their live response
+                // an explicit runtime marker instead of reopening an old answer.
+                let lastBoundary = -1;
+                let lastUser = -1;
+                for (const event of replay) {
+                    if (['turn_succeeded', 'turn_failed', 'turn_interrupted'].includes(event.kind))
+                        lastBoundary = event.sequence;
+                    if (event.kind === 'user_message')
+                        lastUser = event.sequence;
+                }
+                if (!projected.some(turn => turn.role === 'user')
+                    || (connection.session.descriptor?.turn_state !== 'busy' && lastUser <= lastBoundary)) {
+                    projected.push({ role: 'user', prompt: HISTORY_MARKER_PROMPT });
+                }
+                // Leave the final request without a historical response, so the
+                // callback creates its response from live progress. Rehydrated
+                // responses can be stale; their command buttons are disabled.
+                const last = projected.at(-1);
+                if (last?.role === 'assistant') {
+                    activeParts.push(...(projected.pop()?.parts ?? []).map(part => part.part === 'answers'
+                        ? { part: 'markdown', value: `**${part.title}**\n\n${part.message}` }
+                        : part));
+                }
+            }
+            if (usingSavedHistory && connection.historyTruncated)
                 history.push(new turns.ChatRequestTurn('[Earlier conversation history]', undefined, [], authorId, []), new turns.ChatResponseTurn([new vscode.ChatResponseMarkdownPart('_Showing the latest 120 saved messages. Earlier context remains in the harness session._')], {}, authorId));
             for (const turn of projected) {
                 if (turn.role === 'user') {
@@ -2059,16 +2108,16 @@ function registerSessions(context, frontends, participant, granted, handler, his
                 }
                 history.push(new turns.ChatResponseTurn(historyParts(oneRowPerToolCall(turn.parts ?? [])), {}, authorId));
             }
-            const busy = connection.session.descriptor?.turn_state === 'busy';
             const renderedCursor = connection.session.cursor;
-            if (!busy)
+            const pendingAtCursor = [...connection.session.pendingRequests.values()];
+            if (!live)
                 connection.viewReady = attached;
             return {
                 title: connection.label,
                 options: controls?.attached(connection) ? undefined : controls?.currentOptions(resource),
                 history,
                 requestHandler: boundHandler,
-                activeResponseCallback: busy
+                activeResponseCallback: live
                     ? async (stream, token) => {
                         // A turn re-joined after a reload has lost the handler that ran it, so its approvals are
                         // answered here under the conversation's mode (t_39dac582): Auto approve answers the cards
@@ -2076,22 +2125,24 @@ function registerSessions(context, frontends, participant, granted, handler, his
                         const watch = controls && !controls.attached(connection) ? controls.watchApprovals(connection, stream, token) : undefined;
                         try {
                             const state = { toolInputs: new Map(), toolNames: new Map(), toolTitles: new Map(), toolCommands: new Map(), quiet: watch?.answers };
-                            writeProjected(stream, projectPendingRequests(connection.session.pendingRequests.values(), {
+                            for (const part of oneRowPerToolCall(activeParts))
+                                writePart(stream, part, state);
+                            writeProjected(stream, projectPendingRequests(pendingAtCursor.filter(request => connection.session.pendingRequests.has(request.id)), {
                                 connectionId: connection.id,
-                                canRespond: connection.session.descriptor?.actions.respond !== false,
+                                canRespond: Boolean(connection.session.descriptor?.actions.respond && connection.session.permissions.has('approve')),
                             }), granted, state);
                             watch?.sweep();
                             await observeActiveResponse(connection.session, token, (event) => {
                                 writeProjected(stream, projectEvent(event, {
                                     connectionId: connection.id,
                                     pendingRequest: (id) => connection.session.pendingRequests.get(id) ?? connection.session.resolvedRequests.get(id),
-                                    canRespond: connection.session.descriptor?.actions.respond !== false,
+                                    canRespond: Boolean(connection.session.descriptor?.actions.respond && connection.session.permissions.has('approve')),
                                 }), granted, state);
                                 watch?.sweep();
                             }, () => { connection.viewReady = true; }, renderedCursor);
                         }
                         finally {
-                            connection.viewReady = connection.session.descriptor?.turn_state !== 'busy';
+                            connection.viewReady = connection.session.descriptor?.turn_state !== 'busy' && !connection.session.pendingRequests.size;
                             watch?.dispose();
                         }
                     }

package/dist/native-session.d.ts

@@ -3,4 +3,4 @@ import type { FrontendEvent } from '../vendor/supercode-frontend/generated.mjs';
 import { type VscodeFrontendSession } from './session.js';
 export declare function sessionStatus(session: Pick<VscodeFrontendSession, 'descriptor' | 'pendingRequests'>): 'NeedsInput' | 'InProgress' | 'Completed';
 /** Follow a restored turn, including the interval between snapshot and callback. */
-export declare function observeActiveResponse(session: Pick<VscodeFrontendSession, 'descriptor' | 'onEvent' | 'interrupt' | 'actions' | 'replay'>, token: CancellationToken, write: (event: FrontendEvent) => void, onSubscribed?: () => void, afterSequence?: number): Promise<void>;
+export declare function observeActiveResponse(session: Pick<VscodeFrontendSession, 'descriptor' | 'pendingRequests' | 'onEvent' | 'interrupt' | 'actions' | 'replay'>, token: CancellationToken, write: (event: FrontendEvent) => void, onSubscribed?: () => void, afterSequence?: number): Promise<void>;

package/dist/native-session.js

@@ -34,7 +34,12 @@ export async function observeActiveResponse(session, token, write, onSubscribed,
                     reject(error);
                     return;
                 }
-                if (!cancelling && TURN_TERMINAL_KINDS.includes(event.kind))
+                if (event.kind === 'runtime_disconnected') {
+                    resolve();
+                    return;
+                }
+                const ended = TURN_TERMINAL_KINDS.includes(event.kind) || event.kind === 'request_resolved';
+                if (!cancelling && ended && session.descriptor?.turn_state !== 'busy' && !session.pendingRequests.size)
                     resolve();
             };
             unsubscribe = session.onEvent(consume);
@@ -47,7 +52,7 @@ export async function observeActiveResponse(session, token, write, onSubscribed,
             cancellation = token.onCancellationRequested(cancel);
             if (token.isCancellationRequested)
                 cancel();
-            else if (session.descriptor?.turn_state !== 'busy')
+            else if (session.descriptor?.turn_state !== 'busy' && !session.pendingRequests.size)
                 resolve();
         });
     }

package/dist/session.d.ts

@@ -147,7 +147,7 @@ export declare class VscodeFrontendSession {
     actions(): VscodeFrontendActions;
     /** Run one controller action, re-taking an expired lease exactly once. */
     private withControl;
-    submit(prompt: string): Promise<void>;
+    submit(prompt: string, throwIfCancelled?: () => void): Promise<void>;
     steer(prompt: string): Promise<void>;
     interrupt(): Promise<void>;
     /** Stop one of the harness's own background tasks, by the id it listed it with. */
@@ -164,6 +164,7 @@ export declare class VscodeFrontendSession {
      */
     runTurn(prompt: string, onEvent: (event: FrontendEvent) => void, options?: {
         onCancel?: (cancel: () => void) => void;
+        throwIfCancelled?: () => void;
     }): Promise<FrontendEvent | null>;
     private require;
     private notify;

package/dist/session.js

@@ -356,11 +356,16 @@ export class VscodeFrontendSession {
             return action();
         }
     }
-    async submit(prompt) {
+    async submit(prompt, throwIfCancelled) {
+        throwIfCancelled?.();
         this.require('submit');
         if (prompt.length === 0)
             throw new TypeError('prompt must not be empty');
-        await this.withControl(() => this.client.sendInput(prompt));
+        await this.withControl(() => {
+            // The same guard covers a send retried after an awaited lease renewal.
+            throwIfCancelled?.();
+            return this.client.sendInput(prompt);
+        });
     }
     async steer(prompt) {
         this.require('steer');
@@ -474,7 +479,7 @@ export class VscodeFrontendSession {
             void this.interrupt().catch((error) => fail?.(error));
         });
         try {
-            await this.submit(prompt);
+            await this.submit(prompt, options.throwIfCancelled);
             return await finished;
         }
         finally {

package/dist/view.d.ts

@@ -170,14 +170,6 @@ export interface ProjectedTurn {
     /** Rendered parts for an assistant turn. */
     parts?: ChatPart[];
 }
-/**
- * A HOSTED harness runtime's transcript as chat turns.
- *
- * `HostedHarnessRuntime::attach` returns `history: Vec::new()` and puts the
- * whole conversation in `replay` — the canonical ChatMessage history belongs to
- * supercode's own agent loop, and a hosted harness has none. So a resumed
- * Claude Code session's turns are here or nowhere.
- */
 /**
  * A "user" message no person typed: Claude Code's `<task-notification>` (a background task reporting back) or the
  * editor's automatic tripwire nudge. Neither is shown as the person's words. A task notification is said as one
@@ -186,7 +178,7 @@ export interface ProjectedTurn {
 export declare function automaticPrompt(body: string): {
     notice?: string;
 } | undefined;
-export declare function projectReplayTurns(events: readonly FrontendEvent[], granted: ReadonlySet<string>, context: ProjectionContext): ProjectedTurn[];
+export declare function projectReplayTurns(events: readonly FrontendEvent[], granted: ReadonlySet<string>, context: ProjectionContext, history?: readonly ProjectedTurn[]): ProjectedTurn[];
 /**
  * The attach snapshot's canonical history as chat turns. Bounded: when older
  * turns are omitted the view says so, the way the browser observer does.

package/dist/view.js

@@ -650,14 +650,6 @@ function messageText(message) {
         .filter(Boolean)
         .join('\n');
 }
-/**
- * A HOSTED harness runtime's transcript as chat turns.
- *
- * `HostedHarnessRuntime::attach` returns `history: Vec::new()` and puts the
- * whole conversation in `replay` — the canonical ChatMessage history belongs to
- * supercode's own agent loop, and a hosted harness has none. So a resumed
- * Claude Code session's turns are here or nowhere.
- */
 /**
  * A "user" message no person typed: Claude Code's `<task-notification>` (a background task reporting back) or the
  * editor's automatic tripwire nudge. Neither is shown as the person's words. A task notification is said as one
@@ -675,8 +667,13 @@ export function automaticPrompt(body) {
         return {};
     return undefined;
 }
-export function projectReplayTurns(events, granted, context) {
-    const turns = [];
+export function projectReplayTurns(events, granted, context, history = []) {
+    // Join canonical history with its sequenced tail. Retained request/decision
+    // events can be re-sequenced past history_cursor with no originating turn.
+    // Before the replay supplies a prompt, give its parts their own runtime
+    // history turn rather than attributing old approvals to the latest answer.
+    const turns = history.map(turn => ({ ...turn, parts: turn.parts?.slice() }));
+    let replayTurn = false;
     let streamedText;
     for (const event of events) {
         if (event.kind === 'user_message') {
@@ -686,8 +683,10 @@ export function projectReplayTurns(events, granted, context) {
             if (automatic) {
                 if (!automatic.notice)
                     continue;
-                if (turns.length === 0)
+                if (!replayTurn) {
                     turns.push({ role: 'user', prompt: HISTORY_MARKER_PROMPT });
+                    replayTurn = true;
+                }
                 const last = turns[turns.length - 1];
                 const notice = { part: 'markdown', value: `\n\n${automatic.notice}\n\n` };
                 if (last.role === 'assistant' && last.parts)
@@ -697,6 +696,7 @@ export function projectReplayTurns(events, granted, context) {
                 continue;
             }
             turns.push({ role: 'user', prompt: clamp(stripControls(text(payload.text)), VSCODE_CHAT_LIMITS.partCharacters) });
+            replayTurn = true;
             continue;
         }
         const parts = resolveParts(projectEvent(event, context), granted);
@@ -712,8 +712,10 @@ export function projectReplayTurns(events, granted, context) {
         else {
             streamedText = undefined;
         }
-        if (turns.length === 0)
+        if (!replayTurn) {
             turns.push({ role: 'user', prompt: HISTORY_MARKER_PROMPT });
+            replayTurn = true;
+        }
         const last = turns[turns.length - 1];
         if (last.role === 'assistant' && last.parts)
             last.parts.push(...parts);

package/package.json

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