@saadnvd1/agent-os 0.3.737 → 0.3.738

package/components/Chat/ChatPanel.tsx

@@ -1,5 +1,6 @@
 "use client";
 
+import type { StepCounts } from "@/lib/chat/tool-outcome";
 import {
   memo,
   useCallback,
@@ -99,7 +100,15 @@ interface ItemActions {
   onQuote?: (text: string) => void;
 }
 
-function Item({ item, actions }: { item: ChatItem; actions: ItemActions }) {
+function Item({
+  item,
+  actions,
+  steps,
+}: {
+  item: ChatItem;
+  actions: ItemActions;
+  steps?: StepCounts;
+}) {
   switch (item.kind) {
     case "user":
       return (
@@ -119,7 +128,7 @@ function Item({ item, actions }: { item: ChatItem; actions: ItemActions }) {
     case "todos":
       return <Todos item={item} />;
     case "turn_end":
-      return <TurnEnd item={item} />;
+      return <TurnEnd item={item} steps={steps} />;
     case "error":
       return <ErrorMessage item={item} />;
     case "command_output":
@@ -209,7 +218,7 @@ const Block = memo(
       </UndoneBlock>
     ) : (
       <div data-item={b.item.id}>
-        <Item item={b.item} actions={actions} />
+        <Item item={b.item} actions={actions} steps={b.steps} />
       </div>
     );
   },

package/components/Chat/Messages.test.ts

@@ -1,7 +1,7 @@
 import { createElement } from "react";
 import { renderToStaticMarkup } from "react-dom/server";
 import { describe, expect, it, vi } from "vitest";
-import { AssistantMessage, UserMessage } from "./Messages";
+import { AssistantMessage, TurnEnd, UserMessage } from "./Messages";
 
 const item = {
   id: "a1",
@@ -119,3 +119,15 @@ describe("UserMessage code blocks", () => {
     }
   });
 });
+
+describe("TurnEnd steps", () => {
+  it("says what a stopped turn got through", () => {
+    const html = renderToStaticMarkup(
+      createElement(TurnEnd, {
+        item: { id: "e", kind: "turn_end", interrupted: true } as never,
+        steps: { total: 5, ok: 3, failed: 1, stopped: 1, running: 0 },
+      })
+    );
+    expect(html).toContain("Stopped · 4 of 5 steps done, 1 failed, 1 not run");
+  });
+});

package/components/Chat/Messages.tsx

@@ -1,5 +1,6 @@
 "use client";
 
+import type { StepCounts } from "@/lib/chat/tool-outcome";
 import { memo } from "react";
 import { useSnapshot } from "valtio";
 import {
@@ -378,7 +379,23 @@ export function Todos({ item }: { item: Of<"todos"> }) {
   );
 }
 
-export function TurnEnd({ item }: { item: Of<"turn_end"> }) {
+// What a stopped or failed turn got through.
+export function stepsLabel(s: StepCounts): string {
+  const done = s.ok + s.failed;
+  const parts = [`${done} of ${s.total} steps done`];
+  if (s.failed) parts.push(`${s.failed} failed`);
+  const unfinished = s.stopped + s.running;
+  if (unfinished) parts.push(`${unfinished} not run`);
+  return parts.join(", ");
+}
+
+export function TurnEnd({
+  item,
+  steps,
+}: {
+  item: Of<"turn_end">;
+  steps?: StepCounts;
+}) {
   const secs = item.durationMs ? Math.round(item.durationMs / 1000) : null;
   const early = !item.interrupted && item.ended;
   const label = item.interrupted
@@ -407,7 +424,7 @@ export function TurnEnd({ item }: { item: Of<"turn_end"> }) {
       )}
       <div className="group text-muted-foreground/60 flex items-center gap-3 font-mono text-[11px]">
         <span className="bg-foreground/[0.06] h-px flex-1" />
-        {label}
+        {steps ? `${label} · ${stepsLabel(steps)}` : label}
         <TurnCopy turnEndId={item.id} />
         <TurnBookmark turnEndId={item.id} />
         <span className="bg-foreground/[0.06] h-px flex-1" />

package/components/Chat/StepOutcomes.tsx

@@ -0,0 +1,66 @@
+"use client";
+
+import type { ToolItem } from "@/lib/chat/group";
+import { toolOutcome } from "@/lib/chat/tool-outcome";
+import { cn } from "@/lib/utils";
+import { StatusIcon } from "./Tools";
+
+export const MAX_CHIPS = 24;
+
+const WORD = {
+  running: "running",
+  done: "ok",
+  error: "failed",
+  stopped: "not run",
+} as const;
+
+// One line per collapsed group: how each step ended, so the results aren't
+// lost behind the fold.
+export function StepOutcomes({
+  tools,
+  onOpen,
+}: {
+  tools: ToolItem[];
+  onOpen: () => void;
+}) {
+  const shown = tools.slice(0, MAX_CHIPS);
+  return (
+    <button
+      type="button"
+      onClick={onOpen}
+      aria-label="Show steps"
+      className="flex min-h-11 w-full flex-wrap items-center gap-x-3 gap-y-1 px-2 pb-1.5 text-left md:min-h-0"
+    >
+      {shown.map((t) => {
+        const code = toolOutcome(t);
+        return (
+          <span
+            key={t.id}
+            title={`${t.title}: ${WORD[t.status]}${code ? `, ${code}` : ""}`}
+            aria-label={`${t.title}: ${WORD[t.status]}${code ? `, ${code}` : ""}`}
+            className="flex min-w-0 items-center gap-1"
+          >
+            <StatusIcon status={t.status} />
+            {code && (
+              <span
+                className={cn(
+                  "font-mono text-[11px]",
+                  t.status === "error"
+                    ? "text-destructive"
+                    : "text-muted-foreground"
+                )}
+              >
+                {code}
+              </span>
+            )}
+          </span>
+        );
+      })}
+      {tools.length > shown.length && (
+        <span className="text-muted-foreground/70 font-mono text-[11px]">
+          +{tools.length - shown.length} more
+        </span>
+      )}
+    </button>
+  );
+}

package/components/Chat/Tools.test.ts

@@ -0,0 +1,52 @@
+import { createElement } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import { describe, expect, it } from "vitest";
+import type { ToolItem } from "@/lib/chat/group";
+import { MAX_CHIPS } from "./StepOutcomes";
+import { ToolGroup } from "./Tools";
+
+const tool = (id: string, over: Partial<ToolItem> = {}): ToolItem => ({
+  id,
+  kind: "tool",
+  name: "Bash",
+  title: `check ${id}`,
+  input: {},
+  status: "done",
+  createdAt: 0,
+  ...over,
+});
+
+const render = (tools: ToolItem[]) =>
+  renderToStaticMarkup(createElement(ToolGroup, { tools }));
+
+describe("collapsed ToolGroup", () => {
+  it("keeps each step's outcome in view", () => {
+    const html = render([
+      tool("a", { output: "HTTP/2 200 \n" }),
+      tool("b", { status: "error", output: "Exit code 7" }),
+      tool("c", { status: "error", deferred: true, outcome: "HTTP 404" }),
+      tool("d", { status: "stopped" }),
+    ]);
+    expect(html).toContain("4 steps");
+    expect(html).toContain("1 ok");
+    expect(html).toContain("2 failed");
+    expect(html).toContain("1 not run");
+    expect(html).toContain("check a: ok, HTTP 200");
+    expect(html).toContain("check b: failed, exit 7");
+    expect(html).toContain("check c: failed, HTTP 404");
+    expect(html).toContain("check d: not run");
+  });
+
+  it("shows no strip while a step runs", () => {
+    expect(render([tool("a", { status: "running" })])).not.toContain(
+      "Show steps"
+    );
+  });
+
+  it("caps the strip", () => {
+    const tools = Array.from({ length: MAX_CHIPS + 3 }, (_, i) =>
+      tool(`x${i}`)
+    );
+    expect(render(tools)).toContain("+3 more");
+  });
+});

package/components/Chat/Tools.tsx

@@ -8,6 +8,8 @@ import { lineDiff, shortPath, type DiffLine } from "@/lib/chat/diff";
 import { needsBody } from "@/lib/chat/bodyCache";
 import { cn } from "@/lib/utils";
 import { formatElapsed } from "@/lib/chat/elapsed";
+import { stepCounts, toolOutcome } from "@/lib/chat/tool-outcome";
+import { StepOutcomes } from "./StepOutcomes";
 import { Highlighted } from "./Code";
 import { BackgroundButton, BackgroundState, useBackground } from "./background";
 import { useNow } from "./useNow";
@@ -163,6 +165,18 @@ function ToolRow({ tool }: { tool: ToolItem }) {
           <span className="min-w-0 flex-1 truncate font-mono text-xs">
             {tool.title}
           </span>
+          {toolOutcome(tool) && (
+            <span
+              className={cn(
+                "shrink-0 font-mono text-[11px]",
+                tool.status === "error"
+                  ? "text-destructive"
+                  : "text-muted-foreground"
+              )}
+            >
+              {toolOutcome(tool)}
+            </span>
+          )}
           {tool.backgroundTaskId ? (
             <BackgroundState tool={tool} />
           ) : (
@@ -180,8 +194,7 @@ function ToolRow({ tool }: { tool: ToolItem }) {
 // A run of tool calls: one quiet line, expandable to every step.
 export function ToolGroup({ tools }: { tools: ToolItem[] }) {
   const running = tools.some((t) => t.status === "running");
-  const failed = tools.filter((t) => t.status === "error").length;
-  const stopped = tools.filter((t) => t.status === "stopped").length;
+  const { ok, failed, stopped } = stepCounts(tools);
   const edits = tools.filter((t) => t.diff || t.hasDiff).length;
   const moved = tools.filter((t) => t.backgroundTaskId).length;
   const [open, setOpen] = useRowState(`steps:${tools[0].id}`, false);
@@ -211,13 +224,14 @@ export function ToolGroup({ tools }: { tools: ToolItem[] }) {
             {!running &&
               edits > 0 &&
               ` · ${edits} edit${edits === 1 ? "" : "s"}`}
+            {!running && (failed > 0 || stopped > 0) && ` · ${ok} ok`}
           </span>
           {running && <Elapsed tool={latest} />}
           {failed > 0 && (
             <span className="text-destructive">{failed} failed</span>
           )}
-          {stopped > 0 && failed === 0 && (
-            <span className="text-muted-foreground/70">stopped</span>
+          {stopped > 0 && (
+            <span className="text-muted-foreground/70">{stopped} not run</span>
           )}
           {!running && moved > 0 && (
             <span className="text-muted-foreground/70">
@@ -227,6 +241,9 @@ export function ToolGroup({ tools }: { tools: ToolItem[] }) {
         </button>
         {running && <BackgroundButton tool={latest} />}
       </div>
+      {!open && !running && (
+        <StepOutcomes tools={tools} onOpen={() => setOpen(true)} />
+      )}
       {open && (
         <div className="pb-1">
           {tools.map((t) => (

package/lib/chat/drivers/pi-mapper.ts

@@ -2,7 +2,7 @@ import { randomUUID } from "crypto";
 import type { DriverEvent, UsageTotals } from "../events";
 import { toolDiff, toolTitle } from "../tools";
 import { TurnItems, type ToolStart } from "./turn-items";
-import { logTurnEnd, turnOutcome } from "./turn-outcome";
+import { logTurnEnd, needsSummary, turnOutcome } from "./turn-outcome";
 
 type P = Record<string, unknown>;
 const str = (v: unknown) => (typeof v === "string" ? v : "");
@@ -53,6 +53,7 @@ export class PiMapper {
   private error = "";
   // The last answer's text, its tool calls and who gave it, for the notice
   // when a turn ends without doing anything.
+  private toolsRun = 0;
   private last = { text: "", calls: 0, provider: "", model: "", api: "" };
   totals: UsageTotals = {
     costUsd: 0,
@@ -74,6 +75,8 @@ export class PiMapper {
   map(e: P): void {
     switch (e.type) {
       case "agent_start":
+        // A nudged run continues the same turn, so its tools still count.
+        if (!this.items.inTurn) this.toolsRun = 0;
         this.stopReason = this.error = "";
         this.last = { text: "", calls: 0, provider: "", model: "", api: "" };
         return this.items.startTurn();
@@ -85,6 +88,7 @@ export class PiMapper {
       case "message_end":
         return this.ended(e.message as P);
       case "tool_execution_start":
+        this.toolsRun++;
         return this.items.tool(
           str(e.toolCallId),
           piTool(str(e.toolName), e.args)
@@ -168,6 +172,18 @@ export class PiMapper {
     };
   }
 
+  // The run ran tools and ended without saying what they found.
+  needsSummary(): boolean {
+    return needsSummary({
+      toolsRun: this.toolsRun,
+      text: this.last.text,
+      toolCalls: this.last.calls,
+      finishReason: this.stopReason,
+      error: this.error || undefined,
+      aborted: this.aborted,
+    });
+  }
+
   // The run is over: Pi has nothing left to do for it.
   endTurn(): void {
     if (!this.items.inTurn) return;

package/lib/chat/drivers/pi.ts

@@ -7,6 +7,7 @@ import { PiAccess, PiDialogs, writeExtension } from "./pi-approvals";
 import { TEXT_TOOLS_EXTENSION } from "./pi-text-tools";
 import { PiMapper } from "./pi-mapper";
 import { PiRpc } from "./pi-rpc";
+import { RESULTS_BRIEF, SUMMARY_NUDGE } from "./turn-outcome";
 
 type P = Record<string, unknown>;
 
@@ -17,7 +18,10 @@ export function piArgs(o: ChatStartOptions, ...extensions: string[]): string[] {
   // A path, so a conversation started elsewhere never makes Pi ask about it.
   if (o.resumeId) args.push("--session", o.resumeId);
   if (o.model && o.model !== AGENT_DEFAULT_MODEL) args.push("--model", o.model);
-  if (o.systemAppend) args.push("--append-system-prompt", o.systemAppend);
+  args.push(
+    "--append-system-prompt",
+    [o.systemAppend, RESULTS_BRIEF].filter(Boolean).join("\n\n")
+  );
   return args;
 }
 
@@ -78,6 +82,7 @@ export const piDriver: ChatDriver = {
     const dialogs = new PiDialogs(emit);
     const access = new PiAccess(options.access);
     // Sent now: goes once the stopped run has ended.
+    let nudged = false;
     const held: { text: string; images?: ChatImage[] }[] = [];
     const rpc: PiRpc = new PiRpc(
       piArgs(
@@ -132,6 +137,13 @@ export const piDriver: ChatDriver = {
           if (!s.isCompacting) break;
           await new Promise((r) => setTimeout(r, 200));
         }
+      if (!nudged && mapper.needsSummary()) {
+        nudged = true;
+        console.info("[chat] asked the model for its results summary");
+        void prompt(SUMMARY_NUDGE);
+        return;
+      }
+      nudged = false;
       mapper.endTurn();
       void rpc
         .request<{ contextUsage?: P }>("get_session_stats")

package/lib/chat/drivers/turn-outcome.ts

@@ -106,3 +106,28 @@ export function logTurnEnd(o: {
     })
   );
 }
+
+// Asked of the model once when its turn ran tools but ended without the
+// report it set out to give.
+export const SUMMARY_NUDGE =
+  "You ran checks or tools but haven't reported the results. Reply now with a short summary: what worked, what failed (with the exit code or HTTP status) and what you didn't check. Don't run more tools.";
+
+// Appended to the system prompt of agents AgentOS drives itself.
+export const RESULTS_BRIEF =
+  "After running checks, probes or discovery, end your turn with a results summary: what worked, what failed (exit code or HTTP status) and what you didn't check. Never end on a lead-in such as 'Here's what I found:' without the list.";
+
+// Whether a turn that ran tools ended without telling what they found: an
+// empty last reply, or one that only promises the report.
+export function needsSummary(r: {
+  toolsRun: number;
+  text: string;
+  toolCalls: number;
+  finishReason?: string;
+  error?: string;
+  aborted?: boolean;
+}): boolean {
+  if (r.toolsRun === 0 || r.toolCalls > 0 || r.aborted || r.error) return false;
+  if (r.finishReason === "length") return false;
+  const text = r.text.trim();
+  return !text || announcesAction(text) || text.endsWith(":");
+}

package/lib/chat/events.ts

@@ -185,6 +185,8 @@ export type ChatItem =
       input: unknown;
       status: ToolStatus;
       output?: string;
+      // How it ended ("exit 1", "HTTP 404"), kept when the output is deferred.
+      outcome?: string;
       diff?: FileDiff;
       // When it finished, to show how long a step took.
       endedAt?: number;

package/lib/chat/group.ts

@@ -1,12 +1,14 @@
 import type { ChatItem } from "./events";
 import { readingOrder } from "./reading-order";
+import { stepCounts, type StepCounts } from "./tool-outcome";
 import { eventTurnAt, type EventTurn } from "./turns";
 
 export type ToolItem = Extract<ChatItem, { kind: "tool" }>;
 export type UndoItem = Extract<ChatItem, { kind: "undo" }>;
 
 export type TimelineBlock =
-  | { type: "item"; item: ChatItem }
+  // `steps` rides on the end of a stopped or failed turn: what ran in it.
+  | { type: "item"; item: ChatItem; steps?: StepCounts }
   | { type: "tools"; id: string; tools: ToolItem[] }
   | { type: "undone"; id: string; undo: UndoItem; items: ChatItem[] }
   // Consecutive turns an event started, with the reply to each.
@@ -30,6 +32,8 @@ export function groupTimeline(
   const items = opts.foldEvents ? readingOrder(all) : all;
   const blocks: TimelineBlock[] = [];
   let tools: ToolItem[] = [];
+  // Every tool call since the last turn ended, grouped or not.
+  let turnTools: ToolItem[] = [];
   const flush = () => {
     if (tools.length) blocks.push({ type: "tools", id: tools[0].id, tools });
     tools = [];
@@ -74,8 +78,10 @@ export function groupTimeline(
       i = end;
     } else if (item.kind === "tool" && STANDALONE_TOOLS.has(item.name)) {
       flush();
+      turnTools.push(item);
       blocks.push({ type: "item", item });
     } else if (item.kind === "tool") {
+      turnTools.push(item);
       tools.push(item);
     } else if (item.kind === "reasoning" && tools.length) {
       continue;
@@ -91,7 +97,15 @@ export function groupTimeline(
       continue;
     } else {
       flush();
-      blocks.push({ type: "item", item });
+      const cut =
+        item.kind === "turn_end" &&
+        (item.interrupted || item.ended?.reason === "error");
+      blocks.push(
+        cut && turnTools.length
+          ? { type: "item", item, steps: stepCounts(turnTools) }
+          : { type: "item", item }
+      );
+      if (item.kind === "turn_end") turnTools = [];
     }
   }
   flush();
@@ -123,7 +137,13 @@ function undoneRanges(items: ChatItem[]): Map<number, number> {
 // until they change, so a streamed delta re-renders only its own block.
 export function sameBlock(a: TimelineBlock, b: TimelineBlock): boolean {
   if (a === b) return true;
-  if (a.type === "item" && b.type === "item") return a.item === b.item;
+  if (a.type === "item" && b.type === "item")
+    return (
+      a.item === b.item &&
+      a.steps?.total === b.steps?.total &&
+      a.steps?.ok === b.steps?.ok &&
+      a.steps?.failed === b.steps?.failed
+    );
   if (a.type === "tools" && b.type === "tools")
     return sameItems(a.tools, b.tools);
   if (a.type === "undone" && b.type === "undone")

package/lib/chat/page.ts

@@ -1,5 +1,6 @@
 import { db } from "../db";
 import type { ChatItem, ToolBody } from "./events";
+import { toolCode } from "./tool-outcome";
 
 // A conversation opens on its latest items and pages older ones in as the
 // reader scrolls up, so a long one costs what's on screen, not its history.
@@ -23,8 +24,10 @@ export function lighten(item: ChatItem): ChatItem {
   if (item.kind !== "tool" || (item.output === undefined && !item.diff))
     return item;
   const { output, diff, ...rest } = item;
+  const outcome = toolCode(output);
   return {
     ...rest,
+    ...(outcome ? { outcome } : {}),
     deferred: true,
     ...(diff ? { hasDiff: true } : {}),
     ...(output ? { hasOutput: true } : {}),

package/lib/chat/tool-outcome.ts

@@ -0,0 +1,45 @@
+import type { ToolItem } from "./group";
+
+const EDGE = 4096;
+
+// A short label for how a command ended, read from its output: the last HTTP
+// status line (a redirect chain reports where it landed) or an exit code.
+export function toolCode(output?: string): string | undefined {
+  if (!output) return undefined;
+  const text =
+    output.length > EDGE * 2
+      ? `${output.slice(0, EDGE)}\n${output.slice(-EDGE)}`
+      : output;
+  const http = [...text.matchAll(/^HTTP\/[\d.]+ (\d{3})/gm)].pop();
+  if (http) return `HTTP ${http[1]}`;
+  const exit = [
+    ...text.matchAll(
+      /(?:^Exit code |Command exited with code |exit (?:code|status)[:= ]+)(\d+)/gim
+    ),
+  ].pop();
+  return exit ? `exit ${exit[1]}` : undefined;
+}
+
+export const toolOutcome = (tool: ToolItem): string | undefined =>
+  tool.outcome ?? toolCode(tool.output);
+
+export interface StepCounts {
+  total: number;
+  ok: number;
+  failed: number;
+  // Never finished: the turn stopped first.
+  stopped: number;
+  running: number;
+}
+
+export function stepCounts(tools: ToolItem[]): StepCounts {
+  const n = (s: ToolItem["status"]) =>
+    tools.filter((t) => t.status === s).length;
+  return {
+    total: tools.length,
+    ok: n("done"),
+    failed: n("error"),
+    stopped: n("stopped"),
+    running: n("running"),
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.737",
+  "version": "0.3.738",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"

package/scripts/screenshots/chat-verify.ts

@@ -0,0 +1,68 @@
+import type { ChatItem } from "../../lib/chat/events";
+
+const step = (
+  n: number,
+  start: number,
+  title: string,
+  status: "done" | "error" | "stopped",
+  output?: string
+): ChatItem => ({
+  id: `tool-${n}`,
+  createdAt: start + n * 4000,
+  kind: "tool",
+  name: "Bash",
+  title,
+  input: { command: title },
+  status,
+  output,
+  endedAt: start + n * 4000 + 1500,
+});
+
+// A reachability check cut short: some steps answered, one failed, two
+// never ran.
+export function verifyConversation(start: number): ChatItem[] {
+  return [
+    {
+      id: "user-1",
+      createdAt: start,
+      kind: "user",
+      text: "Which services can you reach from here before you scope the sync job?",
+    },
+    {
+      id: "assistant-1",
+      createdAt: start + 2000,
+      kind: "assistant",
+      text: "Here's what I can verify is reachable from this box, before I scope:",
+    },
+    step(
+      1,
+      start,
+      "curl -sI https://api.example.test/health",
+      "done",
+      "HTTP/2 200 \ncontent-type: application/json"
+    ),
+    step(
+      2,
+      start,
+      "curl -sI https://billing.example.test/v1",
+      "done",
+      "HTTP/2 401 \nwww-authenticate: Bearer"
+    ),
+    step(
+      3,
+      start,
+      "pg_isready -h db.internal",
+      "error",
+      "db.internal:5432 - no response\nExit code 2"
+    ),
+    step(4, start, "curl -sI https://search.example.test", "stopped"),
+    step(5, start, "redis-cli -h cache.internal ping", "stopped"),
+    {
+      id: "turn-1",
+      createdAt: start + 40000,
+      kind: "turn_end",
+      durationMs: 40000,
+      interrupted: true,
+    },
+  ];
+}

package/scripts/screenshots/seed.ts

@@ -5,6 +5,7 @@
  *
  *     npx tsx scripts/screenshots/seed.ts
  */
+import { verifyConversation } from "./chat-verify";
 import fs from "fs";
 import path from "path";
 import { randomUUID } from "crypto";
@@ -148,6 +149,14 @@ const SESSIONS: SessionSeed[] = [
     minutesAgo: 60 * 5,
     chat: docsConversation,
   },
+  {
+    key: "verify",
+    name: "sync-reachability",
+    project: "ml-pipeline",
+    view: "chat",
+    minutesAgo: 60 * 8,
+    chat: verifyConversation,
+  },
   {
     key: "backfill",
     name: "feature-backfill",