gsd-pi 2.17.0 → 2.19.0

package/src/resources/extensions/gsd/tests/preferences-wizard-fields.test.ts

@@ -0,0 +1,168 @@
+/**
+ * preferences-wizard-fields.test.ts — Validates that all wizard-configurable
+ * preference fields are properly validated and round-trip through the schema.
+ */
+
+import { createTestContext } from "./test-helpers.ts";
+import { validatePreferences } from "../preferences.ts";
+import type { GSDPreferences } from "../preferences.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+async function main(): Promise<void> {
+  console.log("\n=== budget fields validate correctly ===");
+
+  {
+    const { preferences, errors } = validatePreferences({
+      budget_ceiling: 25.50,
+      budget_enforcement: "warn",
+      context_pause_threshold: 80,
+    });
+    assertEq(errors.length, 0, "valid budget fields produce no errors");
+    assertEq(preferences.budget_ceiling, 25.50, "budget_ceiling passes through");
+    assertEq(preferences.budget_enforcement, "warn", "budget_enforcement passes through");
+    assertEq(preferences.context_pause_threshold, 80, "context_pause_threshold passes through");
+  }
+
+  {
+    const { preferences, errors } = validatePreferences({
+      budget_enforcement: "pause",
+    });
+    assertEq(errors.length, 0, "budget_enforcement 'pause' is valid");
+    assertEq(preferences.budget_enforcement, "pause", "pause passes through");
+  }
+
+  {
+    const { preferences, errors } = validatePreferences({
+      budget_enforcement: "halt",
+    });
+    assertEq(errors.length, 0, "budget_enforcement 'halt' is valid");
+    assertEq(preferences.budget_enforcement, "halt", "halt passes through");
+  }
+
+  {
+    const { errors } = validatePreferences({
+      budget_enforcement: "invalid",
+    } as unknown as GSDPreferences);
+    assertTrue(errors.some(e => e.includes("budget_enforcement")), "invalid budget_enforcement rejected");
+  }
+
+  console.log("\n=== notification fields validate correctly ===");
+
+  {
+    const { preferences, errors } = validatePreferences({
+      notifications: {
+        enabled: true,
+        on_complete: false,
+        on_error: true,
+        on_budget: true,
+        on_milestone: false,
+        on_attention: true,
+      },
+    });
+    assertEq(errors.length, 0, "valid notifications produce no errors");
+    assertEq(preferences.notifications?.enabled, true, "notifications.enabled passes through");
+    assertEq(preferences.notifications?.on_complete, false, "notifications.on_complete passes through");
+    assertEq(preferences.notifications?.on_milestone, false, "notifications.on_milestone passes through");
+  }
+
+  {
+    const { errors } = validatePreferences({
+      notifications: "invalid",
+    } as unknown as GSDPreferences);
+    assertTrue(errors.some(e => e.includes("notifications")), "invalid notifications rejected");
+  }
+
+  console.log("\n=== git fields validate correctly ===");
+
+  {
+    const { preferences, errors } = validatePreferences({
+      git: {
+        auto_push: true,
+        push_branches: false,
+        remote: "upstream",
+        snapshots: true,
+        pre_merge_check: "auto",
+        commit_type: "feat",
+        main_branch: "develop",
+        merge_strategy: "squash",
+        isolation: "branch",
+      },
+    });
+    assertEq(errors.length, 0, "valid git fields produce no errors");
+    assertEq(preferences.git?.auto_push, true, "git.auto_push passes through");
+    assertEq(preferences.git?.push_branches, false, "git.push_branches passes through");
+    assertEq(preferences.git?.remote, "upstream", "git.remote passes through");
+    assertEq(preferences.git?.snapshots, true, "git.snapshots passes through");
+    assertEq(preferences.git?.pre_merge_check, "auto", "git.pre_merge_check passes through");
+    assertEq(preferences.git?.commit_type, "feat", "git.commit_type passes through");
+    assertEq(preferences.git?.main_branch, "develop", "git.main_branch passes through");
+    assertEq(preferences.git?.merge_strategy, "squash", "git.merge_strategy passes through");
+    assertEq(preferences.git?.isolation, "branch", "git.isolation passes through");
+  }
+
+  console.log("\n=== uat_dispatch validates correctly ===");
+
+  {
+    const { preferences, errors } = validatePreferences({ uat_dispatch: true });
+    assertEq(errors.length, 0, "valid uat_dispatch produces no errors");
+    assertEq(preferences.uat_dispatch, true, "uat_dispatch true passes through");
+  }
+
+  {
+    const { preferences, errors } = validatePreferences({ uat_dispatch: false });
+    assertEq(errors.length, 0, "valid uat_dispatch false produces no errors");
+    assertEq(preferences.uat_dispatch, false, "uat_dispatch false passes through");
+  }
+
+  console.log("\n=== unique_milestone_ids validates correctly ===");
+
+  {
+    const { preferences, errors } = validatePreferences({ unique_milestone_ids: true });
+    assertEq(errors.length, 0, "valid unique_milestone_ids produces no errors");
+    assertEq(preferences.unique_milestone_ids, true, "unique_milestone_ids passes through");
+  }
+
+  console.log("\n=== all wizard fields together produce no errors ===");
+
+  {
+    const fullPrefs: GSDPreferences = {
+      version: 1,
+      models: { research: "claude-opus-4-6", planning: "claude-sonnet-4-6" },
+      auto_supervisor: { soft_timeout_minutes: 15, idle_timeout_minutes: 5, hard_timeout_minutes: 25 },
+      git: {
+        main_branch: "main",
+        auto_push: true,
+        push_branches: false,
+        remote: "origin",
+        snapshots: true,
+        pre_merge_check: "auto",
+        commit_type: "feat",
+        merge_strategy: "squash",
+        isolation: "worktree",
+      },
+      skill_discovery: "suggest",
+      unique_milestone_ids: false,
+      budget_ceiling: 50,
+      budget_enforcement: "pause",
+      context_pause_threshold: 75,
+      notifications: {
+        enabled: true,
+        on_complete: true,
+        on_error: true,
+        on_budget: true,
+        on_milestone: true,
+        on_attention: true,
+      },
+      uat_dispatch: false,
+    };
+    const { errors, warnings } = validatePreferences(fullPrefs);
+    const unknownWarnings = warnings.filter(w => w.includes("unknown"));
+    assertEq(errors.length, 0, "full wizard prefs produce no errors");
+    assertEq(unknownWarnings.length, 0, "full wizard prefs produce no unknown-key warnings");
+  }
+
+  report();
+}
+
+main();

package/src/resources/extensions/gsd/tests/queue-order.test.ts

@@ -0,0 +1,204 @@
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import {
+  loadQueueOrder,
+  saveQueueOrder,
+  sortByQueueOrder,
+  pruneQueueOrder,
+  validateQueueOrder,
+} from '../queue-order.ts';
+import { createTestContext } from './test-helpers.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+// ─── Fixture Helpers ───────────────────────────────────────────────────────
+
+function createFixtureBase(): string {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-queue-order-'));
+  mkdirSync(join(base, '.gsd'), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  rmSync(base, { recursive: true, force: true });
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// sortByQueueOrder
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== sortByQueueOrder ===');
+
+// Null order → default milestoneIdSort
+{
+  const result = sortByQueueOrder(['M003', 'M001', 'M002'], null);
+  assertEq(result, ['M001', 'M002', 'M003'], 'null order falls back to numeric sort');
+}
+
+// Custom order → exact sequence
+{
+  const result = sortByQueueOrder(['M001', 'M002', 'M003'], ['M003', 'M001', 'M002']);
+  assertEq(result, ['M003', 'M001', 'M002'], 'custom order produces exact sequence');
+}
+
+// Custom order with new IDs → appended at end in numeric order
+{
+  const result = sortByQueueOrder(['M001', 'M002', 'M003', 'M004'], ['M003', 'M001']);
+  assertEq(result, ['M003', 'M001', 'M002', 'M004'], 'new IDs appended in numeric order');
+}
+
+// Custom order with deleted IDs → silently skipped
+{
+  const result = sortByQueueOrder(['M001', 'M003'], ['M003', 'M002', 'M001']);
+  assertEq(result, ['M003', 'M001'], 'deleted IDs in order are skipped');
+}
+
+// Empty custom order → all IDs in numeric order
+{
+  const result = sortByQueueOrder(['M002', 'M001'], []);
+  assertEq(result, ['M001', 'M002'], 'empty custom order falls back to numeric sort');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// loadQueueOrder / saveQueueOrder
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== loadQueueOrder / saveQueueOrder ===');
+
+// Load returns null when file doesn't exist
+{
+  const base = createFixtureBase();
+  assertEq(loadQueueOrder(base), null, 'returns null when file missing');
+  cleanup(base);
+}
+
+// Save then load round-trip
+{
+  const base = createFixtureBase();
+  saveQueueOrder(base, ['M003', 'M001', 'M002']);
+  const loaded = loadQueueOrder(base);
+  assertEq(loaded, ['M003', 'M001', 'M002'], 'round-trip preserves order');
+
+  // Verify file contains updatedAt
+  const raw = JSON.parse(readFileSync(join(base, '.gsd', 'QUEUE-ORDER.json'), 'utf-8'));
+  assertTrue(typeof raw.updatedAt === 'string' && raw.updatedAt.length > 0, 'file contains updatedAt');
+
+  cleanup(base);
+}
+
+// Load returns null on corrupt JSON
+{
+  const base = createFixtureBase();
+  writeFileSync(join(base, '.gsd', 'QUEUE-ORDER.json'), 'not json');
+  assertEq(loadQueueOrder(base), null, 'returns null on corrupt JSON');
+  cleanup(base);
+}
+
+// Load returns null when order field is not an array
+{
+  const base = createFixtureBase();
+  writeFileSync(join(base, '.gsd', 'QUEUE-ORDER.json'), '{"order": "invalid"}');
+  assertEq(loadQueueOrder(base), null, 'returns null when order is not array');
+  cleanup(base);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// pruneQueueOrder
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== pruneQueueOrder ===');
+
+// Prune removes invalid IDs
+{
+  const base = createFixtureBase();
+  saveQueueOrder(base, ['M001', 'M002', 'M003']);
+  pruneQueueOrder(base, ['M001', 'M003']);
+  assertEq(loadQueueOrder(base), ['M001', 'M003'], 'prune removes invalid IDs');
+  cleanup(base);
+}
+
+// Prune no-ops when file doesn't exist
+{
+  const base = createFixtureBase();
+  pruneQueueOrder(base, ['M001']); // should not throw
+  assertTrue(!existsSync(join(base, '.gsd', 'QUEUE-ORDER.json')), 'prune does not create file');
+  cleanup(base);
+}
+
+// Prune no-ops when all IDs are valid
+{
+  const base = createFixtureBase();
+  saveQueueOrder(base, ['M001', 'M002']);
+  pruneQueueOrder(base, ['M001', 'M002', 'M003']);
+  assertEq(loadQueueOrder(base), ['M001', 'M002'], 'prune is no-op when all valid');
+  cleanup(base);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// validateQueueOrder
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== validateQueueOrder ===');
+
+// Valid order with no dependencies
+{
+  const depsMap = new Map<string, string[]>();
+  const result = validateQueueOrder(['M001', 'M002'], depsMap, new Set());
+  assertTrue(result.valid, 'valid when no dependencies');
+  assertEq(result.violations.length, 0, 'no violations');
+  assertEq(result.redundant.length, 0, 'no redundancies');
+}
+
+// Dependency violation: M002 before M001, but M002 depends on M001
+{
+  const depsMap = new Map<string, string[]>([['M002', ['M001']]]);
+  const result = validateQueueOrder(['M002', 'M001'], depsMap, new Set());
+  assertTrue(!result.valid, 'invalid when dep violated');
+  assertEq(result.violations.length, 1, 'one violation');
+  assertEq(result.violations[0].type, 'would_block', 'violation type is would_block');
+  assertEq(result.violations[0].milestone, 'M002', 'violation milestone is M002');
+  assertEq(result.violations[0].dependsOn, 'M001', 'violation dep is M001');
+}
+
+// Redundant dependency: M002 depends on M001, M001 comes first in order
+{
+  const depsMap = new Map<string, string[]>([['M002', ['M001']]]);
+  const result = validateQueueOrder(['M001', 'M002'], depsMap, new Set());
+  assertTrue(result.valid, 'valid when dep satisfied by position');
+  assertEq(result.redundant.length, 1, 'one redundancy');
+  assertEq(result.redundant[0].milestone, 'M002', 'redundant milestone is M002');
+}
+
+// Completed dep is always satisfied
+{
+  const depsMap = new Map<string, string[]>([['M002', ['M001']]]);
+  const result = validateQueueOrder(['M002'], depsMap, new Set(['M001']));
+  assertTrue(result.valid, 'valid when dep is already completed');
+  assertEq(result.violations.length, 0, 'no violations for completed dep');
+}
+
+// Missing dependency
+{
+  const depsMap = new Map<string, string[]>([['M002', ['M099']]]);
+  const result = validateQueueOrder(['M001', 'M002'], depsMap, new Set());
+  assertTrue(!result.valid, 'invalid when dep does not exist');
+  assertEq(result.violations[0].type, 'missing_dep', 'violation type is missing_dep');
+}
+
+// Circular dependency
+{
+  const depsMap = new Map<string, string[]>([
+    ['M001', ['M002']],
+    ['M002', ['M001']],
+  ]);
+  const result = validateQueueOrder(['M001', 'M002'], depsMap, new Set());
+  assertTrue(!result.valid, 'invalid on circular dependency');
+  const circularViolation = result.violations.find(v => v.type === 'circular');
+  assertTrue(!!circularViolation, 'circular violation detected');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+
+report();

package/src/resources/extensions/gsd/tests/queue-reorder-e2e.test.ts

@@ -0,0 +1,281 @@
+/**
+ * End-to-end integration tests for the Queue Reorder feature.
+ *
+ * Verifies the full chain: QUEUE-ORDER.json + findMilestoneIds() + deriveState()
+ * + depends_on removal from CONTEXT.md files.
+ *
+ * These tests simulate what happens when a user reorders milestones and confirms:
+ * 1. QUEUE-ORDER.json is written with the new order
+ * 2. depends_on is removed from CONTEXT.md frontmatter
+ * 3. deriveState() picks the correct milestone as active
+ * 4. A fresh deriveState() call (simulating new session) also works
+ */
+
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import { deriveState, invalidateStateCache } from '../state.ts';
+import { findMilestoneIds } from '../guided-flow.ts';
+import { saveQueueOrder, loadQueueOrder } from '../queue-order.ts';
+import { parseContextDependsOn } from '../files.ts';
+import { createTestContext } from './test-helpers.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+// ─── Fixture Helpers ───────────────────────────────────────────────────────
+
+function createFixtureBase(): string {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-reorder-e2e-'));
+  mkdirSync(join(base, '.gsd', 'milestones'), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  rmSync(base, { recursive: true, force: true });
+}
+
+function writeMilestoneDir(base: string, mid: string): void {
+  mkdirSync(join(base, '.gsd', 'milestones', mid), { recursive: true });
+}
+
+function writeContext(base: string, mid: string, frontmatter: string, body: string = ''): void {
+  const dir = join(base, '.gsd', 'milestones', mid);
+  mkdirSync(dir, { recursive: true });
+  const fm = frontmatter ? `---\n${frontmatter}\n---\n\n` : '';
+  writeFileSync(join(dir, `${mid}-CONTEXT.md`), `${fm}# ${mid}: Test\n\n${body}`);
+}
+
+function writeCompleteMilestone(base: string, mid: string): void {
+  const dir = join(base, '.gsd', 'milestones', mid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${mid}-ROADMAP.md`), `# ${mid}: Complete
+
+**Vision:** Done.
+
+## Slices
+
+- [x] **S01: Done** \`risk:low\` \`depends:[]\`
+  > After this: Done.
+`);
+  writeFileSync(join(dir, `${mid}-SUMMARY.md`), `# ${mid} Summary\n\nComplete.`);
+}
+
+function readContextFile(base: string, mid: string): string {
+  return readFileSync(join(base, '.gsd', 'milestones', mid, `${mid}-CONTEXT.md`), 'utf-8');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Test: Queue order changes milestone activation
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== E2E: queue-order changes active milestone ===');
+{
+  const base = createFixtureBase();
+  try {
+    // Setup: M007 complete, M008 and M009 pending (no context, no roadmap)
+    writeCompleteMilestone(base, 'M007');
+    writeMilestoneDir(base, 'M008');
+    writeContext(base, 'M008', '', 'Multi-Session Parallel Orchestration');
+    writeMilestoneDir(base, 'M009');
+    writeContext(base, 'M009', '', 'Context-Budget Visibility');
+
+    // Without custom order: M008 comes first (numeric sort)
+    invalidateStateCache();
+    const stateBefore = await deriveState(base);
+    assertEq(stateBefore.activeMilestone?.id, 'M008', 'before reorder: M008 is active');
+
+    // Save custom order: M009 before M008
+    saveQueueOrder(base, ['M009', 'M008']);
+
+    // With custom order: M009 should be active
+    invalidateStateCache();
+    const stateAfter = await deriveState(base);
+    assertEq(stateAfter.activeMilestone?.id, 'M009', 'after reorder: M009 is active');
+
+    // findMilestoneIds respects the order
+    const ids = findMilestoneIds(base);
+    const m008Idx = ids.indexOf('M008');
+    const m009Idx = ids.indexOf('M009');
+    assertTrue(m009Idx < m008Idx, 'findMilestoneIds: M009 comes before M008');
+
+  } finally {
+    cleanup(base);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Test: Reorder + depends_on removal = correct state
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== E2E: reorder with depends_on removal ===');
+{
+  const base = createFixtureBase();
+  try {
+    // Setup: M007 complete, M008 depends_on M009, M009 no deps
+    writeCompleteMilestone(base, 'M007');
+    writeContext(base, 'M008', 'depends_on: [M009]', 'Multi-Session Parallel');
+    writeContext(base, 'M009', '', 'Context-Budget Visibility');
+
+    // Before: M008 depends on M009, so deriveState skips M008, M009 is active
+    invalidateStateCache();
+    const stateBefore = await deriveState(base);
+    assertEq(stateBefore.activeMilestone?.id, 'M009', 'before: M009 active (M008 dep-blocked)');
+
+    // Simulate reorder confirm: save order M009→M008, remove depends_on from M008
+    saveQueueOrder(base, ['M009', 'M008']);
+
+    // Remove depends_on from M008-CONTEXT.md (simulating what handleQueueReorder does)
+    const contextContent = readContextFile(base, 'M008');
+    const newContent = contextContent.replace(/---\ndepends_on: \[M009\]\n---\n\n/, '');
+    writeFileSync(join(base, '.gsd', 'milestones', 'M008', 'M008-CONTEXT.md'), newContent);
+
+    // Verify: depends_on is gone
+    const updatedContent = readContextFile(base, 'M008');
+    const deps = parseContextDependsOn(updatedContent);
+    assertEq(deps.length, 0, 'depends_on removed from M008-CONTEXT.md');
+
+    // Verify: deriveState still picks M009 (it's first in queue order)
+    invalidateStateCache();
+    const stateAfter = await deriveState(base);
+    assertEq(stateAfter.activeMilestone?.id, 'M009', 'after: M009 still active (first in queue)');
+
+    // Verify: M008 is now pending (not dep-blocked)
+    const m008Entry = stateAfter.registry.find(m => m.id === 'M008');
+    assertEq(m008Entry?.status, 'pending', 'M008 is pending (not dep-blocked)');
+    assertTrue(!m008Entry?.dependsOn || m008Entry.dependsOn.length === 0, 'M008 has no dependsOn');
+
+  } finally {
+    cleanup(base);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Test: Fresh deriveState (simulating new session) respects queue order
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== E2E: fresh session respects queue order ===');
+{
+  const base = createFixtureBase();
+  try {
+    writeCompleteMilestone(base, 'M007');
+    writeContext(base, 'M008', '', 'Parallel Orchestration');
+    writeContext(base, 'M009', '', 'Budget Visibility');
+
+    // Save queue order
+    saveQueueOrder(base, ['M009', 'M008']);
+
+    // Simulate fresh session — invalidate all caches
+    invalidateStateCache();
+
+    // Derive state — should read QUEUE-ORDER.json from disk
+    const state = await deriveState(base);
+    assertEq(state.activeMilestone?.id, 'M009', 'fresh session: M009 is active');
+
+    // Verify queue order persisted
+    const order = loadQueueOrder(base);
+    assertEq(order, ['M009', 'M008'], 'QUEUE-ORDER.json persisted correctly');
+
+  } finally {
+    cleanup(base);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Test: Queue order with newly added milestones
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== E2E: new milestones appended to queue ===');
+{
+  const base = createFixtureBase();
+  try {
+    writeCompleteMilestone(base, 'M007');
+    writeContext(base, 'M008', '', 'Parallel');
+    writeContext(base, 'M009', '', 'Visibility');
+
+    // Custom order only has M009, M008
+    saveQueueOrder(base, ['M009', 'M008']);
+
+    // Add M010 (not in queue order)
+    writeContext(base, 'M010', '', 'New feature');
+
+    invalidateStateCache();
+    const ids = findMilestoneIds(base);
+
+    // M009 first, M008 second, M010 appended at end
+    const m009Idx = ids.indexOf('M009');
+    const m008Idx = ids.indexOf('M008');
+    const m010Idx = ids.indexOf('M010');
+    assertTrue(m009Idx < m008Idx, 'M009 before M008');
+    assertTrue(m008Idx < m010Idx, 'M008 before M010 (new milestone appended)');
+
+    // M009 is still active (first non-complete in queue order)
+    const state = await deriveState(base);
+    assertEq(state.activeMilestone?.id, 'M009', 'M009 still active after M010 added');
+
+  } finally {
+    cleanup(base);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Test: No queue order file = default numeric sort (backward compat)
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== E2E: backward compat without QUEUE-ORDER.json ===');
+{
+  const base = createFixtureBase();
+  try {
+    writeCompleteMilestone(base, 'M007');
+    writeContext(base, 'M008', '', 'Parallel');
+    writeContext(base, 'M009', '', 'Visibility');
+
+    // No QUEUE-ORDER.json — default numeric sort
+    invalidateStateCache();
+    const state = await deriveState(base);
+    assertEq(state.activeMilestone?.id, 'M008', 'no queue order: M008 active (numeric)');
+
+    const ids = findMilestoneIds(base);
+    assertTrue(ids.indexOf('M008') < ids.indexOf('M009'), 'default sort: M008 before M009');
+
+  } finally {
+    cleanup(base);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Test: depends_on inline array format removal
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== E2E: depends_on inline format preserved after partial removal ===');
+{
+  const base = createFixtureBase();
+  try {
+    writeCompleteMilestone(base, 'M007');
+    // M008 depends on both M009 and M010
+    writeContext(base, 'M008', 'depends_on: [M009, M010]', 'Parallel');
+    writeContext(base, 'M009', '', 'Visibility');
+    writeContext(base, 'M010', '', 'Other');
+
+    // Verify both deps are parsed
+    const contentBefore = readContextFile(base, 'M008');
+    const depsBefore = parseContextDependsOn(contentBefore);
+    assertEq(depsBefore.length, 2, 'M008 has 2 deps before');
+
+    // Simulate removing only M009 dep (keep M010)
+    const content = readContextFile(base, 'M008');
+    const updated = content.replace('depends_on: [M009, M010]', 'depends_on: [M010]');
+    writeFileSync(join(base, '.gsd', 'milestones', 'M008', 'M008-CONTEXT.md'), updated);
+
+    // Verify only M010 remains
+    const contentAfter = readContextFile(base, 'M008');
+    const depsAfter = parseContextDependsOn(contentAfter);
+    assertEq(depsAfter.length, 1, 'M008 has 1 dep after removal');
+    assertEq(depsAfter[0], 'M010', 'remaining dep is M010');
+
+  } finally {
+    cleanup(base);
+  }
+}
+
+report();