fix(studio): repair browser test suite drift and two Compare/Memory regressions

After the Compare composer redesign (fa2af74, 2f1032f) the connection panel
for an ACP Agent that needs authentication or session discovery was
unreachable: the composer gated Run on prepared === true, and an auth-needing
Agent could never reach that state without the panel. Mount the connection
panel in the input region when a chosen Agent is awaiting a connection
decision, via a new bounded .live-compare-connection region.

The shared AcpSessionStream auto-start (bc405e9) fired for the Memory
analysis composer too, sending the default placeholder prompt before the
reader could edit it. Add an autoStart prop so MemoryAnalysisPanel opts out.

Also fix 22 browser tests left stale by the sidebar reorg, observation-window
default change (all -> last30), composer simplification, Tools removal,
run-badge retirement, and related UI drift:

- project-scan: remove Tools from expected nav list
- shared-scope, artifact-workspace: widen to all before asserting full counts
- acp-connection: rewrite for composer-based connection panel flow
- acp-session-stream: replace retired .run-badge assertions
- project-shell: change from status-bar counts to session-title assertions
- memory-workbench: replace retired .acp-turn-status/Close session assertions
- git-history: widen observation window for backdated fixture commits
- tool-call: adapt single-agent and blocked-comparison to current Compare
- artifact-host/external-artifact-host: adjust stale visibility and thresholds

Co-authored-by: QoderAI (Qwen 3.8 Max) <qoder_ai@qoder.com>

Author: phodal

packages/harness-studio/src/app/CompareLiveView.tsx

@@ -21,6 +21,7 @@ import {
 } from "./run/run-store.js";
 import { streamRun } from "./run/stream-run.js";
 import { AcpSessionStream } from "./run/AcpSessionStream.js";
+import { AcpConnectionPanel } from "./run/AcpConnectionPanel.js";
 import { AcpConversationHistory, loadAcpConversation } from "./run/AcpConversationHistory.js";
 import { postAcpRunAction } from "./run/acp-run-actions.js";
 import { ToolbarActions } from "./shell/ToolbarActions.js";
@@ -376,6 +377,25 @@ export function CompareLiveView(props: {
               ><X aria-hidden="true" size={11} /></button>
             </div>;
           })}
+          {/* An Agent that needs a session decision before it can answer states
+              that decision in the input region it already owns. Preparation
+              cannot finish without it, so Run would otherwise never unlock. */}
+          {chosen.map((agentId) => {
+            const lane = prepared.find((candidate) => candidate.agentId === agentId);
+            if (lane?.state.connection == null) return null;
+            return <div
+              className="live-compare-connection"
+              key={`connection-${agentId}`}
+              role="group"
+              aria-label={t("live.agentSettingsAria", { agent: labelFor(agentId) })}
+            >
+              <AcpConnectionPanel
+                connection={lane.state.connection}
+                actions={createAcpSessionActions(lane.runId)}
+                runId={lane.runId}
+              />
+            </div>;
+          })}
           {chosen.length > 1 && <SharedTreeNote />}
           {prerequisite !== undefined && <span className={`live-compare-readiness${available.length === 0 ? " status-warning" : ""}`} role="status">{prerequisite}</span>}
         </PromptInputTools>

packages/harness-studio/src/app/memory/MemoryAnalysisPanel.tsx

@@ -77,7 +77,7 @@ export function MemoryAnalysisPanel({ snapshot, entry, agents, maxBytes, onClose
   }
   return <aside className="memory-analysis memory-acp-analysis" aria-label={t('memory.aiAnalysis')} onKeyDown={event => { if (event.key === 'Escape' && event.target === close.current) { event.stopPropagation(); onClose(); } }}>
     <div className="memory-analysis-toolbar"><button ref={close} type="button" onClick={onClose} aria-label={t('memory.closeAnalysis')}><X size={15} /></button></div>
-    {state.runId ? <AcpSessionStream contextEvidence={contextEvidence} compact showComposer={false} state={displayState} prompt="" actions={actions} agentId={agentId} onPermission={(requestId, optionId) => postAcpRunAction(state.runId!, { requestId, optionId })} /> : <div className="memory-analysis-transcript" />}
+    {state.runId ? <AcpSessionStream contextEvidence={contextEvidence} compact showComposer={false} autoStart={false} state={displayState} prompt="" actions={actions} agentId={agentId} onPermission={(requestId, optionId) => postAcpRunAction(state.runId!, { requestId, optionId })} /> : <div className="memory-analysis-transcript" />}
     <footer className="memory-analysis-composer">
       {(!state.runId || state.acp.prepared) && <Suggestions className="memory-analysis-suggestions" aria-label={t('memory.analysisSuggestions')}>
         {(['review', 'conflicts'] as const).map(kind => <Suggestion key={kind} suggestion={t(`memory.suggestions.${kind}.prompt`)} disabled={sending} onClick={value => { setDraft(value); input.current?.focus(); }}>{t(`memory.suggestions.${kind}.label`)}</Suggestion>)}

packages/harness-studio/src/app/run/AcpSessionStream.tsx

@@ -24,12 +24,16 @@ import { planElementState } from "./ai-elements-adapter.js";
 import { defaultAcpConfigValue, loadAcpAgentPreferences, saveAcpAgentPreferences } from "./acp-session-preferences.js";
 
 /** A host-independent view: callers own launch, routing and permission authority. */
-export function AcpSessionStream({ state, prompt, failure, onPermission, actions, permissionClassName = "", compact = false, showComposer = true, revealTool, contextEvidence, agentId }: {
+export function AcpSessionStream({ state, prompt, failure, onPermission, actions, permissionClassName = "", compact = false, showComposer = true, autoStart = true, revealTool, contextEvidence, agentId }: {
   revealTool?: { id: string; token: number };
   contextEvidence?: React.ReactNode;
   state: HarnessRunState;
   compact?: boolean;
   showComposer?: boolean;
+  /** A surface that owns its own start action (for example the Memory analysis
+   * composer) opts out, so preparation never sends a prompt the reader has not
+   * reviewed. */
+  autoStart?: boolean;
   actions?: AcpSessionActions;
   prompt: string;
   failure?: string;
@@ -47,7 +51,7 @@ export function AcpSessionStream({ state, prompt, failure, onPermission, actions
   const session = state.acp;
 
   useEffect(() => {
-    if (!session.prepared || state.conversation || !actions || autoConfigured) return;
+    if (!autoStart || !session.prepared || state.conversation || !actions || autoConfigured) return;
     const needsConfig = (session.config?.length ?? 0) > 0 || (session.modes?.length ?? 0) > 0;
     if (!needsConfig) {
       setAutoConfigured(true);
@@ -75,7 +79,7 @@ export function AcpSessionStream({ state, prompt, failure, onPermission, actions
       saveAcpAgentPreferences(agentId, session.config ?? [], session.mode);
       try { await actions.execute({ action: "start" }); } catch (error) { setStartError(String(error)); }
     })();
-  }, [session.prepared, state.conversation, actions, session.config, session.modes, session.mode, agentId, autoConfigured]);
+  }, [autoStart, session.prepared, state.conversation, actions, session.config, session.modes, session.mode, agentId, autoConfigured]);
 
   if (state.connection && state.status === "running" && actions && state.runId) return <AcpConnectionPanel key={state.runId} runId={state.runId} connection={state.connection} actions={actions} />;
 

packages/harness-studio/src/app/styles/workbench.css

@@ -1827,6 +1827,10 @@
    rather than to the summary, so a fourth Agent's disclosure cannot open off the
    viewport at narrow widths. Geometry comes from `.ai-prompt-tools`. */
 .live-compare-composer .acp-settings-fields { position: absolute; z-index: 70; box-sizing: border-box; max-width: min(26rem, 100%); max-height: 45dvh; overflow: auto; padding: var(--space-md); border: 1px solid var(--color-border-strong); border-radius: var(--radius-sm); background: var(--color-panel); box-shadow: var(--shadow-popover); }
+/* A session decision (authentication or session choice) is a modality that needs
+   room for its list and actions, so it takes its own bounded row inside the
+   composer instead of crowding the Agent chip. */
+.live-compare-connection { flex-basis: 100%; min-width: 0; max-height: 38dvh; overflow: auto; border: 1px solid var(--color-border); border-radius: var(--radius-sm); background: var(--color-panel); }
 /* A prerequisite is a compact part of the command row and never claims a
    separate line; a settled Agent states its own status on its own control. */
 .live-compare-note { min-width: 0; flex: 0 1 auto; max-width: min(20rem, 100%); margin: 0; display: flex; align-items: center; gap: var(--space-xs); color: var(--color-text-muted); font-size: var(--type-meta-size); }

packages/harness-studio/test/browser/acp-connection.spec.mjs

@@ -17,7 +17,11 @@ test.beforeAll(async () => {
   });
 });
 test.afterAll(async () => { await studio?.close(); await rm(directory, { recursive: true, force: true }); });
-async function connect(page) {
+
+// Agent configuration lives in the composer, so a connection decision an Agent
+// needs before it can answer is stated in that same input region. Run stays the
+// only transition that creates message lanes.
+async function chooseAgents(page) {
   await page.goto(`${studio.url}/#/compare`);
   const open = page.getByRole("button", { name: "Open Project", exact: true });
   await expect(open.or(page.getByRole("textbox", { name: "What should these Agents do?" }))).toBeVisible();
@@ -26,61 +30,72 @@ async function connect(page) {
   await page.getByRole("button", { name: /^Choose Agents/ }).click();
   for (const name of ["Alpha ACP", "Beta ACP"]) await page.getByRole("menuitemcheckbox", { name: new RegExp(name) }).click();
   await page.keyboard.press("Escape");
-  // Agent settings prepare inline in the shared composer; Run is the only
-  // transition that creates message lanes and opens the connection panel.
+}
+async function connectionPanel(page) {
+  const panel = page.locator(".live-compare-connection .acp-connection-panel");
+  await expect(panel).toBeVisible();
+  return panel;
+}
+async function signIn(panel) {
+  await panel.locator("details.acp-connection-auth").evaluate(node => { if (node instanceof HTMLDetailsElement) node.open = true; });
+  await panel.getByRole("button", { name: "Fixture login", exact: true }).click();
+  await expect(panel).toContainText("Authentication completed.");
+}
+async function startComparison(page) {
   await page.getByRole("button", { name: "Run 2 Agents", exact: true }).click();
   const lanes = page.locator(".live-compare-lane");
-  await expect(lanes.nth(0).getByRole("button", { name: "Browse Agent history" })).toBeVisible();
+  await expect(lanes).toHaveCount(2);
   return [lanes.nth(0), lanes.nth(1)];
 }
-test("discover, authenticate, paginate and restore the selected Agent session", async ({ page }, info) => {
+
+test("discovers, authenticates, paginates and restores the selected Agent session", async ({ page }, info) => {
   await page.emulateMedia({ reducedMotion: "reduce" });
   const errors = []; page.on("pageerror", error => errors.push(error.message)); page.on("console", message => { if (message.type() === "error") errors.push(message.text()); });
-  const [alpha, beta] = await connect(page);
-  await expect(beta).toContainText("This Agent does not support session discovery.");
-  await expect(beta.getByRole("button", { name: "Browse Agent history" })).toHaveCount(0);
-  await alpha.getByText("Sign in", { exact: true }).click();
-  await alpha.getByRole("button", { name: "Fixture login", exact: true }).click();
-  await expect(alpha).toContainText("Authentication completed.");
-  await alpha.getByRole("button", { name: "Browse Agent history" }).click();
-  await expect(alpha.getByTitle("fixture-recent", { exact: true })).toBeVisible();
-  await alpha.getByRole("button", { name: "Load more sessions" }).click();
-  await expect(alpha.getByTitle("fixture-older", { exact: true })).toBeVisible();
-  await expect(alpha.getByRole("button", { name: "Load more sessions" })).toHaveCount(0);
+  await chooseAgents(page);
+  // Only the Agent that publishes session discovery asks for a connection
+  // decision; the other prepares straight into its inline settings.
+  const panel = await connectionPanel(page);
+  await expect(page.locator(".acp-connection-panel")).toHaveCount(1);
+  await signIn(panel);
+  await panel.getByRole("button", { name: "Browse Agent history" }).click();
+  await expect(panel.getByTitle("fixture-recent", { exact: true })).toBeVisible();
+  await panel.getByRole("button", { name: "Load more sessions" }).click();
+  await expect(panel.getByTitle("fixture-older", { exact: true })).toBeVisible();
+  await expect(panel.getByRole("button", { name: "Load more sessions" })).toHaveCount(0);
   for (const width of [1440, 1024, 390]) {
     await page.setViewportSize({ width, height: 900 });
-    const choice = alpha.getByTitle("fixture-older", { exact: true });
+    const choice = panel.getByTitle("fixture-older", { exact: true });
     await choice.scrollIntoViewIfNeeded(); await choice.focus(); await expect(choice).toBeFocused();
     expect(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth)).toBe(true);
     await page.screenshot({ path: info.outputPath(`connection-${width}.png`), animations: "disabled" });
   }
-  await alpha.getByTitle("fixture-older", { exact: true }).press("Enter");
-  await expect(alpha.locator(".acp-turn-status")).toHaveText("Ready");
-  await expect(alpha).toContainText("Loaded fixture session");
-  await expect(alpha).toContainText("session:fixture-older");
+  await panel.getByTitle("fixture-older", { exact: true }).press("Enter");
+  const [alpha] = await startComparison(page);
+  await expect(alpha.locator(".acp-session-events")).toContainText("Loaded fixture session");
+  await expect(alpha.locator(".acp-session-events")).toContainText("turn:21 session:fixture-older");
   await alpha.locator(".acp-composer textarea").fill("one more turn");
   await alpha.locator(".acp-composer textarea").press("Enter");
   await expect(alpha).toContainText("turn:22 session:fixture-older");
-  await beta.getByRole("button", { name: "Start new session" }).click();
-  await expect(beta.locator(".acp-turn-status")).toHaveText("Ready");
-  await alpha.getByRole("button", { name: "Close session", exact: true }).click();
-  await beta.getByRole("button", { name: "Close session", exact: true }).click();
   const records = await Promise.all((await readdir(join(directory, "conversations"))).filter(name => name.endsWith(".json")).map(async name => JSON.parse(await readFile(join(directory, "conversations", name), "utf8"))));
   const record = records.find(item => item.snapshot.sessionId === "fixture-older");
   expect(record).toBeDefined();
   const methods = record.events.filter(item => item.event.type === "protocol-event" && item.event.direction === "Client → Agent").map(item => item.event.method);
   expect(methods.filter(method => method === "session/load")).toHaveLength(1);
-  expect(methods).not.toContain("session/new");
+  // The chosen Session is restored, not replaced: the fixture rejects the single
+  // pre-authentication session/new attempt and none is made again afterwards.
+  const authIndex = methods.indexOf("authenticate");
+  expect(methods.slice(0, authIndex)).toContain("session/new");
+  expect(methods.slice(authIndex)).not.toContain("session/new");
   expect(errors).toEqual([]);
 });
 
 test("closing preparation releases the connection without creating a session", async ({ page }) => {
-  const [alpha, beta] = await connect(page);
-  await alpha.getByRole("button", { name: "Close session", exact: true }).click();
-  await expect(alpha.locator(".acp-connection-panel")).toHaveCount(0);
-  await expect(alpha.locator(".acp-composer")).toHaveCount(0);
-  await beta.getByRole("button", { name: "Close session", exact: true }).click();
-  await page.getByRole("button", { name: "New comparison", exact: true }).click();
+  await chooseAgents(page);
+  const panel = await connectionPanel(page);
+  await panel.getByRole("button", { name: "Close session", exact: true }).click();
+  await expect(page.locator(".acp-connection-panel")).toHaveCount(0);
+  await expect(page.locator(".acp-composer")).toHaveCount(0);
+  await expect(page.locator(".live-compare-lane")).toHaveCount(0);
   await expect(page.getByRole("textbox", { name: "What should these Agents do?" })).toHaveValue("Continue the selected conversation");
 });
 
@@ -97,6 +112,7 @@ test("Debugger returns failed session setup to authentication and retries the or
   await page.getByRole("button", { name: "Run", exact: true }).click();
   const panel = page.locator(".acp-connection-panel");
   await expect(panel.getByRole("alert")).toBeVisible();
+  await panel.locator("details.acp-connection-auth").evaluate(node => { if (node instanceof HTMLDetailsElement) node.open = true; });
   await panel.getByRole("button", { name: "Fixture login", exact: true }).click();
   await expect(panel).toContainText("Authentication completed.");
   for (const width of [1440, 1024, 390]) {
@@ -106,8 +122,9 @@ test("Debugger returns failed session setup to authentication and retries the or
     await page.screenshot({ path: info.outputPath(`debugger-connection-${width}.png`) });
   }
   await panel.getByRole("button", { name: "Start new session" }).click();
-  await expect(page.locator(".acp-turn-status")).toHaveText("Ready");
+  // The simplified composer retired the caption that stated "Ready", so the
+  // recovered transcript is what proves the retried prompt reached the Agent.
+  await expect(page.locator(".acp-connection-panel")).toHaveCount(0);
   await expect(page.locator(".acp-session-events")).toContainText("Retry my original prompt");
-  await page.getByRole("button", { name: "Close session", exact: true }).click();
   expect(errors).toEqual([]);
 });

packages/harness-studio/test/browser/acp-session-stream.spec.mjs

@@ -92,12 +92,13 @@ test("compares rich ACP streams with isolated retryable decisions, stable readin
   // Keep the transcript parked at the top while a new chunk completes the turn.
   await scroll.evaluate((node) => { node.scrollTop = 0; });
   await alpha.getByRole("button", { name: "Continue stream", exact: true }).click();
-  await expect(alpha.locator(".run-badge")).toHaveText("Completed");
+  // A live lane states completion through its transcript; the run badge that
+  // summarized status was retired from live lanes.
+  await expect(alpha.locator(".streaming-message").last()).toContainText("stream:complete");
   expect(await scroll.evaluate((node) => node.scrollTop)).toBe(0);
   await alpha.getByRole("button", { name: "Back to latest" }).focus();
   await page.keyboard.press("Enter");
   await expect(scroll).toBeFocused();
-  await expect(alpha.locator(".streaming-message").last()).toContainText("stream:complete");
   await expect.poll(() => scroll.evaluate((node) => node.scrollHeight - node.scrollTop - node.clientHeight)).toBeLessThanOrEqual(24);
   // A failed cancel is visible and retryable; the sibling stays finished.
   let cancels = 0;
@@ -111,7 +112,8 @@ test("compares rich ACP streams with isolated retryable decisions, stable readin
   await expect(beta.getByRole("alert")).toBeVisible();
   await expect(beta.getByRole("button", { name: "Stop", exact: true })).toBeEnabled();
   await beta.getByRole("button", { name: "Stop", exact: true }).click();
-  await expect(beta.locator(".run-badge")).toHaveText("Interrupted");
+  // The retired run badge is replaced by the transcript stating the stop.
+  await expect(beta).toContainText("Turn stopped: cancelled");
   await expect(beta.locator(".acp-permission-gate")).toHaveCount(0);
   for (const layout of layouts) {
     await page.setViewportSize(layout);

packages/harness-studio/test/browser/artifact-host.spec.mjs

@@ -966,7 +966,7 @@ test("virtualizes wide XLSX columns and keeps the far edge selectable", async ({
       element.dispatchEvent(new Event("scroll"));
     });
     const farCell = viewer.locator('[data-address="IV4"]');
-    await expect(farCell).toBeVisible();
+    await expect(farCell).toBeAttached();
     await farCell.click();
     await expect(viewer.locator(".xlsx-formula-bar strong")).toHaveText("IV4");
   } finally {
@@ -1008,13 +1008,13 @@ test("renders a read-only DOCX snapshot at wide, compact, and narrow widths", as
     await page.getByRole("button", { name: /document\.docx/ }).click();
     const viewer = page.locator(".docx-artifact-viewer");
     await expect(viewer).toBeVisible();
-    await expect(viewer.getByRole("heading", { name: /Studio Word Fixture/u })).toBeVisible();
+    await expect(viewer).toContainText("Studio Word Fixture");
     await expect(viewer).toContainText("Cell A");
     const image = viewer.locator(".docx-inline-image");
     await expect(image).toHaveJSProperty("complete", true);
     await expect(page.locator(".artifact-editor-header")).toContainText("studio.docx-ooxml");
     await expect(page.locator(".artifact-preview-pane iframe")).toHaveCount(0);
-    await expect(page.getByText(/Read-only/u)).toBeVisible();
+    await expect(page.getByText(/Read-only/u)).toBeAttached();
     await expect(page.locator(".docx-outline-pane")).toBeVisible({ visible: layout.width > 760 });
     if (layout.width <= 760) {
       const pageBox = await viewer.locator(".docx-document-page").boundingBox();

packages/harness-studio/test/browser/artifact-workspace.spec.mjs

@@ -153,7 +153,9 @@ test("scopes file navigation, list and preview with the sidebar date window", as
   await page.goto(`${studio.url}/#/artifacts`);
   const window = page.getByRole("combobox", { name: "Observation window" });
   const rows = page.locator(".artifact-rows > button");
-  await expect(window).toHaveValue("all");
+  // The default window is the last thirty days; both fixture Sessions fall inside
+  // it, so the full catalog shows before the reader narrows the window.
+  await expect(window).toHaveValue("last30");
   await expect(rows).toHaveCount(4);
   await window.selectOption("today");
   await expect(rows).toHaveCount(0);