@opengsd/gsd-pi 1.2.0-dev.fbdca60b → 1.3.0-dev.65546769

package/src/resources/extensions/gsd/tests/system-context-message-routing.test.ts

@@ -4,7 +4,35 @@
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
 
-import { buildContextMessage } from "../bootstrap/system-context.ts";
+import { buildContextMessage, stripVolatileCodebaseMetadata } from "../bootstrap/system-context.ts";
+
+describe("stripVolatileCodebaseMetadata (#847 — KV cache stability)", () => {
+  const map = [
+    "# Codebase Map",
+    "",
+    "Generated: 2026-03-23T14:00:00Z | Files: 3 | Described: 2/3",
+    `<!-- gsd:codebase-meta {"generatedAt":"2026-03-23T14:00:00Z","fingerprint":"abc","fileCount":3,"truncated":false} -->`,
+    "",
+    "### src/",
+    "- `a.ts` — does a",
+    "- `b.ts`",
+  ].join("\n");
+
+  test("removes the Generated timestamp and meta comment lines", () => {
+    const stripped = stripVolatileCodebaseMetadata(map);
+    assert.ok(!stripped.includes("Generated:"));
+    assert.ok(!stripped.includes("gsd:codebase-meta"));
+    assert.ok(stripped.includes("- `a.ts` — does a"));
+    assert.ok(stripped.includes("### src/"));
+  });
+
+  test("is stable across regenerations that only change the timestamp", () => {
+    const later = map
+      .replace("2026-03-23T14:00:00Z | Files", "2026-03-24T09:30:00Z | Files")
+      .replace('"generatedAt":"2026-03-23T14:00:00Z"', '"generatedAt":"2026-03-24T09:30:00Z"');
+    assert.equal(stripVolatileCodebaseMetadata(map), stripVolatileCodebaseMetadata(later));
+  });
+});
 
 describe("buildContextMessage (#5019 — memory routing)", () => {
   const markedMemory = "[GSD Context Metadata]\n- Memory supplied: yes\n\n[MEMORY]\nrule one";

package/src/resources/extensions/gsd/tests/terminal-tool-surface-classification.test.ts

@@ -0,0 +1,80 @@
+// Project/App: gsd-pi
+// File Purpose: Contract coverage for terminal tool-surface failure classification (#783).
+//
+// A terminal MCP server status (failed / needs-auth / disabled) must not be
+// classified as transient — retrying the same model cannot repair a dead
+// server and burns retries until the per-unit cost cap pauses auto-mode.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import { isTerminalToolSurfaceError, getToolSurfaceReadinessError, TOOL_SURFACE_NOT_READY } from "../tool-surface-readiness.ts";
+import { classifyError, isTransient } from "../error-classifier.ts";
+
+const SERVER = "gsd-workflow";
+
+function readinessFor(status: string): string {
+  return getToolSurfaceReadinessError({
+    unitType: "run-uat",
+    workflowServerName: SERVER,
+    observation: { tools: ["read"], mcpServers: [{ name: SERVER, status }] },
+  })!;
+}
+
+describe("isTerminalToolSurfaceError", () => {
+  test("recognizes every canonical terminal status", () => {
+    for (const status of ["failed", "needs-auth", "disabled"]) {
+      const error = readinessFor(status);
+      assert.ok(error, `expected a readiness error for status=${status}`);
+      assert.equal(
+        isTerminalToolSurfaceError(error),
+        true,
+        `status=${status} should be terminal`,
+      );
+    }
+  });
+
+  test("returns false for genuinely transient (not-yet-connected) variants", () => {
+    assert.equal(isTerminalToolSurfaceError(readinessFor("pending")), false);
+    assert.equal(isTerminalToolSurfaceError(readinessFor("connected")), false);
+    assert.equal(isTerminalToolSurfaceError(readinessFor("connecting")), false);
+  });
+
+  test("returns false for non-readiness and unrelated messages", () => {
+    assert.equal(isTerminalToolSurfaceError(null), false);
+    assert.equal(isTerminalToolSurfaceError(undefined), false);
+    assert.equal(isTerminalToolSurfaceError(""), false);
+    assert.equal(isTerminalToolSurfaceError("some unrelated network error"), false);
+    // A bare "(terminal)" without a real readiness prefix/status must not trip.
+    assert.equal(isTerminalToolSurfaceError("something (terminal) happened"), false);
+  });
+
+  test("the readiness prefix alone (without the terminal marker) is not terminal", () => {
+    const transientMessage = `${TOOL_SURFACE_NOT_READY} for run-uat: MCP server "${SERVER}" is absent from the init surface (not yet connected): gsd_uat_exec`;
+    assert.equal(isTerminalToolSurfaceError(transientMessage), false);
+  });
+});
+
+describe("classifyError terminal readiness contract (#783)", () => {
+  test("every terminal status classifies as non-transient permanent", () => {
+    for (const status of ["failed", "needs-auth", "disabled"]) {
+      const cls = classifyError(`Claude Code error: ${readinessFor(status)}`);
+      assert.equal(isTransient(cls), false, `status=${status} must not be transient`);
+      assert.equal(cls.kind, "permanent", `status=${status} must classify as permanent`);
+    }
+  });
+
+  test("transient not-yet-connected variants still classify as transient network", () => {
+    const cls = classifyError(`Claude Code error: ${readinessFor("pending")}`);
+    assert.equal(isTransient(cls), true);
+    assert.equal(cls.kind, "network");
+  });
+
+  test("terminal branch is matched ahead of the shared transient prefix branch", () => {
+    // The failed-status message shares the TOOL_SURFACE_NOT_READY prefix with
+    // the transient branches. If ordering regressed, this would be `network`.
+    const cls = classifyError(readinessFor("needs-auth"));
+    assert.notEqual(cls.kind, "network");
+    assert.equal(cls.kind, "permanent");
+  });
+});

package/src/resources/extensions/gsd/tests/thinking-level-resolution.test.ts

@@ -19,7 +19,7 @@ function withPreferences<T>(frontmatter: string[], fn: () => T): T {
   const home = mkdtempSync(join(tmpdir(), "gsd-thinking-"));
   try {
     process.env.GSD_HOME = home;
-    writeFileSync(join(home, "preferences.md"), ["---", ...frontmatter, "---", ""].join("\n"));
+    writeFileSync(join(home, "preferences.md"), ["---", "token_profile: burn-max", ...frontmatter, "---", ""].join("\n"));
     return fn();
   } finally {
     if (oldHome === undefined) delete process.env.GSD_HOME;

package/src/resources/extensions/gsd/tests/tool-schema-model-fallback.test.ts

@@ -0,0 +1,64 @@
+/**
+ * tool-schema-model-fallback.test.ts — Regression test for #813.
+ *
+ * Auto mode aborted with "Schema overload: consecutive tool validation
+ * failures exceeded cap" instead of recovering. The tool-schema handler now
+ * attempts the unit's configured fallbacks and the auto-mode start model (the
+ * model the user actually selected) before hard-pausing, mirroring the
+ * model-error path.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { classifyError } from "../error-classifier.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const RECOVERY_PATH = join(__dirname, "..", "bootstrap", "agent-end-recovery.ts");
+
+function getRecoverySource(): string {
+  return readFileSync(RECOVERY_PATH, "utf-8");
+}
+
+test("schema overload classifies as tool-schema (#813)", () => {
+  const cls = classifyError(
+    "Schema overload: consecutive tool validation failures exceeded cap",
+  );
+  assert.equal(cls.kind, "tool-schema");
+});
+
+test("tool-schema handler attempts model fallback before pausing (#813)", () => {
+  const src = getRecoverySource();
+
+  // Isolate the tool-schema branch body.
+  const branchStart = src.indexOf('if (cls.kind === "tool-schema")');
+  assert.ok(branchStart !== -1, "tool-schema branch must exist");
+  const branch = src.slice(branchStart, branchStart + 1200);
+
+  assert.ok(
+    branch.includes("tryProviderModelFallback"),
+    "tool-schema branch must attempt tryProviderModelFallback before pausing (#813)",
+  );
+  // Fallback success must short-circuit the pause so auto-mode continues.
+  assert.ok(
+    /if\s*\(switched\)\s*return;/.test(branch),
+    "tool-schema branch must return early when a fallback model is switched in (#813)",
+  );
+});
+
+test("tool-schema handler still pauses when no fallback succeeds (#813)", () => {
+  const src = getRecoverySource();
+
+  const branchStart = src.indexOf('if (cls.kind === "tool-schema")');
+  const branch = src.slice(branchStart, branchStart + 1200);
+
+  // The terminal pause must still classify as a tool-schema pause, not a
+  // generic provider pause.
+  assert.ok(
+    /category:\s*"tool-schema"/.test(branch),
+    "tool-schema branch must retain its tool-schema pause category when fallback fails (#813)",
+  );
+});

package/src/resources/extensions/gsd/tests/tool-search-shim.test.ts

@@ -2,6 +2,7 @@ import test from "node:test";
 import assert from "node:assert/strict";
 
 import { parseToolSearchSelectQuery } from "@gsd/pi-ai";
+import { registerToolSearchShim } from "../bootstrap/tool-search-shim.ts";
 
 test("parseToolSearchSelectQuery extracts MCP tool name", () => {
   assert.equal(
@@ -18,3 +19,73 @@ test("parseToolSearchSelectQuery returns null for non-select queries", () => {
   assert.equal(parseToolSearchSelectQuery("gsd_save_gate_result"), null);
   assert.equal(parseToolSearchSelectQuery(""), null);
 });
+
+// ── #852 follow-up: registerToolSearchShim tolerates the pre-bind runtime ──
+//
+// During extension loading, getActiveTools()/setActiveTools() are throwing
+// stubs ("Extension runtime not initialized"). The old shim called them
+// unconditionally, the throw propagated to register-extension.ts's catch,
+// and the whole "Extension setup partially failed" warning fired — which
+// under Claude Code CLI could leave workflow tools missing and trap
+// plan-milestone in a finalize-retry loop. The shim must register the tool
+// regardless and tolerate the pre-bind throw.
+
+function makeFakePi(opts: {
+  getActiveToolsThrows?: boolean;
+  setActiveToolsThrows?: boolean;
+  activeTools?: string[];
+}): {
+  registerTool(tool: { name: string }): void;
+  getActiveTools(): string[];
+  setActiveTools(tools: string[]): void;
+  registered: string[];
+  setCalls: string[][];
+} {
+  const registered: string[] = [];
+  const setCalls: string[][] = [];
+  const active = opts.activeTools ?? [];
+  return {
+    registerTool(tool) {
+      registered.push(tool.name);
+    },
+    getActiveTools() {
+      if (opts.getActiveToolsThrows) {
+        throw new Error("Extension runtime not initialized. Action methods cannot be called during extension loading.");
+      }
+      return [...active];
+    },
+    setActiveTools(tools) {
+      if (opts.setActiveToolsThrows) {
+        throw new Error("Extension runtime not initialized. Action methods cannot be called during extension loading.");
+      }
+      setCalls.push(tools);
+      active.length = 0;
+      active.push(...tools);
+    },
+    registered,
+    setCalls,
+  };
+}
+
+test("registerToolSearchShim registers the tool even when getActiveTools throws (pre-bind runtime)", () => {
+  const pi = makeFakePi({ getActiveToolsThrows: true, setActiveToolsThrows: true });
+  // Must not throw — the old code let this propagate.
+  assert.doesNotThrow(() => registerToolSearchShim(pi as any));
+  assert.ok(pi.registered.includes("ToolSearch"), "tool must be registered despite the pre-bind stubs");
+});
+
+test("registerToolSearchShim activates ToolSearch when the runtime is bound (no throw)", () => {
+  const pi = makeFakePi({ activeTools: ["bash", "read"] });
+  registerToolSearchShim(pi as any);
+  assert.ok(pi.registered.includes("ToolSearch"));
+  assert.equal(pi.setCalls.length, 1, "setActiveTools called once to add ToolSearch");
+  assert.ok(pi.setCalls[0]!.includes("ToolSearch"), "ToolSearch added to the active set");
+});
+
+test("registerToolSearchShim does not re-add ToolSearch if already active", () => {
+  const pi = makeFakePi({ activeTools: ["ToolSearch", "bash"] });
+  registerToolSearchShim(pi as any);
+  assert.ok(pi.registered.includes("ToolSearch"));
+  assert.equal(pi.setCalls.length, 0, "setActiveTools not called when ToolSearch is already active");
+});
+

package/src/resources/extensions/gsd/tests/tool-surface-readiness.test.ts

@@ -305,23 +305,42 @@ describe("awaitWorkflowMcpToolRegistration", () => {
 });
 
 describe("readiness error classification contract", () => {
-  const readinessError = getToolSurfaceReadinessError({
+  const terminalReadinessError = getToolSurfaceReadinessError({
     unitType: "run-uat",
     workflowServerName: SERVER,
     observation: { tools: [], mcpServers: [{ name: SERVER, status: "failed" }] },
   })!;
+  const transientReadinessError = getToolSurfaceReadinessError({
+    unitType: "run-uat",
+    workflowServerName: SERVER,
+    observation: { tools: [], mcpServers: [{ name: SERVER, status: "pending" }] },
+  })!;
 
-  test("auto-tool-tracking treats the readiness error as tool-unavailable", () => {
-    assert.equal(isToolUnavailableError(readinessError), true);
+  test("auto-tool-tracking treats both readiness error variants as tool-unavailable", () => {
+    assert.equal(isToolUnavailableError(terminalReadinessError), true);
+    assert.equal(isToolUnavailableError(transientReadinessError), true);
   });
 
-  test("error-classifier treats the readiness error as transient", () => {
-    const cls = classifyError(`Claude Code error: ${readinessError}`);
+  test("error-classifier treats a TERMINAL readiness error as non-transient (#783)", () => {
+    const cls = classifyError(`Claude Code error: ${terminalReadinessError}`);
+    assert.equal(isTransient(cls), false);
+    assert.equal(cls.kind, "permanent");
+  });
+
+  test("error-classifier still treats a TRANSIENT readiness error as transient", () => {
+    const cls = classifyError(`Claude Code error: ${transientReadinessError}`);
     assert.equal(isTransient(cls), true);
+    assert.equal(cls.kind, "network");
+  });
+
+  test("Recovery Classification escalates a TERMINAL readiness error instead of retrying (#783)", () => {
+    const recovery = classifyFailure({ error: new Error(terminalReadinessError), unitType: "run-uat", unitId: "M001" });
+    assert.equal(recovery.action, "escalate");
+    assert.notEqual(recovery.failureKind, "tool-unavailable");
   });
 
-  test("Recovery Classification maps the readiness error to tool-unavailable → retry", () => {
-    const recovery = classifyFailure({ error: new Error(readinessError), unitType: "run-uat", unitId: "M001" });
+  test("Recovery Classification still retries a TRANSIENT readiness error", () => {
+    const recovery = classifyFailure({ error: new Error(transientReadinessError), unitType: "run-uat", unitId: "M001" });
     assert.equal(recovery.failureKind, "tool-unavailable");
     assert.equal(recovery.action, "retry");
     assert.equal(recovery.exitReason, "tool-unavailable");

package/src/resources/extensions/gsd/tests/tool-unavailable-retry.test.ts

@@ -31,3 +31,26 @@ describe("toolUnavailableRetries on AutoSession", () => {
     assert.equal(s.toolUnavailableRetries, 3);
   });
 });
+
+describe("tool-unavailable retry backoff (#817)", () => {
+  // Mirrors the delay formula in auto-post-unit.ts. The MCP workflow server can
+  // take tens of seconds to finish connecting, so the backoff must start high
+  // enough that re-dispatch does not land before the server is ready.
+  const backoffMs = (retry: number) =>
+    Math.min(10_000 * Math.pow(2, retry - 1), 45_000);
+
+  test("starts at 10s, doubles, and caps at 45s", () => {
+    assert.equal(backoffMs(1), 10_000);
+    assert.equal(backoffMs(2), 20_000);
+    assert.equal(backoffMs(3), 40_000);
+  });
+
+  test("never exceeds the 45s cap", () => {
+    assert.equal(backoffMs(4), 45_000);
+    assert.equal(backoffMs(10), 45_000);
+  });
+
+  test("first retry survives a multi-second MCP startup (regression for 1s delay)", () => {
+    assert.ok(backoffMs(1) >= 10_000, "first retry must wait at least 10s");
+  });
+});

package/src/resources/extensions/gsd/tests/tui-header-lifecycle.test.ts

@@ -10,14 +10,18 @@ import assert from "node:assert/strict";
 import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { visibleWidth } from "@gsd/pi-tui";
-
 import {
   _resetWidgetModeForTests,
   setCompletionProgressWidget,
   setWidgetMode,
   updateProgressWidget,
 } from "../auto-dashboard.ts";
+import {
+  createProgressStripUiMock,
+  renderProgressStrip,
+  renderProgressStripLines,
+  assertLinesFit,
+} from "./progress-strip-test-helpers.ts";
 import type { GSDState } from "../types.ts";
 
 interface CapturedSetHeader {
@@ -52,15 +56,6 @@ const baseAccessors = {
   getCurrentDispatchedModelId: () => null,
 };
 
-function assertLinesFit(lines: string[], width: number): void {
-  for (const line of lines) {
-    assert.ok(
-      visibleWidth(line) <= width,
-      `line exceeds width ${width}: ${visibleWidth(line)} "${line}"`,
-    );
-  }
-}
-
 // ── Header lifecycle ────────────────────────────────────────────────────
 
 test("updateProgressWidget installs an EMPTY-rendering header (not undefined) — addresses codex P1 finding that setHeader(undefined) restores the built-in logo+instructions header", (t) => {
@@ -148,7 +143,7 @@ test("updateProgressWidget gracefully no-ops when ctx.ui lacks setHeader/setStat
 
 // ── NEXT-mode footer guidance ───────────────────────────────────────────
 
-test("auto-dashboard full widget render output includes /gsd next guidance when isStepMode is true", (t) => {
+test("progress strip uses NEXT mode tag when step mode is active", (t) => {
   const dir = makeTempDir("step-hint");
   mkdirSync(join(dir, ".gsd"), { recursive: true });
   const projectPrefsPath = join(dir, ".gsd", "preferences.md");
@@ -156,21 +151,17 @@ test("auto-dashboard full widget render output includes /gsd next guidance when
   writeFileSync(projectPrefsPath, "---\nversion: 1\n---\n", "utf-8");
   _resetWidgetModeForTests();
   setWidgetMode("full", projectPrefsPath, globalPrefsPath);
+  const mock = createProgressStripUiMock();
   t.after(() => {
+    mock.disposeProgress();
     _resetWidgetModeForTests();
     cleanup(dir);
   });
 
-  let widgetFactory: ((tui: unknown, theme: unknown) => any) | undefined;
-
   updateProgressWidget(
     {
       hasUI: true,
-      ui: {
-        setWidget(_key: string, factory: any) { widgetFactory = factory; },
-        setHeader() {},
-        setStatus() {},
-      },
+      ui: mock.ui,
     } as any,
     "execute-task",
     "M001/S01/T01",
@@ -178,24 +169,14 @@ test("auto-dashboard full widget render output includes /gsd next guidance when
     { ...baseAccessors, getBasePath: () => dir, isStepMode: () => true },
   );
 
-  assert.ok(widgetFactory, "widget factory must be installed");
-
-  const fakeTui = { requestRender() {} };
-  const fakeTheme = {
-    fg: (_color: string, text: string) => text,
-    bold: (text: string) => text,
-  };
-  const component = widgetFactory!(fakeTui, fakeTheme);
-  t.after(() => component.dispose?.());
-  const lines = component.render(120);
-
-  const hasStepHint = lines.some((line: string) => line.includes("/gsd next to advance one step"));
-  assert.ok(hasStepHint, `expected step-mode hint in render output; got:\n${lines.join("\n")}`);
-
-  if (component.dispose) component.dispose();
+  const progress = mock.getProgressState();
+  assert.ok(progress, "progress strip state should be published");
+  assert.equal(progress!.modeTag, "NEXT");
+  const rendered = renderProgressStrip(progress!, 120, { cwd: dir });
+  assert.match(rendered, /NEXT/);
 });
 
-test("auto-dashboard full widget render output omits /gsd next guidance when isStepMode is false", (t) => {
+test("progress strip uses AUTO mode tag when step mode is inactive", (t) => {
   const dir = makeTempDir("no-step-hint");
   mkdirSync(join(dir, ".gsd"), { recursive: true });
   const projectPrefsPath = join(dir, ".gsd", "preferences.md");
@@ -203,21 +184,17 @@ test("auto-dashboard full widget render output omits /gsd next guidance when isS
   writeFileSync(projectPrefsPath, "---\nversion: 1\n---\n", "utf-8");
   _resetWidgetModeForTests();
   setWidgetMode("full", projectPrefsPath, globalPrefsPath);
+  const mock = createProgressStripUiMock();
   t.after(() => {
+    mock.disposeProgress();
     _resetWidgetModeForTests();
     cleanup(dir);
   });
 
-  let widgetFactory: ((tui: unknown, theme: unknown) => any) | undefined;
-
   updateProgressWidget(
     {
       hasUI: true,
-      ui: {
-        setWidget(_key: string, factory: any) { widgetFactory = factory; },
-        setHeader() {},
-        setStatus() {},
-      },
+      ui: mock.ui,
     } as any,
     "execute-task",
     "M001/S01/T01",
@@ -225,38 +202,27 @@ test("auto-dashboard full widget render output omits /gsd next guidance when isS
     { ...baseAccessors, getBasePath: () => dir, isStepMode: () => false },
   );
 
-  assert.ok(widgetFactory);
-
-  const fakeTui = { requestRender() {} };
-  const fakeTheme = {
-    fg: (_color: string, text: string) => text,
-    bold: (text: string) => text,
-  };
-  const component = widgetFactory!(fakeTui, fakeTheme);
-  t.after(() => component.dispose?.());
-  const lines = component.render(120);
-
-  const hasStepHint = lines.some((line: string) => line.includes("/gsd next to advance one step"));
-  assert.equal(hasStepHint, false, "step-mode hint must NOT appear when isStepMode is false");
-
-  if (component.dispose) component.dispose();
+  const progress = mock.getProgressState();
+  assert.ok(progress, "progress strip state should be published");
+  assert.equal(progress!.modeTag, "AUTO");
+  const rendered = renderProgressStrip(progress!, 120, { cwd: dir });
+  assert.match(rendered, /AUTO/);
+  assert.doesNotMatch(rendered, /NEXT/);
 });
 
-test("auto-dashboard widget render output fits common terminal widths", (t) => {
+test("progress strip render output fits common terminal widths", (t) => {
   const dir = makeTempDir("width-safe");
   mkdirSync(join(dir, ".gsd"), { recursive: true });
-  t.after(() => cleanup(dir));
-
-  let widgetFactory: ((tui: unknown, theme: unknown) => any) | undefined;
+  const mock = createProgressStripUiMock();
+  t.after(() => {
+    mock.disposeProgress();
+    cleanup(dir);
+  });
 
   updateProgressWidget(
     {
       hasUI: true,
-      ui: {
-        setWidget(_key: string, factory: any) { widgetFactory = factory; },
-        setHeader() {},
-        setStatus() {},
-      },
+      ui: mock.ui,
     } as any,
     "execute-task",
     "M001/S01/T01",
@@ -264,23 +230,12 @@ test("auto-dashboard widget render output fits common terminal widths", (t) => {
     { ...baseAccessors, getBasePath: () => dir },
   );
 
-  assert.ok(widgetFactory);
-
-  const component = widgetFactory!(
-    { requestRender() {} },
-    {
-      fg: (_color: string, text: string) => text,
-      bold: (text: string) => text,
-    },
-  );
-  t.after(() => component.dispose?.());
+  const progress = mock.getProgressState();
+  assert.ok(progress, "progress strip state should be published");
 
   for (const width of [40, 80, 120]) {
-    assertLinesFit(component.render(width), width);
-    component.invalidate();
+    assertLinesFit(renderProgressStripLines(progress!, width, { cwd: dir }), width);
   }
-
-  if (component.dispose) component.dispose();
 });
 
 test("completion dashboard keeps final milestone roll-up in the progress widget", (t) => {
@@ -341,12 +296,11 @@ test("completion dashboard keeps final milestone roll-up in the progress widget"
   assert.match(output, /Users can see what shipped/);
   assert.match(output, /Keep completion closeout/);
   assert.match(output, /Verification/);
-  assert.match(output, /Files: src\/resources\/extensions\/gsd\/auto-dashboard\.ts/);
-  assert.match(output, /Run totals 3\/3 slices/);
-  assert.match(output, /100% cache hit/);
-  assert.match(output, /\$21\.29/);
-  assert.match(output, /1\.0M tokens/);
-  assert.match(output, /8 units/);
+  assert.match(output, /Files:/);
+  assert.match(output, /auto-dashboard\.ts/);
+  assert.doesNotMatch(output, /Run totals/);
+  assert.doesNotMatch(output, /\$21\.29/);
+  assert.doesNotMatch(output, /1\.0M tokens/);
   assert.doesNotMatch(output, /COMPLETE-MILESTONE/);
 
   if (component.dispose) component.dispose();

package/src/resources/extensions/gsd/tests/tui-render-kit.test.ts

@@ -12,6 +12,7 @@ import {
   renderFrame,
   renderKeyHints,
   renderPanel,
+  renderPlainOutcome,
   renderProgressBar,
   rightAlign,
   safeLine,
@@ -86,13 +87,50 @@ describe("tui render kit", () => {
     }
   });
 
-  test("renderPanel indents body lines so chrome never sits on copyable text", () => {
+  test("renderPanel keeps body on dedicated lines without vertical borders", () => {
     const lines = renderPanel(theme, "Title", ["body"], 40);
-    // [header, blank, body, footer rule]
-    const body = lines[2];
-    assert.ok(body.startsWith("  body"), `body should be indented: "${body}"`);
-    assert.match(lines[0], /^── Title ─+$/, "header is an inline-titled rule");
-    assert.match(lines[lines.length - 1], /^─+$/, "panel closes with a plain rule");
+    const body = lines[1];
+    assert.match(body, /^body/, `body line should start with copyable text: "${body}"`);
+    assert.match(lines[0] ?? "", /^──+ .* ─+$/);
+    assert.match(lines.at(-1) ?? "", /^─+$/);
+    for (const line of lines) {
+      assert.ok(!line.includes("│"), `renderPanel line must not contain a vertical bar: "${line}"`);
+    }
+  });
+
+  test("renderPlainOutcome uses a chat-style header without rule borders", () => {
+    const lines = renderPlainOutcome(
+      theme,
+      60,
+      "✓ Milestone M002 complete",
+      ["Dark Mode. Milestone M002 complete.", "Next · Review the closeout."],
+    );
+    assertWidth(lines, 60);
+    assert.match(lines[0] ?? "", /^GSD · /);
+    assert.doesNotMatch(lines.join("\n"), /^─/m);
+    for (const line of lines) {
+      assert.ok(!line.includes("│"), `plain outcome must not use vertical bars: "${line}"`);
+    }
+  });
+
+  test("renderPlainOutcome spreads header meta and footer commands to the right edge", () => {
+    const width = 80;
+    const lines = renderPlainOutcome(
+      theme,
+      width,
+      "● Step complete",
+      ["Next · Advance one step."],
+      {
+        headerRight: "2m 05s",
+        footerRight: "/gsd next  ·  /gsd auto",
+      },
+    );
+    assertWidth(lines, width);
+    const header = lines[0] ?? "";
+    const footer = lines.at(-2) ?? "";
+    assert.ok(header.endsWith("2m 05s"), `elapsed should be right-aligned: "${header}"`);
+    assert.ok(footer.endsWith("/gsd auto"), `commands should be right-aligned: "${footer}"`);
+    assert.ok(visibleWidth(header) >= width - 1, "header should use full row width");
   });
 
   test("renderKeyHints and renderProgressBar fit caller budgets", () => {