gsd-pi 2.80.0-dev.fbe7c8c6f → 2.81.0-dev.3cddbbba2

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

@@ -1,173 +1,21 @@
-/**
- * Regression tests for subagent model preference wiring.
- *
- * Fixes: subagent_model config in reactive_execution was validated and stored
- * but never passed through to subagent dispatch instruction strings, so the
- * executing agent autonomously chose "sonnet" instead of the configured model.
- *
- * Issue: gsd-build/gsd-2#4078
- */
+// GSD-2 — Subagent model dispatch behavior tests.
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { fileURLToPath } from "node:url";
-import { validatePreferences } from "../preferences-validation.ts";
-import { extractSourceRegion } from "./test-helpers.ts";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const promptsSrc = readFileSync(join(__dirname, "..", "auto-prompts.ts"), "utf-8");
-const dispatchSrc = readFileSync(join(__dirname, "..", "auto-dispatch.ts"), "utf-8");
-
-// ─── Preference Validation ────────────────────────────────────────────────
-
-test("reactive_execution: subagent_model is preserved in validated preferences", () => {
-  const result = validatePreferences({
-    reactive_execution: {
-      enabled: true,
-      max_parallel: 2,
-      isolation_mode: "same-tree",
-      subagent_model: "claude-opus-4-6",
-    },
-  });
-  assert.equal(result.errors.length, 0);
-  assert.equal(
-    result.preferences.reactive_execution?.subagent_model,
-    "claude-opus-4-6",
-    "subagent_model should be preserved through validation",
-  );
-});
-
-test("reactive_execution: subagent_model rejects empty string", () => {
-  const result = validatePreferences({
-    reactive_execution: {
-      enabled: true,
-      max_parallel: 2,
-      isolation_mode: "same-tree",
-      subagent_model: "",
-    } as any,
-  });
-  assert.ok(
-    result.errors.some((e) => e.includes("subagent_model")),
-    "empty subagent_model should produce a validation error",
-  );
-});
-
-// ─── Structural: Prompt Builders Accept subagentModel ────────────────────
-
-test("buildReactiveExecutePrompt: accepts subagentModel parameter", () => {
-  const fnStart = promptsSrc.indexOf("export async function buildReactiveExecutePrompt");
-  assert.ok(fnStart !== -1, "buildReactiveExecutePrompt should be exported");
-  const signature = extractSourceRegion(promptsSrc, "export async function buildReactiveExecutePrompt", { fromIdx: fnStart });
-  assert.ok(
-    signature.includes("subagentModel"),
-    "buildReactiveExecutePrompt should accept a subagentModel parameter",
-  );
-});
-
-test("buildParallelResearchSlicesPrompt: accepts subagentModel parameter", () => {
-  const fnStart = promptsSrc.indexOf("export async function buildParallelResearchSlicesPrompt");
-  assert.ok(fnStart !== -1, "buildParallelResearchSlicesPrompt should be exported");
-  const signature = extractSourceRegion(promptsSrc, "export async function buildParallelResearchSlicesPrompt", { fromIdx: fnStart });
-  assert.ok(
-    signature.includes("subagentModel"),
-    "buildParallelResearchSlicesPrompt should accept a subagentModel parameter",
-  );
-});
-
-test("buildGateEvaluatePrompt: accepts subagentModel parameter", () => {
-  const fnStart = promptsSrc.indexOf("export async function buildGateEvaluatePrompt");
-  assert.ok(fnStart !== -1, "buildGateEvaluatePrompt should be exported");
-  const signature = extractSourceRegion(promptsSrc, "export async function buildGateEvaluatePrompt", { fromIdx: fnStart });
-  assert.ok(
-    signature.includes("subagentModel"),
-    "buildGateEvaluatePrompt should accept a subagentModel parameter",
-  );
-});
 
-// ─── Structural: Instruction Strings Inject Model ────────────────────────
-
-test("buildReactiveExecutePrompt: instruction string uses subagentModel when set", () => {
-  const fnStart = promptsSrc.indexOf("export async function buildReactiveExecutePrompt");
-  const fnEnd = promptsSrc.indexOf("\nexport async function", fnStart + 1);
-  const fnBody = promptsSrc.slice(fnStart, fnEnd);
-  assert.ok(
-    fnBody.includes("subagentModel"),
-    "buildReactiveExecutePrompt body should reference subagentModel",
-  );
-  // The instruction line must be dynamic (not a plain string literal)
-  assert.ok(
-    !fnBody.includes('"Use this as the prompt for a `subagent` call:"'),
-    "instruction should not be a plain static string — model must be injectable",
-  );
-});
-
-test("buildParallelResearchSlicesPrompt: instruction string uses subagentModel when set", () => {
-  const fnStart = promptsSrc.indexOf("export async function buildParallelResearchSlicesPrompt");
-  const fnEnd = promptsSrc.indexOf("\nexport async function", fnStart + 1);
-  const fnBody = promptsSrc.slice(fnStart, fnEnd);
-  assert.ok(
-    fnBody.includes("subagentModel"),
-    "buildParallelResearchSlicesPrompt body should reference subagentModel",
-  );
-});
-
-test("buildGateEvaluatePrompt: instruction string uses subagentModel when set", () => {
-  const fnStart = promptsSrc.indexOf("export async function buildGateEvaluatePrompt");
-  const fnEnd = promptsSrc.indexOf("\nexport async function", fnStart + 1);
-  const fnBody = promptsSrc.slice(fnStart, fnEnd);
-  assert.ok(
-    fnBody.includes("subagentModel"),
-    "buildGateEvaluatePrompt body should reference subagentModel",
-  );
-});
-
-// ─── Structural: Dispatch Wires Model to Prompt Builders ─────────────────
-
-test("auto-dispatch: passes model to buildReactiveExecutePrompt", () => {
-  // Find the reactive-execute dispatch rule
-  const ruleStart = dispatchSrc.indexOf("reactive-execute (parallel dispatch)");
-  assert.ok(ruleStart !== -1, "reactive-execute dispatch rule should exist");
-  const ruleBlock = extractSourceRegion(dispatchSrc, "reactive-execute (parallel dispatch)", { fromIdx: ruleStart });
-  assert.ok(
-    ruleBlock.includes("subagent_model") || ruleBlock.includes("subagentModel"),
-    "reactive-execute rule should resolve and pass the subagent model",
-  );
-});
-
-test("auto-dispatch: passes model to buildParallelResearchSlicesPrompt", () => {
-  const callIdx = dispatchSrc.indexOf("buildParallelResearchSlicesPrompt(");
-  assert.ok(callIdx !== -1, "buildParallelResearchSlicesPrompt call should exist");
-  // The call site should pass a model argument (not just 4 args)
-  const callSite = extractSourceRegion(dispatchSrc, "buildParallelResearchSlicesPrompt(", { fromIdx: callIdx });
-  assert.ok(
-    callSite.includes("subagentModel") || callSite.includes("resolveModelWithFallbacksForUnit"),
-    "buildParallelResearchSlicesPrompt call should include model argument",
-  );
-});
-
-test("auto-dispatch: passes model to buildGateEvaluatePrompt", () => {
-  const callIdx = dispatchSrc.indexOf("buildGateEvaluatePrompt(");
-  assert.ok(callIdx !== -1, "buildGateEvaluatePrompt call should exist");
-  const callSite = extractSourceRegion(dispatchSrc, "buildGateEvaluatePrompt(", { fromIdx: callIdx });
-  assert.ok(
-    callSite.includes("subagentModel") || callSite.includes("resolveModelWithFallbacksForUnit"),
-    "buildGateEvaluatePrompt call should include model argument",
-  );
-});
-
-// ─── Integration: Prompt Output Contains Model String ────────────────────
-
-test("buildReactiveExecutePrompt: output contains model string when subagentModel provided", async (t) => {
-  const { buildReactiveExecutePrompt } = await import("../auto-prompts.ts");
-  const repo = mkdtempSync(join(tmpdir(), "gsd-subagent-model-reactive-"));
-  t.after(() => rmSync(repo, { recursive: true, force: true }));
+import { validatePreferences } from "../preferences-validation.ts";
+import {
+  buildGateEvaluatePrompt,
+  buildParallelResearchSlicesPrompt,
+  buildReactiveExecutePrompt,
+} from "../auto-prompts.ts";
 
+function writeReactiveFixture(repo: string): void {
   const gsd = join(repo, ".gsd", "milestones", "M001", "slices", "S01");
   mkdirSync(join(gsd, "tasks"), { recursive: true });
-
   writeFileSync(
     join(gsd, "S01-PLAN.md"),
     [
@@ -183,7 +31,6 @@ test("buildReactiveExecutePrompt: output contains model string when subagentMode
       "",
     ].join("\n"),
   );
-
   writeFileSync(
     join(gsd, "tasks", "T01-PLAN.md"),
     [
@@ -201,82 +48,87 @@ test("buildReactiveExecutePrompt: output contains model string when subagentMode
       "- `src/out.ts` — Result",
     ].join("\n"),
   );
+}
+
+test("reactive_execution subagent_model is preserved in validated preferences", () => {
+  const result = validatePreferences({
+    reactive_execution: {
+      enabled: true,
+      max_parallel: 2,
+      isolation_mode: "same-tree",
+      subagent_model: "claude-opus-4-6",
+    },
+  });
+  assert.equal(result.errors.length, 0);
+  assert.equal(result.preferences.reactive_execution?.subagent_model, "claude-opus-4-6");
+});
+
+test("reactive_execution subagent_model rejects empty string", () => {
+  const result = validatePreferences({
+    reactive_execution: {
+      enabled: true,
+      max_parallel: 2,
+      isolation_mode: "same-tree",
+      subagent_model: "",
+    } as any,
+  });
+  assert.ok(result.errors.some((e) => e.includes("subagent_model")));
+});
+
+test("buildReactiveExecutePrompt injects subagent model when provided", async (t) => {
+  const repo = mkdtempSync(join(tmpdir(), "gsd-subagent-model-reactive-"));
+  t.after(() => rmSync(repo, { recursive: true, force: true }));
+  writeReactiveFixture(repo);
 
   const prompt = await buildReactiveExecutePrompt(
-    "M001", "Test Milestone", "S01", "Test Slice",
-    ["T01"], repo, "claude-opus-4-6",
+    "M001",
+    "Test Milestone",
+    "S01",
+    "Test Slice",
+    ["T01"],
+    repo,
+    "claude-opus-4-6",
   );
 
-  assert.ok(
-    prompt.includes('model: "claude-opus-4-6"'),
-    `Prompt should contain model instruction. Got:\n${prompt.slice(0, 500)}`,
-  );
-  assert.ok(
-    prompt.includes("Context Mode (execution lane):"),
-    "embedded reactive-execute task prompt should use nested Context Mode guidance",
-  );
-  assert.ok(
-    prompt.includes("## Context Mode"),
-    "reactive-execute parent prompt should include standalone Context Mode guidance",
-  );
+  assert.match(prompt, /model: "claude-opus-4-6"/);
+  assert.match(prompt, /Context Mode \(execution lane\):/);
+  assert.match(prompt, /## Context Mode/);
 });
 
-test("buildReactiveExecutePrompt: no model instruction when subagentModel omitted", async (t) => {
-  const { buildReactiveExecutePrompt } = await import("../auto-prompts.ts");
+test("buildReactiveExecutePrompt omits model instruction when subagentModel is omitted", async (t) => {
   const repo = mkdtempSync(join(tmpdir(), "gsd-subagent-model-none-"));
   t.after(() => rmSync(repo, { recursive: true, force: true }));
+  writeReactiveFixture(repo);
 
-  const gsd = join(repo, ".gsd", "milestones", "M001", "slices", "S01");
-  mkdirSync(join(gsd, "tasks"), { recursive: true });
-
-  writeFileSync(
-    join(gsd, "S01-PLAN.md"),
-    [
-      "# S01: Test Slice",
-      "",
-      "**Goal:** Verify no model when omitted",
-      "**Demo:** No model string",
-      "",
-      "## Tasks",
-      "",
-      "- [ ] **T01: Task One** `est:15m`",
-      "  Do something.",
-      "",
-    ].join("\n"),
+  const prompt = await buildReactiveExecutePrompt(
+    "M001",
+    "Test Milestone",
+    "S01",
+    "Test Slice",
+    ["T01"],
+    repo,
   );
 
-  writeFileSync(
-    join(gsd, "tasks", "T01-PLAN.md"),
-    [
-      "# T01: Task One",
-      "",
-      "## Description",
-      "Do something.",
-      "",
-      "## Inputs",
-      "",
-      "- `src/config.json` — Config",
-      "",
-      "## Expected Output",
-      "",
-      "- `src/out.ts` — Result",
-    ].join("\n"),
-  );
+  assert.doesNotMatch(prompt, /with model:/);
+});
 
-  const prompt = await buildReactiveExecutePrompt(
-    "M001", "Test Milestone", "S01", "Test Slice",
-    ["T01"], repo,
-    // no subagentModel
-  );
+test("buildParallelResearchSlicesPrompt injects subagent model for each slice", async (t) => {
+  const repo = mkdtempSync(join(tmpdir(), "gsd-subagent-model-parallel-"));
+  t.after(() => rmSync(repo, { recursive: true, force: true }));
+  mkdirSync(join(repo, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
 
-  assert.ok(
-    !prompt.includes('with model:'),
-    "Prompt should not contain model instruction when subagentModel is omitted",
+  const prompt = await buildParallelResearchSlicesPrompt(
+    "M001",
+    "Test Milestone",
+    [{ id: "S01", title: "Research Slice" }],
+    repo,
+    "claude-opus-4-6",
   );
+
+  assert.match(prompt, /model: "claude-opus-4-6"/);
 });
 
-test("buildGateEvaluatePrompt: embedded gate prompts use nested Context Mode guidance", async (t) => {
-  const { buildGateEvaluatePrompt } = await import("../auto-prompts.ts");
+test("buildGateEvaluatePrompt uses nested context guidance and model instruction", async (t) => {
   const { closeDatabase, insertGateRow, insertMilestone, insertSlice, openDatabase } = await import("../gsd-db.ts");
   const repo = mkdtempSync(join(tmpdir(), "gsd-subagent-model-gate-"));
   t.after(() => {
@@ -315,13 +167,7 @@ test("buildGateEvaluatePrompt: embedded gate prompts use nested Context Mode gui
     "claude-opus-4-6",
   );
 
-  assert.ok(
-    prompt.includes("Context Mode (verification lane):"),
-    "embedded gate-evaluate prompt should use nested Context Mode guidance",
-  );
-  assert.ok(
-    prompt.includes("## Context Mode"),
-    "gate-evaluate parent prompt should include standalone Context Mode guidance",
-  );
-  assert.ok(prompt.includes('model: "claude-opus-4-6"'), "gate subagent prompt should preserve model instruction");
+  assert.match(prompt, /Context Mode \(verification lane\):/);
+  assert.match(prompt, /## Context Mode/);
+  assert.match(prompt, /model: "claude-opus-4-6"/);
 });

package/src/resources/extensions/gsd/tests/sync-worktree-skip-current.test.ts

@@ -1,43 +1,40 @@
 /**
  * Regression test for DB-authoritative syncWorktreeStateBack behavior.
- *
- * Worktree milestone projections are not authoritative. syncWorktreeStateBack
- * may reconcile a legacy worktree DB and copy diagnostics, but must not copy
- * milestone markdown directories back into the project root.
  */
 
-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";
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 
-const src = readFileSync(
-  resolve(process.cwd(), 'src', 'resources', 'extensions', 'gsd', 'auto-worktree.ts'),
-  'utf-8',
-)
+import { syncWorktreeStateBack } from "../auto-worktree.ts";
 
-describe('syncWorktreeStateBack does not copy worktree milestone projections', () => {
-  it('syncWorktreeStateBack function exists', () => {
-    assert.ok(
-      src.includes('function syncWorktreeStateBack('),
-      'syncWorktreeStateBack function must be defined',
-    )
-  })
+describe("syncWorktreeStateBack does not copy worktree milestone projections", () => {
+  it("copies root diagnostics but leaves milestone markdown directories behind", () => {
+    const root = mkdtempSync(join(tmpdir(), "gsd-sync-back-"));
+    const main = join(root, "main");
+    const worktree = join(root, "worktree");
+    try {
+      mkdirSync(join(main, ".gsd", "milestones"), { recursive: true });
+      mkdirSync(join(worktree, ".gsd", "milestones", "M001"), { recursive: true });
+      writeFileSync(join(worktree, ".gsd", "metrics.json"), "{}\n", "utf-8");
+      writeFileSync(
+        join(worktree, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+        "# M001: Worktree-only projection\n",
+        "utf-8",
+      );
 
-  it('does not iterate worktree milestones for copy-back', () => {
-    // Find syncWorktreeStateBack
-    const fnStart = src.indexOf('function syncWorktreeStateBack(')
-    assert.ok(fnStart !== -1)
+      const result = syncWorktreeStateBack(main, worktree, "M001");
 
-    // Get a reasonable portion of the function
-    const fnBlock = extractSourceRegion(src, 'function syncWorktreeStateBack(', { fromIdx: fnStart })
-
-    assert.ok(!fnBlock.includes('for (const mid of wtMilestones)'), 'must not iterate worktree milestones')
-    assert.ok(!fnBlock.includes('syncMilestoneDir('), 'must not copy milestone markdown projections')
-  })
-
-  it('legacy milestone copy helper has been removed', () => {
-    assert.ok(!src.includes('function syncMilestoneDir('), 'syncMilestoneDir helper should not exist')
-  })
-})
+      assert.deepEqual(result.synced, ["metrics.json"]);
+      assert.equal(existsSync(join(main, ".gsd", "metrics.json")), true);
+      assert.equal(
+        existsSync(join(main, ".gsd", "milestones", "M001", "M001-ROADMAP.md")),
+        false,
+      );
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+});

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

@@ -0,0 +1,112 @@
+// Project/App: GSD-2
+// File Purpose: System context memory gating regression tests.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { buildContextMessage, isLowEntropyResumePrompt, loadMemoryBlock } from "../bootstrap/system-context.ts";
+import { closeDatabase, openDatabase } from "../gsd-db.ts";
+import { createMemory } from "../memory-store.ts";
+
+test("buildContextMessage marks hidden guided context when memory is supplied", () => {
+  const message = buildContextMessage({
+    memoryBlock: "\n\n[MEMORY]\n\n- keep this",
+    injection: "[GSD Guided Execute Context]\nUse the task plan.",
+    forensicsInjection: null,
+  });
+
+  assert.ok(message, "expected hidden context message");
+  assert.equal(message.customType, "gsd-guided-context");
+  assert.equal(message.display, false);
+  assert.match(message.content, /\[GSD Context Metadata\]\n- Memory supplied: yes/);
+  assert.ok(
+    message.content.indexOf("Memory supplied: yes") < message.content.indexOf("[GSD Guided Execute Context]"),
+    "memory marker should appear before guided context",
+  );
+});
+
+test("buildContextMessage caps hidden context by default", () => {
+  const original = process.env.PI_GSD_CONTEXT_MAX_CHARS;
+  delete process.env.PI_GSD_CONTEXT_MAX_CHARS;
+  try {
+    const message = buildContextMessage({
+      memoryBlock: "",
+      injection: `[GSD Guided Execute Context]\n${"large context\n".repeat(500)}`,
+      forensicsInjection: null,
+    });
+
+    assert.ok(message, "expected hidden context message");
+    assert.equal(message.customType, "gsd-guided-context");
+    assert.ok(message.content.length <= 4000);
+    assert.match(message.content, /\[GSD Context Truncated\]/);
+  } finally {
+    if (original === undefined) delete process.env.PI_GSD_CONTEXT_MAX_CHARS;
+    else process.env.PI_GSD_CONTEXT_MAX_CHARS = original;
+  }
+});
+
+test("buildContextMessage supports explicit context cap override", () => {
+  const original = process.env.PI_GSD_CONTEXT_MAX_CHARS;
+  process.env.PI_GSD_CONTEXT_MAX_CHARS = "1200";
+  try {
+    const message = buildContextMessage({
+      memoryBlock: "",
+      injection: `[GSD Guided Execute Context]\n${"large context\n".repeat(200)}`,
+      forensicsInjection: null,
+    });
+
+    assert.ok(message, "expected hidden context message");
+    assert.equal(message.customType, "gsd-guided-context");
+    assert.ok(message.content.length <= 1200);
+    assert.match(message.content, /\[GSD Context Truncated\]/);
+  } finally {
+    if (original === undefined) delete process.env.PI_GSD_CONTEXT_MAX_CHARS;
+    else process.env.PI_GSD_CONTEXT_MAX_CHARS = original;
+  }
+});
+
+test("buildContextMessage does not add memory marker when only guided context is supplied", () => {
+  const message = buildContextMessage({
+    memoryBlock: "",
+    injection: "[GSD Guided Execute Context]\nUse the task plan.",
+    forensicsInjection: null,
+  });
+
+  assert.ok(message, "expected guided context message");
+  assert.equal(message.customType, "gsd-guided-context");
+  assert.doesNotMatch(message.content, /Memory supplied: yes/);
+});
+
+test("loadMemoryBlock keeps critical memories while gating prompt-relevant query hits", async () => {
+  closeDatabase();
+  assert.equal(openDatabase(":memory:"), true);
+  try {
+    createMemory({
+      category: "gotcha",
+      content: "Always preserve critical resume safety context.",
+      confidence: 0.95,
+    });
+    createMemory({
+      category: "preference",
+      content: "React dashboard preference should only appear for a React prompt query.",
+      confidence: 0.95,
+    });
+
+    const withPromptRelevant = await loadMemoryBlock("React dashboard", { includePromptRelevant: true });
+    assert.match(withPromptRelevant, /critical resume safety context/);
+    assert.match(withPromptRelevant, /React dashboard preference/);
+
+    const withoutPromptRelevant = await loadMemoryBlock("React dashboard", { includePromptRelevant: false });
+    assert.match(withoutPromptRelevant, /critical resume safety context/);
+    assert.doesNotMatch(withoutPromptRelevant, /React dashboard preference/);
+  } finally {
+    closeDatabase();
+  }
+});
+
+test("isLowEntropyResumePrompt identifies bare resume prompts only", () => {
+  assert.equal(isLowEntropyResumePrompt("continue"), true);
+  assert.equal(isLowEntropyResumePrompt("Go ahead."), true);
+  assert.equal(isLowEntropyResumePrompt("run the tests"), false);
+  assert.equal(isLowEntropyResumePrompt("/gsd auto"), false);
+});

package/src/resources/extensions/gsd/tests/system-context-message-routing.test.ts

@@ -1,9 +1,5 @@
-// GSD bootstrap + system-context-message-routing.test — regression coverage
-// for #5019. `memoryBlock` is FTS-queried against the user prompt and changes
-// per call; embedding it in the cached system prefix invalidates Anthropic
-// prompt-cache hits on every request. The fix routes memory through the
-// existing context-message channel (volatile user-message suffix) and combines
-// it with any active guided-execute or forensics injection.
+// Project/App: GSD-2
+// File Purpose: Regression coverage for volatile system-context message routing.
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
@@ -11,6 +7,8 @@ import assert from "node:assert/strict";
 import { buildContextMessage } from "../bootstrap/system-context.ts";
 
 describe("buildContextMessage (#5019 — memory routing)", () => {
+  const markedMemory = "[GSD Context Metadata]\n- Memory supplied: yes\n\n[MEMORY]\nrule one";
+
   test("returns null when nothing to inject", () => {
     const result = buildContextMessage({
       memoryBlock: "",
@@ -37,7 +35,7 @@ describe("buildContextMessage (#5019 — memory routing)", () => {
     });
     assert.ok(result, "expected a context message");
     assert.equal(result.customType, "gsd-memory");
-    assert.equal(result.content, "[MEMORY]\nrule one\nrule two");
+    assert.equal(result.content, "[GSD Context Metadata]\n- Memory supplied: yes\n\n[MEMORY]\nrule one\nrule two");
     assert.equal(result.display, false);
   });
 
@@ -71,7 +69,7 @@ describe("buildContextMessage (#5019 — memory routing)", () => {
     });
     assert.ok(result);
     assert.equal(result.customType, "gsd-guided-context");
-    assert.equal(result.content, "[MEMORY]\nrule one\n\n[GUIDED]\nexecute T01");
+    assert.equal(result.content, `${markedMemory}\n\n[GUIDED]\nexecute T01`);
   });
 
   test("memory + forensics: memory prepended, customType is gsd-forensics", () => {
@@ -82,7 +80,7 @@ describe("buildContextMessage (#5019 — memory routing)", () => {
     });
     assert.ok(result);
     assert.equal(result.customType, "gsd-forensics");
-    assert.equal(result.content, "[MEMORY]\nrule one\n\n[FORENSICS]\ninvestigation context");
+    assert.equal(result.content, `${markedMemory}\n\n[FORENSICS]\ninvestigation context`);
   });
 
   test("guided takes precedence over forensics when both are somehow present", () => {