🐛 fix(vscode): finalize unresolved tool activity

Stop tool cards from remaining or returning to running after tracking ends, while preserving partial output and authoritative persisted results.

Author: frostime

CHANGELOG.md

@@ -16,6 +16,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- Stop unresolved tool cards from remaining or returning to a running state after history restoration or session termination; preserve partial output and indicate that the final tool result was not recorded.
 - Prevent invalid project `enabledModels` values from falling through to global scope, resolve relative `PI_CODING_AGENT_DIR` paths from the session directory, and keep picker scope labels synchronized when scoped models disappear.
 
 ## [0.10.3] - 2026-08-06

apps/vscode/src/extension/conversation/ConversationItemStore.ts

@@ -143,6 +143,19 @@ export class ConversationItemStore {
     return this.#toolItems.has(toolCallId);
   }
 
+  finalizeUnresolvedTools(): void {
+    for (const owner of this.#toolItems.values()) {
+      const { turnId, itemId } = owner.location;
+      if (!turnId) continue;
+      const item = this.turnItem(turnId, itemId);
+      if (item?.type !== "tool" || item.tool.status !== "running") continue;
+      this.upsertTurnItem(turnId, {
+        ...item,
+        tool: { ...item.tool, status: "cancelled", isError: false },
+      });
+    }
+  }
+
   /** Detects ambiguous live adoption before any public item is mutated. */
   preflightPersistedOwnership(input: PersistedOwnershipPreflight): PlacementConflict | undefined {
     const assistantCounts = countByKey(input.assistantSources, (source) => source.correlationKey);
@@ -182,7 +195,11 @@ export class ConversationItemStore {
 
     const existing = this.#persistedAssistants.get(source.entryId);
     if (existing) {
-      this.#publishAssistant(existing, input.turnId, input.buildActivities(existing.viewMessageId));
+      this.#publishAssistant(
+        existing,
+        input.turnId,
+        this.#preserveToolExecutionState(input.buildActivities(existing.viewMessageId)),
+      );
       return { kind: "placed", viewMessageId: existing.viewMessageId };
     }
 
@@ -202,7 +219,11 @@ export class ConversationItemStore {
       addSetValue(this.#persistedAssistantKeys, source.correlationKey, source.entryId);
       if (liveOwner) this.#liveAssistants.set(source.correlationKey, owner);
     }
-    this.#publishAssistant(owner, input.turnId, input.buildActivities(owner.viewMessageId));
+    this.#publishAssistant(
+      owner,
+      input.turnId,
+      this.#preserveToolExecutionState(input.buildActivities(owner.viewMessageId)),
+    );
     return { kind: "placed", viewMessageId: owner.viewMessageId };
   }
 
@@ -333,6 +354,25 @@ export class ConversationItemStore {
     return this.#items.flatMap((item) => item.type === "turn" ? item.items : [item]);
   }
 
+  #preserveToolExecutionState(activities: AgentActivityView[]): AgentActivityView[] {
+    return activities.map((activity) => {
+      if (activity.type !== "tool") return activity;
+      const owner = this.#toolItems.get(activity.tool.id);
+      const current = owner ? this.turnItem(owner.location.turnId, owner.location.itemId) : undefined;
+      if (current?.type !== "tool") return activity;
+      return {
+        ...activity,
+        tool: {
+          ...activity.tool,
+          status: current.tool.status,
+          isError: current.tool.isError,
+          ...(current.tool.output !== undefined ? { output: current.tool.output } : {}),
+          ...(current.tool.endedAt !== undefined ? { endedAt: current.tool.endedAt } : {}),
+        },
+      };
+    });
+  }
+
   #publishAssistant(owner: AssistantOwner, turnId: string, activities: AgentActivityView[]): void {
     const staysInTurn = owner.locations.length > 0
       && owner.locations.every((location) => location.turnId === turnId);

apps/vscode/src/extension/conversation/ConversationProjection.ts

@@ -90,6 +90,7 @@ export class ConversationProjection {
 
     this.#projectEntries(entries, branchEdges);
     this.#completePersistedTurn(true);
+    this.#store.finalizeUnresolvedTools();
     this.#touch();
   }
 
@@ -194,6 +195,11 @@ export class ConversationProjection {
     return true;
   }
 
+  finalizeUnresolvedTools(): void {
+    this.#store.finalizeUnresolvedTools();
+    this.#touch();
+  }
+
   applyEvent(event: RpcEvent): void {
     switch (event.type) {
       case "agent_start":
@@ -416,6 +422,7 @@ export class ConversationProjection {
   }
 
   #settleAgentTurn(): void {
+    this.#store.finalizeUnresolvedTools();
     if (this.#activeTurnId) {
       const turn = this.#turn(this.#activeTurnId);
       if (turn.status === "running") {

apps/vscode/src/extension/conversation/conversation-projection.SPEC.md

@@ -23,6 +23,7 @@ The Host emits one ordered `conversationItems` collection. A visual turn has its
 - A user `message` opens a visual turn and supplies its stable `sourceEntryId`.
 - Assistant content becomes reasoning, response, and tool activities in protocol order. The persisted assistant identity is the session entry ID; a Pi message ID or timestamp is only a live-to-persisted correlation clue and never merges two persisted entries.
 - A tool result updates the activity identified by `toolCallId`; it is not a second visible activity. Assistant takeover relocates all reasoning, response, and embedded tool-call parts as one ownership unit, including the tool location. Once a persisted tool result arrives, delayed live tool events cannot replace its stable content.
+- A complete history replacement finalizes every tool still marked `running` as `cancelled`: FrostPi no longer has live tracking and did not receive a final result. This local status preserves partial output and may be replaced by a later persisted tool result.
 - `compaction`, `branch_summary`, and `custom_message` are independent items at their active-path positions.
 - Compaction never removes or hides earlier active-path items. Nested `retainedTail` values are LLM-context metadata and are not expanded into transcript items.
 - Every `custom_message` with `display: true` renders generic text and image blocks. `display: false` messages and plain `custom` state entries are omitted.
@@ -46,7 +47,7 @@ A persisted user message closes the preceding visual turn and opens a user-ancho
 
 Live `message_end(error)` displays the error activity but leaves the turn running until `agent_end` decides whether Pi will retry. `agent_end(willRetry: true)` keeps the running turn and `auto_retry_start` adds a notice; `willRetry: false` commits the pending error. This uses the existing turn statuses and does not persist retry notices.
 
-While an agent run is active, queued follow-ups remain outside persisted conversation order. Pi may emit a follow-up user message without another `agent_start`; promotion follows protocol FIFO order and closes the prior visual turn. Abort, process stop, and process failure clear the local queue.
+While an agent run is active, queued follow-ups remain outside persisted conversation order. Pi may emit a follow-up user message without another `agent_start`; promotion follows protocol FIFO order and closes the prior visual turn. Abort, process stop, and process failure clear the local queue. `agent_settled`, process stop, and process failure also finalize unresolved running tools as `cancelled`; they do not infer a tool error or alter the turn status.
 
 Live activity updates replace existing view objects instead of mutating them. This is required for bridge deltas and Webview-owned disclosure state. Documented assistant events provide an ID or timestamp correlation clue; a malformed live assistant without either is omitted until persisted refresh rather than emitted as an uncorrelatable duplicate. Notices emitted during an active turn remain inside its ordered items; idle notices are top-level conversation items.
 

apps/vscode/src/extension/sessions/SessionRuntime.ts

@@ -151,6 +151,7 @@ export class SessionRuntime {
 
   async stop(): Promise<void> {
     this.#lifecycleVersion += 1;
+    this.#conversation.finalizeUnresolvedTools();
     this.#viewState.setStatus("stopping");
     this.#stopLiveStatsRefresh();
     this.#notifyChange();
@@ -595,6 +596,7 @@ export class SessionRuntime {
     connection.onFailure((error) => {
       this.#logger.error(`Session ${this.id} failed`, error);
       this.#stopLiveStatsRefresh();
+      this.#conversation.finalizeUnresolvedTools();
       this.#conversation.clearQueuedFollowUps();
       this.#viewState.setStatus("failed", errorMessage(error));
       this.#notifyChange();

apps/vscode/src/webview/features/conversation/ToolActivity.svelte

@@ -9,7 +9,24 @@
 
   const tool = $derived(activity.tool);
   const icon = $derived(toolIcon(tool.name));
-  const statusIcon = $derived(tool.status === "running" ? "loading codicon-modifier-spin" : tool.status === "error" ? "error" : "check");
+  const statusIcon = $derived(
+    tool.status === "running"
+      ? "loading codicon-modifier-spin"
+      : tool.status === "error"
+        ? "error"
+        : tool.status === "cancelled"
+          ? "warning"
+          : "check",
+  );
+  const statusLabel = $derived(
+    tool.status === "cancelled"
+      ? "Final tool result was not received; execution may have been interrupted."
+      : tool.status === "running"
+        ? "Tool is running"
+        : tool.status === "error"
+          ? "Tool failed"
+          : "Tool completed",
+  );
   const errorSummary = $derived(tool.status === "error" ? firstLine(tool.output) : "");
 </script>
 
@@ -19,7 +36,11 @@
     <span class="tool-activity-name">{tool.name}</span>
     <span class="tool-activity-label" title={tool.label}>{tool.label}</span>
     {#if errorSummary}<span class="tool-error-summary" title={tool.output}>{errorSummary}</span>{/if}
-    <span class={`codicon codicon-${statusIcon} activity-status`} aria-hidden="true"></span>
+    <span
+      class={`codicon codicon-${statusIcon} activity-status${tool.status === "cancelled" ? " tool-status-cancelled" : ""}`}
+      title={statusLabel}
+      aria-label={statusLabel}
+    ></span>
     <span class={`codicon codicon-chevron-${open ? "down" : "right"} activity-chevron`} aria-hidden="true"></span>
   </Collapsible.Trigger>
   <Collapsible.Content class="activity-content tool-activity-content">
@@ -160,6 +181,7 @@
   color: var(--frost-muted);
   font: 10.5px/1.35 var(--font-mono);
 }
+.tool-status-cancelled { color: var(--frost-warning); }
 .tool-error-summary {
   min-width: 0;
   max-width: 38%;

apps/vscode/test/unit/ConversationProjection.test.ts

@@ -3,6 +3,7 @@ import { describe, expect, it } from "vitest";
 
 import { ConversationProjection } from "../../src/extension/conversation/ConversationProjection.js";
 import type { AgentTurnView } from "../../src/shared/model/conversationModel.js";
+import type { ToolCallView } from "../../src/shared/model/toolCallModel.js";
 
 describe("ConversationProjection", () => {
   it("preserves active-path order across turns, branch edges, boundaries, and custom blocks", () => {
@@ -375,6 +376,79 @@ describe("ConversationProjection", () => {
     expect(normalizePersistedProjection(projection)).toEqual(normalizePersistedProjection(replacement));
   });
 
+  it("finalizes unresolved tools after complete history replacement without inventing a result", () => {
+    const projection = new ConversationProjection();
+    projection.replaceEntries([
+      userEntry("u1", null, "Inspect", 1),
+      assistantEntry("a1", "u1", [{ type: "toolCall", id: "t1", name: "read", arguments: { path: "a.ts" } }], "toolUse", 2),
+    ], []);
+
+    const [tool] = turns(projection.read().items)[0]?.items.filter((item) => item.type === "tool") ?? [];
+    expect(tool?.tool).toMatchObject({
+      id: "t1",
+      status: "cancelled",
+      args: { path: "a.ts" },
+      isError: false,
+    });
+    expect(tool?.tool.output).toBeUndefined();
+    expect(tool?.tool.endedAt).toBeUndefined();
+  });
+
+  it("preserves settled tool state through assistant takeover and accepts a later authoritative result", () => {
+    const projection = new ConversationProjection();
+    projection.appendUserPrompt("Inspect", [], 1);
+    projection.applyEvent({ type: "agent_start" });
+    projection.applyEvent({ type: "message_start", message: { role: "user", content: "Inspect", timestamp: 1 } });
+    projection.applyEvent({
+      type: "message_end",
+      message: {
+        id: "assistant-1",
+        role: "assistant",
+        content: [{ type: "toolCall", id: "t1", name: "read", arguments: { path: "a.ts" } }],
+        stopReason: "toolUse",
+        timestamp: 2,
+      },
+    });
+    projection.applyEvent({
+      type: "tool_execution_update",
+      toolCallId: "t1",
+      toolName: "read",
+      args: { path: "a.ts" },
+      partialResult: [{ type: "text", text: "partial" }],
+    });
+    projection.applyEvent({ type: "agent_settled" });
+    expect(projectedTool(projection, "t1")).toMatchObject({ status: "cancelled", output: "partial", isError: false });
+
+    expect(projection.reconcileEntries([
+      userEntry("u1", null, "Inspect", 1),
+      assistantEntry(
+        "a1",
+        "u1",
+        [{ type: "toolCall", id: "t1", name: "read", arguments: { path: "a.ts" } }],
+        "toolUse",
+        2,
+        "assistant-1",
+      ),
+    ], [])).toBe("applied");
+    expect(projectedTool(projection, "t1")).toMatchObject({ status: "cancelled", output: "partial", isError: false });
+
+    expect(projection.reconcileEntries([
+      toolResultEntry("r1", "a1", "t1", "final", 3),
+    ], [])).toBe("applied");
+    expect(projectedTool(projection, "t1")).toMatchObject({ status: "complete", output: "final", isError: false, endedAt: 3 });
+  });
+
+  it("keeps persisted tool failures authoritative", () => {
+    const projection = new ConversationProjection();
+    projection.replaceEntries([
+      userEntry("u1", null, "Inspect", 1),
+      assistantEntry("a1", "u1", [{ type: "toolCall", id: "t1", name: "read", arguments: {} }], "toolUse", 2),
+      toolResultEntry("r1", "a1", "t1", "failed", 3, true),
+    ], []);
+
+    expect(projectedTool(projection, "t1")).toMatchObject({ status: "error", output: "failed", isError: true, endedAt: 3 });
+  });
+
   it("ignores stale assistant and compaction replay after persisted replacement", () => {
     const projection = new ConversationProjection();
     projection.replaceEntries([
@@ -532,6 +606,15 @@ describe("ConversationProjection", () => {
   });
 });
 
+function projectedTool(projection: ConversationProjection, toolCallId: string): ToolCallView | undefined {
+  for (const turn of turns(projection.read().items)) {
+    for (const item of turn.items) {
+      if (item.type === "tool" && item.tool.id === toolCallId) return item.tool;
+    }
+  }
+  return undefined;
+}
+
 function responseText(item: Extract<AgentTurnView["items"][number], { type: "response" }>): string {
   return item.blocks.map((block) => block.type === "text" || block.type === "error" ? block.text : "").join("");
 }
@@ -626,13 +709,14 @@ function toolResultEntry(
   toolCallId: string,
   output: string,
   timestamp: number,
+  isError = false,
 ): RpcSessionEntry {
   return {
     type: "message",
     id,
     parentId,
     timestamp,
-    message: { role: "toolResult", toolCallId, toolName: "read", content: [{ type: "text", text: output }], timestamp },
+    message: { role: "toolResult", toolCallId, toolName: "read", content: [{ type: "text", text: output }], isError, timestamp },
   };
 }