gsd-pi 2.77.0-dev.538325aea → 2.77.0-dev.eaa4973bc

package/dist/resources/extensions/gsd/file-lock.js

@@ -1,11 +1,19 @@
 import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { join } from "node:path";
+// The file-lock module is loaded in both CJS builds and ESM sources. Under ESM
+// the bare `require` identifier is not defined, so we always go through
+// createRequire. We try the current module's resolution context first and fall
+// back to the installed gsd-pi package if we are running from a consumer
+// project that does not hoist proper-lockfile.
+const localRequire = createRequire(import.meta.url);
 function _require(name) {
     try {
-        return require(name);
+        return localRequire(name);
     }
     catch {
         try {
-            const gsdPiRequire = require("module").createRequire(require("path").join(process.cwd(), "node_modules", "gsd-pi", "index.js"));
+            const gsdPiRequire = createRequire(join(process.cwd(), "node_modules", "gsd-pi", "index.js"));
             return gsdPiRequire(name);
         }
         catch {
@@ -13,14 +21,44 @@ function _require(name) {
         }
     }
 }
-export function withFileLockSync(filePath, fn) {
+const DEFAULT_RETRIES = 5;
+const DEFAULT_STALE_MS = 10000;
+const SYNC_RETRY_DELAY_MS = 50;
+// Block the thread for `ms` milliseconds without spinning the CPU.
+// Used by the sync lock retry loop, since proper-lockfile's lockSync does not
+// accept a `retries` option (only the async `lock` does).
+function sleepSync(ms) {
+    if (ms <= 0)
+        return;
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function acquireLockSyncWithRetry(lockfile, filePath, retries, stale) {
+    let lastErr;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+        try {
+            return lockfile.lockSync(filePath, { stale });
+        }
+        catch (err) {
+            lastErr = err;
+            if (err?.code !== "ELOCKED")
+                throw err;
+            if (attempt < retries)
+                sleepSync(SYNC_RETRY_DELAY_MS);
+        }
+    }
+    throw lastErr;
+}
+export function withFileLockSync(filePath, fn, opts = {}) {
     const lockfile = _require("proper-lockfile");
     if (!lockfile)
         return fn();
     if (!existsSync(filePath))
         return fn();
+    const retries = opts.retries ?? DEFAULT_RETRIES;
+    const stale = opts.stale ?? DEFAULT_STALE_MS;
+    const onLocked = opts.onLocked ?? "fail";
     try {
-        const release = lockfile.lockSync(filePath, { retries: 5, stale: 10000 });
+        const release = acquireLockSyncWithRetry(lockfile, filePath, retries, stale);
         try {
             return fn();
         }
@@ -29,21 +67,23 @@ export function withFileLockSync(filePath, fn) {
         }
     }
     catch (err) {
-        if (err.code === "ELOCKED") {
-            // Could not get lock after retries, let's fallback to un-locked instead of crashing the whole state machine
+        if (err?.code === "ELOCKED" && onLocked === "skip") {
             return fn();
         }
         throw err;
     }
 }
-export async function withFileLock(filePath, fn) {
+export async function withFileLock(filePath, fn, opts = {}) {
     const lockfile = _require("proper-lockfile");
     if (!lockfile)
         return await fn();
     if (!existsSync(filePath))
         return await fn();
+    const retries = opts.retries ?? DEFAULT_RETRIES;
+    const stale = opts.stale ?? DEFAULT_STALE_MS;
+    const onLocked = opts.onLocked ?? "fail";
     try {
-        const release = await lockfile.lock(filePath, { retries: 5, stale: 10000 });
+        const release = await lockfile.lock(filePath, { retries, stale });
         try {
             return await fn();
         }
@@ -52,7 +92,7 @@ export async function withFileLock(filePath, fn) {
         }
     }
     catch (err) {
-        if (err.code === "ELOCKED") {
+        if (err?.code === "ELOCKED" && onLocked === "skip") {
             return await fn();
         }
         throw err;

package/dist/resources/extensions/gsd/git-service.js

@@ -84,6 +84,7 @@ export class MergeConflictError extends GSDError {
  */
 export const RUNTIME_EXCLUSION_PATHS = [
     ".gsd/activity/",
+    ".gsd/audit/",
     ".gsd/forensics/",
     ".gsd/runtime/",
     ".gsd/worktrees/",

package/dist/resources/extensions/gsd/gitignore.js

@@ -24,6 +24,7 @@ import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
  */
 const GSD_RUNTIME_PATTERNS = [
     ".gsd/activity/",
+    ".gsd/audit/",
     ".gsd/forensics/",
     ".gsd/runtime/",
     ".gsd/worktrees/",

package/dist/resources/extensions/gsd/guided-flow-queue.js

@@ -13,6 +13,7 @@ import { deriveState } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
 import { gsdRoot, resolveMilestoneFile, resolveGsdRootFile, relGsdRootFile, } from "./paths.js";
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { atomicWriteSync } from "./atomic-write.js";
 import { nativeAddPaths, nativeCommit } from "./native-git-bridge.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { saveQueueOrder } from "./queue-order.js";
@@ -361,5 +362,7 @@ function syncProjectMdSequence(basePath, registry, newOrder) {
     const separatorLine = lines[tableStart + 1];
     const newTable = [headerLine, separatorLine, ...newRows];
     lines.splice(tableStart, tableEnd - tableStart, ...newTable);
-    writeFileSync(projectPath, lines.join("\n"), "utf-8");
+    // Atomic write: tmp+rename avoids a torn PROJECT.md appearing dirty in
+    // another worktree's working tree during a concurrent /gsd auto merge.
+    atomicWriteSync(projectPath, lines.join("\n"), "utf-8");
 }

package/dist/resources/extensions/gsd/guided-flow.js

@@ -228,7 +228,7 @@ export function checkAutoStartAfterDiscuss() {
         }
     }
     pendingAutoStartMap.delete(basePath);
-    ctx.ui.notify(`Milestone ${milestoneId} ready.`, "info");
+    ctx.ui.notify(`Milestone ${milestoneId} ready.`, "success");
     startAutoDetached(ctx, pi, basePath, false, { step });
     return true;
 }

package/dist/resources/extensions/gsd/journal.js

@@ -11,8 +11,10 @@
  * - queryJournal() enables programmatic filtering by flowId, eventType, unitId, time range
  * - Silent failure: journal writes never throw — absence of events is the failure signal
  */
-import { appendFileSync, mkdirSync, readdirSync, readFileSync } from "node:fs";
+import { appendFileSync, closeSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, } from "node:fs";
 import { join } from "node:path";
+import { isStaleWrite } from "./auto/turn-epoch.js";
+import { withFileLockSync } from "./file-lock.js";
 import { gsdRoot } from "./paths.js";
 import { buildAuditEnvelope, emitUokAuditEvent } from "./uok/audit.js";
 import { isUnifiedAuditEnabled } from "./uok/audit-toggle.js";
@@ -26,12 +28,25 @@ import { isUnifiedAuditEnabled } from "./uok/audit-toggle.js";
  * Never throws — all errors are silently caught.
  */
 export function emitJournalEvent(basePath, entry) {
+    // Drop writes from a turn superseded by timeout recovery / cancellation.
+    // See auto/turn-epoch.ts for the full rationale.
+    if (isStaleWrite("journal"))
+        return;
     try {
         const journalDir = join(gsdRoot(basePath), "journal");
         mkdirSync(journalDir, { recursive: true });
         const dateStr = entry.ts.slice(0, 10);
         const filePath = join(journalDir, `${dateStr}.jsonl`);
-        appendFileSync(filePath, JSON.stringify(entry) + "\n");
+        // Ensure file exists so proper-lockfile can acquire a lock against it.
+        if (!existsSync(filePath))
+            closeSync(openSync(filePath, "a"));
+        // onLocked: "skip" — journal writes are best-effort. POSIX O_APPEND
+        // atomicity still protects small entries; the lock mainly serializes
+        // larger writes and gives cross-process exclusivity on platforms where
+        // O_APPEND semantics are weaker (Windows).
+        withFileLockSync(filePath, () => {
+            appendFileSync(filePath, JSON.stringify(entry) + "\n");
+        }, { onLocked: "skip" });
     }
     catch {
         // Silent failure — journal must never break auto-mode

package/dist/resources/extensions/gsd/milestone-actions.js

@@ -18,6 +18,18 @@ import { loadQueueOrder, saveQueueOrder } from "./queue-order.js";
 import { deleteMilestone, getMilestone, isDbAvailable, updateMilestoneStatus } from "./gsd-db.js";
 import { removeWorktree } from "./worktree-manager.js";
 import { logWarning } from "./workflow-logger.js";
+import { isAutoActive } from "./auto.js";
+/**
+ * Writer-side assert for mutations that race with auto-mode's squash merge (#4704).
+ * Auto-mode is confirmed not to call parkMilestone/discardMilestone/unparkMilestone
+ * internally — these throws only surface invariant violations from new or forgotten
+ * call sites, which is the correct failure mode to catch loudly.
+ */
+function assertNotAutoActive(action) {
+    if (isAutoActive()) {
+        throw new Error(`${action} cannot run while auto-mode is active. Stop auto-mode first with /gsd stop.`);
+    }
+}
 // ─── Park ──────────────────────────────────────────────────────────────────
 /**
  * Park a milestone — creates a PARKED.md marker file with reason and timestamp.
@@ -25,6 +37,7 @@ import { logWarning } from "./workflow-logger.js";
  * Returns true if successfully parked, false if milestone not found or already parked.
  */
 export function parkMilestone(basePath, milestoneId, reason) {
+    assertNotAutoActive("park milestone");
     const mDir = resolveMilestonePath(basePath, milestoneId);
     if (!mDir || !existsSync(mDir))
         return false;
@@ -65,6 +78,7 @@ export function parkMilestone(basePath, milestoneId, reason) {
  * Returns true if successfully unparked, false if milestone not found or not parked.
  */
 export function unparkMilestone(basePath, milestoneId) {
+    assertNotAutoActive("unpark milestone");
     const mDir = resolveMilestonePath(basePath, milestoneId);
     if (!mDir || !existsSync(mDir))
         return false;
@@ -97,6 +111,7 @@ export function unparkMilestone(basePath, milestoneId) {
  * Returns true if successfully discarded, false if milestone not found.
  */
 export function discardMilestone(basePath, milestoneId) {
+    assertNotAutoActive("discard milestone");
     const mDir = resolveMilestonePath(basePath, milestoneId);
     if (!mDir || !existsSync(mDir))
         return false;

package/dist/resources/extensions/gsd/notifications.js

@@ -2,7 +2,6 @@
 // Cross-platform desktop notifications for auto-mode events.
 import { execFileSync } from "node:child_process";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
-import { CmuxClient, emitOsc777Notification, resolveCmuxConfig } from "../cmux/index.js";
 import { sendRemoteNotification } from "../remote-questions/notify.js";
 /**
  * Send a native desktop notification. Non-blocking, non-fatal.
@@ -20,22 +19,37 @@ export function sendDesktopNotification(title, message, level = "info", kind = "
     void sendRemoteNotification(title, message).catch(() => { });
     if (!shouldSendDesktopNotification(kind, loaded?.notifications))
         return;
-    const cmux = resolveCmuxConfig(loaded);
-    if (cmux.notifications) {
-        const delivered = CmuxClient.fromPreferences(loaded).notify(title, message);
-        if (delivered)
-            return;
-        emitOsc777Notification(title, message);
-    }
-    try {
-        const command = buildDesktopNotificationCommand(process.platform, title, message, level);
-        if (!command)
+    // cmux delivery and desktop delivery are independent — if cmux import or
+    // delivery fails, we must still attempt the native desktop notification.
+    const runCmux = async () => {
+        try {
+            const { CmuxClient, emitOsc777Notification, resolveCmuxConfig } = await import("../cmux/index.js");
+            const cmux = resolveCmuxConfig(loaded);
+            if (cmux.notifications) {
+                const delivered = CmuxClient.fromPreferences(loaded).notify(title, message);
+                if (delivered)
+                    return true;
+                emitOsc777Notification(title, message);
+            }
+        }
+        catch {
+            // cmux unavailable — fall through to desktop notification
+        }
+        return false;
+    };
+    void runCmux().then((deliveredByCmux) => {
+        if (deliveredByCmux)
             return;
-        execFileSync(command.file, command.args, { timeout: 3000, stdio: "ignore" });
-    }
-    catch {
-        // Non-fatal — desktop notifications are best-effort
-    }
+        try {
+            const command = buildDesktopNotificationCommand(process.platform, title, message, level);
+            if (!command)
+                return;
+            execFileSync(command.file, command.args, { timeout: 3000, stdio: "ignore" });
+        }
+        catch {
+            // Non-fatal — desktop notifications are best-effort
+        }
+    }).catch(() => { });
 }
 export function shouldSendDesktopNotification(kind, preferences = loadEffectiveGSDPreferences()?.preferences.notifications) {
     if (preferences?.enabled === false)

package/dist/resources/extensions/gsd/reports.js

@@ -13,8 +13,9 @@
  * Auto-triggered: after each milestone completion (when auto_report: true).
  * Manual: /gsd export --html
  */
-import { writeFileSync, readFileSync, mkdirSync, existsSync } from 'node:fs';
+import { readFileSync, mkdirSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
+import { atomicWriteSync } from './atomic-write.js';
 import { gsdRoot } from './paths.js';
 import { formatCost, formatTokenCount } from './metrics.js';
 import { formatDateShort, formatDuration } from '../shared/format-utils.js';
@@ -43,7 +44,7 @@ export function loadReportsIndex(basePath) {
 function saveReportsIndex(basePath, index) {
     const dir = reportsDir(basePath);
     mkdirSync(dir, { recursive: true });
-    writeFileSync(reportsIndexPath(basePath), JSON.stringify(index, null, 2) + '\n', 'utf-8');
+    atomicWriteSync(reportsIndexPath(basePath), JSON.stringify(index, null, 2) + '\n', 'utf-8');
 }
 /**
  * Write a report snapshot to .gsd/reports/, update reports.json, regenerate index.html.
@@ -56,7 +57,7 @@ export function writeReportSnapshot(args) {
     const prefix = args.milestoneId === 'final' ? 'final' : args.milestoneId;
     const filename = `${prefix}-${timestamp}.html`;
     const filePath = join(dir, filename);
-    writeFileSync(filePath, args.html, 'utf-8');
+    atomicWriteSync(filePath, args.html, 'utf-8');
     // Load or init registry
     const existing = loadReportsIndex(args.basePath);
     const index = existing ?? {
@@ -97,7 +98,7 @@ export function writeReportSnapshot(args) {
 // ─── HTML Index Generator ─────────────────────────────────────────────────────
 export function regenerateHtmlIndex(basePath, index) {
     const html = buildIndexHtml(index);
-    writeFileSync(reportsHtmlIndexPath(basePath), html, 'utf-8');
+    atomicWriteSync(reportsHtmlIndexPath(basePath), html, 'utf-8');
 }
 function buildIndexHtml(index) {
     const { projectName, projectPath, gsdVersion, entries } = index;

package/dist/resources/extensions/gsd/tools/complete-slice.js

@@ -16,6 +16,7 @@ import { checkOwnership, sliceUnitKey } from "../unit-ownership.js";
 import { saveFile, clearParseCache } from "../files.js";
 import { invalidateStateCache } from "../state.js";
 import { renderRoadmapCheckboxes } from "../markdown-renderer.js";
+import { isStaleWrite } from "../auto/turn-epoch.js";
 import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
@@ -228,6 +229,10 @@ export async function handleCompleteSlice(params, basePath) {
         }
         const slice = getSlice(params.milestoneId, params.sliceId);
         if (slice && isClosedStatus(slice.status)) {
+            if (isStaleWrite("complete-slice")) {
+                guardError = "__stale_duplicate__";
+                return;
+            }
             guardError = `slice ${params.sliceId} is already complete — use gsd_slice_reopen first if you need to redo it`;
             return;
         }
@@ -248,6 +253,22 @@ export async function handleCompleteSlice(params, basePath) {
         insertSlice({ id: params.sliceId, milestoneId: params.milestoneId, title: params.sliceId });
         updateSliceStatus(params.milestoneId, params.sliceId, "complete", completedAt);
     });
+    if (guardError === "__stale_duplicate__") {
+        // Stale duplicate from a turn superseded by timeout recovery. Return a
+        // non-mutating success so the orphaned LLM tool call unwinds quietly.
+        const sliceDir = resolveSlicePath(basePath, params.milestoneId, params.sliceId);
+        const staleSummaryPath = sliceDir
+            ? join(sliceDir, `${params.sliceId}-SUMMARY.md`)
+            : join(basePath, ".gsd", "milestones", params.milestoneId, "slices", params.sliceId, `${params.sliceId}-SUMMARY.md`);
+        return {
+            sliceId: params.sliceId,
+            milestoneId: params.milestoneId,
+            summaryPath: staleSummaryPath,
+            uatPath: staleSummaryPath.replace(/-SUMMARY\.md$/, "-UAT.md"),
+            duplicate: true,
+            stale: true,
+        };
+    }
     if (guardError) {
         return { error: guardError };
     }

package/dist/resources/extensions/gsd/tools/complete-task.js

@@ -21,6 +21,7 @@ import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning, logError } from "../workflow-logger.js";
 import { loadEffectiveGSDPreferences } from "../preferences.js";
+import { isStaleWrite } from "../auto/turn-epoch.js";
 import { buildEscalationArtifact, writeEscalationArtifact } from "../escalation.js";
 /**
  * Map an execute-task-owned gate id to the CompleteTaskParams field whose
@@ -167,6 +168,18 @@ export async function handleCompleteTask(params, basePath) {
         }
         const existingTask = getTask(params.milestoneId, params.sliceId, params.taskId);
         if (existingTask && isClosedStatus(existingTask.status)) {
+            // Stale-turn path: a timed-out turn that was superseded by recovery
+            // can still reach this code when its LLM call eventually returns and
+            // invokes gsd_complete_task. Returning an error would produce noisy
+            // "already complete — use reopen first" logs in the orphaned turn.
+            // Instead, signal the duplicate via a non-mutating success shape that
+            // callers can detect via `duplicate: true` / `stale: true`.
+            if (isStaleWrite("complete-task")) {
+                // Sentinel handled below — outside the transaction — so we don't
+                // render SUMMARY.md or flip plan checkboxes for a stale duplicate.
+                guardError = "__stale_duplicate__";
+                return;
+            }
             guardError = `task ${params.taskId} is already complete — use gsd_task_reopen first if you need to redo it`;
             return;
         }
@@ -201,6 +214,24 @@ export async function handleCompleteTask(params, basePath) {
             });
         }
     });
+    if (guardError === "__stale_duplicate__") {
+        // Orphaned-turn duplicate: the task is already complete from the
+        // superseded turn's earlier (real) call. Return a non-mutating success
+        // so the stale LLM tool call unwinds cleanly. summaryPath is synthesized
+        // from the existing on-disk layout; no file is written.
+        const tasksDir = resolveTasksDir(basePath, params.milestoneId, params.sliceId);
+        const staleSummaryPath = tasksDir
+            ? join(tasksDir, `${params.taskId}-SUMMARY.md`)
+            : join(basePath, ".gsd", "milestones", params.milestoneId, "slices", params.sliceId, "tasks", `${params.taskId}-SUMMARY.md`);
+        return {
+            taskId: params.taskId,
+            sliceId: params.sliceId,
+            milestoneId: params.milestoneId,
+            summaryPath: staleSummaryPath,
+            duplicate: true,
+            stale: true,
+        };
+    }
     if (guardError) {
         return { error: guardError };
     }

package/dist/resources/extensions/gsd/uok/audit.js

@@ -1,6 +1,8 @@
-import { appendFileSync, mkdirSync } from "node:fs";
+import { appendFileSync, closeSync, existsSync, mkdirSync, openSync } from "node:fs";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
+import { isStaleWrite } from "../auto/turn-epoch.js";
+import { withFileLockSync } from "../file-lock.js";
 import { gsdRoot } from "../paths.js";
 import { isDbAvailable, insertAuditEvent } from "../gsd-db.js";
 function auditLogPath(basePath) {
@@ -22,9 +24,23 @@ export function buildAuditEnvelope(args) {
     };
 }
 export function emitUokAuditEvent(basePath, event) {
+    // Drop writes from a turn superseded by timeout recovery / cancellation.
+    if (isStaleWrite("uok-audit"))
+        return;
     try {
         ensureAuditDir(basePath);
-        appendFileSync(auditLogPath(basePath), `${JSON.stringify(event)}\n`, "utf-8");
+        const path = auditLogPath(basePath);
+        // proper-lockfile requires the target file to exist before locking.
+        // Touch it via open(O_APPEND|O_CREAT) so the first writer wins the race
+        // atomically at the kernel level.
+        if (!existsSync(path))
+            closeSync(openSync(path, "a"));
+        // onLocked: "skip" — audit writes are best-effort; under heavy contention
+        // POSIX O_APPEND atomicity still protects small line writes, so skipping
+        // the lock rather than stalling orchestration is the correct tradeoff.
+        withFileLockSync(path, () => {
+            appendFileSync(path, `${JSON.stringify(event)}\n`, "utf-8");
+        }, { onLocked: "skip" });
     }
     catch {
         // Best-effort: audit writes must never break orchestration.

package/dist/resources/extensions/gsd/workflow-logger.js

@@ -15,8 +15,9 @@
 // a process. The auto-loop must call _resetLogs() (or drainAndSummarize()) at
 // the start of each unit to prevent log bleed between units running in the same
 // Node process.
-import { appendFileSync, readFileSync, existsSync, mkdirSync } from "node:fs";
+import { appendFileSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, } from "node:fs";
 import { join } from "node:path";
+import { withFileLockSync } from "./file-lock.js";
 import { appendNotification } from "./notification-store.js";
 import { buildAuditEnvelope, emitUokAuditEvent } from "./uok/audit.js";
 import { isUnifiedAuditEnabled } from "./uok/audit-toggle.js";
@@ -231,8 +232,15 @@ function _push(severity, component, message, context) {
         try {
             const auditDir = join(_auditBasePath, ".gsd");
             mkdirSync(auditDir, { recursive: true });
+            const auditPath = join(auditDir, "audit-log.jsonl");
             const sanitized = _sanitizeForAudit(entry);
-            appendFileSync(join(auditDir, "audit-log.jsonl"), JSON.stringify(sanitized) + "\n", "utf-8");
+            // Ensure file exists so proper-lockfile can acquire a lock against it.
+            if (!existsSync(auditPath))
+                closeSync(openSync(auditPath, "a"));
+            // onLocked: "skip" — never block error logging on lock contention.
+            withFileLockSync(auditPath, () => {
+                appendFileSync(auditPath, JSON.stringify(sanitized) + "\n", "utf-8");
+            }, { onLocked: "skip" });
         }
         catch (auditErr) {
             // Best-effort — never let audit write failures bubble up

package/dist/resources/extensions/gsd/worktree-manager.js

@@ -479,6 +479,7 @@ const SKIP_PATHS = [
     ".gsd/worktrees/",
     ".gsd/runtime/",
     ".gsd/activity/",
+    ".gsd/audit/",
     ".gsd/forensics/",
     ".gsd/parallel/",
     ".gsd/journal/",

package/dist/resources/extensions/mcp-client/auth.js

@@ -10,7 +10,16 @@
 // ─── Env resolution ───────────────────────────────────────────────────────────
 /** Resolve `${VAR}` references in a string against `process.env`. */
 function resolveEnvValue(value) {
-    return value.replace(/\$\{([^}]+)\}/g, (_match, varName) => process.env[varName] ?? "");
+    return value.replace(/\$\{([^}]+)\}/g, (_match, varName) => {
+        const resolved = process.env[varName];
+        if (resolved === undefined || resolved === "") {
+            // eslint-disable-next-line no-console
+            console.warn(`[mcp-client auth] Environment variable "${varName}" referenced in MCP server config is unset. ` +
+                `Requests will go out with a malformed header and the remote server will likely reject them with 401.`);
+            return "";
+        }
+        return resolved;
+    });
 }
 function resolveHeaders(raw) {
     const resolved = {};