@opengsd/gsd-pi 1.8.1-dev.897b3c90 → 1.9.0-dev.5c1a3ff2

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

@@ -4,9 +4,12 @@ import assert from "node:assert/strict";
 import {
   createObservationMask,
   createResponsesInputObservationMask,
+  filterSupersededContextInjections,
+  filterSupersededResponsesContextInjections,
   truncateContextResultMessages,
   truncateResponsesInputResultItems,
 } from "../context-masker.js";
+import { GSD_CONTEXT_MESSAGE_SENTINEL } from "../bootstrap/system-context.js";
 
 // These helpers produce messages in the pi-ai LLM payload format
 // (post-convertToLlm, pre-provider), which is what before_provider_request sees.
@@ -43,25 +46,35 @@ test("masks nothing when message count is within keepRecentTurns", () => {
   assert.deepEqual((result[2].content as any)[0].text, "file contents");
 });
 
-test("masks tool results older than keepRecentTurns", () => {
+test("masks tool results older than a full quantization block", () => {
+  // With keepRecentTurns=2, masking is quantized in blocks of 2 turns: nothing
+  // is masked until a full block (2 turns) of excess history accumulates.
   const mask = createObservationMask(2);
   const messages = [
     userMsg("turn 1"),
-    toolResult("old tool output"),
+    toolResult("turn 1 tool output"),
     assistantMsg("response 1"),
     userMsg("turn 2"),
-    toolResult("newer tool output"),
+    toolResult("turn 2 tool output"),
     assistantMsg("response 2"),
     userMsg("turn 3"),
-    toolResult("newest tool output"),
+    toolResult("turn 3 tool output"),
     assistantMsg("response 3"),
+    userMsg("turn 4"),
+    toolResult("turn 4 tool output"),
+    assistantMsg("response 4"),
+    userMsg("turn 5"),
+    toolResult("turn 5 tool output"),
+    assistantMsg("response 5"),
   ];
   const result = mask(messages as any);
-  // Old tool result (before boundary) should be masked
+  // First block (turns 1-2) is masked
   assert.equal((result[1].content as any)[0].text, MASK_TEXT);
-  // Recent tool results (within keep window) should be preserved
-  assert.equal((result[4].content as any)[0].text, "newer tool output");
-  assert.equal((result[7].content as any)[0].text, "newest tool output");
+  assert.equal((result[4].content as any)[0].text, MASK_TEXT);
+  // Remaining turns (3-5) are within the unmasked window
+  assert.equal((result[7].content as any)[0].text, "turn 3 tool output");
+  assert.equal((result[10].content as any)[0].text, "turn 4 tool output");
+  assert.equal((result[13].content as any)[0].text, "turn 5 tool output");
 });
 
 test("never masks assistant messages", () => {
@@ -126,6 +139,67 @@ test("masks toolResult by role, not by type field", () => {
   assert.equal((result[1].content as any)[0].text, MASK_TEXT);
 });
 
+function buildTurns(count: number) {
+  const messages: unknown[] = [];
+  for (let i = 1; i <= count; i++) {
+    messages.push(userMsg(`turn ${i}`));
+    messages.push(toolResult(`turn ${i} tool output`));
+    messages.push(assistantMsg(`response ${i}`));
+  }
+  return messages;
+}
+
+function maskedTextsByTurn(mask: (m: any) => any[], messages: unknown[], turnCount: number): (string | undefined)[] {
+  const result = mask(messages as any);
+  const texts: (string | undefined)[] = [];
+  for (let i = 0; i < turnCount; i++) {
+    const toolResultIndex = i * 3 + 1;
+    texts.push((result[toolResultIndex].content as any)[0].text);
+  }
+  return texts;
+}
+
+test("quantized mask invariant: at least keepRecentTurns most recent turns are always unmasked", () => {
+  const N = 3;
+  const mask = createObservationMask(N);
+  for (let totalTurns = 1; totalTurns <= 20; totalTurns++) {
+    const messages = buildTurns(totalTurns);
+    const texts = maskedTextsByTurn(mask, messages, totalTurns);
+    for (let i = Math.max(0, totalTurns - N); i < totalTurns; i++) {
+      assert.notEqual(texts[i], MASK_TEXT, `turn ${i + 1} of ${totalTurns} should be unmasked`);
+    }
+  }
+});
+
+test("quantized mask invariant: at most 2*keepRecentTurns-1 turns are unmasked", () => {
+  const N = 3;
+  const mask = createObservationMask(N);
+  for (let totalTurns = 1; totalTurns <= 20; totalTurns++) {
+    const messages = buildTurns(totalTurns);
+    const texts = maskedTextsByTurn(mask, messages, totalTurns);
+    const unmaskedCount = texts.filter((t) => t !== MASK_TEXT).length;
+    assert.ok(unmaskedCount <= 2 * N - 1, `expected <= ${2 * N - 1} unmasked turns at total=${totalTurns}, got ${unmaskedCount}`);
+  }
+});
+
+test("quantized mask invariant: prefix is byte-stable except at block rollover", () => {
+  const N = 3;
+  const mask = createObservationMask(N);
+  let previousTexts: (string | undefined)[] = [];
+  for (let totalTurns = 1; totalTurns <= 20; totalTurns++) {
+    const messages = buildTurns(totalTurns);
+    const texts = maskedTextsByTurn(mask, messages, totalTurns);
+    // Compare the shared prefix (turns 1..totalTurns-1) against the previous turn's run.
+    let changedCount = 0;
+    for (let i = 0; i < previousTexts.length; i++) {
+      if (previousTexts[i] !== texts[i]) changedCount++;
+    }
+    // A block rollover flips at most N turns from unmasked to masked; otherwise 0 should change.
+    assert.ok(changedCount === 0 || changedCount <= N, `turn ${totalTurns}: ${changedCount} prefix turns changed status`);
+    previousTexts = texts;
+  }
+});
+
 test("truncates recent bash result user messages", () => {
   const messages = [
     userMsg("turn 1"),
@@ -175,3 +249,125 @@ test("truncates Responses API function outputs and recent bash result items", ()
   assert.ok((result[1].output as string).length < (items[1].output as string).length);
   assert.ok((result[2].content as any)[0].text.length < (items[2].content as any)[0].text.length);
 });
+
+function contextInjectionMsg(label: string) {
+  return userMsg(`${GSD_CONTEXT_MESSAGE_SENTINEL}\n[MEMORY] turn=${label}`);
+}
+
+test("filterSupersededContextInjections keeps only the latest of three same-kind injections", () => {
+  const messages = [
+    userMsg("turn 1 prompt"),
+    contextInjectionMsg("1"),
+    assistantMsg("response 1"),
+    userMsg("turn 2 prompt"),
+    contextInjectionMsg("2"),
+    assistantMsg("response 2"),
+    userMsg("turn 3 prompt"),
+    contextInjectionMsg("3"),
+  ];
+  const original = JSON.parse(JSON.stringify(messages));
+
+  const result = filterSupersededContextInjections(messages as any);
+
+  const survivors = result.filter((m: any) => (m.content?.[0]?.text ?? "").startsWith(GSD_CONTEXT_MESSAGE_SENTINEL));
+  assert.equal(survivors.length, 1);
+  assert.match((survivors[0] as any).content[0].text, /turn=3/);
+  assert.equal(result.length, messages.length - 2);
+  // Pure function — input array is untouched.
+  assert.deepEqual(messages, original);
+});
+
+test("filterSupersededContextInjections keeps the latest injection overall across mixed kinds", () => {
+  // buildContextMessage emits one message per turn (guided > forensics > memory);
+  // the latest one already embeds the memory block when present, so "keep the
+  // latest overall" is correct — no separate per-kind tracking needed.
+  const memoryOnly = userMsg(`${GSD_CONTEXT_MESSAGE_SENTINEL}\n[GSD Context Metadata]\n- Memory supplied: yes\n\n[MEMORY]`);
+  const guided = userMsg(`${GSD_CONTEXT_MESSAGE_SENTINEL}\n[GSD Context Metadata]\n- Memory supplied: yes\n\n[GUIDED EXECUTE]`);
+  const messages = [userMsg("turn 1"), memoryOnly, assistantMsg("r1"), userMsg("turn 2"), guided];
+
+  const result = filterSupersededContextInjections(messages as any);
+
+  const survivors = result.filter((m: any) => (m.content?.[0]?.text ?? "").startsWith(GSD_CONTEXT_MESSAGE_SENTINEL));
+  assert.equal(survivors.length, 1);
+  assert.match((survivors[0] as any).content[0].text, /GUIDED EXECUTE/);
+});
+
+test("filterSupersededContextInjections dedupes legacy pre-sentinel injections via bracketed GSD markers", () => {
+  // Sessions created before the sentinel existed carry the stable
+  // "[GSD Context Metadata]" / "[GSD Guided Execute Context]" labels but no
+  // sentinel prefix; resuming them must still collapse to the latest injection.
+  const legacyMemory1 = userMsg("[GSD Context Metadata]\n- Memory supplied: yes\n\n[MEMORY] turn=1");
+  const legacyMemory2 = userMsg("[GSD Context Metadata]\n- Memory supplied: yes\n\n[MEMORY] turn=2");
+  const messages = [userMsg("turn 1"), legacyMemory1, assistantMsg("r1"), userMsg("turn 2"), legacyMemory2];
+
+  const result = filterSupersededContextInjections(messages as any);
+
+  const survivors = result.filter((m: any) => (m.content?.[0]?.text ?? "").startsWith("[GSD Context Metadata]"));
+  assert.equal(survivors.length, 1);
+  assert.match((survivors[0] as any).content[0].text, /turn=2/);
+  assert.equal(result.length, messages.length - 1);
+});
+
+test("filterSupersededContextInjections never drops a real user message that starts with forensics prose", () => {
+  // "Debug GSD itself." is the forensics prompt text — generic prose, not a
+  // bracketed GSD marker. A user can legitimately type it; treating it as an
+  // injection would silently delete real user input. Only sentinel/bracketed
+  // injections may be superseded.
+  const userAsk = userMsg("Debug GSD itself. Why does resume hang after a crash?");
+  const injection = userMsg(`${GSD_CONTEXT_MESSAGE_SENTINEL}\n[GSD Context Metadata]\n- Memory supplied: yes\n\n[MEMORY]`);
+  const messages = [userAsk, assistantMsg("r1"), userMsg("turn 2"), injection];
+
+  const result = filterSupersededContextInjections(messages as any);
+
+  assert.ok(result.some((m: any) => (m.content?.[0]?.text ?? "").startsWith("Debug GSD itself.")));
+  assert.equal(result.length, messages.length);
+});
+
+test("filterSupersededContextInjections returns the array unchanged when no injections present", () => {
+  const messages = [userMsg("hi"), assistantMsg("hello"), toolResult("data")];
+  const result = filterSupersededContextInjections(messages as any);
+  assert.equal(result, messages);
+});
+
+test("filterSupersededContextInjections preserves forensics opening prompt across follow-up reinjection", () => {
+  const forensicsOpening =
+    "Debug GSD itself. Trace the symptom to root cause in current source and produce a filing-ready GitHub issue.";
+  const messages = [
+    userMsg(forensicsOpening),
+    assistantMsg("I found the root cause in auto-loop.ts."),
+    userMsg("yes, create the issue"),
+    userMsg(`${GSD_CONTEXT_MESSAGE_SENTINEL}\n${forensicsOpening}`),
+    assistantMsg("Creating the issue now."),
+    userMsg("also add the stack trace"),
+    userMsg(`${GSD_CONTEXT_MESSAGE_SENTINEL}\n${forensicsOpening}\n\n## Follow-up\nalso add the stack trace`),
+  ];
+
+  const result = filterSupersededContextInjections(messages as any);
+
+  assert.equal(result.length, messages.length - 1);
+  assert.equal((result[0] as any).content[0].text, forensicsOpening);
+  assert.match((result[5] as any).content[0].text, /Follow-up/);
+});
+
+test("filterSupersededResponsesContextInjections keeps only the latest injection in payload.input", () => {
+  const items = [
+    { role: "user", content: [{ type: "input_text", text: "turn 1" }] },
+    { role: "user", content: [{ type: "input_text", text: `${GSD_CONTEXT_MESSAGE_SENTINEL}\n[MEMORY] turn=1` }] },
+    { type: "function_call_output", call_id: "call_1", output: "ok" },
+    { role: "user", content: [{ type: "input_text", text: `${GSD_CONTEXT_MESSAGE_SENTINEL}\n[MEMORY] turn=2` }] },
+  ];
+  const original = JSON.parse(JSON.stringify(items));
+
+  const result = filterSupersededResponsesContextInjections(items as any);
+
+  const survivors = result.filter((i: any) => (i.content?.[0]?.text ?? "").startsWith(GSD_CONTEXT_MESSAGE_SENTINEL));
+  assert.equal(survivors.length, 1);
+  assert.match((survivors[0] as any).content[0].text, /turn=2/);
+  assert.deepEqual(items, original);
+});
+
+test("filterSupersededResponsesContextInjections returns the array unchanged when no injections present", () => {
+  const items = [{ role: "user", content: [{ type: "input_text", text: "hi" }] }];
+  const result = filterSupersededResponsesContextInjections(items as any);
+  assert.equal(result, items);
+});

package/src/resources/extensions/gsd/tests/db-tools-alias-suppression.test.ts

@@ -0,0 +1,62 @@
+// Project/App: gsd-pi
+// File Purpose: Verifies GSD_ADVERTISE_TOOL_ALIASES gates alias registration on the native tool path (plan 035).
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { registerDbTools } from '../bootstrap/db-tools.ts';
+import { WORKFLOW_TOOL_ALIAS_NAMES, WORKFLOW_TOOL_CONTRACTS } from '../workflow-tool-surface.ts';
+
+function makeMockPi() {
+  const tools: any[] = [];
+  return {
+    registerTool: (tool: any) => tools.push(tool),
+    tools,
+  } as any;
+}
+
+function withEnv(name: string, value: string | undefined, fn: () => void): void {
+  const previous = process.env[name];
+  if (value === undefined) delete process.env[name];
+  else process.env[name] = value;
+  try {
+    fn();
+  } finally {
+    if (previous === undefined) delete process.env[name];
+    else process.env[name] = previous;
+  }
+}
+
+test('default: only canonical names are registered, no aliases', () => {
+  withEnv('GSD_ADVERTISE_TOOL_ALIASES', undefined, () => {
+    const pi = makeMockPi();
+    registerDbTools(pi);
+    const names = new Set(pi.tools.map((tool: any) => tool.name));
+
+    for (const alias of WORKFLOW_TOOL_ALIAS_NAMES) {
+      assert.ok(!names.has(alias), `alias "${alias}" should not be registered by default`);
+    }
+    const registeredCanonical = WORKFLOW_TOOL_CONTRACTS
+      .map((tool) => tool.canonicalName)
+      .filter((name) => names.has(name));
+    assert.ok(registeredCanonical.length > 0, 'canonical tools should still be registered');
+  });
+});
+
+test('GSD_ADVERTISE_TOOL_ALIASES=1: aliases are registered with the "(alias for ...)" description suffix', () => {
+  withEnv('GSD_ADVERTISE_TOOL_ALIASES', '1', () => {
+    const pi = makeMockPi();
+    registerDbTools(pi);
+    const toolByName = new Map<string, any>(pi.tools.map((tool: any) => [tool.name, tool]));
+
+    const registeredAliases = WORKFLOW_TOOL_ALIAS_NAMES.filter((alias) => toolByName.has(alias));
+    assert.ok(registeredAliases.length > 0, 'at least one alias should be registered when opted in');
+
+    for (const alias of registeredAliases) {
+      const aliasTool = toolByName.get(alias);
+      assert.ok(
+        aliasTool.description.includes('(alias for '),
+        `alias "${alias}" description should include "(alias for ...)"`,
+      );
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/destructive-confirmation.test.ts

@@ -18,6 +18,7 @@ import test from "node:test";
 import assert from "node:assert/strict";
 
 import { registerHooks } from "../bootstrap/register-hooks.ts";
+import { autoSession } from "../auto-runtime-state.ts";
 import { classifyCommand } from "../safety/destructive-guard.ts";
 import {
   DESTRUCTIVE_CONFIRM_GATE_MARKER,
@@ -232,6 +233,38 @@ test("integration: real hooks block a force push, then allow it once after confi
   assert.equal(thirdAttempt?.block, true, "second run of the same command re-blocks (one-shot)");
 });
 
+test("integration: auto-mode destructive block does not pause before confirmation can be asked", async (t) => {
+  const dir = "/tmp/gsd-destructive-confirm-int-auto-defer";
+  const notifications: string[] = [];
+  const ctx = {
+    cwd: dir,
+    isIdle: () => true,
+    sessionManager: { getSessionFile: () => null },
+    ui: { notify: (message: string) => notifications.push(message) },
+  } as any;
+  resetDestructiveConfirmation(dir);
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.basePath = dir;
+  t.after(() => {
+    resetDestructiveConfirmation(dir);
+    autoSession.reset();
+  });
+
+  const { handlers, pi } = makeHookHarness();
+  registerHooks(pi, []);
+
+  const block = await runBashGuard(handlers, FORCE_PUSH, ctx);
+
+  assert.equal(block?.block, true, "real guard blocks the first destructive attempt");
+  assert.equal(autoSession.active, true, "auto-mode must remain active so ask_user_questions can run");
+  assert.deepEqual(
+    notifications.filter((message) => message.includes("Destructive-command confirmation")),
+    [],
+    "destructive confirmation pause must not fire from the bash tool_call hook",
+  );
+});
+
 test("integration: declining the confirm gate leaves the command blocked", async (t) => {
   const dir = "/tmp/gsd-destructive-confirm-int-decline";
   const ctx = { cwd: dir, ui: { notify: () => undefined } } as any;

package/src/resources/extensions/gsd/tests/destructive-guard.test.ts

@@ -29,6 +29,7 @@ test("destructive guard still detects direct and wrapper-prefixed recursive dele
     "find . -exec rm -rf {} \\;",
     "cat doomed.txt | xargs rm -rf /tmp/x",
     'rm -rf "/tmp/my build"',
+    "rm --recursive build",
   ];
 
   for (const command of destructiveCommands) {
@@ -39,6 +40,19 @@ test("destructive guard still detects direct and wrapper-prefixed recursive dele
   }
 });
 
+test("destructive guard does not classify force-only rm as recursive delete", () => {
+  const nonRecursiveCommands = [
+    "rm -f single-file.md",
+    "rm -fv single-file.md",
+    "rm single-file.md -f",
+    "rm --force single-file.md",
+  ];
+
+  for (const command of nonRecursiveCommands) {
+    assert.deepEqual(classifyCommand(command), { destructive: false, labels: [] }, command);
+  }
+});
+
 test("destructive guard treats quoted interpreter payloads as literals", () => {
   assert.deepEqual(classifyCommand('bash -c "rm -rf /"'), { destructive: false, labels: [] });
 });

package/src/resources/extensions/gsd/tests/integration/paths.test.ts

@@ -1,6 +1,6 @@
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync, realpathSync, symlinkSync, writeFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, rmSync, realpathSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { spawnSync } from "node:child_process";
@@ -12,6 +12,8 @@ import {
   resolveGsdPathContract,
   resolveSliceFile,
   resolveTaskFile,
+  resolveTaskFiles,
+  taskIdFromTaskFileName,
   _clearGsdRootCache,
 } from "../../paths.ts";
 /** Create a tmp dir and resolve symlinks + 8.3 short names (macOS /var→/private/var, Windows RUNNER~1→runneradmin). */
@@ -171,21 +173,37 @@ describe('paths', () => {
   test('Case 9: flat-phase task SUMMARY resolves at phase root despite a stray slices/SID/ dir', () => {
     const root = tmp();
     try {
-      // Hybrid flat-phase milestone: phase dir holds flat TID-SUMMARY.md, but a
+      // Hybrid flat-phase milestone: phase dir holds flat task summaries, but a
       // stray slices/S01/ folder also exists on disk. resolveSlicePath then points
       // under slices/, so layout (phases/ vs milestones/) — not slicePath===phaseDir
       // — must decide the flat-phase task summary location.
       const phaseDir = join(root, ".gsd", "phases", "01-foo");
       mkdirSync(join(phaseDir, "slices", "S01"), { recursive: true });
-      const flatSummary = join(phaseDir, "T01-SUMMARY.md");
+      const flatSummary = join(phaseDir, "S01-T01-SUMMARY.md");
+      const legacyFlatSummary = join(phaseDir, "T01-SUMMARY.md");
       writeFileSync(flatSummary, "# task summary\n");
+      writeFileSync(legacyFlatSummary, "# legacy task summary\n");
 
       _clearGsdRootCache();
 
+      assert.deepStrictEqual(resolveTaskFiles(phaseDir, "SUMMARY").sort(), [
+        "S01-T01-SUMMARY.md",
+        "T01-SUMMARY.md",
+      ]);
+      assert.equal(taskIdFromTaskFileName("S01-T01-SUMMARY.md", "SUMMARY"), "T01");
+      assert.equal(taskIdFromTaskFileName("T01-SUMMARY.md", "SUMMARY"), "T01");
+
       assert.deepStrictEqual(
         resolveTaskFile(root, "M001", "S01", "T01", "SUMMARY"),
         flatSummary,
-        "flat-phase TID-SUMMARY.md at phase root is found even when slices/S01/ exists",
+        "flat-phase S01-T01-SUMMARY.md at phase root is preferred even when slices/S01/ exists",
+      );
+
+      unlinkSync(flatSummary);
+      assert.deepStrictEqual(
+        resolveTaskFile(root, "M001", "S01", "T01", "SUMMARY"),
+        legacyFlatSummary,
+        "legacy flat T01-SUMMARY.md is still found as a fallback",
       );
     } finally { cleanup(root); }
   });

package/src/resources/extensions/gsd/tests/integration-branch-meta-location.test.ts

@@ -0,0 +1,62 @@
+// gsd-pi — Integration-branch META lives OUTSIDE milestones/<MID>/ (ADR-045).
+// Verifies the relocation from milestones/<MID>/<MID>-META.json to the flat
+// .gsd/<MID>-META.json so it can never poison isLegacyMilestonesLayout.
+
+import assert from "node:assert/strict";
+import { afterEach, beforeEach, test } from "node:test";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { readIntegrationBranch, writeIntegrationBranch } from "../git-service.js";
+import { gsdRoot, isLegacyMilestonesLayout } from "../paths.js";
+
+let repo: string;
+
+beforeEach(() => {
+  repo = mkdtempSync(join(tmpdir(), "gsd-meta-loc-"));
+});
+
+afterEach(() => {
+  rmSync(repo, { recursive: true, force: true });
+});
+
+test("write goes to the new flat .gsd/<MID>-META.json, not milestones/<MID>/", () => {
+  writeIntegrationBranch(repo, "M001", "main");
+
+  assert.ok(
+    existsSync(join(gsdRoot(repo), "M001-META.json")),
+    "META written to flat .gsd/<MID>-META.json",
+  );
+  assert.ok(
+    !existsSync(join(gsdRoot(repo), "milestones", "M001", "M001-META.json")),
+    "no META in legacy milestones/<MID>/ location",
+  );
+});
+
+test("round-trip: read returns what write recorded", () => {
+  writeIntegrationBranch(repo, "M001", "main");
+  assert.equal(readIntegrationBranch(repo, "M001"), "main");
+});
+
+test("read falls back to the legacy milestones/<MID>/ location", () => {
+  const legacyDir = join(gsdRoot(repo), "milestones", "M001");
+  mkdirSync(legacyDir, { recursive: true });
+  writeFileSync(
+    join(legacyDir, "M001-META.json"),
+    JSON.stringify({ integrationBranch: "develop" }) + "\n",
+    "utf-8",
+  );
+
+  assert.equal(readIntegrationBranch(repo, "M001"), "develop");
+});
+
+test("writing META does not create milestones/<MID>/ or flip layout detection", () => {
+  assert.equal(isLegacyMilestonesLayout(repo), false, "clean tree is not legacy layout");
+  writeIntegrationBranch(repo, "M001", "main");
+  assert.equal(
+    isLegacyMilestonesLayout(repo),
+    false,
+    "writing integration-branch META must not poison layout detection",
+  );
+});

package/src/resources/extensions/gsd/tests/markdown-renderer.test.ts

@@ -824,9 +824,9 @@ test('── markdown-renderer: renderTaskSummary round-trip ──', async () =
 
     // Verify file exists on disk
     const summaryPath = path.join(
-      tmpDir, '.gsd', 'phases', '01-test', 'T01-SUMMARY.md',
+      tmpDir, '.gsd', 'phases', '01-test', 'S01-T01-SUMMARY.md',
     );
-    assert.ok(fs.existsSync(summaryPath), 'T01-SUMMARY.md written to disk');
+    assert.ok(fs.existsSync(summaryPath), 'S01-T01-SUMMARY.md written to disk');
 
     // Parse and verify
     const rendered = fs.readFileSync(summaryPath, 'utf-8');
@@ -1020,7 +1020,7 @@ test('── markdown-renderer: renderAllFromDb produces all files ──', asyn
 
     // Verify task summary written
     const taskSummaryPath = path.join(
-      tmpDir, '.gsd', 'phases', '01-test', 'T01-SUMMARY.md',
+      tmpDir, '.gsd', 'phases', '01-test', 'S01-T01-SUMMARY.md',
     );
     assert.ok(fs.existsSync(taskSummaryPath), 'T01 summary written by renderAll');
   } finally {
@@ -1546,9 +1546,9 @@ test('── markdown-renderer: repairStaleRenders writes missing task summary
 
     // Verify file written
     const summaryPath = path.join(
-      tmpDir, '.gsd', 'phases', '01-test', 'T01-SUMMARY.md',
+      tmpDir, '.gsd', 'phases', '01-test', 'S01-T01-SUMMARY.md',
     );
-    assert.ok(fs.existsSync(summaryPath), 'T01-SUMMARY.md should exist after repair');
+    assert.ok(fs.existsSync(summaryPath), 'S01-T01-SUMMARY.md should exist after repair');
 
     // Second detect should be empty
     clearAllCaches();

package/src/resources/extensions/gsd/tests/model-cost-table.test.ts

@@ -74,7 +74,7 @@ test("#2885: cost table includes openai-codex provider models", () => {
   const ids = BUNDLED_COST_TABLE.map(e => e.id);
   const codexModels = [
     "gpt-5.1", "gpt-5.1-codex-max", "gpt-5.1-codex-mini",
-    "gpt-5.2", "gpt-5.2-codex", "gpt-5.3-codex", "gpt-5.3-codex-spark", "gpt-5.4", "gpt-5.4-mini", "gpt-5.5",
+    "gpt-5.2", "gpt-5.2-codex", "gpt-5.3-codex", "gpt-5.3-codex-spark", "gpt-5.4", "gpt-5.4-mini", "gpt-5.5", "gpt-5.6",
   ];
   for (const model of codexModels) {
     assert.ok(ids.includes(model), `cost table should include openai-codex model "${model}"`);
@@ -109,3 +109,11 @@ test("gpt-5.5 uses official OpenAI list pricing", () => {
   assert.equal(entry.outputPer1k, 0.03);
   assert.equal(entry.updatedAt, "2026-04-23");
 });
+
+test("gpt-5.6 mirrors gpt-5.5 pricing until official pricing is published", () => {
+  const entry = lookupModelCost("gpt-5.6");
+  assert.ok(entry, "lookupModelCost should find gpt-5.6");
+  assert.equal(entry.inputPer1k, 0.005);
+  assert.equal(entry.outputPer1k, 0.03);
+  assert.equal(entry.updatedAt, "2026-07-08");
+});

package/src/resources/extensions/gsd/tests/model-router.test.ts

@@ -900,7 +900,7 @@ test("#2885: openai-codex standard-tier models are recognized", () => {
 
 test("#2885: openai-codex heavy-tier models are recognized", () => {
   const config = { ...defaultRoutingConfig(), enabled: true };
-  const heavyModels = ["gpt-5", "gpt-5-pro", "gpt-5.1", "gpt-5.2", "gpt-5.2-codex", "gpt-5.3-codex", "gpt-5.4", "gpt-5.5", "o4-mini", "o4-mini-deep-research"];
+  const heavyModels = ["gpt-5", "gpt-5-pro", "gpt-5.1", "gpt-5.2", "gpt-5.2-codex", "gpt-5.3-codex", "gpt-5.4", "gpt-5.5", "gpt-5.6", "o4-mini", "o4-mini-deep-research"];
   for (const model of heavyModels) {
     const result = resolveModelForComplexity(
       makeClassification("heavy"),

package/src/resources/extensions/gsd/tests/parallel-skill-prompt-integration.test.ts

@@ -29,12 +29,14 @@ import {
 
 const SKILL_NAME = "testskill";
 const COMPLETE_SLICE_SKILL_NAME = "complete-slice-policies";
-const SKILL_ACTIVATION_SUBSTRING = `Read the installed '${SKILL_NAME}' skill file from <available_skills>`;
-const COMPLETE_SLICE_SKILL_ACTIVATION_SUBSTRING = `Read the installed '${COMPLETE_SLICE_SKILL_NAME}' skill file from <available_skills>`;
 
 const tmpDirs: string[] = [];
 let savedCwd: string | undefined;
 
+function expectedSkillRead(base: string, name: string): string {
+  return `Read the skill file at \`${join(base, ".agents", "skills", name, "SKILL.md")}\``;
+}
+
 function setupProjectWithSkill(options: {
   skillName?: string;
   preferencesLines?: string[];
@@ -139,7 +141,7 @@ test("worker prompt (buildResearchSlicePrompt) includes <skill_activation> from
     "research-slice prompt should contain a <skill_activation> block",
   );
   assert.ok(
-    prompt.includes(SKILL_ACTIVATION_SUBSTRING),
+    prompt.includes(expectedSkillRead(base, SKILL_NAME)),
     `research-slice prompt should reference the always-used skill '${SKILL_NAME}'`,
   );
 });
@@ -164,7 +166,7 @@ test("complete-slice prompt includes <skill_activation> from unit-specific skill
     "complete-slice prompt should contain a <skill_activation> block",
   );
   assert.ok(
-    prompt.includes(COMPLETE_SLICE_SKILL_ACTIVATION_SUBSTRING),
+    prompt.includes(expectedSkillRead(base, COMPLETE_SLICE_SKILL_NAME)),
     `complete-slice prompt should reference the skill-rule skill '${COMPLETE_SLICE_SKILL_NAME}'`,
   );
 });
@@ -192,7 +194,7 @@ test("subagent dispatch prompt (buildParallelResearchSlicesPrompt) carries <skil
     `expected at least 2 <skill_activation> blocks (one per slice), got ${blockCount}`,
   );
   assert.ok(
-    prompt.includes(SKILL_ACTIVATION_SUBSTRING),
+    prompt.includes(expectedSkillRead(base, SKILL_NAME)),
     `parallel-research-slices prompt should reference the always-used skill '${SKILL_NAME}'`,
   );
   assert.ok(