lsd-pi 1.0.0 → 1.1.0

package/src/resources/extensions/gsd/tests/reconciliation-edge-cases.test.ts

@@ -1,162 +0,0 @@
-// GSD State Machine Regression Tests — Event Replay & Reconciliation (#3161)
-
-import { describe, test, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import { createHash } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
-import { findForkPoint, readEvents, appendEvent } from "../workflow-events.ts";
-import type { WorkflowEvent } from "../workflow-events.ts";
-import { extractEntityKey, detectConflicts } from "../workflow-reconcile.ts";
-
-// ─── Helper: build a full WorkflowEvent from cmd + params ────────────────────
-
-function makeEvent(cmd: string, params: Record<string, unknown>, ts?: string): WorkflowEvent {
-  const hash = createHash("sha256")
-    .update(JSON.stringify({ cmd, params }))
-    .digest("hex")
-    .slice(0, 16);
-  return { cmd, params, ts: ts ?? new Date().toISOString(), hash, actor: "agent", session_id: "test-session" };
-}
-
-// ─── Temp dir management ─────────────────────────────────────────────────────
-
-const tempDirs: string[] = [];
-
-function tempDir(): string {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-recon-test-"));
-  tempDirs.push(dir);
-  return dir;
-}
-
-afterEach(() => {
-  for (const dir of tempDirs.splice(0)) {
-    try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* best effort */ }
-  }
-});
-
-// ─── Tests ────────────────────────────────────────────────────────────────────
-
-describe("reconciliation-edge-cases", () => {
-
-  // findForkPoint
-  test("findForkPoint returns -1 for completely diverged logs", () => {
-    const eA = makeEvent("complete_task", { milestoneId: "M001", sliceId: "S01", taskId: "T01" });
-    const eB = makeEvent("complete_task", { milestoneId: "M001", sliceId: "S01", taskId: "T02" });
-
-    const logA: WorkflowEvent[] = [eA];
-    const logB: WorkflowEvent[] = [eB];
-
-    assert.equal(findForkPoint(logA, logB), -1, "completely diverged logs should return -1");
-  });
-
-  test("findForkPoint returns last index when one log is prefix of another", () => {
-    const e1 = makeEvent("start_task", { milestoneId: "M001", sliceId: "S01", taskId: "T01" });
-    const e2 = makeEvent("complete_task", { milestoneId: "M001", sliceId: "S01", taskId: "T01" });
-    const e3 = makeEvent("complete_slice", { milestoneId: "M001", sliceId: "S01" });
-
-    const logA: WorkflowEvent[] = [e1, e2];
-    const logB: WorkflowEvent[] = [e1, e2, e3];
-
-    assert.equal(findForkPoint(logA, logB), 1, "prefix log should fork at last shared index");
-  });
-
-  test("findForkPoint returns -1 for empty logs", () => {
-    assert.equal(findForkPoint([], []), -1, "two empty logs should return -1");
-  });
-
-  // extractEntityKey
-  test("extractEntityKey returns null for malformed events (missing taskId)", () => {
-    const event = makeEvent("complete_task", {});
-    // params has no taskId — should return null rather than return a bad key
-    assert.equal(extractEntityKey(event), null, "missing taskId should yield null entity key");
-  });
-
-  test("extractEntityKey returns null for unknown commands", () => {
-    const event = makeEvent("future_cmd", { foo: "bar" });
-    assert.equal(extractEntityKey(event), null, "unknown command should yield null entity key");
-  });
-
-  test("plan_slice and complete_slice use different entity types", () => {
-    const planEvent = makeEvent("plan_slice", { sliceId: "S01" });
-    const completeEvent = makeEvent("complete_slice", { sliceId: "S01" });
-
-    const planKey = extractEntityKey(planEvent);
-    const completeKey = extractEntityKey(completeEvent);
-
-    assert.ok(planKey !== null, "plan_slice should produce an entity key");
-    assert.ok(completeKey !== null, "complete_slice should produce an entity key");
-    assert.equal(planKey!.type, "slice_plan", "plan_slice entity type should be 'slice_plan'");
-    assert.equal(completeKey!.type, "slice", "complete_slice entity type should be 'slice'");
-    assert.notEqual(
-      planKey!.type,
-      completeKey!.type,
-      "plan_slice and complete_slice must map to different entity types",
-    );
-  });
-
-  // detectConflicts
-  test("detectConflicts finds no conflicts when entities do not overlap", () => {
-    const mainDiverged: WorkflowEvent[] = [
-      makeEvent("complete_task", { milestoneId: "M001", sliceId: "S01", taskId: "T01" }),
-    ];
-    const wtDiverged: WorkflowEvent[] = [
-      makeEvent("complete_task", { milestoneId: "M001", sliceId: "S01", taskId: "T02" }),
-    ];
-
-    const conflicts = detectConflicts(mainDiverged, wtDiverged);
-    assert.equal(conflicts.length, 0, "non-overlapping task edits should produce no conflicts");
-  });
-
-  test("detectConflicts flags conflict when both sides touch the same task", () => {
-    const mainDiverged: WorkflowEvent[] = [
-      makeEvent("start_task", { milestoneId: "M001", sliceId: "S01", taskId: "T01" }),
-    ];
-    const wtDiverged: WorkflowEvent[] = [
-      makeEvent("complete_task", { milestoneId: "M001", sliceId: "S01", taskId: "T01" }),
-    ];
-
-    const conflicts = detectConflicts(mainDiverged, wtDiverged);
-    assert.equal(conflicts.length, 1, "same task touched by both sides should produce exactly one conflict");
-
-    const conflict = conflicts[0]!;
-    assert.equal(conflict.entityType, "task", "conflict entityType should be 'task'");
-    assert.equal(conflict.entityId, "T01", "conflict entityId should be 'T01'");
-  });
-
-  test("detectConflicts ignores events with null entity keys", () => {
-    // Events with unknown commands produce null keys and must not cause false conflicts.
-    const mainDiverged: WorkflowEvent[] = [
-      makeEvent("unknown_future_cmd", { milestoneId: "M001" }),
-    ];
-    const wtDiverged: WorkflowEvent[] = [
-      makeEvent("another_unknown_cmd", { milestoneId: "M001" }),
-    ];
-
-    const conflicts = detectConflicts(mainDiverged, wtDiverged);
-    assert.equal(conflicts.length, 0, "unknown commands with null entity keys should not produce conflicts");
-  });
-
-  // appendEvent — filesystem creation
-  test("appendEvent creates event log if directory does not exist", () => {
-    const base = tempDir();
-    // Remove the .gsd directory if it somehow exists — appendEvent should create it.
-    const gsdDir = path.join(base, ".gsd");
-    if (fs.existsSync(gsdDir)) fs.rmSync(gsdDir, { recursive: true, force: true });
-
-    appendEvent(base, {
-      cmd: "complete_task",
-      params: { milestoneId: "M001", sliceId: "S01", taskId: "T01" },
-      ts: new Date().toISOString(),
-      actor: "agent",
-    });
-
-    const logPath = path.join(base, ".gsd", "event-log.jsonl");
-    assert.ok(fs.existsSync(logPath), "event-log.jsonl should be created by appendEvent");
-
-    const events = readEvents(logPath);
-    assert.equal(events.length, 1, "event log should contain exactly one event");
-    assert.equal(events[0]!.cmd, "complete_task", "persisted event should have the correct cmd");
-  });
-});

package/src/resources/extensions/gsd/tests/recovery-attempts-reset.test.ts

@@ -1,176 +0,0 @@
-/**
- * Regression test for #2322: recoveryAttempts persists across re-dispatches,
- * causing instant task skip.
- *
- * When a unit hits recovery limits and is later re-dispatched, the
- * recoveryAttempts counter from the prior execution carries over because
- * the dispatch-time writeUnitRuntimeRecord call does not reset it.
- * This causes the next execution to be instantly skipped with no steering
- * message or second chance.
- *
- * The fix: include `recoveryAttempts: 0` in the dispatch-time runtime
- * record write in runUnitPhase.
- */
-
-import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import {
-  writeUnitRuntimeRecord,
-  readUnitRuntimeRecord,
-} from "../unit-runtime.ts";
-import { createTestContext } from "./test-helpers.ts";
-
-const { assertEq, assertTrue, report } = createTestContext();
-
-// ═══ Setup ════════════════════════════════════════════════════════════════════
-
-const base = mkdtempSync(join(tmpdir(), "gsd-recovery-reset-test-"));
-mkdirSync(join(base, ".gsd", "runtime", "units"), { recursive: true });
-
-try {
-  // ═══ #2322: recoveryAttempts should reset on re-dispatch ═══════════════════
-
-  {
-    console.log("\n=== #2322: recoveryAttempts should reset on re-dispatch ===");
-
-    const unitType = "execute-task";
-    const unitId = "M001/S01/T01";
-    const startedAt1 = Date.now() - 10000;
-
-    // Simulate first dispatch — clean state
-    writeUnitRuntimeRecord(base, unitType, unitId, startedAt1, {
-      phase: "dispatched",
-      wrapupWarningSent: false,
-      timeoutAt: null,
-      lastProgressAt: startedAt1,
-      progressCount: 0,
-      lastProgressKind: "dispatch",
-    });
-
-    // Simulate timeout recovery incrementing recoveryAttempts
-    writeUnitRuntimeRecord(base, unitType, unitId, startedAt1, {
-      phase: "recovered",
-      recoveryAttempts: 1,
-      lastRecoveryReason: "hard",
-    });
-
-    const afterRecovery = readUnitRuntimeRecord(base, unitType, unitId);
-    assertEq(afterRecovery?.recoveryAttempts, 1, "recoveryAttempts should be 1 after recovery");
-    assertEq(afterRecovery?.lastRecoveryReason, "hard", "lastRecoveryReason should be 'hard'");
-
-    // Simulate re-dispatch (second execution of same unit).
-    // This is what runUnitPhase should do at dispatch time — explicitly reset
-    // recoveryAttempts so the new execution gets its full recovery budget.
-    const startedAt2 = Date.now();
-    writeUnitRuntimeRecord(base, unitType, unitId, startedAt2, {
-      phase: "dispatched",
-      wrapupWarningSent: false,
-      timeoutAt: null,
-      lastProgressAt: startedAt2,
-      progressCount: 0,
-      lastProgressKind: "dispatch",
-      recoveryAttempts: 0, // FIX: must be explicitly reset
-    });
-
-    const afterRedispatch = readUnitRuntimeRecord(base, unitType, unitId);
-    assertEq(
-      afterRedispatch?.recoveryAttempts,
-      0,
-      "recoveryAttempts should be 0 after re-dispatch (was carried over from prior execution)",
-    );
-  }
-
-  // ═══ Verify the BUG scenario: omitting recoveryAttempts carries it over ═══
-
-  {
-    console.log("\n=== #2322: demonstrates bug — omitting recoveryAttempts carries it over ===");
-
-    const unitType = "execute-task";
-    const unitId = "M001/S01/T02";
-    const startedAt1 = Date.now() - 10000;
-
-    // First dispatch
-    writeUnitRuntimeRecord(base, unitType, unitId, startedAt1, {
-      phase: "dispatched",
-    });
-
-    // Timeout bumps recoveryAttempts to 1
-    writeUnitRuntimeRecord(base, unitType, unitId, startedAt1, {
-      recoveryAttempts: 1,
-      lastRecoveryReason: "hard",
-    });
-
-    // Re-dispatch WITHOUT resetting recoveryAttempts (the bug)
-    const startedAt2 = Date.now();
-    writeUnitRuntimeRecord(base, unitType, unitId, startedAt2, {
-      phase: "dispatched",
-      wrapupWarningSent: false,
-      timeoutAt: null,
-      lastProgressAt: startedAt2,
-      progressCount: 0,
-      lastProgressKind: "dispatch",
-      // recoveryAttempts: NOT included — this is the bug
-    });
-
-    const afterBuggyRedispatch = readUnitRuntimeRecord(base, unitType, unitId);
-    // This DEMONSTRATES the bug: recoveryAttempts is still 1
-    assertEq(
-      afterBuggyRedispatch?.recoveryAttempts,
-      1,
-      "BUG DEMO: recoveryAttempts carries over when not explicitly reset",
-    );
-  }
-
-  // ═══ Hard timeout maxRecoveryAttempts=1 — second dispatch must get full budget ═══
-
-  {
-    console.log("\n=== #2322: second dispatch gets full hard-timeout budget after reset ===");
-
-    const unitType = "execute-task";
-    const unitId = "M001/S01/T03";
-
-    // First dispatch
-    const start1 = Date.now() - 20000;
-    writeUnitRuntimeRecord(base, unitType, unitId, start1, {
-      phase: "dispatched",
-      recoveryAttempts: 0,
-    });
-
-    // Hard timeout recovery — exhausts the budget (maxRecoveryAttempts=1 for hard)
-    writeUnitRuntimeRecord(base, unitType, unitId, start1, {
-      phase: "recovered",
-      recoveryAttempts: 1,
-      lastRecoveryReason: "hard",
-    });
-
-    const afterExhausted = readUnitRuntimeRecord(base, unitType, unitId);
-    assertEq(afterExhausted?.recoveryAttempts, 1, "budget exhausted after hard recovery");
-
-    // Second dispatch with fix: reset recoveryAttempts
-    const start2 = Date.now();
-    writeUnitRuntimeRecord(base, unitType, unitId, start2, {
-      phase: "dispatched",
-      wrapupWarningSent: false,
-      timeoutAt: null,
-      lastProgressAt: start2,
-      progressCount: 0,
-      lastProgressKind: "dispatch",
-      recoveryAttempts: 0,
-    });
-
-    const afterReset = readUnitRuntimeRecord(base, unitType, unitId);
-    assertEq(afterReset?.recoveryAttempts, 0, "second dispatch has full recovery budget");
-
-    // Now a hard timeout should be recoverable (0 < 1)
-    assertTrue(
-      (afterReset?.recoveryAttempts ?? 0) < 1,
-      "hard recovery should be allowed (recoveryAttempts < maxRecoveryAttempts)",
-    );
-  }
-
-} finally {
-  rmSync(base, { recursive: true, force: true });
-}
-
-report();

package/src/resources/extensions/gsd/tests/regex-hardening.test.ts

@@ -1,281 +0,0 @@
-// Regex-hardening tests for S02/T02 — proves all 12 regex/parser sites
-// accept both M001 (classic) and M001-abc123 (unique) milestone ID formats.
-//
-// Sections:
-//   (a) Directory scanning regex — findMilestoneIds pattern
-//   (b) Title-strip regex — milestone title cleanup
-//   (c) SLICE_BRANCH_RE — branch name parsing (with/without worktree prefix)
-//   (d) Milestone detection regex — hasExistingMilestones pattern
-//   (e) MILESTONE_CONTEXT_RE — context write-gate filename match
-//   (f) Prompt dispatch regexes — executeMatch and resumeMatch capture
-//   (g) milestoneIdSort — mixed-format ordering
-//   (h) extractMilestoneSeq — numeric extraction from both formats
-
-import { test } from 'node:test';
-
-import {
-  MILESTONE_ID_RE,
-  extractMilestoneSeq,
-  milestoneIdSort,
-} from '../guided-flow.ts';
-
-import { SLICE_BRANCH_RE } from '../worktree.ts';
-import { createTestContext } from './test-helpers.ts';
-
-
-const { assertEq, assertTrue, report } = createTestContext();
-// ─── Tests ─────────────────────────────────────────────────────────────────
-
-async function main(): Promise<void> {
-  console.log('regex-hardening tests');
-
-  // (a) Directory scanning regex — used in state.ts, workspace-index.ts, files.ts
-  //     Pattern: /^(M\d+(?:-[a-z0-9]{6})?)/
-  {
-    console.log('  (a) Directory scanning regex');
-    const DIR_SCAN_RE = /^(M\d+(?:-[a-z0-9]{6})?)/;
-
-    // Classic format matches
-    assertTrue(DIR_SCAN_RE.test('M001'), 'dir scan matches M001');
-    assertTrue(DIR_SCAN_RE.test('M042'), 'dir scan matches M042');
-    assertTrue(DIR_SCAN_RE.test('M999'), 'dir scan matches M999');
-    assertEq(('M001' as string).match(DIR_SCAN_RE)?.[1], 'M001', 'captures M001');
-
-    // Unique format matches
-    assertTrue(DIR_SCAN_RE.test('M001-abc123'), 'dir scan matches M001-abc123');
-    assertTrue(DIR_SCAN_RE.test('M042-z9a8b7'), 'dir scan matches M042-z9a8b7');
-    assertEq(('M001-abc123' as string).match(DIR_SCAN_RE)?.[1], 'M001-abc123', 'captures M001-abc123 from dir name');
-
-    // Rejects
-    assertTrue(!DIR_SCAN_RE.test('S01'), 'dir scan rejects S01');
-    assertTrue(!DIR_SCAN_RE.test('X001'), 'dir scan rejects X001');
-    assertTrue(!DIR_SCAN_RE.test('.DS_Store'), 'dir scan rejects .DS_Store');
-    assertTrue(!DIR_SCAN_RE.test('notes'), 'dir scan rejects notes');
-  }
-
-  // (b) Title-strip regex — used in state.ts, workspace-index.ts
-  //     Pattern: /^M\d+(?:-[a-z0-9]{6})?[^:]*:\s*/
-  {
-    console.log('  (b) Title-strip regex');
-    const TITLE_STRIP_RE = /^M\d+(?:-[a-z0-9]{6})?[^:]*:\s*/;
-
-    // Classic format strip
-    assertEq('M001: Title'.replace(TITLE_STRIP_RE, ''), 'Title', 'strips M001: Title → Title');
-    assertEq('M042: Payment Integration'.replace(TITLE_STRIP_RE, ''), 'Payment Integration', 'strips M042: Payment Integration');
-
-    // Unique format strip
-    assertEq('M001-abc123: Title'.replace(TITLE_STRIP_RE, ''), 'Title', 'strips M001-abc123: Title → Title');
-    assertEq('M042-z9a8b7: Dashboard'.replace(TITLE_STRIP_RE, ''), 'Dashboard', 'strips M042-z9a8b7: Dashboard');
-
-    // Em dash in title — current format (M001: Title) correctly preserves em dash in title body
-    assertEq(
-      'M001: Foundation — Build Core'.replace(TITLE_STRIP_RE, ''),
-      'Foundation — Build Core',
-      'strips M001: prefix and preserves em dash in title body',
-    );
-    assertEq(
-      'M001-abc123: Foundation — Build Core'.replace(TITLE_STRIP_RE, ''),
-      'Foundation — Build Core',
-      'strips M001-abc123: prefix and preserves em dash in title body (unique format)',
-    );
-
-    // Edge case: dash-style separator (M001 — Title: Subtitle preserves colon in body)
-    assertEq(
-      'M001 — Unique Milestone IDs: Foo'.replace(TITLE_STRIP_RE, ''),
-      'Foo',
-      'strips M001 — Unique Milestone IDs: Foo → Foo (first colon consumed)',
-    );
-
-    // Edge case: colon inside title body preserved
-    assertEq(
-      'M001: Note: important'.replace(TITLE_STRIP_RE, ''),
-      'Note: important',
-      'preserves colons in title body',
-    );
-
-    // No match — leaves non-milestone strings alone
-    assertEq('S01: Slice Title'.replace(TITLE_STRIP_RE, ''), 'S01: Slice Title', 'does not strip S01 prefix');
-  }
-
-  // (c) SLICE_BRANCH_RE — from worktree.ts
-  //     Pattern: /^gsd\/(?:([a-zA-Z0-9_-]+)\/)?(M\d+(?:-[a-z0-9]{6})?)\/(S\d+)$/
-  {
-    console.log('  (c) SLICE_BRANCH_RE');
-
-    // Classic format — no worktree prefix
-    {
-      const m = 'gsd/M001/S01'.match(SLICE_BRANCH_RE);
-      assertTrue(m !== null, 'matches gsd/M001/S01');
-      assertEq(m?.[1], undefined, 'no worktree prefix for gsd/M001/S01');
-      assertEq(m?.[2], 'M001', 'captures M001');
-      assertEq(m?.[3], 'S01', 'captures S01');
-    }
-
-    // Unique format — no worktree prefix
-    {
-      const m = 'gsd/M001-abc123/S01'.match(SLICE_BRANCH_RE);
-      assertTrue(m !== null, 'matches gsd/M001-abc123/S01');
-      assertEq(m?.[1], undefined, 'no worktree prefix for unique format');
-      assertEq(m?.[2], 'M001-abc123', 'captures M001-abc123');
-      assertEq(m?.[3], 'S01', 'captures S01');
-    }
-
-    // Classic format — with worktree prefix
-    {
-      const m = 'gsd/worktree/M001/S01'.match(SLICE_BRANCH_RE);
-      assertTrue(m !== null, 'matches gsd/worktree/M001/S01');
-      assertEq(m?.[1], 'worktree', 'captures worktree prefix');
-      assertEq(m?.[2], 'M001', 'captures M001 with worktree');
-      assertEq(m?.[3], 'S01', 'captures S01 with worktree');
-    }
-
-    // Unique format — with worktree prefix
-    {
-      const m = 'gsd/worktree/M001-abc123/S01'.match(SLICE_BRANCH_RE);
-      assertTrue(m !== null, 'matches gsd/worktree/M001-abc123/S01');
-      assertEq(m?.[1], 'worktree', 'captures worktree prefix with unique format');
-      assertEq(m?.[2], 'M001-abc123', 'captures M001-abc123 with worktree');
-      assertEq(m?.[3], 'S01', 'captures S01 with worktree and unique format');
-    }
-
-    // Rejects
-    assertTrue(!SLICE_BRANCH_RE.test('gsd/S01'), 'rejects gsd/S01 (no milestone)');
-    assertTrue(!SLICE_BRANCH_RE.test('main'), 'rejects main');
-    assertTrue(!SLICE_BRANCH_RE.test('gsd/M001'), 'rejects gsd/M001 (no slice)');
-    assertTrue(!SLICE_BRANCH_RE.test('feature/M001/S01'), 'rejects feature/ prefix');
-  }
-
-  // (d) Milestone detection regex — used in worktree-command.ts (hasExistingMilestones)
-  //     Pattern: /^M\d+(?:-[a-z0-9]{6})?/
-  {
-    console.log('  (d) Milestone detection regex');
-    const MILESTONE_DETECT_RE = /^M\d+(?:-[a-z0-9]{6})?/;
-
-    // Classic format matches
-    assertTrue(MILESTONE_DETECT_RE.test('M001'), 'detect matches M001');
-    assertTrue(MILESTONE_DETECT_RE.test('M042'), 'detect matches M042');
-
-    // Unique format matches
-    assertTrue(MILESTONE_DETECT_RE.test('M001-abc123'), 'detect matches M001-abc123');
-    assertTrue(MILESTONE_DETECT_RE.test('M042-z9a8b7'), 'detect matches M042-z9a8b7');
-
-    // Rejects
-    assertTrue(!MILESTONE_DETECT_RE.test('S01'), 'detect rejects S01');
-    assertTrue(!MILESTONE_DETECT_RE.test('notes'), 'detect rejects notes');
-    assertTrue(!MILESTONE_DETECT_RE.test('.DS_Store'), 'detect rejects .DS_Store');
-  }
-
-  // (e) MILESTONE_CONTEXT_RE — used in index.ts (write-gate)
-  //     Pattern: /M\d+(?:-[a-z0-9]{6})?-CONTEXT\.md$/
-  {
-    console.log('  (e) MILESTONE_CONTEXT_RE');
-    const CONTEXT_RE = /M\d+(?:-[a-z0-9]{6})?-CONTEXT\.md$/;
-
-    // Classic format matches
-    assertTrue(CONTEXT_RE.test('M001-CONTEXT.md'), 'context matches M001-CONTEXT.md');
-    assertTrue(CONTEXT_RE.test('.gsd/milestones/M001/M001-CONTEXT.md'), 'context matches full path classic format');
-
-    // Unique format matches
-    assertTrue(CONTEXT_RE.test('M001-abc123-CONTEXT.md'), 'context matches M001-abc123-CONTEXT.md');
-    assertTrue(CONTEXT_RE.test('.gsd/milestones/M001-abc123/M001-abc123-CONTEXT.md'), 'context matches full path unique format');
-
-    // Rejects
-    assertTrue(!CONTEXT_RE.test('M001-ROADMAP.md'), 'context rejects M001-ROADMAP.md');
-    assertTrue(!CONTEXT_RE.test('M001-SUMMARY.md'), 'context rejects M001-SUMMARY.md');
-    assertTrue(!CONTEXT_RE.test('CONTEXT.md'), 'context rejects bare CONTEXT.md');
-  }
-
-  // (f) Prompt dispatch regexes — used in index.ts (executeMatch, resumeMatch)
-  {
-    console.log('  (f) Prompt dispatch regexes');
-    const EXECUTE_RE = /Execute the next task:\s+(T\d+)\s+\("([^"]+)"\)\s+in slice\s+(S\d+)\s+of milestone\s+(M\d+(?:-[a-z0-9]{6})?)/i;
-    const RESUME_RE = /Resume interrupted work\.[\s\S]*?slice\s+(S\d+)\s+of milestone\s+(M\d+(?:-[a-z0-9]{6})?)/i;
-
-    // Execute — classic format
-    {
-      const prompt = 'Execute the next task: T01 ("Write tests") in slice S01 of milestone M001';
-      const m = prompt.match(EXECUTE_RE);
-      assertTrue(m !== null, 'execute matches classic format');
-      assertEq(m?.[1], 'T01', 'execute captures T01');
-      assertEq(m?.[3], 'S01', 'execute captures S01');
-      assertEq(m?.[4], 'M001', 'execute captures M001');
-    }
-
-    // Execute — unique format
-    {
-      const prompt = 'Execute the next task: T02 ("Build feature") in slice S03 of milestone M001-abc123';
-      const m = prompt.match(EXECUTE_RE);
-      assertTrue(m !== null, 'execute matches unique format');
-      assertEq(m?.[1], 'T02', 'execute captures T02 (unique format)');
-      assertEq(m?.[3], 'S03', 'execute captures S03 (unique format)');
-      assertEq(m?.[4], 'M001-abc123', 'execute captures M001-abc123');
-    }
-
-    // Resume — classic format
-    {
-      const prompt = 'Resume interrupted work.\nContinuing slice S02 of milestone M001';
-      const m = prompt.match(RESUME_RE);
-      assertTrue(m !== null, 'resume matches classic format');
-      assertEq(m?.[1], 'S02', 'resume captures S02');
-      assertEq(m?.[2], 'M001', 'resume captures M001');
-    }
-
-    // Resume — unique format
-    {
-      const prompt = 'Resume interrupted work.\nContinuing slice S01 of milestone M042-z9a8b7';
-      const m = prompt.match(RESUME_RE);
-      assertTrue(m !== null, 'resume matches unique format');
-      assertEq(m?.[1], 'S01', 'resume captures S01 (unique format)');
-      assertEq(m?.[2], 'M042-z9a8b7', 'resume captures M042-z9a8b7');
-    }
-  }
-
-  // (g) milestoneIdSort — mixed-format ordering
-  {
-    console.log('  (g) milestoneIdSort');
-    const mixed = ['M002-abc123', 'M001', 'M001-xyz789'];
-    const sorted = [...mixed].sort(milestoneIdSort);
-    assertEq(sorted, ['M001', 'M001-xyz789', 'M002-abc123'], 'sorts mixed IDs by sequence number');
-
-    // Stable within same seq — preserves insertion order
-    const sameSorted = ['M001-abc123', 'M001'].sort(milestoneIdSort);
-    assertEq(sameSorted[0], 'M001-abc123', 'same seq preserves order (first)');
-    assertEq(sameSorted[1], 'M001', 'same seq preserves order (second)');
-
-    // Classic format only
-    const oldOnly = ['M003', 'M001', 'M002'];
-    assertEq([...oldOnly].sort(milestoneIdSort), ['M001', 'M002', 'M003'], 'sorts classic-format IDs');
-
-    // Unique format only
-    const newOnly = ['M003-abc123', 'M001-def456', 'M002-ghi789'];
-    assertEq([...newOnly].sort(milestoneIdSort), ['M001-def456', 'M002-ghi789', 'M003-abc123'], 'sorts unique-format IDs');
-  }
-
-  // (h) extractMilestoneSeq — numeric extraction from both formats
-  {
-    console.log('  (h) extractMilestoneSeq');
-
-    // Classic format
-    assertEq(extractMilestoneSeq('M001'), 1, 'M001 → 1');
-    assertEq(extractMilestoneSeq('M042'), 42, 'M042 → 42');
-    assertEq(extractMilestoneSeq('M999'), 999, 'M999 → 999');
-
-    // Unique format — confirms dispatch-guard refactor correctness
-    assertEq(extractMilestoneSeq('M001-abc123'), 1, 'M001-abc123 → 1');
-    assertEq(extractMilestoneSeq('M042-z9a8b7'), 42, 'M042-z9a8b7 → 42');
-    assertEq(extractMilestoneSeq('M100-xyz789'), 100, 'M100-xyz789 → 100');
-
-    // Invalid → 0 (not NaN — the old parseInt(slice(1)) bug)
-    assertEq(extractMilestoneSeq(''), 0, 'empty → 0');
-    assertEq(extractMilestoneSeq('notes'), 0, 'notes → 0');
-    assertEq(extractMilestoneSeq('S01'), 0, 'S01 → 0');
-    assertTrue(!Number.isNaN(extractMilestoneSeq('M001-abc123')), 'unique format does not return NaN');
-    assertTrue(!Number.isNaN(extractMilestoneSeq('M001-ABCDEF')), 'invalid format does not return NaN');
-  }
-
-  report();
-}
-
-test('regex-hardening: all 12 sites accept both formats', async () => {
-  await main();
-});

package/src/resources/extensions/gsd/tests/register-extension-guard.test.ts

@@ -1,59 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-
-import { handleRecoverableExtensionProcessError } from "../bootstrap/register-extension.ts";
-
-test("handleRecoverableExtensionProcessError swallows spawn ENOENT", () => {
-  let stderr = "";
-  const originalWrite = process.stderr.write.bind(process.stderr);
-  process.stderr.write = ((chunk: string | Uint8Array) => {
-    stderr += String(chunk);
-    return true;
-  }) as typeof process.stderr.write;
-
-  try {
-    const handled = handleRecoverableExtensionProcessError(
-      Object.assign(new Error("missing binary"), {
-        code: "ENOENT",
-        syscall: "spawn npm",
-        path: "npm",
-      }),
-    );
-    assert.equal(handled, true);
-    assert.match(stderr, /spawn ENOENT: npm/);
-  } finally {
-    process.stderr.write = originalWrite;
-  }
-});
-
-test("handleRecoverableExtensionProcessError swallows uv_cwd ENOENT", () => {
-  let stderr = "";
-  const originalWrite = process.stderr.write.bind(process.stderr);
-  process.stderr.write = ((chunk: string | Uint8Array) => {
-    stderr += String(chunk);
-    return true;
-  }) as typeof process.stderr.write;
-
-  try {
-    const handled = handleRecoverableExtensionProcessError(
-      Object.assign(new Error("process.cwd failed"), {
-        code: "ENOENT",
-        syscall: "uv_cwd",
-      }),
-    );
-    assert.equal(handled, true);
-    assert.match(stderr, /ENOENT \(uv_cwd\): process\.cwd failed/);
-  } finally {
-    process.stderr.write = originalWrite;
-  }
-});
-
-test("handleRecoverableExtensionProcessError leaves unrelated errors unhandled", () => {
-  const handled = handleRecoverableExtensionProcessError(
-    Object.assign(new Error("permission denied"), {
-      code: "EPERM",
-      syscall: "open",
-    }),
-  );
-  assert.equal(handled, false);
-});