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

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

@@ -17,11 +17,13 @@ import {
   insertVerificationEvidence,
   insertGateRow,
   getGateResults,
+  saveReworkBrief,
   updateMilestoneStatus,
   updateSliceStatus,
   SCHEMA_VERSION,
 } from '../gsd-db.ts';
 import { handleCompleteTask } from '../tools/complete-task.ts';
+import { resolveTaskFile } from '../paths.ts';
 
 const { assertEq, assertTrue, assertMatch, report } = createTestContext();
 
@@ -380,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
 // ═══════════════════════════════════════════════════════════════════════════
@@ -415,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);
@@ -507,6 +583,77 @@ console.log('\n=== complete-task: disabled hard-blocker escalation rolls back co
   cleanup(dbPath);
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// complete-task: rollback reverts applied rework resolutions
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== complete-task: rollback reverts applied rework resolutions ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  const { basePath } = createTempProject();
+  writeProjectPreferences(basePath, 'phases:\n  mid_execution_escalation: false\n');
+
+  insertMilestone({ id: 'M001', title: 'Test Milestone' });
+  insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Test Slice' });
+  insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Test task', status: 'pending' });
+  saveReworkBrief({
+    briefId: 'RB-001',
+    milestoneId: 'M001',
+    sliceId: 'S01',
+    taskId: 'T01',
+    findings: [{
+      findingId: 'F1',
+      severity: 'blocking',
+      description: 'Compile regression',
+      requiredFix: 'Fix compile error',
+      verificationCommands: ['pnpm run typecheck:extensions'],
+    }],
+  });
+
+  // Completion resolves the blocking finding but then rolls back because the
+  // hard-blocker escalation is disabled. The rollback must also revert the
+  // finding. Otherwise a retry would see no unresolved blocking findings and
+  // silently skip the blocking gate.
+  const result = await withWorkingDirectory(basePath, () => handleCompleteTask({
+    ...makeValidParams(),
+    blockerDiscovered: true,
+    reworkResolution: [{
+      findingId: 'F1',
+      status: 'resolved',
+      evidence: 'Fixed compile error and reran pnpm run typecheck:extensions.',
+    }],
+    escalation: {
+      question: 'Should execution pause for the hard blocker?',
+      options: makeEscalationOptions(),
+      recommendation: 'pause',
+      recommendationRationale: 'The blocker should not be silently advanced.',
+      continueWithDefault: false,
+    },
+  }, basePath));
+
+  assertTrue('error' in result, 'completion should roll back when hard-blocker escalation is disabled');
+  assertEq(getTask('M001', 'S01', 'T01')?.status, 'pending', 'task status should roll back to pending');
+
+  const finding = _getAdapter()!.prepare(
+    "SELECT status, evidence, decision_ref FROM rework_brief_findings WHERE brief_id = 'RB-001' AND finding_id = 'F1'"
+  ).get() as { status: string; evidence: string; decision_ref: string };
+  assertEq(finding.status, 'pending', 'rework finding should revert to pending after rollback');
+  assertEq(finding.evidence, '', 'rework finding evidence should be cleared after rollback');
+
+  // Retry-safety invariant: the blocking gate must fire again because the
+  // finding is unresolved once more.
+  const retry = await withWorkingDirectory(basePath, () => handleCompleteTask(makeValidParams(), basePath));
+  assertTrue('error' in retry, 'retry without reworkResolution should be blocked again');
+  if ('error' in retry) {
+    assertMatch(retry.error, /unresolved blocking rework finding/i, 'retry should re-trigger the blocking gate');
+  }
+
+  cleanupDir(basePath);
+  cleanup(dbPath);
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // complete-task: soft escalation with mid-execution escalation disabled
 // ═══════════════════════════════════════════════════════════════════════════
@@ -838,6 +985,220 @@ console.log('\n=== complete-task: closes Q5/Q6/Q7 gates (pass vs omitted) ===');
   cleanup(dbPath);
 }
 
+
+// ═══════════════════════════════════════════════════════════════════════════
+// complete-task: unresolved blocking rework findings reject completion
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== complete-task: rejects unresolved blocking rework findings ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+  const { basePath } = createTempProject();
+
+  insertMilestone({ id: 'M001', title: 'Test Milestone' });
+  insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Test Slice' });
+  insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Test task', status: 'pending' });
+
+  saveReworkBrief({
+    briefId: 'RB-001',
+    milestoneId: 'M001',
+    sliceId: 'S01',
+    taskId: 'T01',
+    findings: [{
+      findingId: 'F1',
+      severity: 'blocking',
+      description: 'Compile regression',
+      requiredFix: 'Fix compile error',
+      verificationCommands: ['pnpm run typecheck:extensions'],
+    }],
+  });
+
+  const result = await handleCompleteTask(makeValidParams(), basePath);
+  assertTrue('error' in result, 'completion should reject unresolved blocking rework findings');
+  if ('error' in result) {
+    assertMatch(result.error, /unresolved blocking rework finding/i, 'error should explain unresolved rework');
+    assertMatch(result.error, /F1/, 'error should name the unresolved finding id');
+  }
+
+  cleanupDir(basePath);
+  cleanup(dbPath);
+}
+
+
+console.log('\n=== complete-task: accepts resolved blocking rework evidence ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+  const { basePath } = createTempProject();
+
+  insertMilestone({ id: 'M001', title: 'Test Milestone' });
+  insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Test Slice' });
+  insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Test task', status: 'pending' });
+  saveReworkBrief({
+    briefId: 'RB-001',
+    milestoneId: 'M001',
+    sliceId: 'S01',
+    taskId: 'T01',
+    findings: [{
+      findingId: 'F1',
+      severity: 'blocking',
+      description: 'Compile regression',
+      requiredFix: 'Fix compile error',
+      verificationCommands: ['pnpm run typecheck:extensions'],
+    }],
+  });
+
+  const result = await handleCompleteTask({
+    ...makeValidParams(),
+    reworkResolution: [{
+      findingId: 'F1',
+      status: 'resolved',
+      evidence: 'Fixed compile error and reran pnpm run typecheck:extensions.',
+    }],
+  }, basePath);
+
+  assertTrue(!('error' in result), 'completion should accept resolved blocking rework evidence');
+  assertEq(getTask('M001', 'S01', 'T01')?.status, 'complete', 'task should complete after resolving rework');
+  const finding = _getAdapter()!.prepare("SELECT status, evidence FROM rework_brief_findings WHERE brief_id = 'RB-001' AND finding_id = 'F1'").get() as { status: string; evidence: string };
+  assertEq(finding.status, 'resolved', 'finding status should be updated');
+  assertMatch(finding.evidence, /Fixed compile error/, 'resolution evidence should be persisted');
+
+  cleanupDir(basePath);
+  cleanup(dbPath);
+}
+
+console.log('\n=== complete-task: accepts deferred blocking rework with decision reference ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+  const { basePath } = createTempProject();
+
+  insertMilestone({ id: 'M001', title: 'Test Milestone' });
+  insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Test Slice' });
+  insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Test task', status: 'pending' });
+  saveReworkBrief({
+    briefId: 'RB-001',
+    milestoneId: 'M001',
+    sliceId: 'S01',
+    taskId: 'T01',
+    findings: [{
+      findingId: 'F1',
+      severity: 'blocking',
+      description: 'Compile regression',
+      requiredFix: 'Fix compile error',
+      verificationCommands: ['pnpm run typecheck:extensions'],
+    }],
+  });
+
+  const result = await handleCompleteTask({
+    ...makeValidParams(),
+    reworkResolution: [{
+      findingId: 'F1',
+      status: 'deferred-with-override',
+      evidence: 'Maintainer accepted temporary deferral.',
+      decisionRef: 'DEC-2026-07-07-rework-deferral',
+    }],
+  }, basePath);
+
+  assertTrue(!('error' in result), 'completion should accept deferred blocking rework with decision reference');
+  const finding = _getAdapter()!.prepare("SELECT status, decision_ref FROM rework_brief_findings WHERE brief_id = 'RB-001' AND finding_id = 'F1'").get() as { status: string; decision_ref: string };
+  assertEq(finding.status, 'deferred-with-override', 'finding status should record the override');
+  assertEq(finding.decision_ref, 'DEC-2026-07-07-rework-deferral', 'decision reference should be persisted');
+
+  cleanupDir(basePath);
+  cleanup(dbPath);
+}
+
+console.log('\n=== complete-task: invalid duplicate rework resolution cannot overwrite a valid one ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+  const { basePath } = createTempProject();
+
+  insertMilestone({ id: 'M001', title: 'Test Milestone' });
+  insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Test Slice' });
+  insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Test task', status: 'pending' });
+  saveReworkBrief({
+    briefId: 'RB-001',
+    milestoneId: 'M001',
+    sliceId: 'S01',
+    taskId: 'T01',
+    findings: [{
+      findingId: 'F1',
+      severity: 'blocking',
+      description: 'Compile regression',
+      requiredFix: 'Fix compile error',
+      verificationCommands: ['pnpm run typecheck:extensions'],
+    }],
+  });
+
+  // The guard admits F1 because a satisfying entry exists, but a later
+  // non-satisfying duplicate for the same finding must NOT overwrite the valid
+  // resolution and leave F1 resolved with no evidence.
+  const result = await handleCompleteTask({
+    ...makeValidParams(),
+    reworkResolution: [
+      { findingId: 'F1', status: 'resolved', evidence: 'Fixed compile error and reran pnpm run typecheck:extensions.' },
+      { findingId: 'F1', status: 'resolved', evidence: '' },
+    ],
+  }, basePath);
+
+  assertTrue(!('error' in result), 'completion should succeed on the valid resolution');
+  const finding = _getAdapter()!.prepare(
+    "SELECT status, evidence FROM rework_brief_findings WHERE brief_id = 'RB-001' AND finding_id = 'F1'"
+  ).get() as { status: string; evidence: string };
+  assertEq(finding.status, 'resolved', 'finding should remain resolved');
+  assertMatch(finding.evidence, /Fixed compile error/, 'valid evidence must survive the invalid duplicate');
+
+  cleanupDir(basePath);
+  cleanup(dbPath);
+}
+
+console.log('\n=== complete-task: invalid deferred duplicate cannot strip decisionRef ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+  const { basePath } = createTempProject();
+
+  insertMilestone({ id: 'M001', title: 'Test Milestone' });
+  insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Test Slice' });
+  insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Test task', status: 'pending' });
+  saveReworkBrief({
+    briefId: 'RB-001',
+    milestoneId: 'M001',
+    sliceId: 'S01',
+    taskId: 'T01',
+    findings: [{
+      findingId: 'F1',
+      severity: 'blocking',
+      description: 'Compile regression',
+      requiredFix: 'Fix compile error',
+      verificationCommands: ['pnpm run typecheck:extensions'],
+    }],
+  });
+
+  // A deferred-with-override duplicate that omits decisionRef is non-satisfying
+  // and must not overwrite the valid deferral.
+  const result = await handleCompleteTask({
+    ...makeValidParams(),
+    reworkResolution: [
+      { findingId: 'F1', status: 'deferred-with-override', evidence: 'Maintainer accepted temporary deferral.', decisionRef: 'DEC-2026-07-07-rework-deferral' },
+      { findingId: 'F1', status: 'deferred-with-override', evidence: 'Maintainer accepted temporary deferral.' },
+    ],
+  }, basePath);
+
+  assertTrue(!('error' in result), 'completion should succeed on the valid deferral');
+  const finding = _getAdapter()!.prepare(
+    "SELECT status, decision_ref FROM rework_brief_findings WHERE brief_id = 'RB-001' AND finding_id = 'F1'"
+  ).get() as { status: string; decision_ref: string };
+  assertEq(finding.status, 'deferred-with-override', 'finding should remain deferred-with-override');
+  assertEq(finding.decision_ref, 'DEC-2026-07-07-rework-deferral', 'valid decisionRef must survive the invalid duplicate');
+
+  cleanupDir(basePath);
+  cleanup(dbPath);
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 
 report();

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);
+});