@pi-archimedes/subagent 2.10.4 → 2.11.0

package/README.md

@@ -112,6 +112,6 @@ Available with the suite (and subagent enabled), `/agents` opens the interactive
 
 ## Part of the suite
 
-The full suite is the supported connected setup. With the relevant components loaded together, subagent token and cost events flow over core's bus into the footer, subagent tasks get their own columns on the todo board, and subagent `ask` questions surface in your terminal. On/off is managed by the suite: toggle via `/plugins` (`archimedes.subagent.enabled`, default on).
+The full suite is the supported connected setup. With the relevant components loaded together, a subagent's tokens and cost ride its own tool result into the footer's totals, subagent tasks get their own columns on the todo board, and subagent `ask` questions surface in your terminal. On/off is managed by the suite: toggle via `/plugins` (`archimedes.subagent.enabled`, default on).
 
 ← [Back to pi-archimedes](https://github.com/danielcherubini/pi-archimedes)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-archimedes/subagent",
-  "version": "2.10.4",
+  "version": "2.11.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/danielcherubini/pi-archimedes.git"
@@ -15,20 +15,20 @@
   ],
   "main": "./src/index.ts",
   "dependencies": {
-    "@pi-archimedes/core": "2.10.4",
-    "@pi-archimedes/todo": "2.10.4"
+    "@pi-archimedes/core": "2.11.0",
+    "@pi-archimedes/todo": "2.11.0"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": ">=0.1.0",
-    "@earendil-works/pi-coding-agent": ">=0.1.0",
-    "@earendil-works/pi-tui": ">=0.1.0",
+    "@earendil-works/pi-ai": ">=1.2.0",
+    "@earendil-works/pi-coding-agent": ">=1.2.0",
+    "@earendil-works/pi-tui": ">=1.2.0",
     "typebox": ">=1.1.0"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "^0.87.0",
-    "@earendil-works/pi-coding-agent": "^0.87.0",
-    "@earendil-works/pi-tui": "^0.87.0",
-    "@types/node": "^22.0.0",
+    "@earendil-works/pi-ai": "1.2.0",
+    "@earendil-works/pi-coding-agent": "1.2.0",
+    "@earendil-works/pi-tui": "1.2.0",
+    "@types/node": "22.19.19",
     "typebox": "^1.1.38",
     "typescript": "^6.0.3"
   },

package/src/agent-panel.mcp.test.ts

@@ -0,0 +1,76 @@
+/**
+ * The `/agents` panel's half of the tool-allowlist contract: the detail screen
+ * has to say whether an agent's child runs with MCP tools, and the tools field
+ * has to refuse entries the `pi` CLI cannot take as a name.
+ *
+ * The panel is driven through its own `handleInput` so the assertions run on the
+ * frames a user would actually see (same approach as the width audit).
+ */
+
+import { describe, it, expect } from "vitest";
+import { stripTerminalSequences } from "@earendil-works/pi-tui";
+import { createAgentPanel } from "./agent-panel.js";
+import type { AgentConfig } from "./agents.js";
+
+const theme = { fg: (_token: string, text: string) => text, bold: (text: string) => text };
+
+const ENTER = "\r";
+
+function makeAgent(overrides: Partial<AgentConfig> = {}): AgentConfig {
+  return {
+    name: "reviewer",
+    description: "reviews things",
+    systemPrompt: "be terse",
+    source: "user",
+    filePath: "/tmp/agents/reviewer.md",
+    tools: ["read", "bash"],
+    ...overrides,
+  };
+}
+
+function makePanel(agents: AgentConfig[]) {
+  return createAgentPanel(
+    agents,
+    [],
+    [],
+    null,
+    "/tmp/agents",
+    null,
+    { requestRender: () => {} },
+    theme,
+    () => {},
+    [],
+    [
+      { name: "read", description: "read a file" },
+      { name: "bash", description: "run a command" },
+    ],
+  );
+}
+
+/** The frame as drawn text (ANSI stripped), one entry per row. */
+function drawn(panel: ReturnType<typeof makePanel>): string[] {
+  return panel.render(84).map((l) => stripTerminalSequences(l));
+}
+
+function rowContaining(lines: string[], needle: string): string | undefined {
+  return lines.find((l) => l.includes(needle));
+}
+
+describe("/agents detail screen: the mcp opt-in is visible", () => {
+  it("shows mcp: true for an agent that opted in", () => {
+    const panel = makePanel([makeAgent({ mcp: true })]);
+    panel.handleInput(ENTER);
+    const lines = drawn(panel);
+    expect(rowContaining(lines, "Agent:")).toBeTruthy();
+    expect(rowContaining(lines, "mcp: true")).toBeTruthy();
+  });
+
+  it("shows the closed default for an agent with no mcp key", () => {
+    const panel = makePanel([makeAgent()]);
+    panel.handleInput(ENTER);
+    const lines = drawn(panel);
+    const row = rowContaining(lines, "mcp:");
+    expect(row).toBeTruthy();
+    expect(row).not.toContain("true");
+  });
+});

package/src/agent-panel.tools.test.ts

@@ -0,0 +1,162 @@
+/**
+ * The `/agents` panel's tools edit gate.
+ *
+ * The panel edits tools through the multi-select picker (`[t]`), whose list is
+ * `pi.getAllTools()`. Its commit is the only place a tools list is written from
+ * the panel, so that is where the **lexical** rules are enforced: an entry pi
+ * cannot read as a name is refused with the entry named, and the value the agent
+ * had before the picker opened stays exactly as it was.
+ *
+ * Membership (is this a tool right now?) is deliberately NOT checked here — see
+ * `tool-validation.ts` for why that belongs at dispatch.
+ */
+
+import { describe, it, expect } from "vitest";
+import { stripTerminalSequences } from "@earendil-works/pi-tui";
+import { createAgentPanel } from "./agent-panel.js";
+import type { AgentConfig } from "./agents.js";
+
+const theme = { fg: (_token: string, text: string) => text, bold: (text: string) => text };
+
+const ENTER = "\r";
+const DOWN = "\x1b[B";
+const ESCAPE = "\x1b";
+const SPACE = " ";
+
+function makeAgent(overrides: Partial<AgentConfig> = {}): AgentConfig {
+  return {
+    name: "reviewer",
+    description: "reviews things",
+    systemPrompt: "be terse",
+    source: "user",
+    filePath: "/tmp/agents/reviewer.md",
+    tools: ["read"],
+    ...overrides,
+  };
+}
+
+function makePanel(agents: AgentConfig[], tools: Array<{ name: string; description: string }>) {
+  return createAgentPanel(
+    agents,
+    [],
+    [],
+    null,
+    "/tmp/agents",
+    null,
+    { requestRender: () => {} },
+    theme,
+    () => {},
+    [],
+    tools,
+  );
+}
+
+/** list → detail → edit → cursor on the tools row → picker open. */
+function openToolPicker(panel: ReturnType<typeof makePanel>): void {
+  panel.handleInput(ENTER); // detail
+  panel.handleInput("e"); // edit (mutable copy)
+  panel.handleInput(DOWN); // name → description
+  panel.handleInput(DOWN); // description → tools
+  panel.handleInput("t"); // open the tool picker
+}
+
+function drawn(panel: ReturnType<typeof makePanel>): string[] {
+  return panel.render(90).map((l) => stripTerminalSequences(l));
+}
+
+function rowContaining(lines: string[], needle: string): string | undefined {
+  return lines.find((l) => l.includes(needle));
+}
+
+describe("/agents tool picker: lexical entries are refused at commit", () => {
+  it("a selected entry that is not a legal name is refused, naming the entry", () => {
+    const panel = makePanel([makeAgent()], [
+      { name: "+danger", description: "an extension tool whose name reads as a modifier" },
+      { name: "read", description: "read" },
+    ]);
+    openToolPicker(panel);
+    panel.handleInput(SPACE); // select "+danger" (first row)
+    panel.handleInput(ENTER); // commit
+    const lines = drawn(panel);
+    expect(rowContaining(lines, "Error:")).toBeTruthy();
+    // The entry has to be legible, not clipped off the end of one row.
+    expect(lines.some((l) => l.includes('+danger"'))).toBe(true);
+  });
+
+  it("a refused commit leaves the previously selected tools exactly as they were", () => {
+    const panel = makePanel([makeAgent({ tools: ["read", "bash"] })], [
+      { name: "-minus", description: "reads as a removal" },
+      { name: "read", description: "read" },
+    ]);
+    openToolPicker(panel);
+    panel.handleInput(SPACE); // select "-minus" on top of the pre-selected pair
+    panel.handleInput(ENTER);
+    const lines = drawn(panel);
+    expect(rowContaining(lines, "tools: read, bash")).toBeTruthy();
+    expect(rowContaining(lines, "tools: read, bash, -minus")).toBeUndefined();
+  });
+
+  it("a legal selection still commits (the gate does not eat valid input)", () => {
+    const panel = makePanel([makeAgent({ tools: ["read"] })], [
+      { name: "read", description: "read" },
+      { name: "bash", description: "bash" },
+    ]);
+    openToolPicker(panel);
+    panel.handleInput(DOWN); // to bash
+    panel.handleInput(SPACE);
+    panel.handleInput(ENTER);
+    const lines = drawn(panel);
+    expect(rowContaining(lines, "Error:")).toBeUndefined();
+    expect(rowContaining(lines, "tools: read, bash")).toBeTruthy();
+  });
+
+  it("clearing every tool commits an empty allowlist, which is not a lexical error", () => {
+    const panel = makePanel([makeAgent({ tools: ["read"] })], [
+      { name: "read", description: "read" },
+    ]);
+    openToolPicker(panel);
+    panel.handleInput(SPACE); // deselect the only entry
+    panel.handleInput(ENTER);
+    const lines = drawn(panel);
+    expect(rowContaining(lines, "Error:")).toBeUndefined();
+    expect(rowContaining(lines, "tools: (not set)")).toBeTruthy();
+  });
+
+  it("discarding after a commit leaves the original agent's preserved line intact", () => {
+    // The edit copy is `{ ...agent }`, so `extraFields` is shared with the
+    // original until something copies it. A commit that deleted the preserved
+    // raw `tools` value in place therefore deleted it from the ORIGINAL agent as
+    // well: commit, then discard, and the agent's own record no longer carried
+    // the line the config read promised to keep — so the next save wrote no
+    // `tools:` key and the allowlist vanished from the file.
+    const broken = makeAgent({
+      extraFields: { tools: "read, +web_search" },
+    });
+    delete broken.tools; // the read path leaves no allowlist in force
+    broken.toolsError = 'Agent "reviewer" has a tools entry starting with "+": "+web_search".';
+    const panel = makePanel([broken], [{ name: "read", description: "read" }]);
+    openToolPicker(panel);
+    panel.handleInput(SPACE); // select read on top of the rejected config's empty set
+    panel.handleInput(ENTER); // commit (marks the edit dirty)
+    panel.handleInput(ESCAPE); // escape a dirty edit → discard prompt
+    panel.handleInput("y"); // discard
+    panel.handleInput(ESCAPE); // back to the detail screen
+    const lines = drawn(panel);
+    expect(rowContaining(lines, "tools: read, +web_search")).toBeTruthy();
+    // And the rejection it belongs to, since this agent is unchanged on disk.
+    expect(lines.some((l) => l.includes('"+web_search"'))).toBe(true);
+  });
+});
+
+describe("/agents detail screen: a rejected tools list says so", () => {
+  it("shows the config-read rejection on the agent that carries it", () => {
+    const broken = makeAgent();
+    delete broken.tools; // the read path leaves no allowlist in force
+    broken.toolsError = 'Agent "reviewer" lists the tool "read" twice (in /tmp/agents/reviewer.md).';
+    const panel = makePanel([broken], []);
+    panel.handleInput(ENTER); // detail
+    const lines = drawn(panel);
+    expect(rowContaining(lines, '"read" twice')).toBeTruthy();
+    expect(rowContaining(lines, "/tmp/agents/reviewer.md")).toBeTruthy();
+  });
+});

package/src/agent-panel.ts

@@ -14,6 +14,7 @@ import {
 import type { AgentConfig } from "./agents.js";
 import { discoverAgentsAll } from "./agents.js";
 import { validateAgentName } from "./frontmatter-io.js";
+import { applyToolEntries } from "./tool-validation.js";
 import {
   visibleWidth,
   padEnd,
@@ -298,6 +299,11 @@ function renderDetail(state: ManagerState, width: number, theme: Theme): string[
   } else {
     fieldLines.push(theme.fg("accent", `tools:`) + ` ${theme.fg("dim", "(none)")}`);
   }
+  // The allowlist is closed unless this says true (ADR 0028): with a `tools:`
+  // list the child runs `--no-mcp`, so the panel has to say which reading applies.
+  fieldLines.push(
+    theme.fg("accent", `mcp:`) + " " + (agent.mcp === true ? "true" : theme.fg("dim", "(off)")),
+  );
   fieldLines.push(theme.fg("accent", `model:`) + ` ${agentModel(agent)}`);
   fieldLines.push(theme.fg("accent", `thinking:`) + ` ${agent.thinking ?? theme.fg("dim", "(none)")}`);
 
@@ -305,6 +311,13 @@ function renderDetail(state: ManagerState, width: number, theme: Theme): string[
     lines.push(padEnd(fl, width));
   }
 
+  // The config read rejected this agent's tools list: show why, because the
+  // alternative is an agent that silently runs with no allowlist at all.
+  if (agent.toolsError) {
+    for (const line of wrapText(agent.toolsError, width)) {
+      lines.push(padEnd(theme.fg("error", line), width));
+    }
+  }
   // Extra fields
   if (agent.extraFields && Object.keys(agent.extraFields).length > 0) {
     lines.push(padEnd(theme.fg("dim", "─".repeat(width)), width));
@@ -429,9 +442,13 @@ function renderEdit(state: ManagerState, width: number, theme: Theme): string[]
   const dirtyMark = state.editDirty ? " *" : "";
   lines.push(renderHeader(` Edit: ${agent.name}${dirtyMark} `, width, theme));
 
-  // Error line
+  // Error line — wrapped, not truncated: the messages this panel can produce
+  // name the offending entry at the END of the sentence, so a single clipped row
+  // would report a problem without saying what it is.
   if (state.editError) {
-    lines.push(padEnd(theme.fg("error", `Error: ${state.editError}`), width));
+    for (const line of wrapText(`Error: ${state.editError}`, width)) {
+      lines.push(padEnd(theme.fg("error", line), width));
+    }
   }
 
   // System prompt edit mode
@@ -740,14 +757,21 @@ function handleEditInput(
       state.toolSearch = "";
       requestRender();
     } else if (matchesKey(data, Key.enter)) {
-      const names = [...state.toolSelected];
-      if (names.length > 0) {
-        state.editAgent.tools = names;
-      } else {
-        delete state.editAgent.tools;
-      }
+      // The picker's commit is the only way the panel writes a tools list, so it
+      // is where the lexical rules apply. A refusal leaves the previous list
+      // untouched (`applyToolEntries`) and does not mark the agent dirty — the
+      // user must not be able to save a list pi would reject.
+      const error = applyToolEntries(state.editAgent, [...state.toolSelected], {
+        agentName: state.editAgent.name,
+        agentFilePath: state.editAgent.filePath,
+      });
       state.toolPickerOpen = false;
       state.toolSearch = "";
+      if (error) {
+        state.editError = error;
+        requestRender();
+        return;
+      }
       state.editDirty = true;
       requestRender();
     } else if (matchesKey(data, Key.up)) {
@@ -1013,6 +1037,11 @@ function setFieldValue(agent: AgentConfig, field: EditField, value: string): voi
       agent.description = value;
       break;
     case "tools": {
+      // A typing buffer, not a commit: the tools field is edited through the
+      // picker (an `enter` on that row opens it), so this path is not reachable
+      // from the keyboard today. It stays permissive on purpose — an unfinished
+      // comma is a keystroke, not a mistake. Everything that leaves the panel
+      // goes through `applyToolEntries`, which is where the lexical rules live.
       const parsed = value
         ? value.split(",").map((t) => t.trim()).filter(Boolean)
         : [];

package/src/agent-panel.width-audit.test.ts

@@ -0,0 +1,258 @@
+/**
+ * Frame-width audit for the `/agents` overlay.
+ *
+ * Automated stand-in for a `PI_TUI_WRITE_LOG` capture: drive the real panel
+ * factory through every screen with hostile content, measure **every produced
+ * line** with pi-tui's own `visibleWidth` (what the terminal draws), and require
+ * it to fit the frame. A line wider than the frame is hard-wrapped by the
+ * terminal, which pushes the closing border to the next row and shifts the whole
+ * overlay — the exact failure the old `.length`-based width maths produced for
+ * cursor markers, OSC 8 hyperlinks and east-asian text.
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  CURSOR_MARKER,
+  stripTerminalSequences,
+  visibleWidth as tuiVisibleWidth,
+} from "@earendil-works/pi-tui";
+import { createAgentPanel } from "./agent-panel.js";
+import type { AgentConfig } from "./agents.js";
+
+// One entry per failure mode of the deleted width maths.
+const URL = `https://example.com/${"segment/".repeat(12)}`;
+
+function agent(name: string, description: string, systemPrompt: string): AgentConfig {
+  return {
+    name,
+    description,
+    systemPrompt,
+    model: "anthropic/claude-opus-4.5",
+    tools: ["read", "bash"],
+    source: "user",
+    filePath: `/tmp/agents/${name}.md`,
+  };
+}
+
+const AGENTS: AgentConfig[] = [
+  agent("検証エージェント", "日本語の説明テキスト".repeat(8), "説".repeat(200)),
+  agent(`\x1b]8;;${URL}\x07doc-link\x1b]8;;\x07`, `see \x1b]8;;${URL}\x07here\x1b]8;;\x07 for details`, "plain body"),
+  agent("\x1b[31mred-name\x1b[0m", "\x1b[33mcoloured description\x1b[0m tail", "\x1b[32mgreen body line\x1b[0m\nsecond"),
+  agent("wide-mixed", `説明 \x1b]8;;${URL}\x07link\x1b]8;;\x07 ${"語".repeat(120)}`, `${"文".repeat(90)}\nmore`),
+];
+
+/** A theme that actually colourises, so SGR sequences are in the measured lines. */
+const theme = {
+  fg: (token: string, text: string) =>
+    `\x1b[38;2;120;160;200m${text}\x1b[0m`.replace("120;160;200", token === "accent" ? "80;120;255" : "120;160;200"),
+  bold: (text: string) => `\x1b[1m${text}\x1b[0m`,
+};
+
+const RAW = {
+  enter: "\r",
+  escape: "\x1b",
+  slash: "/",
+  n: "n",
+  e: "e",
+  d: "d",
+  down: "\x1b[B",
+};
+
+function makePanel() {
+  return createAgentPanel(
+    AGENTS,
+    [],
+    [],
+    null,
+    "/tmp/agents",
+    null,
+    { requestRender: () => {} },
+    theme,
+    () => {},
+    [{ id: "claude-opus-4.5", provider: "anthropic", fullId: "anthropic/claude-opus-4.5" }],
+    [{ name: "read", description: "Read a file" }],
+  );
+}
+
+interface Violation {
+  screen: string;
+  frameWidth: number;
+  row: number;
+  measured: number;
+}
+
+/** Every produced line of a bordered overlay must land on the frame exactly. */
+function audit(screen: string, frameWidth: number, lines: string[]): Violation[] {
+  const bad: Violation[] = [];
+  lines.forEach((line, row) => {
+    const measured = tuiVisibleWidth(line);
+    if (measured !== frameWidth) bad.push({ screen, frameWidth, row, measured });
+  });
+  return bad;
+}
+
+// ── Capture content checks ───────────────────────────────────────────────────
+//
+// A width audit only proves something if the captured frame is the frame it
+// means to measure. The panel's input gates are strict — list search and the name
+// field accept printable ASCII only (`handleListInput` / `handleNameInput` test
+// `data.length === 1 && data >= " " && data <= "~"`), and in list mode `n`, `c`
+// and `d` are commands even while filtering — so a keystroke can be silently
+// dropped and leave the capture showing a placeholder instead of typed content.
+// Every capture therefore declares the content it expects, and a capture that
+// does not contain it fails instead of auditing the wrong frame.
+
+/** Drawn text of the list's search bar, or undefined when there is no bar. */
+function searchRow(raw: string[]): string | undefined {
+  return raw.map((l) => stripTerminalSequences(l)).find((l) => l.includes("◎"));
+}
+
+function hasMarker(raw: string[]): boolean {
+  return raw.some((l) => l.includes(CURSOR_MARKER));
+}
+
+function drawnIncludes(raw: string[], needle: string): boolean {
+  return raw.some((l) => stripTerminalSequences(l).includes(needle));
+}
+
+describe("/agents frame-width audit", () => {
+  const FRAME_WIDTHS = [40, 60, 84, 100];
+
+  it("keeps every produced line on the frame, on every screen", () => {
+    const violations: Violation[] = [];
+    const over: Violation[] = [];
+
+    for (const frameWidth of FRAME_WIDTHS) {
+      // Each screen is reached through the panel's own input handler, so the
+      // captured frames are what the user would see on that screen. `expect`
+      // runs before the width measurement: measure the frame we claim to measure.
+      const capture = (
+        screen: string,
+        drive: (panel: ReturnType<typeof makePanel>) => void,
+        expectContent?: (raw: string[]) => string | null,
+      ) => {
+        const panel = makePanel();
+        drive(panel);
+        const lines = panel.render(frameWidth);
+        const problem = expectContent?.(lines);
+        expect(problem ?? null, `${screen}@${frameWidth} is not the capture this audit measures`).toBeNull();
+        const bad = audit(screen, frameWidth, lines);
+        violations.push(...bad);
+        over.push(...bad.filter((v) => v.measured > frameWidth));
+      };
+
+      capture("list", () => {});
+
+      // The row that carries the cursor marker: `/` opens the search bar with the
+      // placeholder, and the wide keystrokes that follow are dropped by the
+      // ASCII gate.
+      capture(
+        "list:searching",
+        (p) => {
+          p.handleInput(RAW.slash);
+          for (const ch of "検証") p.handleInput(ch);
+        },
+        (raw) => {
+          // Tripwire for that gate: if list search ever accepts wide input, this
+          // capture has to feed the wide query — otherwise a CJK search row goes
+          // unmeasured and the frame-width claim goes stale again.
+          if (!hasMarker(raw)) return "search bar (and its CURSOR_MARKER) not rendered";
+          const row = searchRow(raw);
+          if (!row?.includes("type to filter..."))
+            return `search bar is not the empty-query placeholder: ${JSON.stringify(row?.trim())}`;
+          return null;
+        },
+      );
+
+      // A populated search row with a filtered result set. `k` is printable ASCII
+      // (so the gate accepts it) and is not a list command, unlike `doc` / `link`
+      // / `new`, whose first letter switches screen before it reaches the query.
+      capture(
+        "list:filter",
+        (p) => {
+          p.handleInput(RAW.slash);
+          for (const ch of "k") p.handleInput(ch);
+        },
+        (raw) => {
+          const row = searchRow(raw);
+          if (!row?.includes("◎ k")) return `search bar does not show the query: ${JSON.stringify(row?.trim())}`;
+          if (row.includes("type to filter...")) return "search bar still shows the placeholder";
+          if (!drawnIncludes(raw, "doc-link")) return "filtered list lost the OSC 8 fixture row";
+          if (drawnIncludes(raw, "検証エージェント")) return "filter did not narrow the list";
+          if (drawnIncludes(raw, "No agents found")) return "query matched nothing, so the populated row is unmeasured";
+          return null;
+        },
+      );
+
+      // The empty-state rows a live filter can produce.
+      capture(
+        "list:no-matches",
+        (p) => {
+          p.handleInput(RAW.slash);
+          for (const ch of "zzq") p.handleInput(ch);
+        },
+        (raw) => {
+          if (!drawnIncludes(raw, "◎ zzq")) return "search bar does not show the query";
+          if (!drawnIncludes(raw, "No agents found")) return "empty-state row missing: the query filtered nothing";
+          return null;
+        },
+      );
+
+      // The name field takes ASCII too, so the echo has to be asserted with ASCII.
+      capture(
+        "name-input",
+        (p) => {
+          p.handleInput(RAW.n);
+          for (const ch of "new-agent") p.handleInput(ch);
+        },
+        (raw) => {
+          if (!hasMarker(raw)) return "name input box (and its CURSOR_MARKER) not rendered";
+          if (!drawnIncludes(raw, "new-agent")) return "typed name not echoed into the input box";
+          return null;
+        },
+      );
+
+      capture(
+        "detail",
+        (p) => {
+          p.handleInput(RAW.enter);
+          p.handleInput(RAW.down);
+          p.handleInput(RAW.enter);
+        },
+        (raw) => (drawnIncludes(raw, "Agent:") ? null : "detail screen not rendered"),
+      );
+
+      capture(
+        "edit",
+        (p) => {
+          p.handleInput(RAW.enter);
+          p.handleInput(RAW.e);
+        },
+        (raw) => (drawnIncludes(raw, "Edit:") ? null : "edit screen not rendered"),
+      );
+
+      capture(
+        "confirm-delete",
+        (p) => {
+          p.handleInput(RAW.d);
+        },
+        (raw) => (drawnIncludes(raw, "Delete") ? null : "confirm-delete screen not rendered"),
+      );
+    }
+
+    // The marker line is the shape that used to measure ten columns too wide;
+    // assert one is actually in the captured frames, so a passing audit cannot
+    // mean the fixtures silently stopped containing one.
+    const probe = makePanel();
+    probe.handleInput(RAW.slash);
+    expect(probe.render(84).some((line) => line.includes(CURSOR_MARKER))).toBe(true);
+
+    const summary = (list: Violation[]) =>
+      list.slice(0, 6).map((v) => `${v.screen}@${v.frameWidth}:row${v.row}=${v.measured}`).join(", ");
+    expect(
+      over,
+      `${over.length}/${violations.length} off-frame line(s) [wider than the frame]: ${summary(over)}`,
+    ).toEqual([]);
+    expect(violations, `${violations.length} off-frame line(s) total: ${summary(violations)}`).toEqual([]);
+  });
+});