@stigmer/cli 3.1.7 → 3.1.8

package/src/resources/stream/events.ts

@@ -15,7 +15,7 @@ import type { JsonObject } from "@bufbuild/protobuf";
 export interface ToolCallInfo {
   readonly id: string;
   readonly name: string;
-  /** Mapped status: pending|running|completed|failed|waiting_approval|skipped|unknown. */
+  /** Mapped status: pending|running|completed|failed|waiting_approval|skipped|interrupted|unknown. */
   readonly status: string;
   readonly args?: JsonObject;
   readonly result: string;
@@ -85,6 +85,19 @@ export interface ToolCompletedEvent {
   readonly subAgentId: string;
 }
 
+/**
+ * A tool call the platform settled to INTERRUPTED because its execution
+ * terminalized mid-call (issue #207). A distinct terminal event — routing it
+ * through toolCompleted would print a dishonest checkmark for a tool that
+ * never finished.
+ */
+export interface ToolInterruptedEvent {
+  readonly kind: "toolInterrupted";
+  readonly toolCallId: string;
+  readonly toolCall: ToolCallInfo;
+  readonly subAgentId: string;
+}
+
 export interface ToolWaitingApprovalEvent {
   readonly kind: "toolWaitingApproval";
   readonly toolCallId: string;
@@ -175,6 +188,7 @@ export type StreamEvent =
   | ToolResultEvent
   | ToolRunningEvent
   | ToolCompletedEvent
+  | ToolInterruptedEvent
   | ToolWaitingApprovalEvent
   | ToolStreamDeltaEvent
   | SystemMessageEvent

package/src/resources/stream/render-ndjson.test.ts

@@ -62,6 +62,16 @@ describe("envelope", () => {
 });
 
 describe("tool events", () => {
+  it("emits tool_interrupted as its own wire type (issue #207)", () => {
+    const { data } = render([
+      { kind: "toolInterrupted", toolCallId: "t1", subAgentId: "", toolCall: toolInfo({ id: "t1", name: "shell", status: "interrupted" }) },
+    ]);
+    expect(data.lines()[0]).toMatchObject({
+      type: "tool_interrupted",
+      payload: { tool_call_id: "t1", tool_name: "shell", status: "interrupted" },
+    });
+  });
+
   it("emits tool_running with only the meaningful fields", () => {
     const { data } = render([
       { kind: "toolRunning", toolCallId: "t1", subAgentId: "", toolCall: toolInfo({ id: "t1", result: "out", durationMs: 42 }) },

package/src/resources/stream/render-ndjson.ts

@@ -77,6 +77,8 @@ function mapToNdjson(event: StreamEvent): MappedEvent | undefined {
       return { type: "tool_running", payload: toolEventPayload(event.toolCallId, event.toolCall, event.subAgentId) };
     case "toolCompleted":
       return { type: "tool_completed", payload: toolEventPayload(event.toolCallId, event.toolCall, event.subAgentId) };
+    case "toolInterrupted":
+      return { type: "tool_interrupted", payload: toolEventPayload(event.toolCallId, event.toolCall, event.subAgentId) };
     case "toolWaitingApproval":
       return {
         type: "tool_waiting_approval",

package/src/resources/stream/render-plaintext.test.ts

@@ -39,6 +39,14 @@ describe("PlaintextRenderer", () => {
     expect(status).toContain("✗ shell: exploded");
   });
 
+  it("renders an interrupted tool with the neutral glyph, not a checkmark (issue #207)", () => {
+    const { status } = render([
+      { kind: "toolInterrupted", toolCallId: "t1", subAgentId: "", toolCall: toolInfo({ name: "shell", status: "interrupted" }) },
+    ]);
+    expect(status).toContain("⊘ shell (interrupted)");
+    expect(status).not.toContain("✓");
+  });
+
   it("notes the auto-skip for approvals and resolves to SKIP", () => {
     const r = new PlaintextRenderer({ data: { write: () => {} }, status: { write: () => {} } });
     const action = r.resolveApproval({

package/src/resources/stream/render-plaintext.ts

@@ -49,6 +49,9 @@ export class PlaintextRenderer implements HeadlessRenderer {
             : `  ✓ ${event.toolCall.name}\n`,
         );
         return;
+      case "toolInterrupted":
+        status.write(`  ⊘ ${event.toolCall.name} (interrupted)\n`);
+        return;
       case "approvalNeeded":
         status.write(`  ⚠ Approval needed: ${event.toolName} (auto-skipped in non-TTY mode)\n`);
         return;

package/src/resources/stream/snapshot.test.ts

@@ -79,6 +79,20 @@ describe("snapshotToEvents", () => {
     expect(events[0]).toMatchObject({ kind: "toolCompleted", toolCallId: "tc1" });
   });
 
+  it("replays a platform-interrupted call as toolInterrupted — never a live running block", () => {
+    // Issue #207: before the fix an INTERRUPTED status fell through to
+    // "unknown" (non-terminal) and replayed as toolRunning, a block that never
+    // closes. It must replay as its own settled event.
+    const events = snapshotToEvents([
+      exec({
+        phase: ExecutionPhase.EXECUTION_CANCELLED,
+        messages: [toolMsg(tool("tc1", ToolCallStatus.TOOL_CALL_INTERRUPTED))],
+      }),
+    ]);
+    expect(kinds(events)).toEqual(["toolInterrupted", "done"]);
+    expect(events[0]).toMatchObject({ kind: "toolInterrupted", toolCallId: "tc1" });
+  });
+
   it("only the final execution emits done", () => {
     const events = snapshotToEvents([
       exec({ message: "first", messages: [aiMsg("a")] }),

package/src/resources/stream/snapshot.ts

@@ -159,7 +159,11 @@ function emitOtherMessage(out: StreamEvent[], msg: AgentMessage): void {
 function emitToolByStatus(out: StreamEvent[], tc: ToolCall): void {
   const status = mapToolCallStatus(tc.status);
   const toolCall = convertToolCall(tc);
-  if (isTerminalToolStatus(status)) {
+  if (status === "interrupted") {
+    // Terminal but never "completed": replaying a platform-interrupted call as
+    // either a checkmark or a live running block would lie (issue #207).
+    out.push({ kind: "toolInterrupted", toolCallId: tc.id, toolCall, subAgentId: "" });
+  } else if (isTerminalToolStatus(status)) {
     out.push({ kind: "toolCompleted", toolCallId: tc.id, toolCall, subAgentId: "" });
   } else if (status === "waiting_approval") {
     out.push({ kind: "toolWaitingApproval", toolCallId: tc.id, toolCall, subAgentId: "" });

package/src/resources/stream/tool-state.ts

@@ -55,14 +55,14 @@ export class ToolStateTracker {
       // First sight, already terminal (e.g. re-attach): synthesize completion so
       // the block exists — otherwise its MESSAGE_TOOL is suppressed and it vanishes.
       if (!seen && isTerminalToolStatus(current)) {
-        pending.push(this.completed(tc, subAgentId));
+        pending.push(this.terminal(tc, current, subAgentId));
         this.states.set(tc.id, current);
         continue;
       }
 
       // running/waiting -> terminal: close the block.
       if (seen && (prev === "running" || prev === "waiting_approval") && isTerminalToolStatus(current)) {
-        pending.push(this.completed(tc, subAgentId));
+        pending.push(this.terminal(tc, current, subAgentId));
         this.states.set(tc.id, current);
         this.results.delete(tc.id);
         continue;
@@ -113,8 +113,16 @@ export class ToolStateTracker {
     return { kind: "toolWaitingApproval", toolCallId: tc.id, toolCall: convertToolCall(tc), subAgentId };
   }
 
-  private completed(tc: ToolCall, subAgentId: string): StreamEvent {
-    return { kind: "toolCompleted", toolCallId: tc.id, toolCall: convertToolCall(tc), subAgentId };
+  // The terminal-close event for a settled status: interrupted gets its own
+  // kind (issue #207) so renderers never print a checkmark for a tool the
+  // platform cut short; every other terminal status closes as completed.
+  private terminal(tc: ToolCall, status: string, subAgentId: string): StreamEvent {
+    return {
+      kind: status === "interrupted" ? "toolInterrupted" : "toolCompleted",
+      toolCallId: tc.id,
+      toolCall: convertToolCall(tc),
+      subAgentId,
+    };
   }
 }
 
@@ -123,6 +131,7 @@ export function toolEventId(event: StreamEvent): string {
   switch (event.kind) {
     case "toolRunning":
     case "toolCompleted":
+    case "toolInterrupted":
     case "toolWaitingApproval":
     case "toolStreamDelta":
       return event.toolCallId;