gsd-pi 2.81.0 → 2.82.0-dev.2841a1e44

package/src/resources/extensions/gsd/tests/token-tool-gating.test.ts

@@ -124,6 +124,8 @@ test("buildMinimalAutoGsdToolSet includes closeout tool for complete-slice", ()
     "gsd_milestone_status",
     "gsd_checkpoint_db",
     "gsd_task_complete",
+    "gsd_task_reopen",
+    "gsd_replan_slice",
     "gsd_slice_complete",
     "gsd_complete_slice",
     "memory_query",
@@ -131,6 +133,8 @@ test("buildMinimalAutoGsdToolSet includes closeout tool for complete-slice", ()
   ], "complete-slice");
 
   assert.ok(result.includes("gsd_slice_complete"));
+  assert.ok(result.includes("gsd_task_reopen"));
+  assert.ok(result.includes("gsd_replan_slice"));
   assert.ok(result.includes("subagent"));
   assert.ok(result.includes("capture_thought"));
   assert.ok(!result.includes("gsd_task_complete"));

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

@@ -10,8 +10,9 @@ import assert from "node:assert/strict";
 import { mkdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { visibleWidth } from "@gsd/pi-tui";
 
-import { updateProgressWidget } from "../auto-dashboard.ts";
+import { setCompletionProgressWidget, updateProgressWidget } from "../auto-dashboard.ts";
 import type { GSDState } from "../types.ts";
 
 interface CapturedSetHeader {
@@ -46,6 +47,15 @@ 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) => {
@@ -208,3 +218,113 @@ test("auto-dashboard widget render output omits Ctrl+N guidance when isStepMode
 
   if (component.dispose) component.dispose();
 });
+
+test("auto-dashboard widget 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;
+
+  updateProgressWidget(
+    {
+      hasUI: true,
+      ui: {
+        setWidget(_key: string, factory: any) { widgetFactory = factory; },
+        setHeader() {},
+        setStatus() {},
+      },
+    } as any,
+    "execute-task",
+    "M001/S01/T01",
+    baseState,
+    { ...baseAccessors, getBasePath: () => dir },
+  );
+
+  assert.ok(widgetFactory);
+
+  const component = widgetFactory!(
+    { requestRender() {} },
+    {
+      fg: (_color: string, text: string) => text,
+      bold: (text: string) => text,
+    },
+  );
+  t.after(() => component.dispose?.());
+
+  for (const width of [40, 80, 120]) {
+    assertLinesFit(component.render(width), width);
+    component.invalidate();
+  }
+
+  if (component.dispose) component.dispose();
+});
+
+test("completion dashboard keeps final milestone roll-up in the progress widget", (t) => {
+  const dir = makeTempDir("completion-widget");
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  t.after(() => cleanup(dir));
+
+  let widgetFactory: ((tui: unknown, theme: unknown) => any) | undefined;
+
+  setCompletionProgressWidget(
+    {
+      hasUI: true,
+      ui: {
+        setWidget(_key: string, factory: any) { widgetFactory = factory; },
+        setHeader() {},
+        setStatus() {},
+      },
+    } as any,
+    {
+      milestoneId: "M003",
+      milestoneTitle: "Budget tracking",
+      oneLiner: "Added milestone budget warning output and provider roll-up details.",
+      successCriteriaResults: "Budget warnings appear at the end of milestone completion.",
+      requirementOutcomes: "Users can see what shipped without opening a fresh session.",
+      keyFiles: ["src/resources/extensions/gsd/auto-dashboard.ts", "src/resources/extensions/gsd/auto.ts"],
+      keyDecisions: ["Keep completion closeout in the same TUI surface."],
+      followUps: "None.",
+      reason: "Milestone M003 complete",
+      startedAt: Date.now() - 90_000,
+      totalCost: 21.29,
+      totalTokens: 1_000_000,
+      unitCount: 8,
+      cacheHitRate: 100,
+      contextPercent: 0.9,
+      contextWindow: 1_000_000,
+      completedSlices: 3,
+      totalSlices: 3,
+      basePath: dir,
+    },
+  );
+
+  assert.ok(widgetFactory, "completion 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);
+  const output = component.render(140).join("\n");
+
+  assert.match(output, /Milestone M003 roll-up/);
+  assert.match(output, /Budget tracking/);
+  assert.match(output, /Outcome/);
+  assert.match(output, /Added milestone budget warning output/);
+  assert.match(output, /What changed/);
+  assert.match(output, /Budget warnings appear/);
+  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.doesNotMatch(output, /COMPLETE-MILESTONE/);
+
+  if (component.dispose) component.dispose();
+});

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

@@ -0,0 +1,66 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for shared GSD TUI render helpers.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import { visibleWidth } from "@gsd/pi-tui";
+import {
+  padRightVisible,
+  renderFrame,
+  renderKeyHints,
+  renderProgressBar,
+  rightAlign,
+  safeLine,
+  wrapVisibleText,
+  type ThemeLike,
+} from "../tui/render-kit.ts";
+
+const theme: ThemeLike = {
+  fg: (_color: string, text: string) => text,
+  bold: (text: string) => text,
+};
+
+function assertWidth(lines: string[], width: number): void {
+  for (const line of lines) {
+    assert.ok(
+      visibleWidth(line) <= width,
+      `line exceeds width ${width}: ${visibleWidth(line)} "${line}"`,
+    );
+  }
+}
+
+describe("tui render kit", () => {
+  test("safeLine clamps visible width", () => {
+    assert.equal(visibleWidth(safeLine("abcdef", 4)), 4);
+    assert.equal(safeLine("abcdef", 0), "");
+  });
+
+  test("padRightVisible fills exact visible width", () => {
+    const line = padRightVisible("abc", 8);
+    assert.equal(visibleWidth(line), 8);
+  });
+
+  test("rightAlign keeps output within width", () => {
+    for (const width of [10, 40, 80]) {
+      assertWidth([rightAlign("left side with overflow", "right side", width)], width);
+    }
+  });
+
+  test("wrapVisibleText clamps long words and ansi-aware content", () => {
+    const lines = wrapVisibleText("https://example.com/" + "a".repeat(120), 24);
+    assert.ok(lines.length > 0);
+    assertWidth(lines, 24);
+  });
+
+  test("renderFrame keeps borders and rows within width", () => {
+    for (const width of [3, 40, 80]) {
+      assertWidth(renderFrame(theme, ["row", "long ".repeat(40)], width), width);
+    }
+  });
+
+  test("renderKeyHints and renderProgressBar fit caller budgets", () => {
+    assert.ok(visibleWidth(renderKeyHints(theme, ["↑↓ scroll", "esc close"], 12)) <= 12);
+    assert.equal(visibleWidth(renderProgressBar(theme, 2, 4, 16)), 16);
+  });
+});

package/src/resources/extensions/gsd/tests/unit-context-manifest.test.ts

@@ -7,6 +7,7 @@ import {
   ARTIFACT_KEYS,
   KNOWN_UNIT_TYPES,
   UNIT_MANIFESTS,
+  resolveSubagentPermissionContract,
   resolveManifest,
   type ArtifactKey,
   type ContextModePolicy,
@@ -244,9 +245,11 @@ test('#4934: only execute-task and reactive-execute may use tools.mode "all" (fu
 test('planning-dispatch mode is reserved for slice-level decomposition and completion units', () => {
   const allowedDispatchUnits = new Set([
     "plan-slice",
+    "research-slice",
     "refine-slice",
     "complete-slice",
     "complete-milestone",
+    "gate-evaluate",
     // Deep planning mode: research-project orchestrates 4 parallel research
     // subagents (stack/features/architecture/pitfalls). Subagent dispatch is
     // the unit's core mechanism — without it, the unit cannot do its job.
@@ -265,6 +268,24 @@ test('planning-dispatch mode is reserved for slice-level decomposition and compl
   }
 });
 
+test('Unit Tool Contract exposes subagent dispatch permissions', () => {
+  assert.deepEqual(resolveSubagentPermissionContract("plan-slice"), {
+    allowed: true,
+    allowedSubagents: ["scout", "planner"],
+    toolsMode: "planning-dispatch",
+  });
+  assert.deepEqual(resolveSubagentPermissionContract("gate-evaluate"), {
+    allowed: true,
+    allowedSubagents: ["reviewer", "security", "tester"],
+    toolsMode: "planning-dispatch",
+  });
+  assert.deepEqual(resolveSubagentPermissionContract("discuss-milestone"), {
+    allowed: false,
+    allowedSubagents: [],
+    toolsMode: "planning",
+  });
+});
+
 test('planning-dispatch manifests declare non-empty allowedSubagents lists', () => {
   for (const [unitType, manifest] of Object.entries(UNIT_MANIFESTS)) {
     if (manifest.tools.mode !== "planning-dispatch") continue;

package/src/resources/extensions/gsd/tests/verification-retry-policy.test.ts

@@ -0,0 +1,83 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for auto-mode verification retry backoff decisions.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  decideVerificationRetry,
+  hashVerificationFailureContext,
+  verificationRetryDelayMs,
+  verificationRetryKey,
+  VERIFICATION_RETRY_MAX_DELAY_MS,
+} from "../auto/verification-retry-policy.ts";
+
+test("verificationRetryDelayMs uses exponential backoff with cap", () => {
+  assert.deepEqual(verificationRetryDelayMs(1, () => 0.5), {
+    delayMs: 2_000,
+    baseDelayMs: 2_000,
+  });
+  assert.deepEqual(verificationRetryDelayMs(2, () => 0.5), {
+    delayMs: 4_000,
+    baseDelayMs: 4_000,
+  });
+  assert.deepEqual(verificationRetryDelayMs(3, () => 0.5), {
+    delayMs: 8_000,
+    baseDelayMs: 8_000,
+  });
+  assert.deepEqual(verificationRetryDelayMs(99, () => 0.5), {
+    delayMs: VERIFICATION_RETRY_MAX_DELAY_MS,
+    baseDelayMs: VERIFICATION_RETRY_MAX_DELAY_MS,
+  });
+});
+
+test("decideVerificationRetry pauses on duplicate failure context", () => {
+  const failureContext = "lint failed\n";
+  const failureHash = hashVerificationFailureContext(failureContext);
+  const decision = decideVerificationRetry({
+    unitType: "execute-task",
+    retryInfo: {
+      unitId: "M001/S01/T01",
+      failureContext,
+      attempt: 2,
+    },
+    previousFailureHash: failureHash,
+    random: () => 0.5,
+  });
+
+  assert.deepEqual(decision, {
+    action: "pause",
+    reason: "duplicate-failure-context",
+    key: verificationRetryKey("execute-task", "M001/S01/T01"),
+    failureHash,
+  });
+});
+
+test("decideVerificationRetry delays changed failure context", () => {
+  const decision = decideVerificationRetry({
+    unitType: "execute-task",
+    retryInfo: {
+      unitId: "M001/S01/T01",
+      failureContext: "test failed differently",
+      attempt: 2,
+    },
+    previousFailureHash: hashVerificationFailureContext("test failed"),
+    random: () => 0.5,
+  });
+
+  assert.equal(decision.action, "delay");
+  assert.equal(decision.key, verificationRetryKey("execute-task", "M001/S01/T01"));
+  assert.equal(decision.delayMs, 4_000);
+  assert.equal(decision.baseDelayMs, 4_000);
+});
+
+test("decideVerificationRetry pauses when retry context is missing", () => {
+  assert.deepEqual(
+    decideVerificationRetry({
+      unitType: "execute-task",
+      retryInfo: null,
+      previousFailureHash: undefined,
+    }),
+    { action: "pause", reason: "missing-retry-context" },
+  );
+});

package/src/resources/extensions/gsd/tests/verification-verdict.test.ts

@@ -0,0 +1,78 @@
+// Project/App: GSD-2
+// File Purpose: Tests for host-owned auto-mode verification verdict policy.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { decideVerificationVerdict } from "../verification-verdict.ts";
+import type { VerificationResult } from "../types.ts";
+
+function makeResult(overrides: Partial<VerificationResult> = {}): VerificationResult {
+  return {
+    passed: true,
+    checks: [],
+    discoverySource: "none",
+    timestamp: 1,
+    ...overrides,
+  };
+}
+
+test("execute-task fails closed when no host-owned checks are discovered", () => {
+  const verdict = decideVerificationVerdict("execute-task", makeResult());
+
+  assert.equal(verdict.passed, false);
+  assert.equal(verdict.reason, "no-host-checks");
+  assert.equal(verdict.retryable, false);
+  assert.match(verdict.failureContext, /No runnable host-owned verification command/);
+});
+
+test("non execute-task units preserve no-check pass semantics", () => {
+  const verdict = decideVerificationVerdict("plan-slice", makeResult());
+
+  assert.equal(verdict.passed, true);
+  assert.equal(verdict.reason, "passed");
+});
+
+test("execute-task command failure remains retryable verification failure", () => {
+  const verdict = decideVerificationVerdict(
+    "execute-task",
+    makeResult({
+      passed: false,
+      discoverySource: "package-json",
+      checks: [
+        {
+          command: "npm test",
+          exitCode: 1,
+          stdout: "",
+          stderr: "failed",
+          durationMs: 10,
+        },
+      ],
+    }),
+  );
+
+  assert.equal(verdict.passed, false);
+  assert.equal(verdict.reason, "checks-failed");
+  assert.equal(verdict.retryable, true);
+});
+
+test("execute-task passes when a discovered host check succeeds", () => {
+  const verdict = decideVerificationVerdict(
+    "execute-task",
+    makeResult({
+      discoverySource: "preference",
+      checks: [
+        {
+          command: "npm test",
+          exitCode: 0,
+          stdout: "ok",
+          stderr: "",
+          durationMs: 10,
+        },
+      ],
+    }),
+  );
+
+  assert.equal(verdict.passed, true);
+  assert.equal(verdict.reason, "passed");
+});

package/src/resources/extensions/gsd/tests/workflow-mcp.test.ts

@@ -35,6 +35,12 @@ test("auto execute-task requires canonical task completion tool", () => {
   assert.deepEqual(getRequiredWorkflowToolsForAutoUnit("execute-task"), ["gsd_task_complete"]);
 });
 
+test("complete-slice requires closeout and execution handoff tools", () => {
+  const expected = ["gsd_slice_complete", "gsd_task_reopen", "gsd_replan_slice"];
+  assert.deepEqual(getRequiredWorkflowToolsForGuidedUnit("complete-slice"), expected);
+  assert.deepEqual(getRequiredWorkflowToolsForAutoUnit("complete-slice"), expected);
+});
+
 test("deep project setup units declare required workflow MCP tools", () => {
   assert.deepEqual(getRequiredWorkflowToolsForGuidedUnit("discuss-project"), [
     "ask_user_questions",