@stigmer/react 3.12.2 → 3.12.3

package/src/execution/ApprovalCard.tsx

@@ -12,6 +12,7 @@ import {
 import {
   resolveToolCategoryFromKind,
   extractPrimaryArgFromPreview,
+  extractShellIntentFromPreview,
   extractWriteContentFromPreview,
   isFileCategory,
   type ToolCategory,
@@ -160,6 +161,26 @@ export function ApprovalCardHeader({
     ],
   );
 
+  // A shell gate whose call carries a model-authored intent phrase titles
+  // the header with it (stigmer#276) — supplementary context only: the
+  // command stays foregrounded in the body's terminal preview, which remains
+  // the content the user is approving.
+  const intent = useMemo(
+    () =>
+      extractShellIntentFromPreview(
+        pendingApproval.toolName,
+        pendingApproval.argsPreview,
+        pendingApproval.mcpServerSlug,
+        pendingApproval.toolKind,
+      ),
+    [
+      pendingApproval.toolName,
+      pendingApproval.argsPreview,
+      pendingApproval.mcpServerSlug,
+      pendingApproval.toolKind,
+    ],
+  );
+
   return (
     <div
       className={cn(
@@ -173,7 +194,7 @@ export function ApprovalCardHeader({
 
       <span className="stg:min-w-0 stg:flex-1 stg:flex stg:items-center stg:gap-1.5 stg:overflow-hidden">
         <span className="stg:shrink-0 stg:font-medium stg:text-foreground">
-          {categoryInfo.label}
+          {intent ?? categoryInfo.label}
         </span>
         {primaryArg &&
           categoryInfo.category !== "shell" &&
@@ -186,7 +207,7 @@ export function ApprovalCardHeader({
             />
           ) : (
             // Shell is the exception: its command is shown in the body's
-            // terminal session, so the header stays minimal (icon + label).
+            // terminal session, so the header stays minimal (icon + title).
             <span className="stg:min-w-0 stg:truncate stg:font-mono stg:text-muted-foreground">
               {primaryArg}
             </span>

package/src/execution/ArtifactPreviewModal.tsx

@@ -1,8 +1,9 @@
 "use client";
 
-import { useCallback, useEffect, useRef } from "react";
+import { useCallback } from "react";
 import type { ExecutionArtifact } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/artifact_pb";
 import { cn } from "@stigmer/theme";
+import { DialogShell } from "../internal/DialogShell.js";
 import { useArtifactDownload } from "./useArtifactDownload.js";
 import { formatArtifactSize } from "./artifact-utils.js";
 import { ArtifactContentBody } from "./ArtifactContentBody.js";
@@ -253,37 +254,24 @@ export function ArtifactPreviewModal({
   onImplement,
   className,
 }: ArtifactPreviewModalProps) {
-  const dialogRef = useRef<HTMLDialogElement>(null);
-
-  useEffect(() => {
-    const dialog = dialogRef.current;
-    if (!dialog) return;
-
-    if (open && !dialog.open) {
-      dialog.showModal();
-    } else if (!open && dialog.open) {
-      dialog.close();
-    }
-  }, [open]);
-
-  const handleCancel = useCallback(
-    (e: React.SyntheticEvent) => {
-      e.preventDefault();
-      onClose();
+  const handleOpenChange = useCallback(
+    (nextOpen: boolean) => {
+      if (!nextOpen) onClose();
     },
     [onClose],
   );
 
   return (
-    <dialog
-      ref={dialogRef}
-      onCancel={handleCancel}
+    <DialogShell
+      open={open}
+      onOpenChange={handleOpenChange}
+      width="3xl"
       aria-label={`Preview ${artifact.name}`}
-      className={cn(
-        "stg:fixed stg:inset-0 stg:m-auto stg:w-full stg:max-w-3xl stg:rounded-lg stg:border stg:border-border stg:bg-background stg:p-0 stg:text-foreground stg:shadow-lg stg:outline-none",
-        "stg:[&::backdrop]:bg-black/50",
-        className,
-      )}
+      // Background surface is deliberate for content previews. The
+      // previously hardcoded ::backdrop color (bg-black/50 — it escaped the
+      // #652 fence via the arbitrary-variant spelling) now rides the
+      // shell's token backdrop.
+      className={cn("stg:bg-background stg:text-foreground stg:outline-none", className)}
     >
       {open && (
         <ArtifactPreviewContent
@@ -296,7 +284,7 @@ export function ArtifactPreviewModal({
           onImplement={onImplement}
         />
       )}
-    </dialog>
+    </DialogShell>
   );
 }
 

package/src/execution/ToolCallItem.tsx

@@ -105,7 +105,9 @@ export interface ToolCallItemProps {
  *
  * Shows category-aware labels (e.g., "Shell", "Read", "Edit") with
  * the primary argument as a subtitle, a category-specific icon, and
- * an inline approval decision badge when applicable.
+ * an inline approval decision badge when applicable. A shell row whose
+ * call carries a model-authored intent phrase is titled with that phrase
+ * instead — the command becomes the subtitle (stigmer#276).
  *
  * Wrapped in `React.memo` — structural sharing (DD-009/010) preserves
  * the `ToolCall` reference when unchanged, so a settled row skips
@@ -138,7 +140,7 @@ export const ToolCallItem = memo(function ToolCallItem({
   const duration = formatHeaderDuration(toolCall.startedAt, toolCall.completedAt);
   const isSubAgent = subAgentExecution != null;
 
-  const { category, label, primaryArg, result, resultSummary, disclosure, chrome } =
+  const { category, label, intent, title, primaryArg, result, resultSummary, disclosure, chrome } =
     useToolPresentation(toolCall);
   const CategoryIcon = CATEGORY_ICON[category];
 
@@ -173,9 +175,12 @@ export const ToolCallItem = memo(function ToolCallItem({
     initialOpen: defaultExpanded || autoOpen,
   });
 
+  // Sub-agents title the row with their subject; every other row titles with
+  // the resolved presentation `title` (host label override > model-authored
+  // shell intent > category label, stigmer#276).
   const displayLabel = isSubAgent
     ? subAgentExecution.subject || subAgentExecution.name || label
-    : label;
+    : title;
 
   const approvalBadge = getApprovalBadge(toolCall);
 
@@ -308,11 +313,17 @@ export const ToolCallItem = memo(function ToolCallItem({
     );
   }
 
-  // Shell shows neither a command subtitle nor an exit summary in the header —
-  // both live in the terminal session body below, so the header stays minimal
-  // (icon + label + status + duration).
-  const displaySubtitle =
-    isSubAgent || category === "shell" ? null : primaryArg;
+  // Shell headers stay minimal (icon + label + status + duration) — the
+  // command and exit summary live in the terminal session body — EXCEPT when
+  // the model authored an intent title (stigmer#276): the title then says
+  // *why*, so the command surfaces as the secondary text and a fully
+  // collapsed row still reads like a narrated log. Intent-less shell rows
+  // render byte-identically to before.
+  const displaySubtitle = isSubAgent
+    ? null
+    : category === "shell"
+      ? (intent ? primaryArg : null)
+      : primaryArg;
 
   // For file tools the subtitle is a path: render it filename-first through
   // FilePathLink (full path on hover) rather than the raw, often-absolute string

package/src/execution/__tests__/intent-title.test.tsx

@@ -0,0 +1,221 @@
+/**
+ * Model-authored intent titles for shell tool calls (stigmer#276).
+ *
+ * The extraction contract is pinned by the cross-surface fixture
+ * test/fixtures/tool-view/intent-title.json — the same file the runner's
+ * tool-intent middleware tests assert against, so the wire key and the
+ * kind-scoping can never drift between the writer and the readers.
+ */
+
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, it, expect, afterEach } from "vitest";
+import { render, screen, cleanup } from "@testing-library/react";
+import { renderHook } from "@testing-library/react";
+import { create, type JsonObject } from "@bufbuild/protobuf";
+import {
+  ToolCallSchema,
+  type ToolCall,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
+import { PendingApprovalSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/approval_pb";
+import { ToolCallStatus, ToolKind } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import {
+  extractShellIntent,
+  extractShellIntentFromPreview,
+  SHELL_INTENT_ARG_FIELD,
+} from "../tool-categories";
+import { useToolPresentation, registerToolPresenter } from "../tool-presenter";
+import { ToolCallItem } from "../ToolCallItem";
+import { ApprovalCardHeader } from "../ApprovalCard";
+
+afterEach(cleanup);
+
+const here = dirname(fileURLToPath(import.meta.url));
+const fixturePath = resolve(here, "../../../../../test/fixtures/tool-view/intent-title.json");
+
+interface IntentFixture {
+  argField: string;
+  cases: Array<{
+    name: string;
+    mcpServerSlug: string;
+    args: Record<string, unknown>;
+    intent: string | null;
+  }>;
+}
+
+const fixture = JSON.parse(readFileSync(fixturePath, "utf8")) as IntentFixture;
+
+function makeToolCall(opts: {
+  name: string;
+  args?: Record<string, unknown>;
+  mcpServerSlug?: string;
+  status?: ToolCallStatus;
+}): ToolCall {
+  return create(ToolCallSchema, {
+    id: opts.name,
+    name: opts.name,
+    args: (opts.args ?? {}) as JsonObject,
+    mcpServerSlug: opts.mcpServerSlug ?? "",
+    status: opts.status ?? ToolCallStatus.TOOL_CALL_COMPLETED,
+  });
+}
+
+describe("intent-title fixture contract", () => {
+  it("pins the wire key shared with the runner middleware", () => {
+    expect(SHELL_INTENT_ARG_FIELD).toBe(fixture.argField);
+  });
+
+  it.each(fixture.cases.map((c, i) => [i, c] as const))(
+    "case %#: %j",
+    (_i, c) => {
+      const tc = makeToolCall({
+        name: c.name,
+        args: c.args,
+        mcpServerSlug: c.mcpServerSlug,
+      });
+      expect(extractShellIntent(tc)).toBe(c.intent);
+    },
+  );
+});
+
+describe("extractShellIntentFromPreview", () => {
+  it("mirrors the ToolCall extraction on a JSON args preview", () => {
+    expect(
+      extractShellIntentFromPreview(
+        "execute",
+        JSON.stringify({ command: "make check", [SHELL_INTENT_ARG_FIELD]: "Verify the build" }),
+      ),
+    ).toBe("Verify the build");
+  });
+
+  it("prefers the denormalized wire kind over the name", () => {
+    // A shell tool whose NAME the classifier does not recognize still
+    // resolves via the wire kind — matching extractPrimaryArgFromPreview.
+    expect(
+      extractShellIntentFromPreview(
+        "custom_runner",
+        JSON.stringify({ command: "ls", [SHELL_INTENT_ARG_FIELD]: "List files" }),
+        "",
+        ToolKind.SHELL,
+      ),
+    ).toBe("List files");
+  });
+
+  it("returns null for malformed previews and non-shell kinds", () => {
+    expect(extractShellIntentFromPreview("execute", "not json{")).toBeNull();
+    expect(extractShellIntentFromPreview("execute", "")).toBeNull();
+    expect(
+      extractShellIntentFromPreview(
+        "read_file",
+        JSON.stringify({ file_path: "a", [SHELL_INTENT_ARG_FIELD]: "x" }),
+      ),
+    ).toBeNull();
+  });
+});
+
+describe("useToolPresentation title precedence", () => {
+  it("titles a shell row with the model-authored intent", () => {
+    const tc = makeToolCall({
+      name: "Shell",
+      args: { command: "npm test", [SHELL_INTENT_ARG_FIELD]: "Run the test suite" },
+    });
+    const { result } = renderHook(() => useToolPresentation(tc));
+
+    expect(result.current.intent).toBe("Run the test suite");
+    expect(result.current.title).toBe("Run the test suite");
+    // The short kind label is unchanged — chips and badges keep "Shell".
+    expect(result.current.label).toBe("Shell");
+  });
+
+  it("falls back to the category label when no intent is present", () => {
+    const tc = makeToolCall({ name: "Shell", args: { command: "ls" } });
+    const { result } = renderHook(() => useToolPresentation(tc));
+
+    expect(result.current.intent).toBeNull();
+    expect(result.current.title).toBe("Shell");
+  });
+
+  it("a registered presenter label override outranks the intent", () => {
+    const dispose = registerToolPresenter(ToolKind.SHELL, {
+      label: () => "Run command",
+    });
+    try {
+      const tc = makeToolCall({
+        name: "Shell",
+        args: { command: "ls", [SHELL_INTENT_ARG_FIELD]: "List files" },
+      });
+      const { result } = renderHook(() => useToolPresentation(tc));
+
+      expect(result.current.title).toBe("Run command");
+      expect(result.current.intent).toBe("List files");
+    } finally {
+      dispose();
+    }
+  });
+});
+
+describe("ToolCallItem shell header", () => {
+  function headerOf(container: HTMLElement): Element {
+    const row = container.querySelector('[data-cursor-target="tool-call-row"]')!;
+    return row.firstElementChild!;
+  }
+
+  it("renders the intent as the title and the command as the subtitle", () => {
+    const tc = makeToolCall({
+      name: "Shell",
+      args: {
+        command: "npx vitest run src/parser",
+        [SHELL_INTENT_ARG_FIELD]: "Run unit tests for the parser",
+      },
+    });
+    const { container } = render(<ToolCallItem toolCall={tc} />);
+
+    const header = headerOf(container);
+    expect(header.textContent).toContain("Run unit tests for the parser");
+    expect(header.textContent).toContain("npx vitest run src/parser");
+    expect(header.textContent).not.toContain("Shell");
+  });
+
+  it("renders an intent-less shell row exactly as before: bare label, no subtitle", () => {
+    const tc = makeToolCall({
+      name: "Shell",
+      args: { command: "ls -la" },
+    });
+    const { container } = render(<ToolCallItem toolCall={tc} />);
+
+    const header = headerOf(container);
+    expect(header.textContent).toContain("Shell");
+    // The command lives in the terminal body only — never in the header.
+    expect(header.textContent).not.toContain("ls -la");
+  });
+});
+
+describe("ApprovalCardHeader shell title", () => {
+  it("titles a gated shell call with the intent phrase", () => {
+    const pending = create(PendingApprovalSchema, {
+      toolCallId: "tc-1",
+      toolName: "execute",
+      toolKind: ToolKind.SHELL,
+      argsPreview: JSON.stringify({
+        command: "rm -rf build",
+        [SHELL_INTENT_ARG_FIELD]: "Clean the build directory",
+      }),
+    });
+    render(<ApprovalCardHeader pendingApproval={pending} />);
+
+    expect(screen.getByText("Clean the build directory")).toBeDefined();
+  });
+
+  it("keeps the bare category label when no intent is present", () => {
+    const pending = create(PendingApprovalSchema, {
+      toolCallId: "tc-2",
+      toolName: "execute",
+      toolKind: ToolKind.SHELL,
+      argsPreview: JSON.stringify({ command: "rm -rf build" }),
+    });
+    render(<ApprovalCardHeader pendingApproval={pending} />);
+
+    expect(screen.getByText("Shell")).toBeDefined();
+  });
+});

package/src/execution/index.ts

@@ -340,6 +340,9 @@ export {
   toolKindToCategoryInfo,
   extractPrimaryArg,
   extractPrimaryArgFromPreview,
+  extractShellIntent,
+  extractShellIntentFromPreview,
+  SHELL_INTENT_ARG_FIELD,
   humanizeToolName,
   defaultDisclosureForCategory,
   isRunGroupableCategory,

package/src/execution/tool-categories.ts

@@ -192,6 +192,14 @@ export interface ToolCategoryInfo {
   readonly primaryArgField: string;
   /** Fallback argument keys tried when the primary key is absent. */
   readonly fallbackArgFields: readonly string[];
+  /**
+   * JSON argument key carrying a model-authored intent phrase for this kind
+   * (stigmer#276), or `undefined` for kinds without one. Shell is the only
+   * carrier today: both harnesses converge on `description` — the Cursor
+   * harness's built-in Shell tool ships it natively, and the native harness's
+   * tool-intent middleware adds it to the `execute` schema at bind time.
+   */
+  readonly intentArgField?: string;
 }
 
 interface KindDisplayEntry {
@@ -199,6 +207,7 @@ interface KindDisplayEntry {
   readonly label: string;
   readonly primaryField: string;
   readonly fallbackFields?: readonly string[];
+  readonly intentField?: string;
 }
 
 // Presentation metadata per ToolKind. Classification (name -> kind) is owned by
@@ -209,7 +218,7 @@ const KIND_DISPLAY: Partial<Record<ToolKind, KindDisplayEntry>> = {
   [ToolKind.FILE_WRITE]:  { category: "write",     label: "Write",     primaryField: "path", fallbackFields: ["file_path", "file", "filename"] },
   [ToolKind.FILE_EDIT]:   { category: "edit",      label: "Edit",      primaryField: "path", fallbackFields: ["file_path", "file", "filename"] },
   [ToolKind.FILE_DELETE]: { category: "delete",    label: "Delete",    primaryField: "path", fallbackFields: ["file_path", "file", "filename"] },
-  [ToolKind.SHELL]:       { category: "shell",     label: "Shell",     primaryField: "command" },
+  [ToolKind.SHELL]:       { category: "shell",     label: "Shell",     primaryField: "command", intentField: "description" },
   [ToolKind.SEARCH]:      { category: "search",    label: "Search",    primaryField: "pattern", fallbackFields: ["query", "q"] },
   [ToolKind.LIST]:        { category: "list",      label: "List",      primaryField: "path" },
   [ToolKind.FETCH]:       { category: "fetch",     label: "Fetch",     primaryField: "url", fallbackFields: ["uri"] },
@@ -264,6 +273,7 @@ export function toolKindToCategoryInfo(
       label: entry.label,
       primaryArgField: entry.primaryField,
       fallbackArgFields: entry.fallbackFields ?? [],
+      ...(entry.intentField ? { intentArgField: entry.intentField } : {}),
     };
   }
 
@@ -440,6 +450,118 @@ export function extractPrimaryArgFromPreview(
   }
 }
 
+/**
+ * Extracts the model-authored intent phrase from a tool call's args
+ * (stigmer#276), or `null` when the kind carries none / the model omitted it.
+ *
+ * The intent is presentation metadata authored by the model *for the user* —
+ * "Run unit tests for the parser" — rendered as the row title in place of the
+ * bare category label. Extraction is kind-scoped via
+ * {@link ToolCategoryInfo.intentArgField} (shell-only today) so a same-named
+ * REAL argument on another kind (e.g. the sub-agent task tool's
+ * `description`, which is its subject) is never misread as an intent.
+ */
+export function extractIntent(toolCall: ToolCall): string | null {
+  const info = resolveToolCategoryFromCall(toolCall);
+  if (!info.intentArgField || !toolCall.args) return null;
+  const value = toolCall.args[info.intentArgField];
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+
+/**
+ * {@link extractIntent} for surfaces that carry a JSON `argsPreview` string
+ * instead of a full {@link ToolCall} — notably `PendingApproval`. Same
+ * kind-scoping; returns `null` on parse failure or when absent.
+ */
+export function extractIntentFromPreview(
+  toolName: string,
+  argsPreview: string,
+  mcpServerSlug?: string,
+  toolKind?: ToolKind,
+): string | null {
+  if (!argsPreview) return null;
+
+  const info =
+    toolKind !== undefined
+      ? resolveToolCategoryFromKind(toolKind, toolName, mcpServerSlug)
+      : resolveToolCategory(toolName, mcpServerSlug);
+  if (!info.intentArgField) return null;
+
+  try {
+    const parsed = JSON.parse(argsPreview);
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const value = (parsed as Record<string, unknown>)[info.intentArgField];
+    return typeof value === "string" && value.length > 0 ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The tool-call argument that carries a model-authored intent phrase for
+ * SHELL tools (stigmer#276) — a short human description of what the command
+ * does and why, rendered as the row title with the command as secondary text.
+ *
+ * Two writers populate it, converged on one wire key by design: the native
+ * harness's tool-intent middleware (`backend/services/runner/src/middleware/
+ * tool-intent.ts`, `INTENT_ARG`) extends the shell tool's bind-time schema
+ * with it, and the Cursor harness's built-in Shell tool carries it natively.
+ * The shared, machine-checked contract is
+ * `test/fixtures/tool-view/intent-title.json` — keep all three in lockstep.
+ */
+export const SHELL_INTENT_ARG_FIELD = "description";
+
+/**
+ * The intent-title extraction core: SHELL-kind-scoped on purpose, because
+ * `description` means other things on other tools (a task tool's description
+ * is the sub-agent subject, never a row title). Blank and non-string values
+ * degrade to null — the caller falls back to the category label.
+ */
+function extractIntentFromArgs(kind: ToolKind, args: JsonObject | undefined): string | null {
+  if (kind !== ToolKind.SHELL || !args) return null;
+  const value = args[SHELL_INTENT_ARG_FIELD];
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+/**
+ * Extracts the model-authored intent phrase from a SHELL tool call, or null
+ * when absent (legacy executions, models that skipped the optional arg, and
+ * every non-shell kind). See {@link SHELL_INTENT_ARG_FIELD}.
+ */
+export function extractShellIntent(toolCall: ToolCall): string | null {
+  return extractIntentFromArgs(resolveToolKind(toolCall), toolCall.args);
+}
+
+/**
+ * Preview-string twin of {@link extractShellIntent} for surfaces that carry a
+ * `PendingApproval` (JSON `argsPreview`) instead of a full {@link ToolCall} —
+ * mirrors {@link extractPrimaryArgFromPreview}'s kind resolution.
+ */
+export function extractShellIntentFromPreview(
+  toolName: string,
+  argsPreview: string,
+  mcpServerSlug?: string,
+  toolKind?: ToolKind,
+): string | null {
+  if (!argsPreview) return null;
+
+  const kind =
+    toolKind !== undefined && toolKind !== ToolKind.UNSPECIFIED
+      ? toolKind
+      : resolveToolKindByName(toolName, mcpServerSlug);
+  if (kind !== ToolKind.SHELL) return null;
+
+  try {
+    const parsed = JSON.parse(argsPreview);
+    if (typeof parsed !== "object" || parsed === null) return null;
+    return extractIntentFromArgs(kind, parsed as JsonObject);
+  } catch {
+    return null;
+  }
+}
+
 const WRITE_CONTENT_FIELDS = [
   "contents",
   "content",

package/src/execution/tool-presenter.ts

@@ -19,6 +19,7 @@ import type { ToolResultView } from "@stigmer/sdk";
 import {
   resolveToolCategoryFromCall,
   extractPrimaryArg,
+  extractShellIntent,
   defaultChromeForCategory,
   defaultDisclosureForCategory,
   isRunGroupableCategory,
@@ -124,6 +125,21 @@ export interface ToolPresentation {
   readonly category: ToolCategory;
   /** Display label, e.g. "Edit", "Shell". */
   readonly label: string;
+  /**
+   * The model-authored intent phrase for a SHELL call (stigmer#276), or null
+   * when absent (legacy executions, skipped optional arg, non-shell kinds).
+   * Raw extraction — precedence against overrides is resolved in
+   * {@link ToolPresentation.title}.
+   */
+  readonly intent: string | null;
+  /**
+   * The row title: a registered presenter's `label` override wins (a host's
+   * explicit wording is never displaced by model output), then the
+   * model-authored {@link intent}, then the category {@link label}. Renderers
+   * that title a row use this; {@link label} stays the short kind label for
+   * chips and badges.
+   */
+  readonly title: string;
   /** Primary argument (path, command, pattern...), or null. */
   readonly primaryArg: string | null;
   /** Normalized result view for rendering with {@link ResultView}. */
@@ -166,7 +182,10 @@ export function useToolPresentation(toolCall: ToolCall): ToolPresentation {
     const result = normalizeToolResult(toolCall);
     const override = registry.get(kind);
 
-    const label = override?.label?.(toolCall) ?? categoryInfo.label;
+    const overrideLabel = override?.label?.(toolCall);
+    const label = overrideLabel ?? categoryInfo.label;
+    const intent = extractShellIntent(toolCall);
+    const title = overrideLabel ?? intent ?? categoryInfo.label;
     const resultSummary =
       override?.summary?.(toolCall, result) ?? summarizeResultView(result);
     const disclosure =
@@ -183,6 +202,8 @@ export function useToolPresentation(toolCall: ToolCall): ToolPresentation {
       kind,
       category: categoryInfo.category,
       label,
+      intent,
+      title,
       primaryArg: extractPrimaryArg(toolCall),
       result,
       resultSummary,

package/src/index.ts

@@ -296,6 +296,9 @@ export {
   toolKindToCategoryInfo,
   defaultDisclosureForCategory,
   extractPrimaryArg,
+  extractShellIntent,
+  extractShellIntentFromPreview,
+  SHELL_INTENT_ARG_FIELD,
   McpToolDetail,
   parseMcpResult,
   formatDuration,