@volter/supercode-frontend-vscode 0.1.63 → 0.1.65

package/dist/host-controls.d.ts

@@ -52,7 +52,6 @@ export interface ChatSetupState {
 }
 export interface HostState {
     history?: ChatMessage[];
-    historyTruncated?: boolean;
     activeSession: string | null;
     openSessionCommand?: string;
     /** Automatic ready-session reveal checks the observed native focus through its queued commit. */

package/dist/proposals.d.ts

@@ -13,7 +13,7 @@
  * unconditionally, so a `typeof vscode.ChatResponseConfirmationPart` probe
  * cannot answer this question — only the description can.
  */
-export declare const REQUESTED_PROPOSALS: readonly ["defaultChatParticipant", "chatParticipantPrivate", "chatParticipantAdditions", "chatSessionsProvider", "chatProvider"];
+export declare const REQUESTED_PROPOSALS: readonly ["defaultChatParticipant", "chatParticipantPrivate", "chatParticipantAdditions", "chatSessionsProvider", "chatProvider", "chatSessionResponses", "chatSystemNotification", "chatConfirmationResolution"];
 export type ProposalName = (typeof REQUESTED_PROPOSALS)[number];
 /** What each requested proposal buys, and what this frontend does without it. */
 export declare const PROPOSAL_EFFECTS: Readonly<Record<ProposalName, {

package/dist/proposals.js

@@ -19,6 +19,10 @@ export const REQUESTED_PROPOSALS = Object.freeze([
     'chatParticipantAdditions',
     'chatSessionsProvider',
     'chatProvider',
+    // Volter's Code-OSS fork (volter-ai/code-oss); a host without them drops the names ("DOES NOT EXIST").
+    'chatSessionResponses',
+    'chatSystemNotification',
+    'chatConfirmationResolution',
 ]);
 /** What each requested proposal buys, and what this frontend does without it. */
 export const PROPOSAL_EFFECTS = Object.freeze({
@@ -27,8 +31,8 @@ export const PROPOSAL_EFFECTS = Object.freeze({
         without: 'the ordinary `@supercode` participant answers; a mention is required',
     },
     chatParticipantPrivate: {
-        grants: 'the dynamic-participant and participant-detection APIs a bundling host can use to route without a mention',
-        without: 'nothing is lost in this package: it registers no dynamic participant and no detection provider',
+        grants: 'the dynamic-participant identity, and an interrupted turn ending with a warning-level, expected error',
+        without: 'a static participant identity; an interrupted turn ends with an ordinary error',
     },
     chatParticipantAdditions: {
         grants: 'tool-invocation, confirmation, warning and codeblock-uri response parts',
@@ -39,6 +43,18 @@ export const PROPOSAL_EFFECTS = Object.freeze({
         grants: 'the runtime’s sessions in the Chat view’s session picker, each reopening with its history',
         without: 'the participant still attaches; there is no session list',
     },
+    chatSessionResponses: {
+        grants: 'a re-joined or saved response ending with its error; questions on a re-joined response as the carousel; a conversation that could not be opened anchored as Code-OSS anchors one',
+        without: 'a re-joined or saved response’s error as a warning part; questions there as buttons; that conversation’s error under the marker request',
+    },
+    chatSystemNotification: {
+        grants: 'a harness notice (a background task finishing, an interruption record) as the system notification row',
+        without: 'the notice as a plain line',
+    },
+    chatConfirmationResolution: {
+        grants: 'an approval card answered elsewhere losing its buttons',
+        without: 'the card stays and one plain line beneath it says the answer',
+    },
 });
 /** Read the proposals the HOST granted this extension, never the ones it asked for. */
 export function grantedProposals(packageJSON) {

package/dist/session.d.ts

@@ -16,9 +16,6 @@ export interface VscodeRuntimeClient {
     steer(prompt: string): Promise<{
         queued: boolean;
     }>;
-    stopTask(taskId: string): Promise<{
-        stopped: boolean;
-    }>;
     interrupt(): Promise<{
         interrupted: boolean;
     }>;
@@ -66,12 +63,6 @@ export declare const TURN_TERMINAL_KINDS: readonly ["turn_succeeded", "turn_fail
  * the view reports.
  */
 export declare const LEASE_ERROR_NAMES: readonly string[];
-/** One of the harness's own background tasks (a Monitor, a background shell), as it last listed them. */
-export interface BackgroundTask {
-    id: string;
-    kind: string;
-    description: string;
-}
 /**
  * One attachment to one already-running Volter Harness SDK runtime: cursor-safe
  * event projection, permission narrowing, and the semantic actions the runtime
@@ -87,7 +78,6 @@ export declare class VscodeFrontendSession {
     history: ChatMessage[];
     historyCursor: number;
     historyEvents: FrontendEvent[];
-    historyEventsDropped: number;
     cursor: number;
     /**
      * Every event this attachment has seen, in order — NOT just the last
@@ -99,15 +89,8 @@ export declare class VscodeFrontendSession {
     replay: FrontendEvent[];
     pendingRequests: Map<number, FrontendRequest>;
     /**
-     * The harness's own background tasks as it last listed them (`background_tasks`). Each event one reports starts a
-     * turn of its own, so while any runs the session can be busy with turns no one here submitted.
-     */
-    backgroundTasks: BackgroundTask[];
-    /**
-     * Requests this attachment has seen resolved. `request_resolved` deletes the
-     * pending entry while it is being projected, so without this the resolution
-     * could only say "request #1" — it would have lost the very thing it needs to
-     * name. Bounded, because a long session resolves a lot of them.
+     * Requests this attachment has seen resolved, so a resolution can still name what it answered once the pending
+     * entry is gone. Bounded, because a long session resolves a lot of them.
      */
     resolvedRequests: Map<number, FrontendRequest>;
     connection: 'disconnected' | 'connected' | 'closed';
@@ -158,8 +141,6 @@ export declare class VscodeFrontendSession {
     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. */
-    stopTask(taskId: string): Promise<boolean>;
     respond(response: FrontendResponse): Promise<void>;
     detach(): Promise<void>;
     close(): Promise<void>;

package/dist/session.js

@@ -48,7 +48,6 @@ export class VscodeFrontendSession {
     history = [];
     historyCursor = 0;
     historyEvents = [];
-    historyEventsDropped = 0;
     cursor = 0;
     /**
      * Every event this attachment has seen, in order — NOT just the last
@@ -60,15 +59,8 @@ export class VscodeFrontendSession {
     replay = [];
     pendingRequests = new Map();
     /**
-     * The harness's own background tasks as it last listed them (`background_tasks`). Each event one reports starts a
-     * turn of its own, so while any runs the session can be busy with turns no one here submitted.
-     */
-    backgroundTasks = [];
-    /**
-     * Requests this attachment has seen resolved. `request_resolved` deletes the
-     * pending entry while it is being projected, so without this the resolution
-     * could only say "request #1" — it would have lost the very thing it needs to
-     * name. Bounded, because a long session resolves a lot of them.
+     * Requests this attachment has seen resolved, so a resolution can still name what it answered once the pending
+     * entry is gone. Bounded, because a long session resolves a lot of them.
      */
     resolvedRequests = new Map();
     connection = 'disconnected';
@@ -130,23 +122,12 @@ export class VscodeFrontendSession {
             descriptor: structuredClone(snapshot.descriptor),
             pendingRequests: new Map((authoritative ? snapshot.pending_requests : [...this.pendingRequests.values()])
                 .map(request => [request.id, structuredClone(request)])),
-            backgroundTasks: structuredClone(this.backgroundTasks),
             cursor: authoritative ? recovery.captureCursor : Math.max(this.cursor, snapshot.history_cursor),
         };
         // Validate and project the whole attachment before any observable field
         // moves or a live listener is registered.
         if (authoritative) {
             // Snapshot state is authoritative at capture, before any later events.
-            // Background listings have no separate snapshot field; retain their
-            // latest original event without replaying historical request state.
-            for (const event of recovery.replay) {
-                const payload = (event.payload ?? {});
-                if (event.kind === 'background_tasks' && Array.isArray(payload.tasks)) {
-                    staged.backgroundTasks = payload.tasks
-                        .filter(task => task && typeof task.id === 'string')
-                        .map(task => ({ id: task.id, kind: String(task.kind ?? 'task'), description: String(task.description ?? '') }));
-                }
-            }
             for (const event of recovery.later)
                 this.projectEvent(staged, event);
         }
@@ -197,10 +178,8 @@ export class VscodeFrontendSession {
         this.history = structuredClone(snapshot.history);
         this.historyCursor = snapshot.history_cursor;
         this.historyEvents = structuredClone(snapshot.history_events ?? []);
-        this.historyEventsDropped = snapshot.history_events_dropped ?? 0;
         this.appendTranscript(structuredClone(recovery.replay));
         this.pendingRequests = staged.pendingRequests;
-        this.backgroundTasks = staged.backgroundTasks;
         const previousCursor = this.cursor;
         this.cursor = staged.cursor;
         this.connection = 'connected';
@@ -392,18 +371,12 @@ export class VscodeFrontendSession {
             if (request && typeof request.id === 'number')
                 state.pendingRequests.set(request.id, structuredClone(request));
         }
-        if (event.kind === 'background_tasks' && Array.isArray(payload.tasks)) {
-            state.backgroundTasks = payload.tasks
-                .filter(task => task && typeof task.id === 'string')
-                .map(task => ({ id: task.id, kind: String(task.kind ?? 'task'), description: String(task.description ?? '') }));
-        }
         if (event.kind === 'request_resolved' && typeof payload.request_id === 'number') {
             const resolved = state.pendingRequests.get(payload.request_id);
             if (resolved) {
                 this.resolvedRequests.set(payload.request_id, resolved);
-                while (this.resolvedRequests.size > 50) {
+                while (this.resolvedRequests.size > 50)
                     this.resolvedRequests.delete(this.resolvedRequests.keys().next().value);
-                }
             }
             state.pendingRequests.delete(payload.request_id);
         }
@@ -480,11 +453,6 @@ export class VscodeFrontendSession {
         this.require('interrupt');
         await this.withControl(() => this.client.interrupt());
     }
-    /** Stop one of the harness's own background tasks, by the id it listed it with. */
-    async stopTask(taskId) {
-        const result = await this.withControl(() => this.client.stopTask(taskId));
-        return result?.stopped === true;
-    }
     async respond(response) {
         this.require('respond');
         if (!this.pendingRequests.has(response.request_id))

package/dist/view.d.ts

@@ -34,6 +34,14 @@ export type ChatPart = {
 } | {
     part: 'progress';
     value: string;
+}
+/** A record of the harness that is neither the agent's words nor the person's (a background task finishing, an
+ *  interruption record, a scheduled prompt's start): Code-OSS's system notification row where the host has it
+ *  (`chatSystemNotification`), with `icon` where it reports no completion, else a plain line. Markdown-safe text. */
+ | {
+    part: 'notice';
+    value: string;
+    icon?: string;
 } | {
     part: 'warning';
     value: string;
@@ -79,11 +87,28 @@ export type ChatPart = {
     background?: boolean;
 } | {
     part: 'answers';
+    connectionId: string;
+    requestId: number;
     approval: boolean;
     title: string;
     message: string;
+    /** None: a request this window cannot answer, drawn read-only. */
     answers: ChatAnswer[];
 }
+/** How a request drawn in this stream was answered, said only when the answer did not come through that card in
+ *  this window (`writePart`), so a card answered elsewhere is not left looking open. Markdown-safe. */
+ | {
+    part: 'resolution';
+    connectionId: string;
+    requestId: number;
+    value: string;
+}
+/** A record that is not conversation (an event kind this version does not know, a malformed request): written to
+ *  the output channel, never to the transcript. */
+ | {
+    part: 'unshown';
+    value: string;
+}
 /** A harness's questions (`requestQuestions`): VS Code's question carousel on a turn this window runs, its
  *  `answers` part anywhere else. */
  | {
@@ -187,7 +212,11 @@ export interface SubagentCall {
 /** A subagent call's description, kind and prompt (Claude Code's Task and Agent tools: `description`,
  *  `subagent_type`, `prompt`), read from its own arguments; undefined for any other tool. */
 export declare function subagentCall(toolName: string, argumentsText: string): SubagentCall | undefined;
-/** The command line of a shell tool call, read from its own arguments; undefined for any other tool. */
+/**
+ * The command line of a shell tool call, read from its own arguments; undefined for any other tool. Claude Code's
+ * BashOutput and KillBash are terminal rows too, as Code-OSS's own Claude host draws them (`claudeToolDisplay.ts`
+ * `TOOL_ROWS`): their command line is their `command`, else their input (`getClaudeToolInputString`).
+ */
 export declare function shellCommand(toolName: string, argumentsText: string): string | undefined;
 /** The information this view shows for a request payload. */
 export declare function requestSummary(request: FrontendRequest): string;
@@ -218,6 +247,15 @@ export declare function requestNeedsTypedReply(request: FrontendRequest): boolea
 export declare function resolutionSentence(response: FrontendResponse | undefined, request: FrontendRequest | undefined, requestId: number): string;
 /** `write_file on hello.txt`, read from the request's own payload. */
 export declare function requestSubject(request: FrontendRequest): string | undefined;
+/**
+ * How a turn that did not succeed ends the response its request handler runs, as VS Code's own agent host ends one
+ * (`agentHostSessionHandler.ts` `_getTurnErrorDetails`): a failed turn is the response's error, an interrupted one its
+ * warning-level, expected error. Undefined for any other event.
+ */
+export declare function turnOutcome(event: FrontendEvent): {
+    message: string;
+    interrupted: boolean;
+} | undefined;
 export interface ProjectionContext {
     /** Identifies which attached runtime a confirmation click must answer. */
     connectionId: string;
@@ -225,8 +263,14 @@ export interface ProjectionContext {
     echoOwnPrompts?: boolean;
     /** Show input arriving in an observed turn, without inventing a native request turn. */
     liveUserMessages?: boolean;
-    /** The request a `request_resolved` answers, so its sentence can name it. */
+    /** The request a `request_resolved` answers, so its line can name it. */
     pendingRequest?: (requestId: number) => FrontendRequest | undefined;
+    /** The calls whose background task's notification this stream has drawn (`firstNotice`), so a task finishing is one
+     *  line: Claude Code reports it both as `system/task_notification` (a `status`) and as the user-role record that
+     *  wakes the agent (a `user_message` notice). */
+    notices?: Set<string>;
+    /** Where a record that is not conversation goes when there is no writer to log it (history). */
+    unshown?: (value: string) => void;
     /**
      * Whether the runtime's own descriptor advertises `respond`. A HOSTED
      * harness runtime sets `actions.respond: false` — the portable contract
@@ -252,10 +296,11 @@ export declare function projectEvent(event: FrontendEvent, context: ProjectionCo
 /** Replace every part whose proposal the host did not grant with its fallback. */
 export declare function resolveParts(parts: readonly ProjectedPart[], granted: ReadonlySet<string>): ChatPart[];
 /**
- * The prompt of the marker turn that carries runtime history with no user turn
- * of its own. It names itself; nothing here is presented as a person's words.
+ * The prompt of the marker turn that carries runtime history with no user turn of its own: VS Code's own words for a
+ * turn whose request is not in the transcript (`claudeReplayMapper.ts` `missingPromptPlaceholder`), so nothing is
+ * presented as a person's words.
  */
-export declare const HISTORY_MARKER_PROMPT = "\u27E8supercode runtime history\u27E9";
+export declare const HISTORY_MARKER_PROMPT = "Message content could not be retrieved";
 export type TurnRole = 'user' | 'assistant';
 export interface ProjectedTurn {
     role: TurnRole;
@@ -263,6 +308,14 @@ export interface ProjectedTurn {
     prompt?: string;
     /** Rendered parts for an assistant turn. */
     parts?: ChatPart[];
+    /** How an assistant turn ended when it did not succeed, kept as the saved response's own error where the host
+     *  shows one (`chatSessionResponses`); otherwise it is a warning part among `parts`. */
+    error?: {
+        message: string;
+        interrupted: boolean;
+    };
+    /** The record `error` came from, drawn as its warning part where anything follows it. */
+    errorEvent?: FrontendEvent;
 }
 export declare function projectReplayTurns(events: readonly FrontendEvent[], granted: ReadonlySet<string>, context: ProjectionContext, history?: readonly ProjectedTurn[]): ProjectedTurn[];
 /**