@opengsd/gsd-pi 1.9.0 → 1.10.0-dev.a5e42e99

package/src/resources/extensions/gsd/tests/auto-wrapup-inflight-guard.test.ts

@@ -3,7 +3,8 @@
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, realpathSync, rmSync } from "node:fs";
+import { mkdtempSync, mkdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { execSync } from "node:child_process";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -96,6 +97,78 @@ describe("hook dispatch session workspace root", () => {
     assert.equal(dispatched, true);
     assert.deepEqual(newSessionOptions, { workspaceRoot: basePath });
   });
+
+  test("dispatchHookUnit commits in-flight work when command context lacks newSession", async (t) => {
+    const originalCwd = process.cwd();
+    const basePath = realpathSync(mkdtempSync(join(tmpdir(), "gsd-hook-nosnap-")));
+    mkdirSync(join(basePath, ".gsd"), { recursive: true });
+    execSync("git init --initial-branch=main", { cwd: basePath, stdio: "ignore" });
+    execSync("git config user.email test@test.com", { cwd: basePath, stdio: "ignore" });
+    execSync("git config user.name Test", { cwd: basePath, stdio: "ignore" });
+    execSync("git commit --allow-empty -m init", { cwd: basePath, stdio: "ignore" });
+
+    autoSession.reset();
+    autoSession.active = true;
+    autoSession.basePath = basePath;
+    autoSession.originalBasePath = basePath;
+    // Simulate an in-flight unit whose executor already wrote files, then a hook
+    // fires with a command context missing newSession.
+    autoSession.currentUnit = {
+      type: "execute-task",
+      id: "M001/S01/T01",
+      startedAt: Date.now(),
+    };
+    t.after(() => {
+      try {
+        process.chdir(originalCwd);
+      } catch {
+        // best effort cleanup after cwd-sensitive dispatch tests
+      }
+      autoSession.reset();
+      rmSync(basePath, { recursive: true, force: true });
+    });
+
+    const outputPath = join(basePath, "executor-output.txt");
+    writeFileSync(outputPath, "in-flight executor work\n", "utf-8");
+
+    // Command context intentionally lacks newSession — the guard must snapshot
+    // the dirty work before stopping instead of discarding it.
+    const ctx = {
+      ui: {
+        notify: () => {},
+        setStatus: () => {},
+        setWidget: () => {},
+      },
+      modelRegistry: {
+        getAvailable: () => [],
+      },
+      sessionManager: {
+        getSessionFile: () => join(basePath, "session.jsonl"),
+      },
+    };
+    const pi = {
+      sendMessage: () => {},
+      setModel: async () => true,
+    };
+
+    const dispatched = await dispatchHookUnit(
+      ctx as any,
+      pi as any,
+      "review",
+      "execute-task",
+      "M001/S01/T01",
+      "review the completed unit",
+      undefined,
+      basePath,
+    );
+
+    assert.equal(dispatched, false);
+    const committed = execSync("git show HEAD:executor-output.txt", {
+      cwd: basePath,
+      encoding: "utf-8",
+    });
+    assert.equal(committed, "in-flight executor work\n");
+  });
 });
 
 describe("deep setup approval questions pause immediately", () => {

package/src/resources/extensions/gsd/tests/before-provider-context-management.test.ts

@@ -143,3 +143,58 @@ test("successful shell result clears source context before provider injection",
   assert.equal(payload.messages.length, 1);
   assert.doesNotMatch(payload.messages[0].content[0].text, /Source Context Block/);
 });
+
+test("before_provider_request keeps only the latest GSD context injection across a 5-turn session", async (t) => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-before-provider-injections-"));
+  const gsdHome = join(dir, "home");
+  const project = join(dir, "project");
+  const previousCwd = process.cwd();
+  const previousGsdHome = process.env.GSD_HOME;
+
+  mkdirSync(join(project, ".gsd"), { recursive: true });
+  mkdirSync(gsdHome, { recursive: true });
+  process.env.GSD_HOME = gsdHome;
+  process.chdir(project);
+  _setAutoActiveForTest(false);
+
+  t.after(() => {
+    _setAutoActiveForTest(false);
+    process.chdir(previousCwd);
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  const beforeProviderRequest = requireHook(createHookHandlers(), "before_provider_request");
+
+  const sentinel = "[GSD Context Injection]";
+  const contextInjection = (turn: number) => ({
+    role: "user",
+    content: [{ type: "text", text: `${sentinel}\n[MEMORY] turn=${turn}` }],
+  });
+
+  const payload = {
+    messages: [
+      { role: "user", content: [{ type: "text", text: "turn 1" }] },
+      contextInjection(1),
+      { role: "assistant", content: [{ type: "text", text: "r1" }] },
+      { role: "user", content: [{ type: "text", text: "turn 2" }] },
+      contextInjection(2),
+      { role: "assistant", content: [{ type: "text", text: "r2" }] },
+      { role: "user", content: [{ type: "text", text: "turn 3" }] },
+      contextInjection(3),
+      { role: "assistant", content: [{ type: "text", text: "r3" }] },
+      { role: "user", content: [{ type: "text", text: "turn 4" }] },
+      contextInjection(4),
+      { role: "assistant", content: [{ type: "text", text: "r4" }] },
+      { role: "user", content: [{ type: "text", text: "turn 5" }] },
+      contextInjection(5),
+    ],
+  };
+
+  await beforeProviderRequest({ payload });
+
+  const survivors = (payload.messages as any[]).filter((m) => (m.content?.[0]?.text ?? "").startsWith(sentinel));
+  assert.equal(survivors.length, 1);
+  assert.match(survivors[0].content[0].text, /turn=5/);
+});

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

@@ -201,6 +201,7 @@ test("handleVerdict rejects missing verdict", async () => {
   const { ctx, calls } = makeMockCtx();
   await handleVerdict("", ctx, "/tmp/unused");
   assert.equal(calls.length, 1);
+  assert.match(calls[0].message, /^Verdict rejected:/);
   assert.match(calls[0].message, /Usage: \/gsd verdict/);
   assert.equal(calls[0].kind, "warning");
 });
@@ -209,6 +210,7 @@ test("handleVerdict rejects invalid verdict", async () => {
   const { ctx, calls } = makeMockCtx();
   await handleVerdict("yolo", ctx, "/tmp/unused");
   assert.equal(calls.length, 1);
+  assert.match(calls[0].message, /^Verdict rejected:/);
   assert.match(calls[0].message, /Invalid verdict "yolo"/);
   assert.equal(calls[0].kind, "warning");
 });
@@ -250,6 +252,10 @@ test("handleVerdict rejects when milestone validation is missing", async () => {
       calls.some((c) => /No milestone validation found/.test(c.message)),
       `expected missing-validation warning, got: ${JSON.stringify(calls)}`,
     );
+    assert.ok(
+      calls.some((c) => /^Verdict rejected:/.test(c.message)),
+      `expected terminal rejection prefix, got: ${JSON.stringify(calls)}`,
+    );
   } finally {
     closeDatabase();
     invalidateStateCache();
@@ -280,6 +286,10 @@ test("handleVerdict pass override flips verdict and preserves sections", async (
       calls.some((c) => c.kind === "success" && /needs-attention.*->.*pass/.test(c.message)),
       `expected success notification, got: ${JSON.stringify(calls)}`,
     );
+    assert.ok(
+      calls.some((c) => c.kind === "success" && /^Verdict recorded:/.test(c.message)),
+      `expected terminal recorded prefix, got: ${JSON.stringify(calls)}`,
+    );
   } finally {
     closeDatabase();
     invalidateStateCache();

package/src/resources/extensions/gsd/tests/compat-marker.test.ts

@@ -242,6 +242,31 @@ test("readCompatMarker preserves legitimate nested projection keys", () => {
   assert.equal(Object.keys(marker.projections).length, 2);
 });
 
+test("readCompatMarker heals invalid keys that canonicalize back under .gsd", () => {
+  const base = makeTmpBase();
+  const safeKey = "m1/roadmap.md";
+  mkdirSync(join(base, ".gsd", "m1"), { recursive: true });
+  writeFileSync(join(base, ".gsd", safeKey), "# Roadmap\n", "utf-8");
+  writeCompatMarker(base, {
+    schema: 2,
+    lastWriter: "gsd-pi",
+    lastProjectedAt: "2026-07-07T00:00:00.000Z",
+    projections: {
+      [`../.gsd/${safeKey}`]: { sha: "aaaaaaaaaaaaaaaa", entities: ["M001"] },
+    },
+    planning: { active: false, layout: null, projections: {}, passthrough: {} },
+    piVersion: "1.8.1",
+  });
+
+  const marker = readCompatMarker(base);
+  assert.ok(marker.projections[safeKey], "derivable traversal-form key must be rewritten");
+  assert.equal(marker.projections[`../.gsd/${safeKey}`], undefined);
+  assert.ok(
+    !readdirSync(join(base, ".gsd")).some((f: string) => f.startsWith(".compat.json.bad-")),
+    "healed marker must not be quarantined",
+  );
+});
+
 test("an escaping key in planning.passthrough also invalidates the whole marker", () => {
   const base = makeTmpBase();
   writeCompatMarker(base, {

package/src/resources/extensions/gsd/tests/complete-task.test.ts

@@ -23,6 +23,7 @@ import {
   SCHEMA_VERSION,
 } from '../gsd-db.ts';
 import { handleCompleteTask } from '../tools/complete-task.ts';
+import { resolveTaskFile } from '../paths.ts';
 
 const { assertEq, assertTrue, assertMatch, report } = createTestContext();
 
@@ -381,6 +382,80 @@ console.log('\n=== complete-task: handler happy path ===');
   cleanup(dbPath);
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// complete-task: Flat-phase duplicate task IDs are slice-qualified
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== complete-task: flat-phase duplicate task IDs are slice-qualified ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  const basePath = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-flat-task-summary-'));
+  const phaseDir = path.join(basePath, '.gsd', 'phases', '01-test');
+  fs.mkdirSync(phaseDir, { recursive: true });
+  fs.writeFileSync(path.join(phaseDir, '01-01-PLAN.md'), `# S01: First Slice
+
+## Tasks
+
+- [ ] **T03: Shared task id** \`est:30m\`
+  - Do: Complete first slice task
+  - Verify: Run first check
+`);
+  fs.writeFileSync(path.join(phaseDir, '01-02-PLAN.md'), `# S02: Second Slice
+
+## Tasks
+
+- [ ] **T03: Shared task id** \`est:30m\`
+  - Do: Complete second slice task
+  - Verify: Run second check
+`);
+
+  insertMilestone({ id: 'M001', title: 'Test Milestone' });
+  insertSlice({ id: 'S01', milestoneId: 'M001', title: 'First Slice', sequence: 1 });
+  insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Second Slice', sequence: 2 });
+
+  const first = await handleCompleteTask({
+    ...makeValidParams(),
+    taskId: 'T03',
+    sliceId: 'S01',
+    oneLiner: 'Completed first slice T03',
+  }, basePath);
+  const second = await handleCompleteTask({
+    ...makeValidParams(),
+    taskId: 'T03',
+    sliceId: 'S02',
+    oneLiner: 'Completed second slice T03',
+  }, basePath);
+
+  assertTrue(!('error' in first), 'first duplicate task ID completion should succeed');
+  assertTrue(!('error' in second), 'second duplicate task ID completion should succeed');
+  if (!('error' in first) && !('error' in second)) {
+    const firstSummary = path.join(phaseDir, 'S01-T03-SUMMARY.md');
+    const secondSummary = path.join(phaseDir, 'S02-T03-SUMMARY.md');
+    const legacySummary = path.join(phaseDir, 'T03-SUMMARY.md');
+
+    assertEq(first.summaryPath, firstSummary, 'S01/T03 should write a slice-qualified summary path');
+    assertEq(second.summaryPath, secondSummary, 'S02/T03 should write a slice-qualified summary path');
+    assertTrue(fs.existsSync(firstSummary), 'S01/T03 summary should exist');
+    assertTrue(fs.existsSync(secondSummary), 'S02/T03 summary should exist');
+    assertTrue(!fs.existsSync(legacySummary), 'flat-phase completion should not create legacy T03-SUMMARY.md');
+
+    const firstContent = fs.readFileSync(firstSummary, 'utf-8');
+    const secondContent = fs.readFileSync(secondSummary, 'utf-8');
+    assertMatch(firstContent, /parent: S01/, 'S01/T03 summary should keep parent S01');
+    assertMatch(secondContent, /parent: S02/, 'S02/T03 summary should keep parent S02');
+    assertEq(resolveTaskFile(basePath, 'M001', 'S02', 'T03', 'SUMMARY'), secondSummary, 'resolver should prefer S02-specific summary');
+
+    const legacyFallback = path.join(phaseDir, 'T99-SUMMARY.md');
+    fs.writeFileSync(legacyFallback, '# Legacy task summary\n');
+    assertEq(resolveTaskFile(basePath, 'M001', 'S09', 'T99', 'SUMMARY'), legacyFallback, 'resolver should fall back to old flat summary names');
+  }
+
+  cleanupDir(basePath);
+  cleanup(dbPath);
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // complete-task: Projection failure rolls DB completion back
 // ═══════════════════════════════════════════════════════════════════════════
@@ -416,7 +491,7 @@ console.log('\n=== complete-task: projection failure rolls DB completion back ==
   ).all();
   assertEq(evRows.length, 0, 'verification evidence should be deleted when projection rollback runs');
 
-  const summaryPath = path.join(path.dirname(planPath), 'T01-SUMMARY.md');
+  const summaryPath = path.join(path.dirname(planPath), 'S01-T01-SUMMARY.md');
   assertTrue(!fs.existsSync(summaryPath), 'SUMMARY.md should be removed so disk state stays pending');
 
   cleanupDir(basePath);

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-engine-cjs-compat.test.ts

@@ -0,0 +1,12 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+test("db engine stays free of import.meta syntax for CommonJS chunks", () => {
+  const enginePath = join(dirname(fileURLToPath(import.meta.url)), "..", "db", "engine.ts");
+  const source = readFileSync(enginePath, "utf-8");
+
+  assert.doesNotMatch(source, /\bimport\.meta\b/);
+});

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 ...)"`,
+      );
+    }
+  });
+});