gsd-pi 2.77.0 → 2.78.0-dev.aeeb2ca00

package/src/resources/extensions/gsd/tests/require-slice-discussion-dispatch.test.ts

@@ -0,0 +1,170 @@
+/**
+ * Regression tests for #3454: auto-dispatch must honour
+ * require_slice_discussion and pause before plan-slice when:
+ *   1. state.phase === "planning"
+ *   2. require_slice_discussion is enabled in preferences
+ *   3. state.activeSlice is non-null
+ *   4. the slice has no CONTEXT file on disk
+ *
+ * Exercises the dispatch rule from DISPATCH_RULES directly with a
+ * DispatchContext built against a real temp directory — no source-string
+ * matching, no brittle rename dependencies.
+ */
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { DISPATCH_RULES, type DispatchContext } from "../auto-dispatch.ts";
+import type { GSDState } from "../types.ts";
+import type { GSDPreferences } from "../preferences.ts";
+
+// Use a stable token (the preference name) for rule lookup instead of the
+// full human-readable title — copy edits to the rule name will not break
+// these tests as long as the rule still references the preference it gates.
+const RULE_NAME_TOKEN = "require_slice_discussion";
+
+function findRule() {
+  const matches = DISPATCH_RULES.filter(r => r.name.includes(RULE_NAME_TOKEN));
+  if (matches.length !== 1) {
+    throw new Error(`expected exactly one dispatch rule containing "${RULE_NAME_TOKEN}", found ${matches.length}`);
+  }
+  return matches[0];
+}
+
+function buildState(overrides: Partial<GSDState> = {}): GSDState {
+  return {
+    activeMilestone: { id: "M001", title: "Test milestone" },
+    activeSlice: { id: "S01", title: "Test slice" },
+    activeTask: null,
+    phase: "planning",
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "",
+    registry: [],
+    ...overrides,
+  };
+}
+
+function makeBasePath(prefix: string): string {
+  const dir = mkdtempSync(join(tmpdir(), `gsd-req-slice-${prefix}-`));
+  mkdirSync(join(dir, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
+  return dir;
+}
+
+function buildCtx(
+  basePath: string,
+  prefs: GSDPreferences | undefined,
+  state: GSDState = buildState(),
+): DispatchContext {
+  return {
+    basePath,
+    mid: "M001",
+    midTitle: "Test milestone",
+    state,
+    prefs,
+  };
+}
+
+describe("require_slice_discussion dispatch rule (#3454)", () => {
+  // ─── Positive case: rule fires ────────────────────────────────────────
+
+  test("returns stop action when preference enabled and CONTEXT missing", async () => {
+    const basePath = makeBasePath("fire");
+    try {
+      const prefs = { phases: { require_slice_discussion: true } } as unknown as GSDPreferences;
+      const action = await findRule().match(buildCtx(basePath, prefs));
+      assert.ok(action, "rule must return a non-null action when pausing is required");
+      assert.strictEqual(action!.action, "stop");
+      if (action!.action === "stop") {
+        assert.match(action!.reason, /S01/);
+        assert.match(action!.reason, /require_slice_discussion/);
+        assert.match(action!.reason, /\/gsd discuss/);
+        assert.strictEqual(action!.level, "info");
+      }
+    } finally {
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+
+  // ─── Negative cases: rule falls through ───────────────────────────────
+
+  test("falls through (null) when preference is disabled", async () => {
+    const basePath = makeBasePath("pref-disabled");
+    try {
+      const prefs = { phases: { require_slice_discussion: false } } as unknown as GSDPreferences;
+      const action = await findRule().match(buildCtx(basePath, prefs));
+      assert.strictEqual(action, null);
+    } finally {
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+
+  test("falls through (null) when preference is absent / undefined", async () => {
+    const basePath = makeBasePath("pref-absent");
+    try {
+      const action = await findRule().match(buildCtx(basePath, undefined));
+      assert.strictEqual(action, null);
+    } finally {
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+
+  test("falls through (null) when phase is not 'planning'", async () => {
+    const basePath = makeBasePath("wrong-phase");
+    try {
+      const prefs = { phases: { require_slice_discussion: true } } as unknown as GSDPreferences;
+      const state = buildState({ phase: "executing" });
+      const action = await findRule().match(buildCtx(basePath, prefs, state));
+      assert.strictEqual(action, null);
+    } finally {
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+
+  test("falls through (null) when no active slice", async () => {
+    const basePath = makeBasePath("no-slice");
+    try {
+      const prefs = { phases: { require_slice_discussion: true } } as unknown as GSDPreferences;
+      const state = buildState({ activeSlice: null });
+      const action = await findRule().match(buildCtx(basePath, prefs, state));
+      assert.strictEqual(action, null);
+    } finally {
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+
+  // ─── Context-file present: should not pause ───────────────────────────
+
+  test("falls through (null) when CONTEXT file already exists on disk", async () => {
+    const basePath = makeBasePath("ctx-present");
+    try {
+      // Seed the CONTEXT file that /gsd discuss would have written.
+      const sliceDir = join(basePath, ".gsd", "milestones", "M001", "slices", "S01");
+      writeFileSync(join(sliceDir, "S01-CONTEXT.md"), "# Discussion notes\n", "utf-8");
+
+      const prefs = { phases: { require_slice_discussion: true } } as unknown as GSDPreferences;
+      const action = await findRule().match(buildCtx(basePath, prefs));
+      assert.strictEqual(
+        action,
+        null,
+        "once the slice has a CONTEXT file, the rule must fall through so planning proceeds",
+      );
+    } finally {
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+
+  // ─── Rule ordering: must run before the plan-slice rule ──────────────
+
+  test("rule is ordered before the 'planning → plan-slice' rule", () => {
+    const discussIdx = DISPATCH_RULES.findIndex(r => r.name.includes(RULE_NAME_TOKEN));
+    const planIdx = DISPATCH_RULES.findIndex(r => r.name.startsWith("planning → plan-slice"));
+    assert.ok(discussIdx >= 0, "require_slice_discussion rule must be registered");
+    assert.ok(planIdx >= 0, "plan-slice rule must be registered");
+    assert.ok(
+      discussIdx < planIdx,
+      "require_slice_discussion rule must be ordered before plan-slice so it preempts dispatch",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/research-milestone-composer.test.ts

@@ -0,0 +1,114 @@
+// GSD-2 — #4782 phase 3 batch 2: research-milestone migrated through composer.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { buildResearchMilestonePrompt } from "../auto-prompts.ts";
+import { invalidateAllCaches } from "../cache.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  upsertMilestonePlanning,
+  insertArtifact,
+} from "../gsd-db.ts";
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-research-ms-composer-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  invalidateAllCaches();
+  rmSync(base, { recursive: true, force: true });
+}
+
+function seed(base: string, mid: string): void {
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: mid, title: "Research Test", status: "active", depends_on: [] });
+  upsertMilestonePlanning(mid, {
+    title: "Research Test",
+    status: "active",
+    vision: "Research composer migration",
+    successCriteria: ["Prompt compiles"],
+    keyRisks: [],
+    proofStrategy: [],
+    verificationContract: "",
+    verificationIntegration: "",
+    verificationOperational: "",
+    verificationUat: "",
+    definitionOfDone: [],
+    requirementCoverage: "",
+    boundaryMapMarkdown: "",
+  });
+}
+
+test("#4782 phase 3: buildResearchMilestonePrompt emits milestone-context then research template via composer", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seed(base, "M001");
+
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
+    "# M001 Context\n\nA research test milestone.\n",
+  );
+
+  const prompt = await buildResearchMilestonePrompt("M001", "Research Test", base);
+
+  // Context wrapper present
+  assert.match(prompt, /## Inlined Context \(preloaded — do not re-read these files\)/);
+
+  // Milestone context inlined first (manifest order)
+  assert.match(prompt, /### Milestone Context/);
+  assert.match(prompt, /A research test milestone/);
+
+  // Research template inlined as the templates artifact
+  assert.match(prompt, /### Output Template: Research/);
+
+  // Ordering: milestone-context precedes the research template
+  const contextIdx = prompt.indexOf("### Milestone Context");
+  const researchIdx = prompt.indexOf("### Output Template: Research");
+  assert.ok(contextIdx > -1 && researchIdx > contextIdx,
+    `milestone-context (${contextIdx}) must precede research template (${researchIdx})`);
+});
+
+test("#4782 phase 3: buildResearchMilestonePrompt preserves manifest order across optional artifacts (#4925 review)", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seed(base, "M001");
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"), "# M001 Context\n");
+  // Seed PROJECT.md into the artifacts table so inlineProjectFromDb resolves
+  // to a non-null body. Lets us verify the project block sits between
+  // milestone-context and the templates block per manifest order.
+  insertArtifact({
+    path: "PROJECT.md",
+    artifact_type: "project",
+    milestone_id: null,
+    slice_id: null,
+    task_id: null,
+    full_content: "# Project\n\nResearch composer fixture project.\n",
+  });
+
+  const prompt = await buildResearchMilestonePrompt("M001", "Research Test", base);
+
+  // Manifest-declared order: milestone-context, project, requirements, decisions, templates.
+  const contextIdx = prompt.indexOf("### Milestone Context");
+  const projectIdx = prompt.indexOf("### Project");
+  const researchIdx = prompt.indexOf("### Output Template: Research");
+  assert.ok(contextIdx > -1, "milestone-context block missing");
+  assert.ok(projectIdx > -1, "project block missing — seed should have populated it");
+  assert.ok(researchIdx > -1, "research template block missing");
+  assert.ok(
+    contextIdx < projectIdx && projectIdx < researchIdx,
+    `manifest order violated: milestone-context (${contextIdx}) < project (${projectIdx}) < research-template (${researchIdx})`,
+  );
+});

package/src/resources/extensions/gsd/tests/restore-tools-after-discuss.test.ts

@@ -13,6 +13,7 @@ import { describe, it } from 'node:test'
 import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
 import { resolve } from 'node:path'
+import { extractSourceRegion } from "./test-helpers.ts";
 
 const src = readFileSync(
   resolve(process.cwd(), 'src', 'resources', 'extensions', 'gsd', 'guided-flow.ts'),
@@ -37,7 +38,7 @@ describe('restore tools after discuss flow scoping (#3628)', () => {
     assert.ok(discussCheck !== -1)
 
     // Look for savedTools assignment within the discuss block
-    const blockAfter = src.slice(discussCheck, discussCheck + 500)
+    const blockAfter = extractSourceRegion(src, 'if (unitType?.startsWith("discuss-"))')
     assert.ok(
       blockAfter.includes('savedTools = currentTools'),
       'savedTools must be assigned from currentTools inside the discuss block',
@@ -55,8 +56,10 @@ describe('restore tools after discuss flow scoping (#3628)', () => {
     const sendMsg = src.indexOf('triggerTurn: true', savedToolsAssign)
     assert.ok(sendMsg !== -1, 'discuss-flow sendMessage with triggerTurn must exist after savedTools capture')
 
-    // After sendMessage, savedTools should be restored via setActiveTools
-    const afterSend = src.slice(sendMsg, sendMsg + 500)
+    // After sendMessage, savedTools should be restored via setActiveTools.
+    // Use fromIdx to anchor at the discuss-flow sendMessage, not the first
+    // triggerTurn: true occurrence in the file.
+    const afterSend = extractSourceRegion(src, 'triggerTurn: true', { fromIdx: savedToolsAssign })
     assert.ok(
       afterSend.includes('if (savedTools)'),
       'savedTools restoration guard must exist after sendMessage',

package/src/resources/extensions/gsd/tests/rewrite-docs-abandon-detect.test.ts

@@ -0,0 +1,195 @@
+/**
+ * Regression tests for #3490: post-unit handler for rewrite-docs must
+ * detect abandon/descope overrides that target the current milestone and
+ * park it — without false-positive parking on unrelated scope-change
+ * overrides that merely contain an abandon-family verb.
+ *
+ * Exercises detectAbandonMilestone() directly — a pure function over
+ * Override objects, no I/O and no production-code import chain.
+ * parkMilestone() end-to-end behavior is covered by the existing
+ * park-milestone.test.ts / park-edge-cases.test.ts / park-db-sync.test.ts
+ * suites; here we only validate the decision layer that feeds it.
+ */
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { detectAbandonMilestone } from "../abandon-detect.ts";
+import type { Override } from "../files.ts";
+
+function mkOverride(change: string): Override {
+  return {
+    timestamp: "2026-04-21T00:00:00.000Z",
+    change,
+    scope: "active",
+    appliedAt: "M001/S01/T01",
+  };
+}
+
+describe("detectAbandonMilestone (#3490)", () => {
+  test("parks on explicit abandon-milestone phrasing", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("abandon this milestone, it's no longer relevant")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, true);
+    assert.strictEqual(d.matched.length, 1);
+    assert.match(d.reason, /abandon this milestone/);
+  });
+
+  test("parks on descope-milestone phrasing", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("descope the entire milestone")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, true);
+  });
+
+  test("parks when override references milestone by ID instead of the word", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("shelve M003 for now, coming back next quarter")],
+      "M003",
+    );
+    assert.strictEqual(d.shouldPark, true);
+    assert.strictEqual(d.matched[0], "shelve M003 for now, coming back next quarter");
+  });
+
+  test("parks on past-tense / gerund verb forms (UK spelling)", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("this milestone was cancelled by product")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, true);
+  });
+
+  test("parks on US spelling 'canceled' (single-l)", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("the milestone was canceled by the PM")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, true);
+  });
+
+  test("parks on hyphenated 'de-scope' variant", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("de-scope this milestone — moved to v2")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, true);
+  });
+
+  test("parks on space-separated 'de scope' variant", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("de scope the milestone entirely")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, true);
+  });
+
+  test("parks on 'de-scoped' past-tense hyphen variant", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("M003 was de-scoped last week")],
+      "M003",
+    );
+    assert.strictEqual(d.shouldPark, true);
+  });
+
+  // ─── False-positive guards ────────────────────────────────────────────
+
+  test("does NOT park on 'cancel the standup reminder' (no milestone ref)", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("cancel the daily standup reminder")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, false);
+    assert.deepStrictEqual(d.matched, []);
+  });
+
+  test("does NOT park on 'drop the dependency on X' (no milestone ref)", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("drop the dependency on X and use Y instead")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, false);
+  });
+
+  test("does NOT park on 'scrap the v1 design' (no milestone ref)", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("scrap the v1 design for the landing page")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, false);
+  });
+
+  test("does NOT park on override with milestone word but no abandon verb", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("change the milestone title to something clearer")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, false);
+  });
+
+  test("does NOT park when a different milestone ID is referenced", () => {
+    // The abandon verb is present and an MID is present, but the MID is
+    // not the current milestone. We require either the literal word
+    // "milestone" OR the current MID — a reference to a different MID
+    // (M007) with neither the word "milestone" nor the current ID (M001)
+    // should not trigger.
+    const d = detectAbandonMilestone(
+      [mkOverride("drop M007")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, false);
+  });
+
+  // ─── Edge cases ───────────────────────────────────────────────────────
+
+  test("empty overrides list returns no-park", () => {
+    const d = detectAbandonMilestone([], "M001");
+    assert.strictEqual(d.shouldPark, false);
+    assert.deepStrictEqual(d.matched, []);
+  });
+
+  test("null/undefined currentMilestoneId returns no-park even with matching text", () => {
+    const d1 = detectAbandonMilestone(
+      [mkOverride("abandon this milestone")],
+      null,
+    );
+    assert.strictEqual(d1.shouldPark, false);
+
+    const d2 = detectAbandonMilestone(
+      [mkOverride("abandon this milestone")],
+      undefined,
+    );
+    assert.strictEqual(d2.shouldPark, false);
+  });
+
+  test("multiple abandon overrides are concatenated in reason", () => {
+    const d = detectAbandonMilestone(
+      [
+        mkOverride("abandon this milestone"),
+        mkOverride("cancel the standup"),           // filtered out (no ref)
+        mkOverride("descope the milestone entirely"),
+      ],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, true);
+    assert.strictEqual(d.matched.length, 2, "only the two milestone-scoped overrides match");
+    assert.match(d.reason, /abandon this milestone/);
+    assert.match(d.reason, /descope the milestone entirely/);
+    assert.doesNotMatch(d.reason, /cancel the standup/);
+  });
+
+  // ─── Regex-injection guard on milestone ID ────────────────────────────
+
+  test("milestone ID with regex metacharacters is escaped, not interpreted", () => {
+    // A pathological MID should not break the matcher — the function
+    // escapes regex metacharacters before building the pattern.
+    const d = detectAbandonMilestone(
+      [mkOverride("abandon M.01 the milestone")],
+      "M.01",
+    );
+    // 'milestone' is present, so this parks regardless of escaping,
+    // but the test confirms the RegExp construction does not throw.
+    assert.strictEqual(d.shouldPark, true);
+  });
+});
+

package/src/resources/extensions/gsd/tests/run-uat-composer.test.ts

@@ -0,0 +1,148 @@
+// GSD-2 — #4782 phase 3: run-uat migrated to compose context via manifest.
+// Regression test: prompt still carries the declared artifacts in the
+// expected shape after the migration.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { buildRunUatPrompt } from "../auto-prompts.ts";
+import { invalidateAllCaches } from "../cache.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  upsertMilestonePlanning,
+  insertSlice,
+  insertArtifact,
+} from "../gsd-db.ts";
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-runuat-composer-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  invalidateAllCaches();
+  rmSync(base, { recursive: true, force: true });
+}
+
+function seed(base: string, mid: string): void {
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: mid, title: "Test", status: "active", depends_on: [] });
+  upsertMilestonePlanning(mid, {
+    title: "Test Milestone",
+    status: "active",
+    vision: "Demo the composer migration",
+    successCriteria: ["Prompt compiles", "UAT passes"],
+    keyRisks: [],
+    proofStrategy: [],
+    verificationContract: "",
+    verificationIntegration: "",
+    verificationOperational: "",
+    verificationUat: "",
+    definitionOfDone: [],
+    requirementCoverage: "",
+    boundaryMapMarkdown: "",
+  });
+  insertSlice({
+    id: "S01",
+    milestoneId: mid,
+    title: "First",
+    status: "complete",
+    risk: "low",
+    depends: [],
+    demo: "",
+    sequence: 1,
+  });
+  // Seed PROJECT.md so inlineProjectFromDb resolves — the run-uat manifest
+  // declares "project" as the third inline artifact (#4925 review).
+  insertArtifact({
+    path: "PROJECT.md",
+    artifact_type: "project",
+    milestone_id: null,
+    slice_id: null,
+    task_id: null,
+    full_content: "# Project\n\nRun-UAT composer fixture project.\n",
+  });
+}
+
+test("#4782 phase 3: buildRunUatPrompt inlines slice UAT, slice summary, project via composer", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seed(base, "M001");
+
+  // Write UAT + SUMMARY files. Deliberately diverge the on-disk UAT body
+  // from the in-memory uatContent the caller passes — if the resolver
+  // ever re-reads disk (the bug fixed in fcf3bfbe), this test fails
+  // because the prompt would contain "stale on-disk body" instead of
+  // "fresh in-memory snapshot" (#4925 follow-up review).
+  const uatRel = ".gsd/milestones/M001/slices/S01/S01-UAT.md";
+  writeFileSync(join(base, uatRel), "# S01 UAT\n\n- stale on-disk body\n");
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md"),
+    "---\nid: S01\nparent: M001\n---\n# S01 Summary\n**One-liner**\n\n## What Happened\nShip.\n",
+  );
+
+  const uatContent = "# S01 UAT\n\n- Check X\n- Check Y\n  (fresh in-memory snapshot)\n";
+  const prompt = await buildRunUatPrompt("M001", "S01", uatRel, uatContent, base);
+
+  // Context wrapper present
+  assert.match(prompt, /## Inlined Context \(preloaded — do not re-read these files\)/);
+
+  // Artifacts from the manifest inline list, in declared order:
+  // slice-uat → slice-summary → project (#4925 review).
+  const uatIdx = prompt.indexOf("### S01 UAT");
+  const summaryIdx = prompt.indexOf("### S01 Summary");
+  const projectIdx = prompt.indexOf("### Project");
+  assert.ok(uatIdx > -1, "slice UAT block missing");
+  assert.ok(summaryIdx > -1, "slice summary block missing");
+  assert.ok(projectIdx > -1, "project block missing — manifest declares project as 3rd inline");
+  assert.ok(
+    uatIdx < summaryIdx && summaryIdx < projectIdx,
+    `manifest order violated: uat (${uatIdx}) < summary (${summaryIdx}) < project (${projectIdx})`,
+  );
+
+  // In-memory uatContent inlined — drift assertion: stale disk content
+  // must NOT appear, fresh snapshot MUST appear (#4925 follow-up review).
+  assert.match(prompt, /fresh in-memory snapshot/);
+  assert.ok(!prompt.includes("stale on-disk body"), "resolver re-read disk instead of using uatContent snapshot");
+
+  // Summary body content inlined
+  assert.match(prompt, /What Happened[\s\S]*Ship/);
+
+  // Project body content inlined
+  assert.match(prompt, /Run-UAT composer fixture project/);
+});
+
+test("#4782 phase 3: buildRunUatPrompt omits optional slice summary when file is missing", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seed(base, "M001");
+
+  const uatRel = ".gsd/milestones/M001/slices/S01/S01-UAT.md";
+  writeFileSync(join(base, uatRel), "# S01 UAT\n");
+  // No SUMMARY.md written — composer should skip the slice-summary key.
+
+  const prompt = await buildRunUatPrompt("M001", "S01", uatRel, "# S01 UAT\n", base);
+
+  // UAT still present
+  assert.match(prompt, /### S01 UAT/);
+  // No empty "S01 Summary" section — section body would be blank without a file
+  assert.ok(!prompt.includes("### S01 Summary"));
+  // Project still present (third inline artifact, not optional) and follows
+  // UAT directly with the skipped summary collapsed (#4925 review).
+  const uatIdx = prompt.indexOf("### S01 UAT");
+  const projectIdx = prompt.indexOf("### Project");
+  assert.ok(projectIdx > uatIdx, `project must follow UAT when summary is omitted (uat=${uatIdx}, project=${projectIdx})`);
+  // No double separator from a skipped block
+  assert.ok(!prompt.includes("---\n\n---"));
+});

package/src/resources/extensions/gsd/tests/service-tier.test.ts

@@ -31,6 +31,10 @@ describe("supportsServiceTier", () => {
     assert.equal(supportsServiceTier("vibeproxy-openai/gpt-5.4"), true);
   });
 
+  test("returns false for gpt-5.5 until service_tier payload support is verified", () => {
+    assert.equal(supportsServiceTier("gpt-5.5"), false);
+  });
+
   test("returns false for provider-only identifier without gpt-5.4 model suffix", () => {
     assert.equal(supportsServiceTier("vibeproxy-openai"), false);
   });