@opengsd/gsd-pi 1.2.0-dev.0b870afa → 1.2.0-dev.23d85b63

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

@@ -4,7 +4,8 @@
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
 
-import { getToolSurfaceReadinessError } from "../tool-surface-readiness.ts";
+import { getToolSurfaceReadinessError, awaitWorkflowMcpToolRegistration } from "../tool-surface-readiness.ts";
+import { clearWorkflowMcpProbeCache, recordWorkflowMcpProbe } from "../workflow-mcp-readiness-cache.ts";
 import { isToolUnavailableError } from "../auto-tool-tracking.ts";
 import { classifyError, isTransient } from "../error-classifier.ts";
 import { toMcpToolName } from "../mcp-tool-name.ts";
@@ -58,18 +59,82 @@ describe("getToolSurfaceReadinessError", () => {
     assert.match(error, /gsd_uat_exec/);
   });
 
-  test("passes a still-connecting (pending) server through instead of aborting", () => {
-    // The SDK reports still-connecting servers as "pending" at init — the
-    // common healthy session. A genuine miss after pass-through is caught
-    // in-session ("No such tool available" → tool-unavailable → retry).
+  test("still blocks pending init when required tools are absent from the live surface", () => {
     const error = getToolSurfaceReadinessError({
-      unitType: "plan-slice",
+      unitType: "run-uat",
       workflowServerName: SERVER,
       observation: { tools: ["read", "bash"], mcpServers: [{ name: SERVER, status: "pending" }] },
     });
+    assert.ok(error);
+    assert.match(error!, /status is "pending"/);
+    assert.match(error!, /gsd_uat_exec/);
+  });
+
+  test("accepts pending server status when the live init surface already contains every required tool", () => {
+    const error = getToolSurfaceReadinessError({
+      unitType: "run-uat",
+      workflowServerName: SERVER,
+      observation: {
+        tools: [
+          prefixed("gsd_uat_exec"),
+          prefixed("gsd_uat_result_save"),
+          prefixed("gsd_resume"),
+          prefixed("gsd_milestone_status"),
+          prefixed("gsd_journal_query"),
+        ],
+        mcpServers: [{ name: SERVER, status: "pending" }],
+      },
+    });
     assert.equal(error, null);
   });
 
+  test("does not accept a pending live init surface just because a probe cache covers required tools", () => {
+    clearWorkflowMcpProbeCache();
+    const projectRoot = "/tmp/project-discuss-probe";
+    recordWorkflowMcpProbe(projectRoot, SERVER, [
+      "ask_user_questions",
+      "gsd_summary_save",
+      "gsd_requirement_save",
+      "gsd_requirement_update",
+      "gsd_plan_milestone",
+      "gsd_milestone_generate_id",
+    ]);
+
+    const error = getToolSurfaceReadinessError({
+      unitType: "discuss-milestone",
+      workflowServerName: SERVER,
+      projectRoot,
+      observation: {
+        tools: [],
+        mcpServers: [{ name: SERVER, status: "pending" }],
+      },
+    });
+
+    assert.ok(error, "expected live init tools to be authoritative over direct probe cache");
+    assert.match(error, /status is "pending"/);
+    assert.match(error, /ask_user_questions/);
+  });
+
+  test("pending server status reports only required tools missing from the live init surface", () => {
+    const error = getToolSurfaceReadinessError({
+      unitType: "run-uat",
+      workflowServerName: SERVER,
+      observation: {
+        tools: [
+          prefixed("gsd_uat_result_save"),
+          prefixed("gsd_resume"),
+          prefixed("gsd_milestone_status"),
+          prefixed("gsd_journal_query"),
+        ],
+        mcpServers: [{ name: SERVER, status: "pending" }],
+      },
+    });
+    assert.ok(error, "expected a readiness error while gsd_uat_exec is still absent");
+    assert.match(error, /status is "pending"/);
+    assert.match(error, /gsd_uat_exec/);
+    assert.doesNotMatch(error, /gsd_uat_result_save/);
+  });
+
   test("returns null when all required tools are registered under the MCP prefix", () => {
     const error = getToolSurfaceReadinessError({
       unitType: "run-uat",
@@ -82,7 +147,7 @@ describe("getToolSurfaceReadinessError", () => {
     assert.equal(error, null);
   });
 
-  test("reports the failed server and the missing tools when the surface never registered", () => {
+  test("reports the failed server as terminal", () => {
     const error = getToolSurfaceReadinessError({
       unitType: "run-uat",
       workflowServerName: SERVER,
@@ -90,7 +155,20 @@ describe("getToolSurfaceReadinessError", () => {
     });
     assert.ok(error, "expected a readiness error");
     assert.match(error, /workflow tool surface not ready for run-uat/);
-    assert.match(error, /status is "failed"/);
+    assert.match(error, /terminal/);
+  });
+
+  test("reports terminal status even when required tools are already on the init surface", () => {
+    const error = getToolSurfaceReadinessError({
+      unitType: "run-uat",
+      workflowServerName: SERVER,
+      observation: {
+        tools: RUN_UAT_TOOLS.map(prefixed),
+        mcpServers: [{ name: SERVER, status: "failed" }],
+      },
+    });
+    assert.ok(error, "expected a readiness error despite tools on the surface");
+    assert.match(error, /terminal/);
     assert.match(error, /gsd_uat_exec/);
   });
 
@@ -101,7 +179,7 @@ describe("getToolSurfaceReadinessError", () => {
       observation: { tools: ["read", "bash"], mcpServers: [{ name: SERVER, status: "needs-auth" }] },
     });
     assert.ok(error, "expected a readiness error for needs-auth");
-    assert.match(error, /status is "needs-auth"/);
+    assert.match(error, /terminal/);
   });
 
   test("aborts on disabled (terminal — cannot self-heal)", () => {
@@ -111,7 +189,7 @@ describe("getToolSurfaceReadinessError", () => {
       observation: { tools: ["read", "bash"], mcpServers: [{ name: SERVER, status: "disabled" }] },
     });
     assert.ok(error, "expected a readiness error for disabled");
-    assert.match(error, /status is "disabled"/);
+    assert.match(error, /terminal/);
   });
 
   test("reports partially-registered surfaces even when the server says connected", () => {
@@ -128,6 +206,102 @@ describe("getToolSurfaceReadinessError", () => {
     assert.match(error, /gsd_uat_result_save/);
     assert.doesNotMatch(error, /gsd_uat_exec,/);
   });
+
+  test("reports the screenshot case: result save registered but UAT exec missing", () => {
+    const error = getToolSurfaceReadinessError({
+      unitType: "run-uat",
+      workflowServerName: SERVER,
+      observation: {
+        tools: [
+          prefixed("gsd_uat_result_save"),
+          prefixed("gsd_resume"),
+          prefixed("gsd_milestone_status"),
+          prefixed("gsd_journal_query"),
+        ],
+        mcpServers: [{ name: SERVER, status: "connected" }],
+      },
+    });
+    assert.ok(error, "expected a readiness error when gsd_uat_exec is absent");
+    assert.match(error, /connected but has not registered/);
+    assert.match(error, /gsd_uat_exec/);
+    assert.doesNotMatch(error, /gsd_uat_result_save/);
+  });
+});
+
+describe("awaitWorkflowMcpToolRegistration", () => {
+  test("does not skip live probe when cache already covers required tools", async () => {
+    clearWorkflowMcpProbeCache();
+    const { recordWorkflowMcpProbe } = await import("../workflow-mcp-readiness-cache.ts");
+    recordWorkflowMcpProbe("/tmp/project-cache-hit", SERVER, RUN_UAT_TOOLS);
+
+    let probeCalls = 0;
+    const error = await awaitWorkflowMcpToolRegistration({
+      unitType: "run-uat",
+      workflowServerName: SERVER,
+      projectRoot: "/tmp/project-cache-hit",
+      timeoutMs: 1,
+      pollMs: 1,
+      probe: async () => {
+        probeCalls += 1;
+        return { ok: true, tools: RUN_UAT_TOOLS };
+      },
+    });
+    assert.equal(error, null);
+    assert.ok(probeCalls > 0, "preflight must probe the live MCP server even when cache is warm");
+  });
+
+  test("resolves when probe reports required tools", async () => {
+    clearWorkflowMcpProbeCache();
+    const error = await awaitWorkflowMcpToolRegistration({
+      unitType: "run-uat",
+      workflowServerName: SERVER,
+      projectRoot: "/tmp/project",
+      timeoutMs: 1_000,
+      pollMs: 1,
+      probe: async () => ({
+        ok: true,
+        tools: RUN_UAT_TOOLS,
+      }),
+    });
+    assert.equal(error, null);
+  });
+
+  test("times out when required tools never register", async () => {
+    clearWorkflowMcpProbeCache();
+    const error = await awaitWorkflowMcpToolRegistration({
+      unitType: "run-uat",
+      workflowServerName: SERVER,
+      projectRoot: "/tmp/project",
+      timeoutMs: 5,
+      pollMs: 1,
+      probe: async () => ({ ok: true, tools: ["gsd_uat_result_save"] }),
+    });
+    assert.ok(error);
+    assert.match(error!, /did not register required tools before session start/);
+  });
+
+  test("aborts while waiting for workflow MCP tools", async () => {
+    clearWorkflowMcpProbeCache();
+    const controller = new AbortController();
+    let probeCount = 0;
+    const wait = awaitWorkflowMcpToolRegistration({
+      unitType: "run-uat",
+      workflowServerName: SERVER,
+      projectRoot: "/tmp/project-abort",
+      timeoutMs: 10_000,
+      pollMs: 10_000,
+      signal: controller.signal,
+      probe: async () => {
+        probeCount += 1;
+        return { ok: true, tools: ["gsd_uat_result_save"] };
+      },
+    });
+
+    controller.abort();
+
+    await assert.rejects(wait, /AbortError/);
+    assert.equal(probeCount, 1);
+  });
 });
 
 describe("readiness error classification contract", () => {

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", () => {