gsd-pi 2.17.0 → 2.18.0

package/dist/resources/extensions/gsd/tests/knowledge.test.ts

@@ -0,0 +1,161 @@
+/**
+ * Unit tests for KNOWLEDGE.md integration.
+ *
+ * Tests:
+ * - KNOWLEDGE is registered in GSD_ROOT_FILES
+ * - resolveGsdRootFile resolves KNOWLEDGE paths correctly
+ * - inlineGsdRootFile works with the KNOWLEDGE key
+ * - before_agent_start hook includes/omits knowledge block appropriately
+ */
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { GSD_ROOT_FILES, resolveGsdRootFile } from '../paths.ts';
+import { inlineGsdRootFile } from '../auto-prompts.ts';
+import { appendKnowledge } from '../files.ts';
+
+// ─── KNOWLEDGE is registered in GSD_ROOT_FILES ─────────────────────────────
+
+test('knowledge: KNOWLEDGE key exists in GSD_ROOT_FILES', () => {
+  assert.ok('KNOWLEDGE' in GSD_ROOT_FILES, 'GSD_ROOT_FILES should have KNOWLEDGE key');
+  assert.strictEqual(GSD_ROOT_FILES.KNOWLEDGE, 'KNOWLEDGE.md');
+});
+
+// ─── resolveGsdRootFile resolves KNOWLEDGE.md ───────────────────────────────
+
+test('knowledge: resolveGsdRootFile returns canonical path when KNOWLEDGE.md exists', () => {
+  const tmp = mkdtempSync(join(tmpdir(), 'gsd-knowledge-'));
+  const gsdDir = join(tmp, '.gsd');
+  mkdirSync(gsdDir, { recursive: true });
+  writeFileSync(join(gsdDir, 'KNOWLEDGE.md'), '# Project Knowledge\n');
+
+  const resolved = resolveGsdRootFile(tmp, 'KNOWLEDGE');
+  assert.strictEqual(resolved, join(gsdDir, 'KNOWLEDGE.md'));
+
+  rmSync(tmp, { recursive: true, force: true });
+});
+
+test('knowledge: resolveGsdRootFile resolves when legacy knowledge.md exists', () => {
+  const tmp = mkdtempSync(join(tmpdir(), 'gsd-knowledge-'));
+  const gsdDir = join(tmp, '.gsd');
+  mkdirSync(gsdDir, { recursive: true });
+  writeFileSync(join(gsdDir, 'knowledge.md'), '# Project Knowledge\n');
+
+  const resolved = resolveGsdRootFile(tmp, 'KNOWLEDGE');
+  // On case-insensitive filesystems (macOS), canonical path matches;
+  // on case-sensitive (Linux), legacy path matches. Either is valid.
+  const canonical = join(gsdDir, 'KNOWLEDGE.md');
+  const legacy = join(gsdDir, 'knowledge.md');
+  assert.ok(
+    resolved === canonical || resolved === legacy,
+    `resolved path should be canonical or legacy, got: ${resolved}`,
+  );
+
+  rmSync(tmp, { recursive: true, force: true });
+});
+
+test('knowledge: resolveGsdRootFile returns canonical path when file does not exist', () => {
+  const tmp = mkdtempSync(join(tmpdir(), 'gsd-knowledge-'));
+  const gsdDir = join(tmp, '.gsd');
+  mkdirSync(gsdDir, { recursive: true });
+
+  const resolved = resolveGsdRootFile(tmp, 'KNOWLEDGE');
+  assert.strictEqual(resolved, join(gsdDir, 'KNOWLEDGE.md'));
+
+  rmSync(tmp, { recursive: true, force: true });
+});
+
+// ─── inlineGsdRootFile works with knowledge.md ─────────────────────────────
+
+test('knowledge: inlineGsdRootFile returns content when KNOWLEDGE.md exists', async () => {
+  const tmp = mkdtempSync(join(tmpdir(), 'gsd-knowledge-'));
+  const gsdDir = join(tmp, '.gsd');
+  mkdirSync(gsdDir, { recursive: true });
+  writeFileSync(join(gsdDir, 'KNOWLEDGE.md'), '# Project Knowledge\n\n## Rules\n\nK001: Use real DB');
+
+  const result = await inlineGsdRootFile(tmp, 'knowledge.md', 'Project Knowledge');
+  assert.ok(result !== null, 'should return content');
+  assert.ok(result!.includes('Project Knowledge'), 'should include label');
+  assert.ok(result!.includes('K001'), 'should include knowledge content');
+
+  rmSync(tmp, { recursive: true, force: true });
+});
+
+test('knowledge: inlineGsdRootFile returns null when KNOWLEDGE.md does not exist', async () => {
+  const tmp = mkdtempSync(join(tmpdir(), 'gsd-knowledge-'));
+  const gsdDir = join(tmp, '.gsd');
+  mkdirSync(gsdDir, { recursive: true });
+
+  const result = await inlineGsdRootFile(tmp, 'knowledge.md', 'Project Knowledge');
+  assert.strictEqual(result, null, 'should return null when file does not exist');
+
+  rmSync(tmp, { recursive: true, force: true });
+});
+
+// ─── appendKnowledge creates file and appends entries ──────────────────────
+
+test('knowledge: appendKnowledge creates KNOWLEDGE.md with rule when file does not exist', async () => {
+  const tmp = mkdtempSync(join(tmpdir(), 'gsd-knowledge-'));
+  const gsdDir = join(tmp, '.gsd');
+  mkdirSync(gsdDir, { recursive: true });
+
+  await appendKnowledge(tmp, 'rule', 'Use real DB for integration tests', 'M001/S01');
+
+  const content = readFileSync(join(gsdDir, 'KNOWLEDGE.md'), 'utf-8');
+  assert.ok(content.includes('# Project Knowledge'), 'should have header');
+  assert.ok(content.includes('K001'), 'should have K001 id');
+  assert.ok(content.includes('Use real DB for integration tests'), 'should have rule text');
+  assert.ok(content.includes('M001/S01'), 'should have scope');
+
+  rmSync(tmp, { recursive: true, force: true });
+});
+
+test('knowledge: appendKnowledge appends to existing KNOWLEDGE.md with auto-incrementing ID', async () => {
+  const tmp = mkdtempSync(join(tmpdir(), 'gsd-knowledge-'));
+  const gsdDir = join(tmp, '.gsd');
+  mkdirSync(gsdDir, { recursive: true });
+
+  // Create initial file with one rule
+  await appendKnowledge(tmp, 'rule', 'First rule', 'M001');
+  // Add second rule
+  await appendKnowledge(tmp, 'rule', 'Second rule', 'M001/S02');
+
+  const content = readFileSync(join(gsdDir, 'KNOWLEDGE.md'), 'utf-8');
+  assert.ok(content.includes('K001'), 'should have K001');
+  assert.ok(content.includes('K002'), 'should have K002');
+  assert.ok(content.includes('First rule'), 'should have first rule');
+  assert.ok(content.includes('Second rule'), 'should have second rule');
+
+  rmSync(tmp, { recursive: true, force: true });
+});
+
+test('knowledge: appendKnowledge handles pattern type', async () => {
+  const tmp = mkdtempSync(join(tmpdir(), 'gsd-knowledge-'));
+  const gsdDir = join(tmp, '.gsd');
+  mkdirSync(gsdDir, { recursive: true });
+
+  await appendKnowledge(tmp, 'pattern', 'Middleware chain for auth', 'M001');
+
+  const content = readFileSync(join(gsdDir, 'KNOWLEDGE.md'), 'utf-8');
+  assert.ok(content.includes('P001'), 'should have P001 id');
+  assert.ok(content.includes('Middleware chain for auth'), 'should have pattern text');
+
+  rmSync(tmp, { recursive: true, force: true });
+});
+
+test('knowledge: appendKnowledge handles lesson type', async () => {
+  const tmp = mkdtempSync(join(tmpdir(), 'gsd-knowledge-'));
+  const gsdDir = join(tmp, '.gsd');
+  mkdirSync(gsdDir, { recursive: true });
+
+  await appendKnowledge(tmp, 'lesson', 'API timeout on large payloads', 'M002');
+
+  const content = readFileSync(join(gsdDir, 'KNOWLEDGE.md'), 'utf-8');
+  assert.ok(content.includes('L001'), 'should have L001 id');
+  assert.ok(content.includes('API timeout on large payloads'), 'should have lesson text');
+
+  rmSync(tmp, { recursive: true, force: true });
+});

package/dist/resources/extensions/gsd/tests/memory-leak-guards.test.ts

@@ -0,0 +1,87 @@
+/**
+ * memory-leak-guards.test.ts — Tests for #611 memory leak fixes.
+ *
+ * Verifies that module-level state accumulators are properly bounded
+ * and cleared to prevent OOM during long-running auto-mode sessions.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { saveActivityLog, clearActivityLogState } from "../activity-log.ts";
+import { clearPathCache } from "../paths.ts";
+import type { ExtensionContext } from "@gsd/pi-coding-agent";
+
+function createCtx(entries: unknown[]) {
+  return { sessionManager: { getEntries: () => entries } } as unknown as ExtensionContext;
+}
+
+// ─── activity-log: clearActivityLogState ─────────────────────────────────────
+
+test("clearActivityLogState resets dedup state so identical saves write again", () => {
+  clearActivityLogState();
+  const baseDir = mkdtempSync(join(tmpdir(), "gsd-memleak-test-"));
+  try {
+    const entries = [{ role: "assistant", content: "test entry" }];
+    const ctx = createCtx(entries);
+
+    // First save
+    saveActivityLog(ctx, baseDir, "execute-task", "M001/S01/T01");
+
+    const actDir = join(baseDir, ".gsd", "activity");
+    assert.equal(readdirSync(actDir).length, 1, "first save creates one file");
+
+    // Same content, same unit — deduped
+    saveActivityLog(ctx, baseDir, "execute-task", "M001/S01/T01");
+    assert.equal(readdirSync(actDir).length, 1, "dedup prevents duplicate write");
+
+    // Clear state
+    clearActivityLogState();
+
+    // Same content again — after clear, writes again (fresh state)
+    saveActivityLog(ctx, baseDir, "execute-task", "M001/S01/T01");
+    assert.equal(readdirSync(actDir).length, 2, "after clear, dedup state is reset");
+  } finally {
+    rmSync(baseDir, { recursive: true, force: true });
+  }
+});
+
+// ─── activity-log: streaming JSONL write ────────────────────────────────────
+
+test("saveActivityLog writes valid JSONL via streaming", () => {
+  clearActivityLogState();
+  const baseDir = mkdtempSync(join(tmpdir(), "gsd-memleak-jsonl-"));
+  try {
+    const entries = [
+      { type: "message", message: { role: "user", content: "hello" } },
+      { type: "message", message: { role: "assistant", content: "world" } },
+      { type: "message", message: { role: "user", content: "test" } },
+    ];
+    const ctx = createCtx(entries);
+
+    saveActivityLog(ctx, baseDir, "execute-task", "M002/S01/T01");
+
+    const actDir = join(baseDir, ".gsd", "activity");
+    const files = readdirSync(actDir);
+    assert.equal(files.length, 1, "one file written");
+
+    const content = readFileSync(join(actDir, files[0]), "utf-8");
+    const lines = content.trim().split("\n");
+    assert.equal(lines.length, 3, "three JSONL lines");
+
+    for (const line of lines) {
+      assert.doesNotThrow(() => JSON.parse(line), `line is valid JSON`);
+    }
+  } finally {
+    rmSync(baseDir, { recursive: true, force: true });
+  }
+});
+
+// ─── paths.ts: directory cache bounds ───────────────────────────────────────
+
+test("clearPathCache does not throw", () => {
+  assert.doesNotThrow(() => clearPathCache(), "clearPathCache should not throw");
+});

package/dist/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/dist/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();