gsd-pi 2.33.1-dev.29a8268 → 2.33.1-dev.bf822e6

package/dist/resources/extensions/gsd/tests/provider-errors.test.ts

@@ -1,338 +0,0 @@
-/**
- * Provider error handling tests — consolidated from:
- *   - provider-error-classify.test.ts (classifyProviderError)
- *   - network-error-fallback.test.ts (isTransientNetworkError, getNextFallbackModel)
- *   - agent-end-provider-error.test.ts (pauseAutoForProviderError)
- */
-
-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 { classifyProviderError, pauseAutoForProviderError } from "../provider-error-pause.ts";
-import { getNextFallbackModel, isTransientNetworkError } from "../preferences.ts";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-// ── classifyProviderError ────────────────────────────────────────────────────
-
-test("classifyProviderError detects rate limit from 429", () => {
-  const result = classifyProviderError("HTTP 429 Too Many Requests");
-  assert.ok(result.isTransient);
-  assert.ok(result.isRateLimit);
-  assert.ok(result.suggestedDelayMs > 0);
-});
-
-test("classifyProviderError detects rate limit from message", () => {
-  const result = classifyProviderError("rate limit exceeded");
-  assert.ok(result.isTransient);
-  assert.ok(result.isRateLimit);
-});
-
-test("classifyProviderError extracts reset delay from message", () => {
-  const result = classifyProviderError("rate limit exceeded, reset in 45s");
-  assert.ok(result.isRateLimit);
-  assert.equal(result.suggestedDelayMs, 45000);
-});
-
-test("classifyProviderError defaults to 60s for rate limit without reset", () => {
-  const result = classifyProviderError("429 too many requests");
-  assert.ok(result.isRateLimit);
-  assert.equal(result.suggestedDelayMs, 60_000);
-});
-
-test("classifyProviderError detects Anthropic internal server error", () => {
-  const msg = '{"type":"error","error":{"details":null,"type":"api_error","message":"Internal server error"}}';
-  const result = classifyProviderError(msg);
-  assert.ok(result.isTransient);
-  assert.ok(!result.isRateLimit);
-  assert.equal(result.suggestedDelayMs, 30_000);
-});
-
-test("classifyProviderError detects Codex server_error from extracted message", () => {
-  // After fix, mapCodexEvents extracts the nested error type and produces
-  // "Codex server_error: <message>" instead of raw JSON.
-  const msg = "Codex server_error: An error occurred while processing your request.";
-  const result = classifyProviderError(msg);
-  assert.ok(result.isTransient);
-  assert.ok(!result.isRateLimit);
-  assert.equal(result.suggestedDelayMs, 30_000);
-});
-
-test("classifyProviderError detects overloaded error", () => {
-  const result = classifyProviderError("overloaded_error: Overloaded");
-  assert.ok(result.isTransient);
-  assert.equal(result.suggestedDelayMs, 30_000);
-});
-
-test("classifyProviderError detects 503 service unavailable", () => {
-  const result = classifyProviderError("HTTP 503 Service Unavailable");
-  assert.ok(result.isTransient);
-});
-
-test("classifyProviderError detects 502 bad gateway", () => {
-  const result = classifyProviderError("HTTP 502 Bad Gateway");
-  assert.ok(result.isTransient);
-});
-
-test("classifyProviderError detects auth error as permanent", () => {
-  const result = classifyProviderError("unauthorized: invalid API key");
-  assert.ok(!result.isTransient);
-  assert.ok(!result.isRateLimit);
-});
-
-test("classifyProviderError detects billing error as permanent", () => {
-  const result = classifyProviderError("billing issue: payment required");
-  assert.ok(!result.isTransient);
-});
-
-test("classifyProviderError detects quota exceeded as permanent", () => {
-  const result = classifyProviderError("quota exceeded for this month");
-  assert.ok(!result.isTransient);
-});
-
-test("classifyProviderError treats unknown error as permanent", () => {
-  const result = classifyProviderError("something went wrong");
-  assert.ok(!result.isTransient);
-});
-
-test("classifyProviderError treats empty string as permanent", () => {
-  const result = classifyProviderError("");
-  assert.ok(!result.isTransient);
-});
-
-test("classifyProviderError: rate limit takes precedence over auth keywords", () => {
-  const result = classifyProviderError("429 unauthorized rate limit");
-  assert.ok(result.isRateLimit);
-  assert.ok(result.isTransient);
-});
-
-// ── isTransientNetworkError ──────────────────────────────────────────────────
-
-test("isTransientNetworkError detects ECONNRESET", () => {
-  assert.ok(isTransientNetworkError("fetch failed: ECONNRESET"));
-});
-
-test("isTransientNetworkError detects ETIMEDOUT", () => {
-  assert.ok(isTransientNetworkError("ETIMEDOUT: request timed out"));
-});
-
-test("isTransientNetworkError detects generic network error", () => {
-  assert.ok(isTransientNetworkError("network error"));
-});
-
-test("isTransientNetworkError detects socket hang up", () => {
-  assert.ok(isTransientNetworkError("socket hang up"));
-});
-
-test("isTransientNetworkError detects fetch failed", () => {
-  assert.ok(isTransientNetworkError("fetch failed"));
-});
-
-test("isTransientNetworkError detects connection reset", () => {
-  assert.ok(isTransientNetworkError("connection was reset by peer"));
-});
-
-test("isTransientNetworkError detects DNS errors", () => {
-  assert.ok(isTransientNetworkError("dns resolution failed"));
-});
-
-test("isTransientNetworkError rejects auth errors", () => {
-  assert.ok(!isTransientNetworkError("unauthorized: invalid API key"));
-});
-
-test("isTransientNetworkError rejects quota errors", () => {
-  assert.ok(!isTransientNetworkError("quota exceeded"));
-});
-
-test("isTransientNetworkError rejects billing errors", () => {
-  assert.ok(!isTransientNetworkError("billing issue: network payment required"));
-});
-
-test("isTransientNetworkError rejects empty string", () => {
-  assert.ok(!isTransientNetworkError(""));
-});
-
-test("isTransientNetworkError rejects non-network errors", () => {
-  assert.ok(!isTransientNetworkError("model not found"));
-});
-
-// ── getNextFallbackModel ─────────────────────────────────────────────────────
-
-test("getNextFallbackModel selects next fallback if current is a fallback", () => {
-  const modelConfig = { primary: "model-a", fallbacks: ["model-b", "model-c"] };
-  assert.equal(getNextFallbackModel("model-b", modelConfig), "model-c");
-});
-
-test("getNextFallbackModel returns undefined if fallbacks exhausted", () => {
-  const modelConfig = { primary: "model-a", fallbacks: ["model-b", "model-c"] };
-  assert.equal(getNextFallbackModel("model-c", modelConfig), undefined);
-});
-
-test("getNextFallbackModel finds current model with provider prefix", () => {
-  const modelConfig = { primary: "p/model-a", fallbacks: ["p/model-b"] };
-  assert.equal(getNextFallbackModel("model-a", modelConfig), "p/model-b");
-});
-
-test("getNextFallbackModel returns primary if current is unknown", () => {
-  const modelConfig = { primary: "model-a", fallbacks: ["model-b", "model-c"] };
-  assert.equal(getNextFallbackModel("model-x", modelConfig), "model-a");
-});
-
-test("getNextFallbackModel returns primary if current is undefined", () => {
-  const modelConfig = { primary: "model-a", fallbacks: ["model-b", "model-c"] };
-  assert.equal(getNextFallbackModel(undefined, modelConfig), "model-a");
-});
-
-// ── pauseAutoForProviderError ────────────────────────────────────────────────
-
-test("pauseAutoForProviderError warns and pauses without requiring ctx.log", async () => {
-  const notifications: Array<{ message: string; level: string }> = [];
-  let pauseCalls = 0;
-
-  await pauseAutoForProviderError(
-    { notify(message, level?) { notifications.push({ message, level: level ?? "info" }); } },
-    ": terminated",
-    async () => { pauseCalls += 1; },
-  );
-
-  assert.equal(pauseCalls, 1);
-  assert.deepEqual(notifications, [
-    { message: "Auto-mode paused due to provider error: terminated", level: "warning" },
-  ]);
-});
-
-test("pauseAutoForProviderError schedules auto-resume for rate limit errors", async () => {
-  const notifications: Array<{ message: string; level: string }> = [];
-  let pauseCalls = 0;
-  let resumeCalled = false;
-
-  const originalSetTimeout = globalThis.setTimeout;
-  const timers: Array<{ fn: () => void; delay: number }> = [];
-  globalThis.setTimeout = ((fn: () => void, delay: number) => {
-    timers.push({ fn, delay });
-    return 0 as unknown as ReturnType<typeof setTimeout>;
-  }) as typeof setTimeout;
-
-  try {
-    await pauseAutoForProviderError(
-      { notify(message, level?) { notifications.push({ message, level: level ?? "info" }); } },
-      ": rate limit exceeded",
-      async () => { pauseCalls += 1; },
-      { isRateLimit: true, retryAfterMs: 90000, resume: () => { resumeCalled = true; } },
-    );
-
-    assert.equal(pauseCalls, 1);
-    assert.equal(timers.length, 1);
-    assert.equal(timers[0].delay, 90000);
-    assert.deepEqual(notifications[0], {
-      message: "Rate limited: rate limit exceeded. Auto-resuming in 90s...",
-      level: "warning",
-    });
-
-    timers[0].fn();
-    assert.equal(resumeCalled, true);
-    assert.deepEqual(notifications[1], {
-      message: "Rate limit window elapsed. Resuming auto-mode.",
-      level: "info",
-    });
-  } finally {
-    globalThis.setTimeout = originalSetTimeout;
-  }
-});
-
-test("pauseAutoForProviderError falls back to indefinite pause when not rate limit", async () => {
-  const notifications: Array<{ message: string; level: string }> = [];
-  let pauseCalls = 0;
-
-  await pauseAutoForProviderError(
-    { notify(message, level?) { notifications.push({ message, level: level ?? "info" }); } },
-    ": connection refused",
-    async () => { pauseCalls += 1; },
-    { isRateLimit: false },
-  );
-
-  assert.equal(pauseCalls, 1);
-  assert.deepEqual(notifications, [
-    { message: "Auto-mode paused due to provider error: connection refused", level: "warning" },
-  ]);
-});
-
-// ── Escalating backoff for transient errors (#1166) ─────────────────────────
-
-test("index.ts tracks consecutive transient errors for escalating backoff", () => {
-  const indexSource = readFileSync(join(__dirname, "..", "index.ts"), "utf-8");
-
-  assert.ok(
-    indexSource.includes("consecutiveTransientErrors"),
-    "index.ts must track consecutiveTransientErrors for escalating backoff (#1166)",
-  );
-  assert.ok(
-    indexSource.includes("MAX_TRANSIENT_AUTO_RESUMES"),
-    "index.ts must define MAX_TRANSIENT_AUTO_RESUMES to cap infinite retries (#1166)",
-  );
-});
-
-test("index.ts resets consecutive transient error counter on success", () => {
-  const indexSource = readFileSync(join(__dirname, "..", "index.ts"), "utf-8");
-
-  // After successful unit completion, the counter must be reset
-  const marker = "successful unit completion";
-  const successSection = indexSource.indexOf(marker);
-  assert.ok(successSection > -1, "must have success section that clears network retries");
-  const nearbyCode = indexSource.slice(Math.max(0, successSection - 100), successSection + 200);
-  assert.ok(
-    nearbyCode.includes("consecutiveTransientErrors = 0"),
-    "consecutive transient error counter must be reset on successful unit completion (#1166)",
-  );
-});
-
-test("index.ts applies escalating delay for repeated transient errors", () => {
-  const indexSource = readFileSync(join(__dirname, "..", "index.ts"), "utf-8");
-
-  // Must contain the exponential backoff formula
-  assert.ok(
-    /retryAfterMs\s*[=*].*2\s*\*\*/.test(indexSource),
-    "index.ts must escalate retryAfterMs exponentially for consecutive transient errors (#1166)",
-  );
-});
-
-// ── Codex error extraction (#1166) ──────────────────────────────────────────
-
-test("openai-codex-responses.ts extracts nested error fields", () => {
-  const codexSource = readFileSync(
-    join(__dirname, "../../../../../packages/pi-ai/src/providers/openai-codex-responses.ts"),
-    "utf-8",
-  );
-
-  // Must access event.error.message (nested), not just event.message (top-level)
-  assert.ok(
-    codexSource.includes("errorObj?.message"),
-    "mapCodexEvents must extract message from nested event.error object (#1166)",
-  );
-  assert.ok(
-    codexSource.includes("errorObj?.type"),
-    "mapCodexEvents must extract type from nested event.error object (#1166)",
-  );
-});
-
-// ── agent-session retryable regex handles server_error (#1166) ──────────────
-
-test("agent-session retryable error regex matches server_error (underscore)", () => {
-  // This regex is extracted from _isRetryableError in agent-session.ts.
-  // It must match both "server error" (space) and "server_error" (underscore)
-  // to properly classify Codex streaming errors as retryable.
-  const retryableRegex = /overloaded|rate.?limit|too many requests|429|500|502|503|504|service.?unavailable|server.?error|internal.?error|connection.?error|connection.?refused|other side closed|fetch failed|upstream.?connect|reset before headers|terminated|retry delay|network.?(?:is\s+)?unavailable|credentials.*expired|temporarily backed off/i;
-
-  // server_error (with underscore — Codex streaming error format)
-  assert.ok(retryableRegex.test("Codex server_error: An error occurred"));
-  // server error (with space — traditional HTTP error format)
-  assert.ok(retryableRegex.test("server error occurred"));
-  // internal_error (with underscore)
-  assert.ok(retryableRegex.test("internal_error: something went wrong"));
-  // internal error (with space)
-  assert.ok(retryableRegex.test("internal error"));
-  // non-retryable errors must not match
-  assert.ok(!retryableRegex.test("model not found"));
-});

package/dist/resources/extensions/gsd/tests/queue-draft-detection.test.ts

@@ -1,126 +0,0 @@
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-import { deriveState } from "../state.js";
-import { buildExistingMilestonesContext } from "../guided-flow.js";
-
-let passed = 0;
-let failed = 0;
-
-function assert(condition: boolean, message: string): void {
-  if (condition) {
-    passed++;
-  } else {
-    failed++;
-    console.error(`  FAIL: ${message}`);
-  }
-}
-
-// ─── Fixture setup ──────────────────────────────────────────────────────
-
-const tmpBase = mkdtempSync(join(tmpdir(), "gsd-queue-draft-test-"));
-const gsd = join(tmpBase, ".gsd");
-
-// M001: has only CONTEXT-DRAFT.md (draft milestone)
-mkdirSync(join(gsd, "milestones", "M001"), { recursive: true });
-writeFileSync(
-  join(gsd, "milestones", "M001", "M001-CONTEXT-DRAFT.md"),
-  "# M001: Draft Milestone\n\nSeed material from prior discussion.\n",
-);
-
-// M002: has full CONTEXT.md (ready milestone)
-mkdirSync(join(gsd, "milestones", "M002"), { recursive: true });
-writeFileSync(
-  join(gsd, "milestones", "M002", "M002-CONTEXT.md"),
-  "# M002: Ready Milestone\n\nFull context from deep discussion.\n",
-);
-
-// M003: has both CONTEXT.md and CONTEXT-DRAFT.md (CONTEXT wins)
-mkdirSync(join(gsd, "milestones", "M003"), { recursive: true });
-writeFileSync(
-  join(gsd, "milestones", "M003", "M003-CONTEXT.md"),
-  "# M003: Full Context\n\nThis is the real context.\n",
-);
-writeFileSync(
-  join(gsd, "milestones", "M003", "M003-CONTEXT-DRAFT.md"),
-  "# M003: Draft\n\nThis should be ignored.\n",
-);
-
-// M004: has neither (empty milestone dir)
-mkdirSync(join(gsd, "milestones", "M004"), { recursive: true });
-
-// ─── Build context ──────────────────────────────────────────────────────
-
-const state = await deriveState(tmpBase);
-const milestoneIds = ["M001", "M002", "M003", "M004"];
-const context = await buildExistingMilestonesContext(tmpBase, milestoneIds, state);
-
-// ─── Test: draft-only milestone includes "Draft context available" ──────
-
-assert(
-  context.includes("Draft context available"),
-  "M001 (draft-only) should include 'Draft context available' label",
-);
-
-assert(
-  context.includes("Seed material from prior discussion"),
-  "M001 draft content should be included in context output",
-);
-
-// ─── Test: full-context milestone uses "Context:" label ────────────────
-
-assert(
-  context.includes("**Context:**"),
-  "M002 (full context) should use 'Context:' label",
-);
-
-assert(
-  context.includes("Full context from deep discussion"),
-  "M002 context content should be included",
-);
-
-// ─── Test: both files → CONTEXT.md wins, no draft label ────────────────
-
-// Find M003's section and check it has Context: but not Draft
-const m003Idx = context.indexOf("M003:");
-const m003Section = context.slice(m003Idx, m003Idx + 500);
-
-assert(
-  m003Section.includes("**Context:**"),
-  "M003 (both files) should use 'Context:' label (CONTEXT.md wins)",
-);
-
-assert(
-  !m003Section.includes("Draft context available"),
-  "M003 (both files) should NOT show draft label — CONTEXT.md takes precedence",
-);
-
-assert(
-  m003Section.includes("This is the real context"),
-  "M003 should show CONTEXT.md content, not draft content",
-);
-
-// ─── Test: neither file → no context section ───────────────────────────
-
-const m004Idx = context.indexOf("M004:");
-const m004Section = context.slice(m004Idx, m004Idx + 500);
-
-assert(
-  !m004Section.includes("**Context:**"),
-  "M004 (neither file) should not have Context: label",
-);
-
-assert(
-  !m004Section.includes("Draft context available"),
-  "M004 (neither file) should not have Draft label",
-);
-
-// ─── Cleanup ──────────────────────────────────────────────────────────
-
-rmSync(tmpBase, { recursive: true, force: true });
-
-// ─── Results ──────────────────────────────────────────────────────────
-
-console.log(`\nqueue-draft-detection: ${passed} passed, ${failed} failed`);
-if (failed > 0) process.exit(1);

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

@@ -1,204 +0,0 @@
-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();