@volter/supercode-frontend-vscode 0.1.62 → 0.1.64

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.js

@@ -27,8 +27,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',

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

@@ -50,6 +50,13 @@ export type ChatPart = {
     uri: string;
     value: string;
     language: string;
+}
+/** A harness hook that blocked or warned: which event it ran on, and what it said. */
+ | {
+    part: 'hook';
+    hookType: HookType;
+    blocked: boolean;
+    reason: string;
 } | {
     part: 'tool';
     toolName: string;
@@ -62,13 +69,62 @@ export type ChatPart = {
     resultText?: string;
     /** A shell call's command line: the row is then VS Code's own terminal block, command and output. */
     commandLine?: string;
+    /** The plan as this call left it (`planItems`, `PlanTracker`): the row is then VS Code's own todo list. */
+    plan?: PlanItem[];
+    /** A subagent call's own fields (`subagentCall`): the row is then VS Code's own subagent row. */
+    subagent?: SubagentCall;
+    /** The subagent call this call was made inside (Claude Code's `parent_tool_use_id`): VS Code groups it there. */
+    parentToolCallId?: string;
+    /** The call started its subagent in the background: its result is a launch notice, not the subagent's answer. */
+    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. */
+ | {
+    part: 'questions';
+    connectionId: string;
+    requestId: number;
+    questions: QuestionField[];
+    fallback: Extract<ChatPart, {
+        part: 'answers';
+    }>;
 };
+/** One question of an elicitation that asks questions (`requestQuestions`), as VS Code's carousel asks it. */
+export interface QuestionField {
+    /** The elicitation's property, which the answer's `content` is keyed by. */
+    key: string;
+    title: string;
+    message?: string;
+    /** Each option's label (also its answer) and what it means. None: a free-text question. */
+    options: {
+        label: string;
+        description?: string;
+    }[];
+    multiSelect: boolean;
+}
 /**
  * One rendered part plus the API proposal it needs and what this view renders
  * instead when the host did not grant it. README.md's proposal table is this
@@ -105,7 +161,54 @@ export declare function toolTitles(toolName: string, argumentsText: string): {
     invocation: string;
     pastTense: string;
 };
-/** The command line of a shell tool call, read from its own arguments; undefined for any other tool. */
+/** A hook's row as words, as VS Code titles its own (`chatHookContentPart.ts`): "Blocked by …" or "Warning from …". */
+export declare function hookSentence(hookEvent: string, blocked: boolean, reason: string): string;
+/** The hook events VS Code's own Chat names (`ChatHookType`), which are Claude Code's. */
+export declare const HOOK_TYPES: readonly ["SessionStart", "SessionEnd", "UserPromptSubmit", "PreToolUse", "PostToolUse", "PreCompact", "SubagentStart", "SubagentStop", "Stop", "ErrorOccurred"];
+export type HookType = (typeof HOOK_TYPES)[number];
+/** One item of an agent's plan, as VS Code's own todo list holds it. */
+export interface PlanItem {
+    title: string;
+    status: 'not-started' | 'in-progress' | 'completed';
+}
+/** A plan call's items (Claude Code's TodoWrite `todos` of `content`; the `update_plan` tool's `plan` of `step`, as
+ *  supercode's own and Codex's take it), each its text and status, read from its own arguments; undefined for any
+ *  other tool, or arguments holding none. Both carry the whole list, so they need no state. */
+export declare function planItems(toolName: string, argumentsText: string): PlanItem[] | undefined;
+/**
+ * The task list Claude Code keeps with its task tools, which it offers in place of TodoWrite (TaskCreate, TaskUpdate,
+ * TaskList; Claude Code 2.1.312 enables them by default and TodoWrite only when its tasks are turned off). Each call
+ * changes ONE task, while VS Code's own todo list shows the WHOLE list, so this keeps the list for one conversation as
+ * the calls go by and gives each call's row the list as that call left it.
+ *
+ * Read from the calls' own arguments, and from Claude Code's own result text where only the result has it (measured
+ * on 2.1.312, its `mapToolResultToToolResultBlockParam`): TaskCreate's `Task #<id> created successfully: <subject>`,
+ * TaskUpdate's `Updated task #<id> <fields>`, and TaskList's lines `#<id> [<status>] <subject>…`. A result in other
+ * words changes nothing here; the row is then an ordinary one.
+ */
+export declare class PlanTracker {
+    #private;
+    /** A call that started: the list as it leaves it, or undefined when it is not a task call (or changes nothing). */
+    started(toolName: string, argumentsText: string, toolCallId: string): PlanItem[] | undefined;
+    /** A call that completed: the list as it now stands (a failed call's change undone; TaskList's result is the
+     *  list), so a finished row never shows an older list than the calls before it left. */
+    completed(toolCallId: string, output: string, isError: boolean): PlanItem[] | undefined;
+    private items;
+}
+/** What a subagent call says of its subagent, as VS Code's own subagent row shows it. */
+export interface SubagentCall {
+    description?: string;
+    agentName?: string;
+    prompt?: string;
+}
+/** 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. 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;
@@ -118,6 +221,14 @@ export declare function requestAnswers(request: FrontendRequest, connectionId: s
 export declare function typedAnswer(request: FrontendRequest, reply: string): FrontendResponse;
 /** The decisions a runtime said its harness accepts, when it said so. */
 export declare function acceptedDecisions(request: FrontendRequest): string[] | undefined;
+/**
+ * An elicitation that asks questions, the shape supercode's `ask_user` asks with and a hosted Claude Code's
+ * AskUserQuestion is raised as (`question-tool.mjs` `questionElicitation`): every property of its
+ * `requested_schema` is one question, with a `title`, the question alone (`x-question`) and its `x-options`
+ * (`[{label, description}]`, with `x-multi-select`; none for free text). Any other form (an MCP server's schema with
+ * its own `enum`, `format` or `required`) is undefined here and keeps the `Answer…` door, which honours them.
+ */
+export declare function requestQuestions(request: FrontendRequest): QuestionField[] | undefined;
 /** True when this request asks for content a button click cannot carry. */
 export declare function requestNeedsTypedReply(request: FrontendRequest): boolean;
 /**
@@ -128,6 +239,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;
@@ -135,8 +255,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
@@ -147,6 +273,8 @@ export interface ProjectionContext {
      * buttons are absent rather than dead.
      */
     canRespond?: boolean;
+    /** The conversation's task list as its task tools change it; without one, those calls are ordinary rows. */
+    plan?: PlanTracker;
 }
 /** Pending requests belong to the live runtime, even when saved transcript
  * history predates them. Rehydrate their controls before waiting for new events. */
@@ -160,10 +288,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;
@@ -179,4 +308,4 @@ export declare function projectReplayTurns(events: readonly FrontendEvent[], gra
  */
 export declare function projectHistory(history: readonly (ChatMessage & {
     metadata?: Record<string, string>;
-})[], granted: ReadonlySet<string>, pendingToolNames?: ReadonlySet<string>): ProjectedTurn[];
+})[], granted: ReadonlySet<string>, pendingToolNames?: ReadonlySet<string>, plan?: PlanTracker): ProjectedTurn[];