fix(chat): pending shell row stops impersonating an error; chips survive a shell-driven session

packages/ui/src/amicode/entity-rail.tsx

@@ -27,43 +27,13 @@ import {
 // handled per-call because fetchProblem resolves the active connection on
 // every invocation.
 
-interface RailPartState {
-  status?: string
-  output?: string
-}
-
-function countAmicodeParts(
-  messages: readonly { id: string }[],
-  partsFor: (messageID: string) => readonly RailPart[] | undefined,
-): { any: number; completed: number } {
-  let any = 0
-  let completed = 0
-  for (const message of messages) {
-    for (const part of partsFor(message.id) ?? []) {
-      if (part?.type !== "tool" || typeof part.tool !== "string") continue
-      if (!part.tool.startsWith("amicode_")) continue
-      any++
-      if (part.state?.status === "completed") completed++
-    }
-  }
-  return { any, completed }
-}
-
-/** The rail's session gate, exported so the host chrome can collapse the
- *  header's chip padding when the rail will not render (no amicode parts —
- *  the title otherwise sits over an empty reserved band). */
-export function sessionHasAmicodeParts(
-  messages: readonly { id: string }[],
-  partsFor: (messageID: string) => readonly RailPart[] | undefined,
-): boolean {
-  return countAmicodeParts(messages, partsFor).any > 0
-}
+// The session gate + refetch key now live in rail-gate.ts (pure, tested): the
+// gate also recognises a SHELL-driven amicode session, which used to show no
+// chips at all despite having real entities to describe.
+export { countAmicodeParts, sessionHasAmicodeParts } from "./rail-gate"
+import { countAmicodeParts as countParts, type GatePartLike } from "./rail-gate"
 
-interface RailPart {
-  type?: string
-  tool?: string
-  state?: RailPartState
-}
+type RailPart = GatePartLike
 
 const RUN_POLL_MS = 2500
 
@@ -139,7 +109,7 @@ export function AmicodeEntityRail(props: {
   // exposes are all in scope.
 
   // Session gate + refetch key: completed amicode parts bump the counter → refetch.
-  const amicodeParts = createMemo(() => countAmicodeParts(props.messages, props.partsFor))
+  const amicodeParts = createMemo(() => countParts(props.messages, props.partsFor))
 
   const [problemRaw, { refetch }] = createResource(
     () => (amicodeParts().any > 0 ? amicodeParts().completed + 1 : undefined),

packages/ui/src/amicode/rail-gate.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, test } from "bun:test"
+import { countAmicodeParts, sessionHasAmicodeParts } from "./rail-gate"
+
+// Regression coverage for the missing entity chips.
+//
+// The gate used to be `part.tool.startsWith("amicode_")` alone, so a session that
+// did its amicode work through the shell showed NO chips — observed 2026-07-29 on
+// a session that created a problem workspace, wrote a solvespec, and drove a solve
+// to iteration 29 with frames on disk, entirely via bash + amico-run.
+
+const msgs = [{ id: "m1" }]
+const parts =
+  (...p: Array<Record<string, unknown>>) =>
+  () =>
+    p as never
+
+const amicodeTool = (status = "completed") => ({ type: "tool", tool: "amicode_record_system", state: { status } })
+const bash = (command: string) => ({ type: "tool", tool: "bash", state: { status: "running", input: { command } } })
+
+describe("rail gate", () => {
+  test("an amicode_* tool part opens the gate (unchanged behaviour)", () => {
+    expect(sessionHasAmicodeParts(msgs, parts(amicodeTool()))).toBe(true)
+  })
+
+  test("a shell part that launches amico-run opens the gate", () => {
+    expect(sessionHasAmicodeParts(msgs, parts(bash("nohup amico-run --spec s.json solve.jl &")))).toBe(true)
+  })
+
+  test("a shell part that only touches the problems dir opens the gate", () => {
+    // the workspace gets created before any run exists
+    expect(sessionHasAmicodeParts(msgs, parts(bash("mkdir -p ~/.amico/problems/x-gate-1")))).toBe(true)
+  })
+
+  test("an unrelated session still shows nothing — the gate's whole purpose", () => {
+    expect(sessionHasAmicodeParts(msgs, parts(bash("git status"), bash("npm test")))).toBe(false)
+    expect(sessionHasAmicodeParts(msgs, parts({ type: "text", text: "hello" }))).toBe(false)
+    expect(sessionHasAmicodeParts([], () => undefined)).toBe(false)
+  })
+
+  test("a part whose input has not arrived yet does not match, and does not throw", () => {
+    expect(sessionHasAmicodeParts(msgs, parts({ type: "tool", tool: "bash", state: { status: "pending" } }))).toBe(
+      false,
+    )
+    expect(sessionHasAmicodeParts(msgs, parts({ type: "tool", tool: "bash" }))).toBe(false)
+  })
+
+  // The refetch key must NOT be broadened: shell parts don't mutate the problem
+  // view through the tool seam, so counting them would refetch the problem on
+  // unrelated shell activity.
+  test("completed counts only amicode_* tools, never shell", () => {
+    const c = countAmicodeParts(msgs, parts(amicodeTool("completed"), bash("amico-run solve.jl")))
+    expect(c.any).toBe(2)
+    expect(c.completed).toBe(1)
+  })
+
+  test("a non-completed amicode tool counts for the gate but not the refetch key", () => {
+    const c = countAmicodeParts(msgs, parts(amicodeTool("running")))
+    expect(c.any).toBe(1)
+    expect(c.completed).toBe(0)
+  })
+})

packages/ui/src/amicode/rail-gate.ts

@@ -0,0 +1,78 @@
+// Does THIS session's transcript show amicode work? The entity rail renders only
+// when it does, so a fresh or non-amicode session shows no empty chrome (the
+// active problem pointer is global, the rail is session-scoped).
+//
+// Extracted from entity-rail.tsx to be testable, and broadened. The original test
+// was `part.tool.startsWith("amicode_")` — a session that did its amicode work
+// through the SHELL therefore showed no chips at all. Observed 2026-07-29: the
+// agent created a problem workspace, wrote a solvespec, and launched a solve that
+// reached iteration 29 with frames on disk — entirely via bash and `amico-run` —
+// and the rail stayed hidden the whole time, because it never called an
+// `amicode_*` tool. The chips had real entities to describe and refused to.
+//
+// A shell-driven solve is still unambiguously an amicode session, so the gate now
+// also recognises a bash part whose command drives amicode. It stays SESSION-scoped
+// (the point of the gate), so an unrelated session still shows nothing.
+
+/** Substrings in a shell command that mark it as amicode work. `amico-run` is the
+ *  launcher; the problems dir is where a workspace gets created before any run. */
+const SHELL_MARKERS = ["amico-run", ".amico/problems", "amico plan", "amico spec"] as const
+
+export interface GatePartLike {
+  type?: string
+  tool?: string
+  state?: {
+    status?: string
+    input?: Record<string, unknown>
+  }
+}
+
+function isAmicodeToolPart(part: GatePartLike): boolean {
+  return part?.type === "tool" && typeof part.tool === "string" && part.tool.startsWith("amicode_")
+}
+
+/** A shell part that drives amicode. Reads only `input.command`, so a part whose
+ *  input has not arrived yet simply doesn't match (it will on the next render). */
+function isAmicodeShellPart(part: GatePartLike): boolean {
+  if (part?.type !== "tool") return false
+  const command = part.state?.input?.command
+  if (typeof command !== "string") return false
+  return SHELL_MARKERS.some((marker) => command.includes(marker))
+}
+
+export interface AmicodePartCounts {
+  /** Parts that mark this as an amicode session — the render gate. */
+  any: number
+  /** Completed `amicode_*` tool parts — the refetch key. Deliberately NOT
+   *  broadened: shell parts don't mutate the problem view through the tool seam,
+   *  so counting them would refetch on unrelated shell activity. */
+  completed: number
+}
+
+export function countAmicodeParts<T extends GatePartLike>(
+  messages: readonly { id: string }[],
+  partsFor: (messageID: string) => readonly T[] | undefined,
+): AmicodePartCounts {
+  let any = 0
+  let completed = 0
+  for (const message of messages) {
+    for (const part of partsFor(message.id) ?? []) {
+      if (isAmicodeToolPart(part)) {
+        any++
+        if (part.state?.status === "completed") completed++
+      } else if (isAmicodeShellPart(part)) {
+        any++
+      }
+    }
+  }
+  return { any, completed }
+}
+
+/** The rail's session gate, exported so the host chrome can collapse the header's
+ *  chip padding when the rail will not render. */
+export function sessionHasAmicodeParts<T extends GatePartLike>(
+  messages: readonly { id: string }[],
+  partsFor: (messageID: string) => readonly T[] | undefined,
+): boolean {
+  return countAmicodeParts(messages, partsFor).any > 0
+}

packages/ui/src/amicode/shell-row.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, test } from "bun:test"
+import { clampShellLabel, shellRowLabel, SHELL_ROW_MAX } from "./shell-row"
+
+// Regression coverage for "a constant error not going away" (2026-07-29).
+//
+// A PENDING bash part has no `input.command` yet, so the label chain fell through
+// to the model's free-text `description` and rendered a full prose sentence where
+// users read a command — for the whole duration of the command. The text happened
+// to paraphrase agent guidance about local launches being refused, so it read as a
+// hard failure while the solve underneath was healthy and on iteration 29.
+const REPORTED =
+  '"A local launch is REFUSED by amico-run while this solver is selected (exit 64), so attempting one only wastes a turn."'
+
+describe("shell row label", () => {
+  test("the reported case no longer fills the row, and loses its quote", () => {
+    const out = shellRowLabel({ state: { input: { description: REPORTED } } })
+    expect(out.length).toBeLessThanOrEqual(SHELL_ROW_MAX)
+    expect(out.startsWith('"')).toBe(false)
+    expect(out.endsWith("…")).toBe(true)
+  })
+
+  test("the real command always wins over title and description", () => {
+    expect(
+      shellRowLabel({ state: { title: "Some title", input: { command: "ls -la", description: "listing files" } } }),
+    ).toBe("ls -la")
+  })
+
+  test("falls back to title, then description — both still useful", () => {
+    expect(shellRowLabel({ state: { title: "Install deps" } })).toBe("Install deps")
+    expect(shellRowLabel({ state: { input: { description: "Install deps" } } })).toBe("Install deps")
+  })
+
+  test("a short description is untouched — the fallback keeps its value", () => {
+    expect(shellRowLabel({ state: { input: { description: "Run the tests" } } })).toBe("Run the tests")
+  })
+
+  test("first line only, and blanks do not win", () => {
+    expect(shellRowLabel({ state: { input: { command: "  make build  \n&& make test" } } })).toBe("make build")
+    // an empty string must not beat a usable description
+    expect(shellRowLabel({ state: { input: { command: "   ", description: "Install deps" } } })).toBe("Install deps")
+  })
+
+  test("nothing usable → the neutral placeholder, never a throw", () => {
+    expect(shellRowLabel({})).toBe("command")
+    expect(shellRowLabel({ state: {} })).toBe("command")
+    expect(shellRowLabel({ state: { input: {} } })).toBe("command")
+  })
+
+  test("clamping is exact and elides rather than truncating silently", () => {
+    const long = "x".repeat(SHELL_ROW_MAX + 20)
+    const out = clampShellLabel(long)
+    expect(out.length).toBe(SHELL_ROW_MAX)
+    expect(out.endsWith("…")).toBe(true)
+    expect(clampShellLabel("x".repeat(SHELL_ROW_MAX))).toBe("x".repeat(SHELL_ROW_MAX))
+  })
+
+  test("single-quoted prose is unwrapped too", () => {
+    expect(clampShellLabel("'Install the dependencies'")).toBe("Install the dependencies")
+  })
+})

packages/ui/src/amicode/shell-row.ts

@@ -0,0 +1,51 @@
+// The one-line label for a bash part's row inside the shell group.
+//
+// Extracted from message-part.tsx so the fallback chain is testable: it caused a
+// bug that read as a hard error. While a bash part is PENDING its `input.command`
+// is not populated yet, so the chain fell through to the model's free-text
+// `description` — and rendered a full prose sentence in the slot where users read
+// a command. Reported 2026-07-29 as "a constant error not going away": the text
+// was `"A local launch is REFUSED by amico-run while this solver is selected
+// (exit 64), so attempting one only wastes…"`, which is agent guidance being
+// paraphrased, not a failure — and the solve underneath was running fine.
+//
+// The description fallback is still worth keeping (often a useful "Install
+// dependencies"), so the fix is not to drop it but to stop it impersonating a
+// command: strip wrapping quotes, keep one line, and clamp to a length that reads
+// as a label rather than an error message.
+
+/** Longest label we render before eliding. Long enough for a real command or a
+ *  short description, short enough that prose cannot fill the row. */
+export const SHELL_ROW_MAX = 72
+
+export interface ShellRowPartLike {
+  state?: {
+    input?: Record<string, unknown>
+    title?: unknown
+  }
+}
+
+/** Trim, take the first line, drop wrapping quotes, and elide past SHELL_ROW_MAX. */
+export function clampShellLabel(raw: string, max: number = SHELL_ROW_MAX): string {
+  let s = raw.split("\n")[0]!.trim()
+  // A quoted prose sentence is the shape that read as an error; unwrap it so the
+  // row shows the sentence rather than a stray quote mark at the elision point.
+  if (s.length >= 2 && ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'")))) {
+    s = s.slice(1, -1).trim()
+  } else if (s.length >= 1 && (s.startsWith('"') || s.startsWith("'"))) {
+    s = s.slice(1).trim()
+  }
+  if (s.length <= max) return s
+  return s.slice(0, max - 1).trimEnd() + "…"
+}
+
+/** Prefer the actual command; fall back to title, then the model's description.
+ *  Whatever wins is clamped, so a pending part can never fill the row with prose. */
+export function shellRowLabel(part: ShellRowPartLike): string {
+  const input = (part.state?.input ?? {}) as Record<string, unknown>
+  const command = typeof input.command === "string" && input.command.trim() !== "" ? input.command : undefined
+  const title = typeof part.state?.title === "string" && part.state.title.trim() !== "" ? part.state.title : undefined
+  const description =
+    typeof input.description === "string" && input.description.trim() !== "" ? input.description : undefined
+  return clampShellLabel(command ?? title ?? description ?? "command")
+}

packages/ui/src/components/message-part.tsx

@@ -1,6 +1,8 @@
 import { AmicoSpinner, AmicoMark } from "../amicode/spinner"
 import { ThinkingLine } from "../amicode/thinking-line"
 import { turnTokens } from "../amicode/thinking"
+import { shellRowLabel } from "../amicode/shell-row"
+import { sessionHasAmicodeParts } from "../amicode/rail-gate"
 import { amicoBrainRef, emitAmicoBrainHover } from "../amicode/brain-ref"
 import {
   Component,
@@ -618,12 +620,13 @@ export function AssistantParts(props: {
   // presence (the working lane below; the rail waking) keys off it. Plain-prose
   // turns are the *normal chat*: no Amico chrome in the flow
   // (spec-20260712-amico-third-actor).
+  // Shares the rail's gate (rail-gate.ts) rather than re-testing `amicode_*`
+  // here. Both used the tool-name test independently, so a SHELL-driven amicode
+  // session lost the chips AND Amico's presence mark together — the H-mark read
+  // as "inactive" while a solve was running at iteration 29 (2026-07-29). One
+  // definition, one place to widen.
   const inDomainTurn = createMemo(() =>
-    props.messages.some((message) =>
-      list(data.store.part?.[message.id], emptyParts).some(
-        (p) => p.type === "tool" && /^amicode_/.test((p as ToolPart).tool ?? ""),
-      ),
-    ),
+    sessionHasAmicodeParts(props.messages, (id) => list(data.store.part?.[id], emptyParts) as never),
   )
 
   return (
@@ -732,15 +735,12 @@ export function AssistantParts(props: {
   )
 }
 
-// One-line command for a bash part's row in the shell group (prefer the actual
-// command, fall back to title/description; first line only).
+// One-line command for a bash part's row in the shell group. Logic lives in
+// ../amicode/shell-row.ts so the fallback chain is testable — it shipped a bug
+// where a pending part rendered the model's prose description as if it were the
+// command, which read as a hard error for the command's whole duration.
 function shellCommandText(part: ToolPart): string {
-  const input = (part.state.input ?? {}) as Record<string, unknown>
-  const command = typeof input.command === "string" ? input.command : undefined
-  const title = "title" in part.state && typeof part.state.title === "string" ? part.state.title : undefined
-  const description = typeof input.description === "string" ? input.description : undefined
-  const raw = command ?? title ?? description ?? "command"
-  return raw.split("\n")[0]!.trim()
+  return shellRowLabel(part)
 }
 
 function contextToolDetail(part: ToolPart): string | undefined {