@youdie006/prodex 0.18.0 → 0.19.1

package/README.md

@@ -35,7 +35,7 @@ prodex ask --file src/auth.ts "Review this for security holes"
 
 `prodex ask` is the short form of `prodex pro browser ask`; the full form and every flag work identically. In an interactive terminal, `login` keeps watching the opened window and tells you exactly which manual step is still missing (log in, clear a check, open a chat) until it reports READY. If you skip `login` and the browser is not running, an interactive `ask` recovers on its own: it launches the dedicated browser, waits for your saved session to be READY, and retries the send once (disable with `--no-auto-login`; scripts opt in with `--auto-login`). While ChatGPT thinks, `prodex` prints progress to stderr (connecting, prompt sent, elapsed seconds while generating), so a multi-minute Pro answer never looks frozen.
 
-The answer prints to your terminal and is saved under `.bridge/` for later (`prodex pro latest` re-prints it). Add `--new-chat` to send into a fresh chat (recommended for repeated consults - long threads eventually confuse send detection). For a structured second-opinion debate between your coding agent and GPT Pro, `prodex pro debate-prompt --topic "..."` prints a ready-to-paste orchestration prompt. `prodex` drives the picker you can see and deliberately will not send into a window you cannot watch — but a dedicated Chrome window left non-minimized (even behind your editor) counts as watchable, so it sends quietly in the background without stealing focus. Just don't minimize it or switch that window to another tab. Pin per-repo defaults once - `prodex setup --model Pro --project "your-project"` - so every ask runs Pro (15-minute timeout) inside that project instead of whatever the ChatGPT UI last had selected; list exact sidebar project names with `prodex pro browser projects`. Pass `--file` more than once to attach several files. When the thread is still generating a previous answer (common right after a timed-out Pro send), the send automatically queues behind it up to the timeout budget; tune that with `--busy-wait-ms` (0 fails fast with a `response_in_progress` blocker). See [First Pro Login](#first-pro-login) for the full flow, and the [FAQ](#faq) if a send stops.
+The answer prints to your terminal and is saved under `.bridge/` for later (`prodex pro latest` re-prints it). Add `--new-chat` to send into a fresh chat (recommended for repeated consults - long threads eventually confuse send detection). For a structured second-opinion debate between your coding agent and GPT Pro, `prodex pro debate-prompt --topic "..."` prints a ready-to-paste orchestration prompt. `prodex` drives the picker you can see and will not send into a tab it cannot read, so leave the dedicated window on a ChatGPT tab; it sends quietly in the background without stealing focus. Prefer no window at all? See [virtual display](#no-window-at-all-virtual-display-recommended). Pin per-repo defaults once - `prodex setup --model Pro --project "your-project"` - so every ask runs Pro (20-minute timeout) inside that project instead of whatever the ChatGPT UI last had selected; list exact sidebar project names with `prodex pro browser projects`. Pass `--file` more than once to attach several files. When the thread is still generating a previous answer (common right after a timed-out Pro send), the send automatically queues behind it up to the timeout budget; tune that with `--busy-wait-ms` (0 fails fast with a `response_in_progress` blocker). See [First Pro Login](#first-pro-login) for the full flow, and the [FAQ](#faq) if a send stops.
 
 ## Core Shape
 

package/dist/chatgpt-browser.js

@@ -477,6 +477,23 @@ async function waitForFreshChatGptPage(page, timeoutMs) {
 export function hasChatGptPromptAcceptance(previous, state) {
     return state.userMessageCount > previous.userMessageCount || state.assistantMessageCount > previous.assistantMessageCount;
 }
+/**
+ * Compare the model that was ASKED for against the model that actually
+ * produced the answer (ChatGPT tags each message with data-message-model-slug).
+ * prodex used to record only the request, so a model click that silently did
+ * not take - or no model pinned at all - was invisible, and the user believed
+ * they were getting Pro reasoning when they were not.
+ */
+export function modelSelectionWarning(requestedModel, modelSlug) {
+    if (!requestedModel || !modelSlug)
+        return undefined;
+    const wantsPro = /\bpro\b/i.test(requestedModel);
+    if (!wantsPro)
+        return undefined;
+    if (/pro/i.test(modelSlug))
+        return undefined;
+    return `model_mismatch: you asked for ${requestedModel}, but the answer came from "${modelSlug}". Check the model picker in the browser; the selection did not take.`;
+}
 export function chatGptBusyBlocker(generating) {
     if (!generating)
         return undefined;
@@ -1570,6 +1587,7 @@ export async function recoverChatGptAnswerFromThread(options) {
         title: state.title,
         answer: state.answer.trim(),
         modelHints: state.modelHints,
+        ...(state.modelSlug ? { modelSlug: state.modelSlug } : {}),
         warnings: []
     };
 }
@@ -1842,7 +1860,8 @@ export async function sendChatGptPrompt(options) {
             title: completed.title,
             answer: completed.answer.trim(),
             modelHints: completed.modelHints,
-            warnings: [...sendWarnings]
+            ...(completed.modelSlug ? { modelSlug: completed.modelSlug } : {}),
+            warnings: [...sendWarnings, modelSelectionWarning(options.model, completed.modelSlug)].filter((warning) => Boolean(warning))
         };
     }
     // Timed out while the answer was still streaming: salvage the partial text
@@ -1855,14 +1874,19 @@ export async function sendChatGptPrompt(options) {
             title: completed.title,
             answer: completed.answer.trim(),
             modelHints: completed.modelHints,
+            ...(completed.modelSlug ? { modelSlug: completed.modelSlug } : {}),
             warnings: [
                 ...sendWarnings,
+                ...(modelSelectionWarning(options.model, completed.modelSlug) ? [modelSelectionWarning(options.model, completed.modelSlug)] : []),
                 `answer_incomplete: ChatGPT was still generating after ${formatDurationMs(timeoutMs)} (${timeoutMs}ms), so the answer below may be truncated. Raise --timeout-ms and retry for the full response.`
             ]
         };
     }
-    throw new Error(`Timed out after ${formatDurationMs(timeoutMs)} (${timeoutMs}ms) waiting for ChatGPT to respond. ` +
-        "Pro reasoning can run many minutes. Raise --timeout-ms and retry.");
+    // Carry the thread the prompt landed in: ChatGPT usually finishes the answer
+    // after prodex gives up, and `pro browser recover --target-url` exists to
+    // fetch it - but only if the caller knows which thread to point at.
+    throw Object.assign(new Error(`Timed out after ${formatDurationMs(timeoutMs)} (${timeoutMs}ms) waiting for ChatGPT to respond. ` +
+        "Pro reasoning can run many minutes. Raise --timeout-ms and retry."), completed?.url ? { thread: completed.url } : {});
 }
 export function modelMenuOptionsExpression() {
     return `(() => {
@@ -2409,10 +2433,17 @@ export function answerExpression() {
       return parts.join(String.fromCharCode(10));
     };
     const lines = text.split(String.fromCharCode(10)).map((line) => line.trim()).filter(Boolean);
-    const messages = [...document.querySelectorAll('[data-message-author-role]')].map((node) => ({
-      role: node.getAttribute('data-message-author-role'),
-      text: node.innerText || ""
-    }));
+    const messages = [...document.querySelectorAll('[data-message-author-role]')].map((node) => {
+      // ChatGPT tags each message with the model that produced it, on the
+      // message node or an ancestor depending on the build. This is the only
+      // ground truth for "did the Pro selection actually take".
+      let modelSlug = node.getAttribute('data-message-model-slug') || undefined;
+      if (!modelSlug && typeof node.closest === "function") {
+        const tagged = node.closest('[data-message-model-slug]');
+        if (tagged) modelSlug = tagged.getAttribute('data-message-model-slug') || undefined;
+      }
+      return { role: node.getAttribute('data-message-author-role'), text: node.innerText || "", modelSlug };
+    });
     const assistantMessages = messages.filter((message) => message.role === "assistant");
     const userMessages = messages.filter((message) => message.role === "user");
     const assistant = assistantMessages.at(-1);
@@ -2436,6 +2467,9 @@ export function answerExpression() {
       generating: placeholder || Boolean(document.querySelector(${streamingSelector})) || buttons.some((label) => generatingControlPattern.test(label)),
       assistantMessageCount: assistantMessages.length,
       userMessageCount: userMessages.length,
+      // ChatGPT tags each assistant message with the model that produced it -
+      // the only ground truth for "did the Pro selection actually take".
+      modelSlug: assistant ? assistant.modelSlug : undefined,
       modelHints: lines.filter((line) => /GPT|Pro|Thinking|ChatGPT|Extra High|Auto/i.test(line)).slice(0, 30)
     };
   })()`;

package/dist/cli-pro.js

@@ -962,7 +962,9 @@ export async function runAskProCommand(rest, io) {
         // after the 2026-07 update reset that to Medium, consults meant for Pro
         // quietly ran on a mid-tier model. Warn loudly and record it.
         if (!selectionModel && !selectionProMode && !selectionEffort) {
-            persistenceWarnings.push("model_selection_warning: no model/effort was selected for this send (no per-ask flag, no saved default), so it used whatever the ChatGPT UI last had selected. Pin one with `prodex setup --model Pro` or pass --model/--effort.");
+            persistenceWarnings.push("model_selection_warning: no model/effort was selected for this send (no per-ask flag, no saved default), so it used whatever the ChatGPT UI last had selected" +
+                (consult.modelSlug ? ` - it answered as "${consult.modelSlug}"` : "") +
+                ". Pin one with `prodex setup --model Pro` or pass --model/--effort.");
         }
         // In-project threads carry the project slug in their URL
         // (/g/g-p-<project>/c/<id>); a bare /c/<id> after requesting a project
@@ -976,6 +978,8 @@ export async function runAskProCommand(rest, io) {
         // would otherwise treat a cut-off answer as complete.
         for (const warning of persistenceWarnings)
             io.stderr(warning);
+        if (consult.modelSlug)
+            io.stderr(`model_used: ${consult.modelSlug}`);
         let answerArtifactPath;
         const answerArtifactBytes = Buffer.byteLength(answerArtifactText, "utf8");
         if (answerArtifactBytes > MAX_FETCHABLE_RESULT_ARTIFACT_BYTES) {
@@ -1003,6 +1007,9 @@ export async function runAskProCommand(rest, io) {
                     ...(answerArtifactPath ? { artifact_path: answerArtifactPath } : {}),
                     thread: consult.url,
                     ...(Object.keys(selectionMetadata).length > 0 ? { selection: selectionMetadata } : {}),
+                    // What actually answered, straight from ChatGPT's own tag - the
+                    // receipt used to record only what prodex asked for.
+                    ...(consult.modelSlug ? { model_used: consult.modelSlug } : {}),
                     warnings: persistenceWarnings
                 }
             });
@@ -1292,6 +1299,9 @@ export function browserSendBlockerFromError(error) {
     }
     // Match the raw ms whether the message uses the old "after 90000ms" form or
     // the newer human-readable "after 20 min (1200000ms)" form.
+    const thread = typeof error === "object" && error !== null && "thread" in error && typeof error.thread === "string"
+        ? (error.thread)
+        : undefined;
     const timedOut = message.match(/Timed out after [\s\S]*?(\d+)\s*ms/);
     if (timedOut) {
         // Suggest a concrete doubled budget so the user can paste a rerun command
@@ -1302,7 +1312,11 @@ export function browserSendBlockerFromError(error) {
             code: "send_timeout",
             message,
             retryable: true,
-            next_step: `Rerun with a bigger budget (${formatDurationMs(suggestedMs)}): \`prodex pro browser ask --timeout-ms ${suggestedMs} "<same prompt>"\`.`
+            ...(thread ? { thread } : {}),
+            next_step: `Rerun with a bigger budget (${formatDurationMs(suggestedMs)}): \`prodex pro browser ask --timeout-ms ${suggestedMs} "<same prompt>"\`.` +
+                (thread
+                    ? ` ChatGPT often finishes after prodex gives up - fetch that answer instead of re-asking: \`prodex pro browser recover --target-url ${thread}\`.`
+                    : "")
         };
     }
     // A CDP command timeout means the page's renderer stalled, which in the

package/dist/cli-server.js

@@ -4,7 +4,7 @@ import { parseProMode, parseReasoningEffort } from "./chatgpt-browser.js";
 import { ASK_PRO_SELECTION_CLEAR_FLAGS, ASK_PRO_SELECTION_DEFAULT_FLAGS, assertNoExtraArgs, assertOnlyOptions, isHelpSubcommand, printHelpIfRequested, readFlag, readPortFlag, readPositiveNumberFlag, resolveCwdFlag, resolveOptionalFileFlag, unknownSubcommandError } from "./cli-args.js";
 import { printInitHelp, printSetupHelp, printStartHelp, printStatusHelp, printTunnelHelp, printTunnelUrlHelp } from "./cli-help.js";
 import { errorMessage, isLoopbackHost, isMissingFileError, sourceAwareSetupMessage } from "./cli-shared.js";
-import { getTokenExpiryStatus, loadLocalConfig, writeLocalConfig } from "./config.js";
+import { getTokenExpiryStatus, loadLocalConfig, writeLocalConfig, composeServerUrlWithToken } from "./config.js";
 import { startHttpMcpServer } from "./http-mcp.js";
 import { readVerifiedUtf8File, writeVerifiedUtf8File } from "./safe-file.js";
 import { BridgeStore } from "./store.js";
@@ -49,7 +49,7 @@ export async function runSetupCommand(rest, io) {
     io.stdout("Saved local ChatGPT Developer Mode MCP profile.");
     io.stdout(`Server URL: ${redactServerUrl(config.server_url)}`);
     io.stdout(formatTokenExpiryLine(config));
-    io.stdout("Full URL is stored in .bridge/config.local.json.");
+    io.stdout("The token is stored (once) in .bridge/config.local.json; print the full URL with `prodex status --show-token --url-only`.");
     if (config.browser_defaults) {
         io.stdout(`Browser send defaults: ${formatBrowserDefaults(config.browser_defaults)}`);
     }
@@ -102,7 +102,10 @@ export async function runStatusCommand(rest, io) {
     const nonExpiringRevealWarning = showToken && allowNonExpiringTokenReveal && tokenStatus.status === "non_expiring"
         ? sourceAwareSetupMessage("Showing a non-expiring token. Keep this local-only and rotate it with `prodex setup --token-ttl-hours <hours>` before any tunnel or ChatGPT Project use.", sourceCli, { cwd: setupHintCwd })
         : undefined;
-    const serverUrl = formatServerUrlForOutput(config.server_url, { showToken });
+    // The token is no longer persisted inside server_url, so compose the
+    // usable URL here; masking still applies when the caller did not ask for
+    // the token.
+    const serverUrl = formatServerUrlForOutput(composeServerUrlWithToken(config), { showToken });
     if (rest.includes("--url-only")) {
         if (showToken)
             io.stderr(TOKEN_BEARING_MCP_URL_AUTHORITY_WARNING);

package/dist/cli.js

@@ -10,7 +10,7 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { renderBanner, shouldColorize } from "./banner.js";
 import { getChatGptBrowserStatus, resolveCdpPort } from "./chatgpt-browser.js";
-import { getTokenExpiryStatus, loadLocalConfig } from "./config.js";
+import { getTokenExpiryStatus, loadLocalConfig, resolveProdexCwd } from "./config.js";
 import { startHttpMcpServer } from "./http-mcp.js";
 import { createMcpToolHandlers } from "./mcp-tools.js";
 import { runMcpServer } from "./mcp.js";
@@ -216,7 +216,10 @@ export async function runCli(args, io = defaultIo()) {
 }
 function defaultIo() {
     return {
-        cwd: process.cwd(),
+        // PRODEX_CWD wins over a working directory prodex cannot use (a /dev/fd
+        // pipe path from an agent harness, a deleted directory); --cwd still wins
+        // over both where a command accepts it.
+        cwd: resolveProdexCwd(),
         stdout: (line) => console.log(line),
         stderr: (line) => console.error(line),
         isInteractive: process.stdout.isTTY === true,
@@ -303,9 +306,13 @@ repo: ${cwd}
    ${cli} pro browser login${sourceCliOption}  # opens visible browser
    ${cli} pro browser login --dry-run${sourceCliOption}  # preview, no browser opens
    In an interactive terminal, login waits and narrates until your ChatGPT session is READY.
+   Sign in once, then keep the browser off your screen for good:
+   ${cli} pro browser login --virtual-display${sourceCliOption}  # no window anywhere (needs Xvfb: sudo apt install -y xvfb x11-xkb-utils xauth)
+   ${cli} pro browser login --minimized${sourceCliOption}  # no install; keeps the window minimized
+   Not --headless: Cloudflare rejects headless browsers, so ChatGPT never loads in one.
    Pin per-repo defaults first - otherwise sends silently use whatever the ChatGPT UI last had selected:
    ${cli} pro browser projects${sourceCliOption}  # read-only: exact sidebar project names
-   ${cli} setup --cwd ${quotedCwd} --model Pro --project "your-project"  # every ask: Pro (15-minute timeout) inside that project
+   ${cli} setup --cwd ${quotedCwd} --model Pro --project "your-project"  # every ask: Pro (20-minute timeout) inside that project
    cd ${quotedCwd}
    ${cli} ask --new-chat "Review this repo"${sourceCliOption}  # short form of pro browser ask
    ${proAskCommand}  # dry-run/manual preview
@@ -314,7 +321,7 @@ repo: ${cwd}
    ${cli} pro browser help${sourceCliOption}
    ${cli} pro browser check${sourceCliOption} --cwd ${quotedCwd}
    ${cli} pro browser smoke${sourceCliOption} --cwd ${quotedCwd}
-   Sharing the browser with other agents? Add --busy-wait-ms 600000 to queue behind an in-flight response instead of failing.
+   Sharing the browser with other agents? Sends queue behind an in-flight response automatically; pass --busy-wait-ms 0 to fail fast instead.
 
 2. Let coding agents consult ChatGPT (stdio MCP: Claude, Codex, Cursor, ...):
    ${cli} claude config --cwd ${quotedCwd}${sourceCliOption}

package/dist/config.js

@@ -59,6 +59,33 @@ export function localConfigPath(cwd) {
 export function makeServerUrl(host, port, token) {
     return `http://${host}:${port}/mcp?prodex_token=${encodeURIComponent(token)}`;
 }
+/**
+ * The endpoint WITHOUT the token, which is what gets persisted. The token used
+ * to be stored twice - as `token` and inside `server_url` - so an operator's
+ * redaction that masked the key still leaked the secret from the URL (field
+ * report). One field is the only shape where masking the token masks it.
+ */
+export function makeServerUrlBase(host, port) {
+    return `http://${host}:${port}/mcp`;
+}
+/** The token-bearing URL, composed on demand for clients that need it. */
+export function composeServerUrlWithToken(config) {
+    const url = new URL(config.server_url);
+    url.searchParams.set("prodex_token", config.token);
+    return url.toString();
+}
+/** Strip a token that an older config (or a hand edit) left in the URL. */
+export function stripTokenFromServerUrl(serverUrl) {
+    try {
+        const url = new URL(serverUrl);
+        url.searchParams.delete("prodex_token");
+        url.search = url.searchParams.toString();
+        return url.toString();
+    }
+    catch {
+        return serverUrl;
+    }
+}
 export function normalizeLoopbackHttpHost(host) {
     const normalized = host.trim().toLowerCase();
     const isLocalhost = normalized === "localhost";
@@ -90,7 +117,7 @@ export async function writeLocalConfig(cwd, input = {}) {
         host,
         port,
         token,
-        server_url: makeServerUrl(host, port, token),
+        server_url: makeServerUrlBase(host, port),
         ...(tokenExpiresAt ? { token_expires_at: tokenExpiresAt } : {}),
         ...(browserDefaults ? { browser_defaults: browserDefaults } : {}),
         created_at: existing?.created_at ?? now,
@@ -126,7 +153,26 @@ export async function loadLocalConfig(cwd) {
     }
     assertLoopbackHttpHost(config.host);
     assertLoopbackHttpHost(new URL(config.server_url).hostname);
+    // Configs written before the split still carry the token in the URL. Drop it
+    // in memory AND rewrite the file: leaving it on disk is the whole problem
+    // being fixed - an operator reading config.local.json would still find the
+    // secret twice, and any redaction keyed to `token` would miss one copy.
+    const strippedServerUrl = stripTokenFromServerUrl(config.server_url);
+    const carriedDuplicate = strippedServerUrl !== config.server_url;
+    config = { ...config, server_url: strippedServerUrl };
     assertServerUrlMatchesConfig(config);
+    if (carriedDuplicate) {
+        // Best effort: a read-only checkout or a concurrent writer must not turn
+        // a working config into a failed command.
+        try {
+            await writeVerifiedUtf8File(localConfigPath(cwd), `${JSON.stringify(config, null, 2)}\n`, () => assertLocalConfigTargetSafe(cwd), {
+                mode: 0o600
+            });
+        }
+        catch {
+            // The in-memory strip above already keeps prodex from printing it.
+        }
+    }
     return config;
 }
 // Global browser-selection defaults from the environment, used when a repo has
@@ -217,13 +263,13 @@ function isTokenExpired(tokenExpiresAt, now) {
 }
 function assertServerUrlMatchesConfig(config) {
     const serverUrl = new URL(config.server_url);
-    const tokenParams = serverUrl.searchParams.getAll("prodex_token");
     const hostMatches = normalizeLoopbackHttpHost(serverUrl.hostname) === normalizeLoopbackHttpHost(config.host);
     const portMatches = effectiveUrlPort(serverUrl) === config.port;
-    const tokenMatches = tokenParams.length === 1 && tokenParams[0] === config.token;
-    const shapeMatches = serverUrl.protocol === "http:" && serverUrl.pathname === "/mcp" && Array.from(serverUrl.searchParams.keys()).length === 1;
-    if (!hostMatches || !portMatches || !tokenMatches || !shapeMatches) {
-        throw new Error(".bridge/config.local.json server_url must match host, port, and token. Run `prodex setup` to replace it.");
+    // The persisted URL must carry NO query at all: the token lives in `token`
+    // and nowhere else.
+    const shapeMatches = serverUrl.protocol === "http:" && serverUrl.pathname === "/mcp" && Array.from(serverUrl.searchParams.keys()).length === 0;
+    if (!hostMatches || !portMatches || !shapeMatches) {
+        throw new Error(".bridge/config.local.json server_url must be the token-free endpoint for host and port. Run `prodex setup` to replace it.");
     }
 }
 function effectiveUrlPort(url) {
@@ -359,3 +405,16 @@ async function assertDirectoryHandle(handle, label) {
         throw new Error(`${label} must be a real directory`);
     }
 }
+/**
+ * The repo prodex should operate on. Defaults to the process working
+ * directory, but PRODEX_CWD (absolute paths only) wins: the MCP server takes
+ * no flags, so when an agent harness starts it from a pipe path or a deleted
+ * directory, the env var is the only way an operator can pin the repo without
+ * changing how that harness spawns the server.
+ */
+export function resolveProdexCwd(fallback = process.cwd(), env = process.env) {
+    const raw = (env.PRODEX_CWD ?? "").trim();
+    if (raw.length === 0 || !path.isAbsolute(raw))
+        return fallback;
+    return raw;
+}

package/dist/schema.js

@@ -35,7 +35,11 @@ export const BlockerSchema = z.object({
     code: z.string(),
     message: z.string(),
     retryable: z.boolean().default(false),
-    next_step: z.string().optional()
+    next_step: z.string().optional(),
+    // The ChatGPT thread the prompt landed in, recorded on send failures so
+    // `pro browser recover --target-url` has something to point at: ChatGPT
+    // usually finishes the answer after prodex has given up waiting.
+    thread: z.string().optional()
 });
 export const TaskSchema = z.object({
     schema_version: z.literal(SCHEMA_VERSION),

package/dist/store.js

@@ -35,6 +35,26 @@ async function claimLockIsStale(lockPath) {
 const FETCHABLE_RESULT_ARTIFACT_PREFIXES = [".bridge/artifacts/pro-consults/", ".bridge/artifacts/results/"];
 export const MAX_FETCHABLE_RESULT_ARTIFACT_BYTES = 100_000;
 const MAX_BRIDGE_ARTIFACT_READ_BYTES = 1_000_000;
+// A bridge root has to be a real directory in a real filesystem. Field report
+// (macOS): an agent harness started `prodex mcp` with a working directory of
+// /dev/fd/<n> - a file-descriptor path - so every call failed with a raw
+// ENOENT/ENOTDIR on <root>/tasks, /sessions, /receipts, with a different
+// number each time, and the operator had no way to tell what prodex had
+// resolved or how to override it.
+const NON_REPO_ROOT_PREFIXES = ["/dev/", "/proc/", "/sys/"];
+export async function assertUsableBridgeRoot(root) {
+    const looksLikeDevicePath = NON_REPO_ROOT_PREFIXES.some((prefix) => root.startsWith(prefix));
+    let isDirectory = false;
+    try {
+        isDirectory = (await stat(root)).isDirectory();
+    }
+    catch {
+        isDirectory = false;
+    }
+    if (isDirectory && !looksLikeDevicePath)
+        return;
+    throw new Error(`Bridge root is not a usable repo directory: ${root}${looksLikeDevicePath ? " (that is a file-descriptor/device path, not a repo)" : ""}. prodex uses the process working directory when no --cwd is given, so a server started from a pipe or a deleted directory lands here. Pass --cwd /absolute/path/to/repo, or set PRODEX_CWD=/absolute/path/to/repo (works for the MCP server, which takes no flags).`);
+}
 export class BridgeStore {
     root;
     bridgeDir;
@@ -43,6 +63,7 @@ export class BridgeStore {
         this.bridgeDir = path.join(root, ".bridge");
     }
     async ensure() {
+        await assertUsableBridgeRoot(this.root);
         await ensurePrivateDirectory(this.bridgeDir, "Bridge directory");
         await Promise.all([
             ensurePrivateDirectory(this.dir("tasks"), "Bridge storage directory .bridge/tasks"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@youdie006/prodex",
-  "version": "0.18.0",
+  "version": "0.19.1",
   "description": "Local receipt bus for coordinating Codex execution with ChatGPT Pro/Projects consultation.",
   "author": "youdie006",
   "license": "MIT",