Align stale chrome and adapter tests with current product behavior

Fleet board chrome and stall bang blink are intentionally off;
transcript Task rows and working chrome own that status. The
duplicate grok-responses unit test still expected summary auto
after the adapter moved to detailed.

Author: TheGreatAxios

src/tui/product-host.test.ts

@@ -302,7 +302,7 @@ describe("mountProductHost", () => {
     expect(host.shell.streamLog).toEqual([])
   })
 
-  test("the agents panel's elapsed clock advances on the sticky poll tick, without another chrome push", async () => {
+  test("setChrome with running agents does not paint an agents panel clock", async () => {
     const now = Date.now()
     const { host, renderOnce, captureCharFrame } = await mountHeadless({
       chrome: {
@@ -320,14 +320,15 @@ describe("mountProductHost", () => {
     })
     try {
       await renderOnce()
-      expect(captureCharFrame()).toContain("0:59")
+      // Fleet board chrome is off — sticky poll must not resurrect an agents
+      // panel clock from injected chrome state.
+      expect(captureCharFrame()).not.toContain("0:59")
+      expect(captureCharFrame()).not.toContain("map callers")
 
-      // No further chrome push or event — only wall-clock time passing.
-      // Only the 200ms sticky poll can be responsible for the clock moving.
       await new Promise((r) => setTimeout(r, 1_100))
       await renderOnce()
-      expect(captureCharFrame()).not.toContain("0:59")
-      expect(captureCharFrame()).toMatch(/1:0\d/)
+      expect(captureCharFrame()).not.toMatch(/1:0\d/)
+      expect(captureCharFrame()).not.toContain("map callers")
     } finally {
       host.dispose()
     }

src/tui/ramp-paint.test.ts

@@ -9,11 +9,7 @@
 import { describe, expect, test } from "bun:test"
 
 import { withTestRenderer } from "./harness"
-import {
-  RAMP_CYCLE_MS,
-  STALL_BLINK_BURST_MS,
-  STALL_BLINK_CYCLE_MS,
-} from "./ramp"
+import { RAMP_CYCLE_MS } from "./ramp"
 import { attachSessionBridge, createRecordingPort } from "./runtime-bridge"
 import { createAppShell } from "./shell"
 import { UI } from "./theme"
@@ -231,7 +227,7 @@ describe("turn ramp paint", () => {
     )
   })
 
-  test("a stalled turn blinks a bang into the border, then settles to a static one", async () => {
+  test("silence past the stall notice still paints working, not a bang", async () => {
     await withTestRenderer(
       async (h) => {
         const shell = createAppShell(h.renderer, {
@@ -249,26 +245,20 @@ describe("turn ramp paint", () => {
           await h.renderOnce()
           expect(slotGlyph(h.captureCharFrame())).toMatch(DENSITY)
 
+          // Past the notice threshold the watchdog may flash, but operator
+          // chrome keeps the working ramp — recovery is silent under the hood.
           advance(1_500)
           await h.renderOnce()
-          // Scoped to the slot: a bang anywhere else in the frame is not this.
-          const blinking = new Set<string>()
-          for (let i = 0; i < 4; i++) {
-            blinking.add(slotGlyph(h.captureCharFrame()))
-            advance(STALL_BLINK_CYCLE_MS / 2)
-            await h.renderOnce()
-          }
-          expect(blinking.has("!")).toBe(true)
-          expect(blinking.size).toBeGreaterThan(1)
+          expect(statusRow(h.captureCharFrame())).toContain("working")
+          expect(slotGlyph(h.captureCharFrame())).toMatch(DENSITY)
+          expect(slotGlyph(h.captureCharFrame())).not.toBe("!")
 
-          // Past the burst the alarm stops strobing but still reads as one.
-          advance(STALL_BLINK_BURST_MS * 2)
-          await h.renderOnce()
-          const settled = statusRow(h.captureCharFrame())
-          expect(slotGlyph(settled)).toBe("!")
-          advance(STALL_BLINK_CYCLE_MS / 2)
+          // The slot keeps moving: still a live working pulse, not a settled bang.
+          const first = slotGlyph(h.captureCharFrame())
+          advance(RAMP_CYCLE_MS / 4)
           await h.renderOnce()
-          expect(statusRow(h.captureCharFrame())).toBe(settled)
+          expect(slotGlyph(h.captureCharFrame())).not.toBe(first)
+          expect(slotGlyph(h.captureCharFrame())).toMatch(DENSITY)
         } finally {
           bridge.dispose()
         }

src/tui/runtime-channels.test.ts

@@ -197,8 +197,8 @@ describe("permission.grant channel", () => {
   })
 })
 
-describe("agents chrome (store-driven tool state)", () => {
-  test("the live tool name reaches the agents chrome zone", async () => {
+describe("agents chrome (zone off — transcript Task rows own live lanes)", () => {
+  test("setChrome with running agents does not paint an agents zone", async () => {
     const { host, frame, cleanup } = await mountHeadless({
       chrome: {
         agents: [
@@ -213,20 +213,19 @@ describe("agents chrome (store-driven tool state)", () => {
       },
     })
     try {
-      // The board right-aligns each lane's tail into a column, so the tool
-      // name is on the row but no longer adjacent to the description.
+      // Fleet board chrome is off: live lane status rides transcript Task rows,
+      // not a dedicated agents zone. Injecting agents into chrome must not paint
+      // them into the frame or the transcript.
       const painted = await frame()
-      expect(painted).toContain("map callers")
-      expect(painted).toContain("grep")
-      // Progress is chrome, never a transcript row: one line per worker tool
-      // call would bury the turn it is a detail of.
+      expect(painted).not.toContain("map callers")
+      expect(painted).not.toContain("grep")
       expect(host.shell.streamLog).toEqual([])
     } finally {
       cleanup()
     }
   })
 
-  test("a later chrome push keeps the live tool name", async () => {
+  test("a later chrome push still leaves the agents zone empty", async () => {
     const { host, frame, cleanup } = await mountHeadless()
     try {
       host.setChrome({
@@ -241,8 +240,8 @@ describe("agents chrome (store-driven tool state)", () => {
         ],
       })
       const painted = await frame()
-      expect(painted).toContain("map callers")
-      expect(painted).toContain("grep")
+      expect(painted).not.toContain("map callers")
+      expect(painted).not.toContain("grep")
     } finally {
       cleanup()
     }

tests/unit/grok-responses-adapter.test.ts

@@ -42,7 +42,7 @@ describe("grok-responses buildRequest", () => {
     expect(body["stream"]).toBe(true);
     expect(body["store"]).toBe(false);
     expect(body["include"]).toEqual(["reasoning.encrypted_content"]);
-    expect(body["reasoning"]).toEqual({ summary: "auto" });
+    expect(body["reasoning"]).toEqual({ summary: "detailed" });
     // No `instructions` field — the system prompt rides as a system input message.
     expect(body["instructions"]).toBeUndefined();
     const input = body["input"] as Array<Record<string, unknown>>;