gsd-pi 2.80.0-dev.42bd34838 → 2.80.0-dev.488219eb6

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", () => {

package/src/resources/extensions/gsd/tests/token-profile.test.ts

@@ -1,325 +1,100 @@
-/**
- * Token Profile — unit tests for M004/S01.
- *
- * Tests profile resolution, preference merging, phase skip defaults,
- * subagent model routing, default-to-balanced behavior, and dispatch
- * table guard clauses (source-level structural verification).
- *
- * Uses source-level checks (readFileSync + string matching) to avoid
- * @gsd/pi-coding-agent import resolution issues in dev environments.
- */
+// GSD-2 — Token profile behavior tests.
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import { extractSourceRegion } from "./test-helpers.ts";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-// ─── Source files for structural checks ───────────────────────────────────
-// After decomposition, code lives across multiple modules. Concatenate them
-// so structural string-matching works regardless of which file holds the code.
-
-const dispatchSrc = readFileSync(join(__dirname, "..", "auto-dispatch.ts"), "utf-8");
-const preferencesSrc = [
-  readFileSync(join(__dirname, "..", "preferences.ts"), "utf-8"),
-  readFileSync(join(__dirname, "..", "preferences-types.ts"), "utf-8"),
-  readFileSync(join(__dirname, "..", "preferences-models.ts"), "utf-8"),
-  readFileSync(join(__dirname, "..", "preferences-validation.ts"), "utf-8"),
-].join("\n");
-const typesSrc = readFileSync(join(__dirname, "..", "types.ts"), "utf-8");
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Type Definitions
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("types: TokenProfile type exported with budget/balanced/quality/burn-max", () => {
-  assert.ok(typesSrc.includes("export type TokenProfile"), "TokenProfile should be exported");
-  assert.match(typesSrc, /["']budget["']/, "should include budget");
-  assert.match(typesSrc, /["']balanced["']/, "should include balanced");
-  assert.match(typesSrc, /["']quality["']/, "should include quality");
-  assert.match(typesSrc, /["']burn-max["']/, "should include burn-max");
-});
-
-test("types: InlineLevel type exported with full/standard/minimal", () => {
-  assert.ok(typesSrc.includes("export type InlineLevel"), "InlineLevel should be exported");
-  assert.match(typesSrc, /["']full["']/, "should include full");
-  assert.match(typesSrc, /["']standard["']/, "should include standard");
-  assert.match(typesSrc, /["']minimal["']/, "should include minimal");
-});
-
-test("types: PhaseSkipPreferences interface exported", () => {
-  assert.ok(typesSrc.includes("export interface PhaseSkipPreferences"), "PhaseSkipPreferences should be exported");
-  assert.ok(typesSrc.includes("skip_research"), "should include skip_research");
-  assert.ok(typesSrc.includes("skip_reassess"), "should include skip_reassess");
-  assert.ok(typesSrc.includes("skip_slice_research"), "should include skip_slice_research");
-  assert.ok(typesSrc.includes("reassess_after_slice"), "should include reassess_after_slice");
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// GSDPreferences Interface
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("preferences: GSDPreferences includes token_profile field", () => {
-  assert.ok(
-    preferencesSrc.includes("token_profile?: TokenProfile"),
-    "GSDPreferences should have token_profile field",
-  );
-});
-
-test("preferences: GSDPreferences includes phases field", () => {
-  assert.ok(
-    preferencesSrc.includes("phases?: PhaseSkipPreferences"),
-    "GSDPreferences should have phases field",
-  );
-});
-
-test("preferences: GSDModelConfig includes subagent field", () => {
-  // Check both v1 and v2 configs
-  const v1Match = preferencesSrc.match(/interface GSDModelConfig\s*\{[^}]*subagent/);
-  assert.ok(v1Match, "GSDModelConfig should have subagent field");
-  const v2Match = preferencesSrc.match(/interface GSDModelConfigV2\s*\{[^}]*subagent/);
-  assert.ok(v2Match, "GSDModelConfigV2 should have subagent field");
-});
-
-test("preferences: KNOWN_PREFERENCE_KEYS includes token_profile and phases", () => {
-  assert.ok(preferencesSrc.includes('"token_profile"'), "KNOWN_PREFERENCE_KEYS should include token_profile");
-  assert.ok(preferencesSrc.includes('"phases"'), "KNOWN_PREFERENCE_KEYS should include phases");
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Profile Resolution
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("profile: resolveProfileDefaults exists and handles all 4 tiers", () => {
-  assert.ok(
-    preferencesSrc.includes("export function resolveProfileDefaults"),
-    "resolveProfileDefaults should be exported",
-  );
-  assert.ok(
-    preferencesSrc.includes('case "budget"') &&
-    preferencesSrc.includes('case "balanced"') &&
-    preferencesSrc.includes('case "quality"') &&
-    preferencesSrc.includes('case "burn-max"'),
-    "resolveProfileDefaults should handle all 4 tiers",
-  );
-});
-
-test("profile: PROFILE_TIER_MAP defines tier intentions for all profiles", async () => {
-  const { getProfileTierMap } = await import("../preferences-models.ts");
-  const profileMaps = {
-    budget: getProfileTierMap("budget"),
-    balanced: getProfileTierMap("balanced"),
-    quality: getProfileTierMap("quality"),
-  };
-
-  assert.deepEqual(
-    Object.keys(profileMaps).sort(),
-    ["balanced", "budget", "quality"],
-    "PROFILE_TIER_MAP should include the profile default tiers",
-  );
+import { validatePreferences } from "../preferences-validation.ts";
+import {
+  getProfileTierMap,
+  resolveProfileDefaults,
+} from "../preferences-models.ts";
 
+test("profile tier maps define provider-agnostic complexity tiers", () => {
   const expectedPhaseKeys = ["completion", "execution", "execution_simple", "planning", "research", "subagent"];
   const validTiers = new Set(["light", "standard", "heavy"]);
-  for (const [profile, tierMap] of Object.entries(profileMaps)) {
-    assert.deepEqual(
-      Object.keys(tierMap).sort(),
-      expectedPhaseKeys,
-      `${profile} should define all model-bearing phases`,
-    );
-    for (const [phase, tier] of Object.entries(tierMap)) {
-      assert.ok(validTiers.has(tier), `${profile}.${phase} should be a tier name`);
-      assert.ok(!tier.includes("claude-"), `${profile}.${phase} should not be a model ID`);
+
+  for (const profile of ["budget", "balanced", "quality"] as const) {
+    const tierMap = getProfileTierMap(profile);
+    assert.deepEqual(Object.keys(tierMap).sort(), expectedPhaseKeys);
+    for (const tier of Object.values(tierMap)) {
+      assert.ok(validTiers.has(tier));
+      assert.doesNotMatch(tier, /claude-|gpt-|gemini-/);
     }
   }
 });
 
-test("profile: resolveProfileDefaults is provider-agnostic — picks OpenAI when only OpenAI is available", async () => {
-  // Behavioral check: with only OpenAI models in the available list, no slot
-  // should resolve to a claude-* model. Source-grep cannot prove this — only
-  // exercising the function with a controlled available-model list can.
-  const { resolveProfileDefaults } = await import("../preferences-models.ts");
+test("profile defaults resolve to available OpenAI models when only OpenAI is available", () => {
   const defaults = resolveProfileDefaults("balanced", ["gpt-4o", "gpt-4o-mini"]);
-  assert.ok(defaults.models, "balanced profile should populate models");
-  for (const [phase, modelId] of Object.entries(defaults.models!)) {
-    assert.ok(
-      typeof modelId === "string" && !String(modelId).startsWith("claude-"),
-      `${phase} resolved to ${modelId} but only OpenAI is available`,
-    );
+  assert.ok(defaults.models);
+  for (const modelId of Object.values(defaults.models!)) {
+    assert.equal(typeof modelId, "string");
+    assert.doesNotMatch(String(modelId), /^claude-/);
   }
 });
 
-test("profile: budget profile sets phase skips to true", () => {
-  // Extract the budget case block
-  const budgetIdx = preferencesSrc.indexOf('case "budget":');
-  const balancedIdx = preferencesSrc.indexOf('case "balanced":');
-  const budgetBlock = preferencesSrc.slice(budgetIdx, balancedIdx);
-  assert.ok(budgetBlock.includes("skip_research: true"), "budget should skip research");
-  assert.ok(budgetBlock.includes("skip_reassess: true"), "budget should skip reassess");
-  assert.ok(budgetBlock.includes("skip_slice_research: true"), "budget should skip slice research");
-});
-
-test("profile: balanced profile skips research, reassess, and slice research (ADR-003)", () => {
-  const balancedIdx = preferencesSrc.indexOf('case "balanced":');
-  const qualityIdx = preferencesSrc.indexOf('case "quality":');
-  const balancedBlock = preferencesSrc.slice(balancedIdx, qualityIdx);
-  assert.ok(balancedBlock.includes("skip_slice_research: true"), "balanced should skip slice research");
-  assert.ok(balancedBlock.includes("skip_research: true"), "balanced should skip milestone research");
-  assert.ok(balancedBlock.includes("skip_reassess: true"), "balanced should skip reassess");
-});
-
-test("profile: quality profile skips research, slice research, and reassess (ADR-003)", () => {
-  const qualityIdx = preferencesSrc.indexOf('case "quality":');
-  // preferencesSrc is concatenated from multiple modules — bound the region
-  // with the next case marker so the assertion stays tightly scoped.
-  const qualityBlock = extractSourceRegion(
-    preferencesSrc,
-    'case "quality":',
-    'case "burn-max":',
-  );
-  assert.ok(qualityBlock.includes("skip_research: true"), "quality should skip research");
-  assert.ok(qualityBlock.includes("skip_slice_research: true"), "quality should skip slice research");
-  assert.ok(qualityBlock.includes("skip_reassess: true"), "quality should skip reassess");
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Default Behavior (D046)
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("profile: resolveEffectiveProfile defaults to balanced (D046)", () => {
-  assert.ok(
-    preferencesSrc.includes("export function resolveEffectiveProfile"),
-    "resolveEffectiveProfile should be exported",
-  );
-  assert.ok(
-    preferencesSrc.includes('return "balanced"'),
-    "resolveEffectiveProfile should default to balanced",
-  );
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Inline Level Mapping
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("profile: resolveInlineLevel maps profile to inline level", () => {
-  assert.ok(
-    preferencesSrc.includes("export function resolveInlineLevel"),
-    "resolveInlineLevel should be exported",
-  );
-  assert.ok(preferencesSrc.includes('case "budget": return "minimal"'), "budget → minimal");
-  assert.ok(preferencesSrc.includes('case "balanced": return "standard"'), "balanced → standard");
-  assert.ok(preferencesSrc.includes('case "quality": return "full"'), "quality → full");
-  assert.ok(preferencesSrc.includes('case "burn-max": return "full"'), "burn-max → full");
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Validation
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("validate: validatePreferences handles token_profile", () => {
-  assert.ok(
-    preferencesSrc.includes("preferences.token_profile") &&
-    preferencesSrc.includes("budget, balanced, quality, burn-max"),
-    "validatePreferences should validate token_profile enum values",
-  );
-});
-
-test("validate: validatePreferences handles phases object", () => {
-  assert.ok(
-    preferencesSrc.includes("preferences.phases") &&
-    preferencesSrc.includes("skip_research") &&
-    preferencesSrc.includes("skip_reassess") &&
-    preferencesSrc.includes("skip_slice_research"),
-    "validatePreferences should validate phases fields",
-  );
-});
-
-test("validate: phases warns on unknown keys", () => {
-  assert.ok(
-    preferencesSrc.includes("knownPhaseKeys") &&
-    preferencesSrc.includes("unknown phases key"),
-    "validatePreferences should warn on unknown phase keys",
-  );
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Merge
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("merge: mergePreferences handles token_profile with nullish coalescing", () => {
-  assert.ok(
-    preferencesSrc.includes("token_profile: override.token_profile ?? base.token_profile"),
-    "mergePreferences should use nullish coalescing for token_profile",
-  );
-});
-
-test("merge: mergePreferences handles phases with spread", () => {
-  assert.ok(
-    preferencesSrc.includes("...(base.phases") && preferencesSrc.includes("...(override.phases"),
-    "mergePreferences should spread phases objects",
-  );
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Subagent Model Routing
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("subagent: budget profile assigns light tier for subagent", () => {
-  // PROFILE_TIER_MAP.budget.subagent should be "light"
-  const tierMapIdx = preferencesSrc.indexOf("PROFILE_TIER_MAP");
-  const budgetIdx = preferencesSrc.indexOf("budget:", tierMapIdx);
-  const balancedIdx = preferencesSrc.indexOf("balanced:", tierMapIdx);
-  const budgetBlock = preferencesSrc.slice(budgetIdx, balancedIdx);
-  assert.ok(budgetBlock.includes("subagent:"), "budget profile should define subagent tier");
-  assert.ok(budgetBlock.includes('"light"'), "budget subagent should use light tier");
-});
-
-test("subagent: resolveModelWithFallbacksForUnit handles subagent unit types", () => {
-  assert.ok(
-    preferencesSrc.includes('"subagent"') && preferencesSrc.includes('startsWith("subagent/")'),
-    "resolveModelWithFallbacksForUnit should handle subagent and subagent/* unit types",
-  );
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Dispatch Table — Phase Skip Guards
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("dispatch: research-milestone rule has skip_research guard", () => {
-  // Find the research-milestone rule and check it has the guard
-  const ruleIdx = dispatchSrc.indexOf("research-milestone");
-  assert.ok(ruleIdx > -1, "should have research-milestone rule");
-  // The guard should appear near this rule
-  assert.ok(
-    dispatchSrc.includes("skip_research") && dispatchSrc.includes("research-milestone"),
-    "research-milestone dispatch rule should check phases.skip_research",
-  );
-});
-
-test("dispatch: research-slice rule has skip guards", () => {
-  const ruleIdx = dispatchSrc.indexOf("research-slice");
-  assert.ok(ruleIdx > -1, "should have research-slice rule");
-  const afterRule = dispatchSrc.slice(ruleIdx);
-  assert.ok(
-    afterRule.includes("skip_research") || afterRule.includes("skip_slice_research"),
-    "research-slice rule should check skip_research or skip_slice_research",
-  );
-});
-
-test("dispatch: reassess-roadmap rule has reassess_after_slice opt-in guard (ADR-003)", () => {
-  assert.ok(
-    dispatchSrc.includes("reassess_after_slice") && dispatchSrc.includes("reassess-roadmap"),
-    "reassess-roadmap dispatch rule should check phases.reassess_after_slice",
-  );
-});
-
-test("dispatch: phase skip guards return null (not stop)", () => {
-  // Verify skip guards use return null pattern
-  const researchGuard = dispatchSrc.match(/skip_research\).*?return null/s);
-  assert.ok(researchGuard, "skip_research guard should return null (fall-through)");
-
-  const reassessGuard = dispatchSrc.match(/reassess_after_slice.*?return null/s);
-  assert.ok(reassessGuard, "reassess_after_slice guard should return null (fall-through)");
+test("budget, balanced, and quality profiles set expected phase skip defaults", () => {
+  assert.deepEqual(resolveProfileDefaults("budget").phases, {
+    skip_research: true,
+    skip_reassess: true,
+    skip_slice_research: true,
+    skip_milestone_validation: true,
+  });
+  assert.deepEqual(resolveProfileDefaults("balanced").phases, {
+    skip_research: true,
+    skip_reassess: true,
+    skip_slice_research: true,
+  });
+  assert.deepEqual(resolveProfileDefaults("quality").phases, {
+    skip_research: true,
+    skip_slice_research: true,
+    skip_reassess: true,
+  });
+});
+
+test("burn-max preserves user model choices and enables full context defaults", () => {
+  const defaults = resolveProfileDefaults("burn-max");
+  assert.equal(defaults.models, undefined);
+  assert.equal(defaults.dynamic_routing?.enabled, false);
+  assert.equal(defaults.context_selection, "full");
+  assert.deepEqual(defaults.phases, {
+    skip_research: false,
+    skip_slice_research: false,
+    skip_reassess: false,
+    skip_milestone_validation: false,
+    reassess_after_slice: true,
+  });
+});
+
+test("validatePreferences accepts token_profile and strict phase booleans", () => {
+  const result = validatePreferences({
+    token_profile: "quality",
+    phases: {
+      skip_research: true,
+      skip_reassess: "false" as any,
+      skip_slice_research: true,
+      reassess_after_slice: false,
+    },
+  });
+
+  assert.equal(result.errors.length, 0);
+  assert.equal(result.preferences.token_profile, "quality");
+  assert.deepEqual(result.preferences.phases, {
+    skip_research: true,
+    skip_reassess: false,
+    skip_slice_research: true,
+    reassess_after_slice: false,
+  });
+});
+
+test("validatePreferences rejects invalid token profiles and warns on unknown phase keys", () => {
+  const result = validatePreferences({
+    token_profile: "fast" as any,
+    phases: {
+      skip_research: true,
+      unknown_phase: true,
+    } as any,
+  });
+
+  assert.ok(result.errors.some((error) => error.includes("token_profile")));
+  assert.ok(result.warnings.some((warning) => warning.includes("unknown phases key")));
 });