gsd-pi 2.57.0-dev.f22a903 → 2.58.0-dev.778d6ac

package/src/resources/extensions/gsd/tests/db-path-worktree-symlink.test.ts

@@ -0,0 +1,131 @@
+/**
+ * db-path-worktree-symlink.test.ts — #2517
+ *
+ * Regression test for the db_unavailable loop in worktree/symlink layouts.
+ *
+ * The path resolver must handle BOTH worktree path families:
+ *   - /.gsd/worktrees/<MID>/...           (direct layout)
+ *   - /.gsd/projects/<hash>/worktrees/<MID>/...  (symlink-resolved layout)
+ *
+ * When the second layout is not recognised, ensureDbOpen derives a wrong DB
+ * path, the open fails silently, and every completion tool call returns
+ * db_unavailable — triggering an artifact retry re-dispatch loop.
+ *
+ * Additionally, the post-unit artifact retry path must NOT retry when the
+ * completion tool failed due to db_unavailable (infra failure), because
+ * retrying can never succeed and causes cost spikes.
+ */
+
+import { readFileSync } from "node:fs";
+import { join, sep } from "node:path";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+// ── Part 1: resolveProjectRootDbPath handles symlink-resolved layout ─────
+
+console.log("\n=== #2517 Part 1: resolveProjectRootDbPath symlink layout ===");
+
+// Import the resolver directly
+const { resolveProjectRootDbPath } = await import("../bootstrap/dynamic-tools.js");
+
+// Standard worktree layout (already works)
+const standardPath = `/home/user/myproject/.gsd/worktrees/M001/work`;
+const standardResult = resolveProjectRootDbPath(standardPath);
+assertEq(
+  standardResult,
+  join("/home/user/myproject", ".gsd", "gsd.db"),
+  "Standard worktree layout resolves to project root DB path",
+);
+
+// Symlink-resolved layout (the regression — /.gsd/projects/<hash>/worktrees/...)
+const symlinkPath = `/home/user/myproject/.gsd/projects/abc123def/worktrees/M001/work`;
+const symlinkResult = resolveProjectRootDbPath(symlinkPath);
+assertEq(
+  symlinkResult,
+  join("/home/user/myproject", ".gsd", "gsd.db"),
+  "Symlink-resolved layout (/.gsd/projects/<hash>/worktrees/) resolves to project root DB path (#2517)",
+);
+
+// Windows-style separators for symlink layout
+if (sep === "\\") {
+  const winSymlinkPath = `C:\\Users\\dev\\project\\.gsd\\projects\\abc123def\\worktrees\\M001\\work`;
+  const winResult = resolveProjectRootDbPath(winSymlinkPath);
+  assertEq(
+    winResult,
+    join("C:\\Users\\dev\\project", ".gsd", "gsd.db"),
+    "Windows symlink layout resolves correctly",
+  );
+} else {
+  // On non-Windows, test forward-slash variant explicitly
+  const fwdSymlinkPath = `/home/user/myproject/.gsd/projects/abc123def/worktrees/M001/work`;
+  const fwdResult = resolveProjectRootDbPath(fwdSymlinkPath);
+  assertEq(
+    fwdResult,
+    join("/home/user/myproject", ".gsd", "gsd.db"),
+    "Forward-slash symlink layout resolves correctly on POSIX",
+  );
+}
+
+// Edge: deeper nesting under projects/<hash>/worktrees
+const deepSymlinkPath = `/home/user/myproject/.gsd/projects/deadbeef42/worktrees/M003/sub/dir`;
+const deepResult = resolveProjectRootDbPath(deepSymlinkPath);
+assertEq(
+  deepResult,
+  join("/home/user/myproject", ".gsd", "gsd.db"),
+  "Deep symlink worktree path still resolves to project root DB",
+);
+
+// Non-worktree path should be unchanged
+const normalPath = `/home/user/myproject`;
+const normalResult = resolveProjectRootDbPath(normalPath);
+assertEq(
+  normalResult,
+  join("/home/user/myproject", ".gsd", "gsd.db"),
+  "Non-worktree path is unchanged",
+);
+
+// ── Part 2: ensureDbOpen returns structured failure context ──────────────
+
+console.log("\n=== #2517 Part 2: ensureDbOpen structured diagnostics ===");
+
+const dynamicToolsSrc = readFileSync(
+  join(import.meta.dirname, "..", "bootstrap", "dynamic-tools.ts"),
+  "utf-8",
+);
+
+// ensureDbOpen should return a structured result, not just boolean false
+// Check that the catch block provides diagnostic information
+assertTrue(
+  dynamicToolsSrc.includes("resolvedPath") || dynamicToolsSrc.includes("diagnostic"),
+  "ensureDbOpen catch block surfaces diagnostic information (resolvedPath or diagnostic) instead of bare false (#2517)",
+);
+
+// ── Part 3: post-unit does NOT artifact-retry on db_unavailable ──────────
+
+console.log("\n=== #2517 Part 3: post-unit db_unavailable is infra-fatal ===");
+
+const postUnitSrc = readFileSync(
+  join(import.meta.dirname, "..", "auto-post-unit.ts"),
+  "utf-8",
+);
+
+// The artifact retry block should check DB availability and skip retry
+// when the DB is unavailable (infra failure, not a missing artifact).
+assertTrue(
+  postUnitSrc.includes("db_unavailable") || postUnitSrc.includes("isDbAvailable"),
+  "post-unit artifact retry path checks DB availability to avoid retry loop (#2517)",
+);
+
+// Verify the retry block is guarded: when !isDbAvailable(), the code must
+// NOT return "retry". The pattern should be: if (!verified && !isDbAvailable()) { skip }
+// followed by else if (!verified) { ... return "retry" }
+const dbUnavailableGuard = postUnitSrc.match(
+  /!triggerArtifactVerified\s*&&\s*!isDbAvailable\(\)/,
+);
+assertTrue(
+  !!dbUnavailableGuard,
+  "The retry block explicitly guards against !isDbAvailable() before returning 'retry' (#2517)",
+);
+
+report();

package/src/resources/extensions/gsd/tests/db-writer.test.ts

@@ -416,23 +416,18 @@ describe('db-writer', () => {
     }
   });
 
-  test('updateRequirementInDb — not found', async () => {
+  test('updateRequirementInDb — upserts when not found (#2919)', async () => {
     const tmpDir = makeTmpDir();
     const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
     openDatabase(dbPath);
 
     try {
-      let threw = false;
-      try {
-        await updateRequirementInDb('R999', { status: 'validated' }, tmpDir);
-      } catch (err) {
-        threw = true;
-        assert.ok(
-          (err as Error).message.includes('R999'),
-          'error message mentions the missing ID',
-        );
-      }
-      assert.ok(threw, 'throws when requirement not found');
+      // Previously threw; now upserts a skeleton requirement with the provided updates
+      await updateRequirementInDb('R999', { status: 'validated' }, tmpDir);
+      const created = getRequirementById('R999');
+      assert.ok(created !== null, 'R999 should be created by upsert');
+      assert.deepStrictEqual(created!.status, 'validated', 'Upserted requirement should have validated status');
+      assert.deepStrictEqual(created!.id, 'R999', 'Upserted requirement should keep the provided ID');
     } finally {
       closeDatabase();
       cleanupDir(tmpDir);

package/src/resources/extensions/gsd/tests/derive-state-db.test.ts

@@ -4,7 +4,7 @@ import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
-import { deriveState, invalidateStateCache, _deriveStateImpl, deriveStateFromDb } from '../state.ts';
+import { deriveState, invalidateStateCache, _deriveStateImpl, deriveStateFromDb, isGhostMilestone } from '../state.ts';
 import {
   openDatabase,
   closeDatabase,
@@ -934,8 +934,8 @@ describe('derive-state-db', async () => {
     }
   });
 
-  // ─── Test 21: Ghost milestone skipped ─────────────────────────────────
-  test('derive-state-db: ghost milestone skipped', async () => {
+  // ─── Test 21: Ghost milestone skipped (no DB row, no worktree) ─────────
+  test('derive-state-db: ghost milestone skipped when no DB row and no worktree', async () => {
     const base = createFixtureBase();
     try {
       // Ghost: milestone dir exists with only META.json, no context/roadmap/summary
@@ -948,8 +948,7 @@ describe('derive-state-db', async () => {
       const fileState = await _deriveStateImpl(base);
 
       openDatabase(':memory:');
-      // Ghost milestone in DB — no slices, status active
-      insertMilestone({ id: 'M001', title: '', status: 'active' });
+      // Only insert M002 — M001 has no DB row (simulates row loss / never inserted)
       insertMilestone({ id: 'M002', title: 'Real', status: 'active' });
 
       invalidateStateCache();
@@ -1051,4 +1050,78 @@ describe('derive-state-db', async () => {
       closeDatabase();
     }
   });
+
+  // ─── Queued milestone with worktree not flagged as ghost (#2921) ──────
+  test('derive-state-db: queued milestone with worktree not flagged as ghost (#2921)', async () => {
+    const base = createFixtureBase();
+    try {
+      // M001: complete milestone with summary
+      writeFile(base, 'milestones/M001/M001-SUMMARY.md', '# M001 Summary\n\nDone.');
+
+      // M002: queued milestone — directory + slices dir exists, but no content files.
+      // This is what happens when ensureMilestoneDbRow creates M002 but the DB row
+      // is lost during worktree teardown.
+      mkdirSync(join(base, '.gsd', 'milestones', 'M002', 'slices'), { recursive: true });
+
+      // A worktree exists for M002, proving it's a legitimate milestone
+      mkdirSync(join(base, '.gsd', 'worktrees', 'M002'), { recursive: true });
+
+      // isGhostMilestone should NOT treat M002 as ghost when worktree exists
+      assert.ok(!isGhostMilestone(base, 'M002'), 'ghost-wt: M002 with worktree is NOT a ghost');
+
+      // DB has M001 complete but M002 row was lost
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M001', title: 'First', status: 'complete' });
+      // No M002 row — simulates DB row loss during worktree teardown
+
+      invalidateStateCache();
+      const dbState = await deriveStateFromDb(base);
+
+      // M002 should be reconciled from disk (not skipped as ghost) and become active
+      const m002Entry = dbState.registry.find(e => e.id === 'M002');
+      assert.ok(m002Entry !== undefined, 'ghost-wt: M002 should be in registry');
+      assert.deepStrictEqual(dbState.activeMilestone?.id, 'M002', 'ghost-wt: M002 should be active');
+      // Should NOT be phase: complete
+      assert.notEqual(dbState.phase, 'complete', 'ghost-wt: phase should not be complete');
+
+      closeDatabase();
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  });
+
+  // ─── Queued milestone with DB row not flagged as ghost (#2921) ────────
+  test('derive-state-db: queued milestone with DB row not flagged as ghost (#2921)', async () => {
+    const base = createFixtureBase();
+    try {
+      // M001: complete milestone with summary
+      writeFile(base, 'milestones/M001/M001-SUMMARY.md', '# M001 Summary\n\nDone.');
+
+      // M002: queued milestone — directory exists, no content files, but has DB row
+      mkdirSync(join(base, '.gsd', 'milestones', 'M002', 'slices'), { recursive: true });
+
+      // DB has both M001 complete and M002 queued
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M001', title: 'First', status: 'complete' });
+      insertMilestone({ id: 'M002', title: 'Second', status: 'queued' });
+
+      // isGhostMilestone should NOT treat M002 as ghost when DB row exists
+      assert.ok(!isGhostMilestone(base, 'M002'), 'ghost-dbrow: M002 with DB row is NOT a ghost');
+
+      invalidateStateCache();
+      const dbState = await deriveStateFromDb(base);
+
+      // M002 should not be skipped
+      const m002Entry = dbState.registry.find(e => e.id === 'M002');
+      assert.ok(m002Entry !== undefined, 'ghost-dbrow: M002 should be in registry');
+      assert.deepStrictEqual(dbState.activeMilestone?.id, 'M002', 'ghost-dbrow: M002 should be active');
+      assert.notEqual(dbState.phase, 'complete', 'ghost-dbrow: phase should not be complete');
+
+      closeDatabase();
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  });
 });

package/src/resources/extensions/gsd/tests/derive-state.test.ts

@@ -930,6 +930,35 @@ slice: S01
     }
   });
 
+  // ─── Test: queued milestone with worktree not flagged as ghost (#2921) ──
+  test('queued milestone with worktree not flagged as ghost (#2921)', async () => {
+    const base = createFixtureBase();
+    try {
+      // Create a milestone directory with only an empty slices subdir — no content files.
+      // This would normally be a ghost, but it has a worktree directory.
+      const milestoneDir = join(base, '.gsd', 'milestones', 'M002');
+      mkdirSync(join(milestoneDir, 'slices'), { recursive: true });
+
+      // Create a worktree directory for M002, simulating an active worktree
+      const worktreeDir = join(base, '.gsd', 'worktrees', 'M002');
+      mkdirSync(worktreeDir, { recursive: true });
+
+      // isGhostMilestone should return false because the worktree exists
+      assert.ok(!isGhostMilestone(base, 'M002'), 'M002 with worktree should NOT be a ghost');
+
+      // Also create a completed M001 so deriveState has something before M002
+      writeMilestoneSummary(base, 'M001', '# M001 Summary\n\nDone.');
+
+      const state = await deriveState(base);
+      // M002 should appear in the registry (not filtered as ghost)
+      const m002Entry = state.registry.find(e => e.id === 'M002');
+      assert.ok(m002Entry !== undefined, 'M002 should be in registry when worktree exists');
+      assert.deepStrictEqual(state.activeMilestone?.id, 'M002', 'M002 should be active milestone');
+    } finally {
+      cleanup(base);
+    }
+  });
+
   // ─── Test: zero-slice roadmap → pre-planning, not blocked (#1785) ────
   test('zero-slice roadmap → pre-planning, not blocked (#1785)', async () => {
     const base = createFixtureBase();

package/src/resources/extensions/gsd/tests/discord-invite-links.test.ts

@@ -0,0 +1,47 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+/**
+ * Validates that all Discord invite links in user-facing files point to valid,
+ * consistent invite URLs — not expired vanity links.
+ *
+ * Regression test for https://github.com/gsd-build/gsd-2/issues/2699
+ */
+
+const ROOT = process.cwd();
+
+/** Canonical Discord invite for the GSD community. */
+const VALID_INVITE = "https://discord.com/invite/nKXTsAcmbT";
+
+/** Files that contain user-facing Discord invite links. */
+const FILES_WITH_INVITE_LINKS: string[] = [
+  "README.md",
+  "docs/what-is-pi/15-pi-packages-the-ecosystem.md",
+];
+
+describe("Discord invite links (#2699)", () => {
+  for (const relPath of FILES_WITH_INVITE_LINKS) {
+    it(`${relPath} contains only the canonical Discord invite`, () => {
+      const content = readFileSync(join(ROOT, relPath), "utf8");
+
+      // Extract all Discord invite URLs (discord.gg/X or discord.com/invite/X)
+      const invitePattern = /https?:\/\/(?:discord\.gg|discord\.com\/invite)\/[A-Za-z0-9]+/g;
+      const matches = content.match(invitePattern);
+
+      assert.ok(
+        matches && matches.length > 0,
+        `Expected at least one Discord invite link in ${relPath}`,
+      );
+
+      for (const link of matches) {
+        assert.equal(
+          link,
+          VALID_INVITE,
+          `Invalid Discord invite in ${relPath}: found "${link}", expected "${VALID_INVITE}"`,
+        );
+      }
+    });
+  }
+});

package/src/resources/extensions/gsd/tests/discuss-empty-db-fallback.test.ts

@@ -0,0 +1,127 @@
+/**
+ * discuss-empty-db-fallback.test.ts — Tests for #2892.
+ *
+ * When the DB is open but empty (e.g., after crash/truncation),
+ * getMilestoneSlices() returns [] and showDiscuss() incorrectly declares
+ * "All slices are complete." The fix adds a roadmap fallback: when the DB
+ * returns zero slices but a ROADMAP file exists, parse slices from the
+ * roadmap instead of treating zero slices as "all complete."
+ */
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { parseRoadmapSlices } from "../roadmap-slices.ts";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function readGuidedFlowSource(): string {
+  const thisFile = fileURLToPath(import.meta.url);
+  const thisDir = dirname(thisFile);
+  return readFileSync(join(thisDir, "..", "guided-flow.ts"), "utf-8");
+}
+
+const SAMPLE_ROADMAP = `# M012 Roadmap
+
+## Slices
+- [ ] **S01: Core setup** \`risk:low\` \`depends:[]\`
+  > After this: basic project scaffolding works
+- [ ] **S02: Auth module** \`risk:medium\` \`depends:[S01]\`
+  > After this: users can log in
+- [ ] **S03: Dashboard** \`risk:low\` \`depends:[S02]\`
+  > After this: dashboard renders
+`;
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe("discuss-empty-db-fallback (#2892)", () => {
+
+  test("1. parseRoadmapSlices extracts slices from a valid ROADMAP", () => {
+    const slices = parseRoadmapSlices(SAMPLE_ROADMAP);
+    assert.strictEqual(slices.length, 3, "should parse 3 slices from sample roadmap");
+    assert.strictEqual(slices[0]!.id, "S01");
+    assert.strictEqual(slices[1]!.id, "S02");
+    assert.strictEqual(slices[2]!.id, "S03");
+    // All slices are incomplete ([ ] not [x])
+    assert.ok(slices.every(s => !s.done), "all slices should be incomplete");
+  });
+
+  test("2. guided-flow imports parseRoadmapSlices for roadmap fallback", () => {
+    const source = readGuidedFlowSource();
+    assert.ok(
+      source.includes("parseRoadmapSlices"),
+      "guided-flow must import parseRoadmapSlices to support roadmap fallback when DB is empty",
+    );
+  });
+
+  test("3. guided-flow has roadmap fallback when normSlices is empty but roadmapContent exists", () => {
+    const source = readGuidedFlowSource();
+    // The fix must add a fallback that checks normSlices.length === 0 && roadmapContent
+    // and repopulates normSlices from the roadmap before the pendingSlices guard.
+    //
+    // Pattern: after DB query produces normSlices, if empty + roadmap exists,
+    // fall back to parseRoadmapSlices(roadmapContent).
+    const fallbackPattern = /normSlices\.length\s*===\s*0\s*&&\s*roadmapContent/;
+    assert.ok(
+      fallbackPattern.test(source),
+      "guided-flow must check normSlices.length === 0 && roadmapContent to trigger roadmap fallback",
+    );
+  });
+
+  test("4. guided-flow no longer has unguarded pendingSlices === 0 exit after DB-only query", () => {
+    const source = readGuidedFlowSource();
+    // Extract the showDiscuss function body
+    const fnMatch = source.match(
+      /async function showDiscuss\s*\([^)]*\)[^{]*\{([\s\S]*?)\nfunction\s/,
+    );
+    assert.ok(!!fnMatch, "showDiscuss function body must be found");
+
+    if (fnMatch) {
+      const body = fnMatch[1]!;
+      // After the DB query block (isDbAvailable/getMilestoneSlices), there should
+      // be a roadmap fallback BEFORE the pendingSlices.length === 0 check.
+      // Find the getMilestoneSlices call and the pendingSlices === 0 check
+      const dbQueryIdx = body.indexOf("getMilestoneSlices");
+      const fallbackIdx = body.indexOf("parseRoadmapSlices");
+      const pendingGuardIdx = body.indexOf('pendingSlices.length === 0');
+
+      assert.ok(dbQueryIdx > 0, "getMilestoneSlices call must exist");
+      assert.ok(fallbackIdx > 0, "parseRoadmapSlices fallback must exist");
+      assert.ok(pendingGuardIdx > 0, "pendingSlices.length === 0 guard must exist");
+      assert.ok(
+        fallbackIdx > dbQueryIdx && fallbackIdx < pendingGuardIdx,
+        "parseRoadmapSlices fallback must appear BETWEEN DB query and pendingSlices === 0 guard",
+      );
+    }
+  });
+
+  test("5. roadmap-parsed slices map to NormSlice format with done=false by default", () => {
+    // When falling back to roadmap, incomplete slices ([ ]) should map to done:false,
+    // ensuring they appear as pending and are NOT falsely reported as complete.
+    const slices = parseRoadmapSlices(SAMPLE_ROADMAP);
+    const normSlices = slices.map(s => ({ id: s.id, done: s.done, title: s.title }));
+    const pendingSlices = normSlices.filter(s => !s.done);
+    assert.strictEqual(pendingSlices.length, 3,
+      "all 3 incomplete roadmap slices should be pending — not falsely treated as complete");
+  });
+
+  test("6. roadmap with completed slices correctly reports them as done", () => {
+    const completedRoadmap = `# M012 Roadmap
+
+## Slices
+- [x] **S01: Core setup** \`risk:low\` \`depends:[]\`
+  > After this: basic project scaffolding works
+- [ ] **S02: Auth module** \`risk:medium\` \`depends:[S01]\`
+  > After this: users can log in
+- [x] **S03: Dashboard** \`risk:low\` \`depends:[S02]\`
+  > After this: dashboard renders
+`;
+    const slices = parseRoadmapSlices(completedRoadmap);
+    const normSlices = slices.map(s => ({ id: s.id, done: s.done, title: s.title }));
+    const pendingSlices = normSlices.filter(s => !s.done);
+    assert.strictEqual(pendingSlices.length, 1, "only S02 should be pending");
+    assert.strictEqual(pendingSlices[0]!.id, "S02");
+  });
+});

package/src/resources/extensions/gsd/tests/discuss-queued-milestones.test.ts

@@ -238,4 +238,44 @@ describe("discuss-queued-milestones (#2307)", () => {
       "queued milestone picker must label entries with [queued] to distinguish from active",
     );
   });
+
+  // ─── #3150: allDiscussed early-return must not block queued milestone discussion ──
+
+  test("12. allDiscussed path checks for pending milestones before returning (#3150)", () => {
+    const source = readGuidedFlowSource();
+
+    // Extract the allDiscussed block — the if (allDiscussed) { ... } body
+    const allDiscussedMatch = source.match(
+      /const allDiscussed = pendingSlices\.every\([\s\S]*?\n    if \(allDiscussed\) \{([\s\S]*?)\n    \}/,
+    );
+    assert.ok(!!allDiscussedMatch, "allDiscussed guard block must exist in showDiscuss()");
+
+    if (allDiscussedMatch) {
+      const body = allDiscussedMatch[1];
+      // The fix must check for pending milestones and route to showDiscussQueuedMilestone
+      assert.ok(
+        body.includes("pending") && body.includes("showDiscussQueuedMilestone"),
+        "allDiscussed block must check for pending milestones and call showDiscussQueuedMilestone before returning (#3150)",
+      );
+    }
+  });
+
+  test("13. pendingSlices.length===0 path checks for pending milestones before returning (#3150)", () => {
+    const source = readGuidedFlowSource();
+
+    // Find the pendingSlices.length === 0 guard block
+    const zeroSlicesMatch = source.match(
+      /if \(pendingSlices\.length === 0\) \{([\s\S]*?)\n  \}/,
+    );
+    assert.ok(!!zeroSlicesMatch, "pendingSlices.length === 0 guard block must exist in showDiscuss()");
+
+    if (zeroSlicesMatch) {
+      const body = zeroSlicesMatch[1];
+      // The fix must check for pending milestones and route to showDiscussQueuedMilestone
+      assert.ok(
+        body.includes("pending") && body.includes("showDiscussQueuedMilestone"),
+        "pendingSlices.length===0 block must check for pending milestones and call showDiscussQueuedMilestone before returning (#3150)",
+      );
+    }
+  });
 });

package/src/resources/extensions/gsd/tests/dist-redirect.mjs

@@ -87,7 +87,26 @@ export function load(url, context, nextLoad) {
         emitDecoratorMetadata: true,
       },
     });
-    return { format: 'module', source: outputText, shortCircuit: true };
+    // Inject CJS-compatible globals (__dirname, __filename, require) so that
+    // workspace packages compiled as ESM can still use them.  This avoids the
+    // need for import.meta.url behind indirect invocation patterns that fail in
+    // CJS and in dynamically-created scopes.
+    // Only inject globals that the source file doesn't already declare itself.
+    const preambleLines = [
+      'import { fileURLToPath as __preamble_fUTP } from "node:url";',
+      'import { dirname as __preamble_dn } from "node:path";',
+      'import { createRequire as __preamble_cR } from "node:module";',
+    ];
+    if (!outputText.includes('const __filename') && !outputText.includes('let __filename')) {
+      preambleLines.push('const __filename = __preamble_fUTP(import.meta.url);');
+    }
+    if (!outputText.includes('const __dirname') && !outputText.includes('let __dirname')) {
+      preambleLines.push('const __dirname = __preamble_dn(__preamble_fUTP(import.meta.url));');
+    }
+    if (!outputText.includes('const require') && !outputText.includes('let require')) {
+      preambleLines.push('const require = __preamble_cR(import.meta.url);');
+    }
+    return { format: 'module', source: preambleLines.join('\n') + '\n' + outputText, shortCircuit: true };
   }
   return nextLoad(url, context);
 }