@youdie006/prodex 0.40.50 → 0.40.51

package/dist/browser-send-lock.js

@@ -24,9 +24,10 @@ export function sendPacingMarkerPath() {
  * Serialize visible-browser sends across processes. Waits up to waitMs for a
  * live holder to finish (0 = fail fast); a lock whose holder process is dead
  * is reaped immediately. budgetFlag is the option that sets waitMs for the
- * command that is waiting, named when the wait runs out.
+ * command that is waiting, named when the wait runs out. A waiter whose signal
+ * aborts leaves the queue with cancelledError.
  */
-export async function withBrowserSendLock(waitMs, onWait, fn, budgetFlag = "--timeout-ms") {
+export async function withBrowserSendLock(waitMs, onWait, fn, budgetFlag = "--timeout-ms", cancel = {}) {
     const file = lockPath();
     const reapClaim = path.join(path.dirname(file), `.${path.basename(file)}.reap`);
     return withCrossProcessFileLock(file, {
@@ -35,6 +36,8 @@ export async function withBrowserSendLock(waitMs, onWait, fn, budgetFlag = "--ti
         privateParent: true,
         onWait: (holder) => onWait(`another prodex send holds the browser (pid ${holder.pid ?? "unknown"}); waiting`),
         busyError: (holder) => new Error(`Another prodex browser send is in progress (pid ${holder.pid ?? "unknown"}) and did not finish within the wait budget. Retry once it finishes, or raise ${budgetFlag} (which is also the queue budget).`),
-        unavailableError: () => new Error(`A prodex browser send lock at ${file} is held by nothing and could not be removed, so no send can start. Stop all prodex senders and verify no request is active before deleting that file and the abandoned reaper claim at ${reapClaim}, then retry.`)
+        unavailableError: () => new Error(`A prodex browser send lock at ${file} is held by nothing and could not be removed, so no send can start. Stop all prodex senders and verify no request is active before deleting that file and the abandoned reaper claim at ${reapClaim}, then retry.`),
+        ...(cancel.signal ? { signal: cancel.signal } : {}),
+        ...(cancel.cancelledError ? { abortedError: cancel.cancelledError } : {})
     }, fn);
 }

package/dist/chatgpt-browser.js

@@ -568,15 +568,26 @@ export const CHATGPT_RENDERED_MESSAGE_TEXT_JS = `
  * and the request marker (measured 2026-10-07: 179 saved answers in one test
  * repo carried a project name). They now come only from the model selector
  * and the visible composer form, matched on word boundaries.
+ *
+ * Measured 2026-11-03, a page can hold more than the composer: a new chat keeps
+ * the home page's composer, with its own trigger, mounted but hidden ahead of
+ * the conversation's, and an "Edit message" editor is a visible form inside
+ * the user turn. Taking the first trigger and every visible form reported the
+ * hidden composer's model and the prompt being edited, so only the visible
+ * composer outside the messages counts, and not the text typed into it.
  */
 export const CHATGPT_MODEL_HINTS_JS = `
     const modelHintLines = () => {
       const sources = [];
-      const trigger = document.querySelector('button[aria-label="Select ChatGPT model"],[data-testid="model-switcher-dropdown-button"]');
+      const shown = (el) => el.getClientRects().length > 0 && !(el.parentElement && el.parentElement.closest('[data-message-author-role],[data-chatgpt-search-unit-key]'));
+      const trigger = [...document.querySelectorAll('button[aria-label="Select ChatGPT model"],[data-testid="model-switcher-dropdown-button"]')].find(shown);
       // The trigger's text names the model; its aria-label only names the control.
       if (trigger) sources.push(trigger.innerText || "");
-      for (const form of [...document.querySelectorAll("form")]) {
-        if (form.getClientRects().length > 0) sources.push(form.innerText || "");
+      const editor = [...document.querySelectorAll('#prompt-textarea,[contenteditable="true"],textarea')].find(shown);
+      const form = editor && editor.closest("form");
+      if (form) {
+        const typed = (editor.innerText || editor.value || "").split(String.fromCharCode(10)).map((line) => line.trim());
+        sources.push((form.innerText || "").split(String.fromCharCode(10)).filter((line) => !typed.includes(line.trim())).join(String.fromCharCode(10)));
       }
       const modelish = /\\b(?:ChatGPT|GPT(?:-[\\w.]+)?|Pro|Plus|Thinking|Instant|Extra High|High|Medium|Auto|Latest)\\b/i;
       const seen = [];

package/dist/cli-args.js

@@ -31,6 +31,33 @@ export function findHelpFlagIndexBeforePromptDelimiter(args) {
     const limit = delimiterIndex === -1 ? args.length : delimiterIndex;
     return args.findIndex((arg, index) => index < limit && isHelpSubcommand(arg));
 }
+/**
+ * Where a help request is, or -1. In a command whose unquoted words are its
+ * prompt, the word "help" asks for help only on its own: found 2026-11-09,
+ * `prodex ask can you help me fix this` was taken for a help request and
+ * failed with "Unexpected argument for ask: can". --help and -h always ask.
+ */
+export function findHelpRequestIndex(args, options = {}) {
+    const delimiterIndex = args.indexOf("--");
+    const limit = delimiterIndex === -1 ? args.length : delimiterIndex;
+    const valueFlagSet = new Set(options.valueFlags ?? []);
+    const words = [];
+    for (let index = 0; index < limit; index += 1) {
+        const arg = args[index];
+        if (arg === "--help" || arg === "-h")
+            return index;
+        if (valueFlagSet.has(arg)) {
+            index += 1;
+            continue;
+        }
+        if (!arg.startsWith("-"))
+            words.push(index);
+    }
+    const helpWord = words.find((index) => args[index] === "help");
+    if (helpWord === undefined)
+        return -1;
+    return !options.promptWords || words.length === 1 ? helpWord : -1;
+}
 export function assertHelpRequestArgs(args, command, options) {
     const delimiterIndex = args.indexOf("--");
     const commandArgs = delimiterIndex === -1 ? args : args.slice(0, delimiterIndex);
@@ -397,7 +424,7 @@ export function readNumberFlag(args, flag) {
 }
 export const RECEIPT_KINDS = ReceiptKindSchema.options;
 export function printHelpIfRequested(args, command, stdout, printHelp, options = {}) {
-    const helpIndex = findHelpFlagIndexBeforePromptDelimiter(args);
+    const helpIndex = options.promptWords ? findHelpRequestIndex(args, options) : findHelpFlagIndexBeforePromptDelimiter(args);
     if (helpIndex === -1)
         return false;
     assertHelpRequestArgs(args, command, options);

package/dist/cli-ledger.js

@@ -92,7 +92,7 @@ export async function runTasksCommand(rest, io) {
             status: "done",
             summary,
             commands: readRepeatedFlag(taskArgs, "--command"),
-            artifacts: await writeTaskCompleteArtifacts(targetStore, readRepeatedFlag(taskArgs, "--artifact"))
+            artifacts: await writeTaskCompleteArtifacts(targetStore, taskId, readRepeatedFlag(taskArgs, "--artifact"))
         });
         io.stdout(`${result.task_id}\t${result.status}\t${result.summary}`);
         return 0;
@@ -355,7 +355,7 @@ export function receiptInspectionListSuffix(receipt) {
     }
     return "";
 }
-export async function writeTaskCompleteArtifacts(store, values) {
+export async function writeTaskCompleteArtifacts(store, taskId, values) {
     const parsed = [];
     const seen = new Set();
     for (const value of values) {
@@ -377,12 +377,7 @@ export async function writeTaskCompleteArtifacts(store, values) {
         seen.add(key);
         parsed.push({ artifactPath, content });
     }
-    const artifacts = [];
-    for (const { artifactPath, content } of parsed) {
-        const storedPath = await store.writeArtifactText(artifactPath, content);
-        artifacts.push({ path: storedPath, role: "result" });
-    }
-    return artifacts;
+    return store.writeResultArtifactTexts(taskId, parsed.map(({ artifactPath, content }) => ({ path: artifactPath, content })));
 }
 export async function listTasksForInspection(store, status) {
     return store.listTasksReadOnly(status);

package/dist/cli-pro.js

@@ -5,7 +5,7 @@ import path from "node:path";
 import { BrowserProcessInspectionError } from "./browser-process.js";
 import { buildDryRunBundle } from "./bundle.js";
 import { ChatGptBrowserBlockerError, DEFAULT_CDP_PORT, resolveCdpPort, resolveConversationToDelete, resolveProjectToDelete, chatGptVisibilityBlocker, defaultChatGptProfileDir, formatDurationMs, getChatGptBrowserStatus, formatModelMenuOption, listChatGptModelOptions, deleteChatGptConversation, endWedgedBrowser, browserRecoveryPlan, findWedgedBrowser, wedgedBrowserBlocker, deleteChatGptProject, listChatGptProjectsWithIds, listRecentChatGptConversations, listChatGptSidebarProjects, normalizeChatGptTargetUrl, openChatGptBrowser, openChatGptTab, parseProMode, parseReasoningEffort, defaultTimeoutForTools, ensureVirtualDisplay, minimizeChatGptWindow, readLastBrowserLoginLaunch, resolveBrowserWindowMode, recordBrowserLoginLaunch, recoverChatGptAnswerFromThread, sendChatGptPrompt, statusMeansBrowserDead, namesPro, sendWarningsFromError, destinationVerification, chatGptProjectIdFromUrl, chatStepNamedAsModel, normalizeChatGptThreadUrl } from "./chatgpt-browser.js";
-import { ASK_PRO_BOOLEAN_FLAGS, ASK_PRO_PREVIEW_VALUE_FLAGS, ASK_PRO_VALUE_FLAGS, assertHelpRequestArgs, assertNoExtraArgs, assertOnlyOptions, findHelpFlagIndexBeforePromptDelimiter, formatCliCommand, hasAskProDryRunMode, hasAskProMode, hasAskProSendMode, isHelpSubcommand, parseAskProArgs, printHelpIfRequested, readFlag, readPortFlag, readPositionalsWithOptions, readNonNegativeIntegerFlag, readPositiveIntegerFlag, readRepeatedFlag, resolveCwdFlag, resolveOptionalFileFlag, unknownSubcommandError, assertProjectName } from "./cli-args.js";
+import { ASK_PRO_BOOLEAN_FLAGS, ASK_PRO_PREVIEW_VALUE_FLAGS, ASK_PRO_VALUE_FLAGS, assertHelpRequestArgs, assertNoExtraArgs, assertOnlyOptions, findHelpFlagIndexBeforePromptDelimiter, findHelpRequestIndex, formatCliCommand, hasAskProDryRunMode, hasAskProMode, hasAskProSendMode, isHelpSubcommand, parseAskProArgs, printHelpIfRequested, readFlag, readPortFlag, readPositionalsWithOptions, readNonNegativeIntegerFlag, readPositiveIntegerFlag, readRepeatedFlag, resolveCwdFlag, resolveOptionalFileFlag, unknownSubcommandError, assertProjectName } from "./cli-args.js";
 import { printProBrowserHelp, printProHelp } from "./cli-help.js";
 import { listRawResultsForInspection, listTasksForInspection } from "./cli-ledger.js";
 import { formatBrowserDefaults, redactServerUrl } from "./cli-server.js";
@@ -158,7 +158,8 @@ export async function runProCommand(rest, io, runCliFn) {
     if (subcommand === "ask") {
         if (printHelpIfRequested(proArgs, "pro ask", io.stdout, printProHelp, {
             valueFlags: [...ASK_PRO_PREVIEW_VALUE_FLAGS],
-            booleanFlags: [...ASK_PRO_BOOLEAN_FLAGS]
+            booleanFlags: [...ASK_PRO_BOOLEAN_FLAGS],
+            promptWords: true
         })) {
             return 0;
         }
@@ -187,7 +188,9 @@ export async function runProCommand(rest, io, runCliFn) {
             "--continue-task",
             "--auto-login",
             "--no-auto-login"
-        ].find((flag) => proArgs.includes(flag));
+            // Only before --: the words after it are the prompt, which may well
+            // mention an option (found 2026-11-09: "what does --project do").
+        ].find((flag) => (proArgs.includes("--") ? proArgs.slice(0, proArgs.indexOf("--")) : proArgs).includes(flag));
         if (straySendFlag) {
             throw new Error(`${straySendFlag} only applies when sending; \`prodex pro ask\` is a dry-run preview. Use \`prodex pro browser ask\` (or \`prodex ask\`) to send.`);
         }
@@ -497,7 +500,8 @@ export async function runProCommand(rest, io, runCliFn) {
         if (browserSubcommand === "ask") {
             if (printProBrowserHelpIfRequested(browserArgs, "pro browser ask", io, {
                 valueFlags: [...ASK_PRO_VALUE_FLAGS],
-                booleanFlags: [...ASK_PRO_BOOLEAN_FLAGS]
+                booleanFlags: [...ASK_PRO_BOOLEAN_FLAGS],
+                promptWords: true
             })) {
                 return 0;
             }
@@ -1475,11 +1479,23 @@ beforeSend) {
     if (hasSendMode) {
         // MCP approval checkpoints run after target validation but before any
         // task creation, pacing, browser recovery, or prompt send.
-        const beforePromptSubmit = (await beforeSend?.({
+        const beforeSubmitStep = (await beforeSend?.({
             store: targetStore,
             ...(normalizedTargetUrl ? { thread: normalizedTargetUrl } : {}),
             ...(continuedFromTaskId ? { continuedFrom: continuedFromTaskId } : {})
         })) || undefined;
+        // A cancelled call is stopped before its prompt is submitted: here, in
+        // the send queue, instead of a browser recovery, and right before the
+        // submit. After the submit it is not: an answer already on its way is
+        // waited for and recorded as usual. The last check runs ahead of the
+        // step, so a cancelled follow-up does not spend the budget it reserves.
+        throwIfConsultCancelled(io.signal);
+        const beforePromptSubmit = io.signal || beforeSubmitStep
+            ? async () => {
+                throwIfConsultCancelled(io.signal);
+                await beforeSubmitStep?.();
+            }
+            : undefined;
         const browserCommandOptions = {
             cwd: targetCwd,
             port: parsedAskPro.optionArgs.includes("--port") ? browserPort : undefined
@@ -1561,7 +1577,7 @@ beforeSend) {
                 ...(beforePromptSubmit ? { beforePromptSubmit } : {}),
                 onProgress: createBrowserSendProgressPrinter(io.stderr)
             });
-        });
+        }, "--timeout-ms", { ...(io.signal ? { signal: io.signal } : {}), cancelledError: consultCancelledError });
         // One-command recovery: interactive terminals (or explicit --auto-login)
         // launch the dedicated browser and retry once when no browser runs.
         // Scripts and agents keep the plain blocker unless they opt in.
@@ -1580,8 +1596,9 @@ beforeSend) {
             catch (error) {
                 const firstBlocker = browserSendBlockerFromError(error);
                 // Loss while reading an already-submitted prompt must not send it again.
+                // Nor is a browser launched for a call that has been cancelled.
                 if (!["browser_unreachable", "chatgpt_page_missing"].includes(firstBlocker.code) ||
-                    !firstBlocker.retryable || firstBlocker.thread || !autoLoginAllowed)
+                    !firstBlocker.retryable || firstBlocker.thread || !autoLoginAllowed || io.signal?.aborted)
                     throw error;
                 const recover = firstBlocker.code === "chatgpt_page_missing" ? attemptMissingChatGptTabRecovery : attemptBrowserAutoRecovery;
                 const recovered = await recover(io.stderr, {
@@ -1940,6 +1957,18 @@ export async function performBrowserRecoverForMcp(cwd, input) {
         notes: stderrLines
     };
 }
+function consultCancelledError() {
+    return new ChatGptBrowserBlockerError({
+        code: "consult_cancelled",
+        message: "The client cancelled this consult before its prompt was submitted, so nothing was sent to ChatGPT.",
+        retryable: true,
+        next_step: "Nothing to recover. Send the consult again if it is still wanted."
+    });
+}
+function throwIfConsultCancelled(signal) {
+    if (signal?.aborted)
+        throw consultCancelledError();
+}
 /** The marker the send prints before throwing, when the answer outlived its record. */
 const ANSWER_NOT_SAVED_MARKER = "consult_answer_received_but_not_saved:";
 /**
@@ -1993,7 +2022,7 @@ export function mcpBlockedConsultOutcome(stdoutLines, error) {
         ...(thread && requestId ? { recover: { tool: "pro_recover", arguments: { thread, request_id: requestId } } } : {})
     };
 }
-export async function performBrowserConsultForMcp(cwd, input, onProgress) {
+export async function performBrowserConsultForMcp(cwd, input, onProgress, signal) {
     const stdoutLines = [];
     const stderrLines = [];
     const sessionKey = resolveProdexSessionKey(input.session_key);
@@ -2041,7 +2070,8 @@ export async function performBrowserConsultForMcp(cwd, input, onProgress) {
                 if (onProgress && line.startsWith("progress:"))
                     onProgress(line);
             },
-            allowAskProBrowserSend: true
+            allowAskProBrowserSend: true,
+            ...(signal ? { signal } : {})
         }, async ({ store, thread, continuedFrom }) => {
             if (!thread || !continuedFrom)
                 return;
@@ -3415,7 +3445,7 @@ export function printBrowserLoginGuide(stdout, input) {
     }
 }
 export function printProBrowserHelpIfRequested(args, command, io, options) {
-    const helpIndex = findHelpFlagIndexBeforePromptDelimiter(args);
+    const helpIndex = options.promptWords ? findHelpRequestIndex(args, options) : findHelpFlagIndexBeforePromptDelimiter(args);
     if (helpIndex === -1)
         return false;
     assertHelpRequestArgs(args, command, options);

package/dist/cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { execFile } from "node:child_process";
 import { realpathSync } from "node:fs";
+import http from "node:http";
 import { lstat, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
@@ -280,7 +281,7 @@ export async function runCli(args, io = defaultIo()) {
         // pro_consult is stdio-only: the HTTP MCP surface is exposed to ChatGPT
         // itself (and possibly a tunnel) and must never drive the user's browser.
         await runMcpServer(mcpCwd, {
-            browserConsult: (input, onProgress) => performBrowserConsultForMcp(mcpCwd, input, onProgress),
+            browserConsult: (input, onProgress, signal) => performBrowserConsultForMcp(mcpCwd, input, onProgress, signal),
             browserRecover: (input) => performBrowserRecoverForMcp(mcpCwd, input)
         });
         return 0;
@@ -288,31 +289,75 @@ export async function runCli(args, io = defaultIo()) {
     throw unknownTopLevelCommandError(command);
 }
 /**
- * Whether something other than prodex is sitting on the configured port.
+ * Whether something other than this repo's prodex server is sitting on the
+ * configured port, which `prodex start` then cannot bind.
  *
- * A prodex HTTP server answers /mcp - with 401 when the token is missing,
- * which is still an answer. Anything else holding the port means `prodex
- * start` cannot bind it, and the configured URL points at a stranger.
- * Silence (nothing listening) is the healthy case.
+ * A prodex server names itself on /health, without a token. Found
+ * 2026-11-09: the check used to take any server answering /mcp with 200, 400
+ * or 401 for prodex, and a program that does not speak HTTP, or accepts the
+ * connection and says nothing, for a free port. Another repo's prodex server
+ * is the likeliest holder, since every repo's setup defaults to port 8787; it
+ * refuses this repo's token. A refused connection is the healthy case.
  */
-export async function describeConfiguredPortHolder(host, port) {
-    let response;
-    try {
-        response = await fetch(`http://${host}:${port}/mcp`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: "{}",
-            signal: AbortSignal.timeout(1_500)
+export async function describeConfiguredPortHolder(host, port, token) {
+    const cannotBind = "so `prodex start` cannot bind it";
+    const health = await probeHttpEndpoint(host, port, "/health", { method: "GET" });
+    if (health.kind === "free")
+        return undefined;
+    if (health.kind === "not-http")
+        return `port ${port} on ${host} is held by a program that does not answer HTTP, ${cannotBind}.`;
+    if (!isProdexHealth(health.body)) {
+        return `port ${port} on ${host} is held by something that is not a prodex server (it answered /health with HTTP ${health.status}), ${cannotBind}.`;
+    }
+    if (token === undefined)
+        return undefined;
+    const mcp = await probeHttpEndpoint(host, port, "/mcp", {
+        method: "POST",
+        headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+        body: "{}"
+    });
+    if (mcp.kind === "http" && mcp.status === 401) {
+        return `port ${port} on ${host} is held by another prodex server, one that refuses this repo's token (another repo's \`prodex start\`, or one started before this token was set), ${cannotBind} here.`;
+    }
+    return undefined;
+}
+function probeHttpEndpoint(host, port, requestPath, options) {
+    return new Promise((resolve) => {
+        let connected = false;
+        const request = http.request({ host, port, path: requestPath, method: options.method, headers: options.headers, timeout: 1_500, agent: false }, (response) => {
+            let body = "";
+            response.setEncoding("utf8");
+            response.on("data", (chunk) => {
+                if (body.length < 4_096)
+                    body += chunk;
+            });
+            response.on("end", () => resolve({ kind: "http", status: response.statusCode ?? 0, body }));
+            response.on("error", () => resolve({ kind: "http", status: response.statusCode ?? 0, body }));
         });
+        request.on("socket", (socket) => socket.once("connect", () => (connected = true)));
+        // A connection accepted and then left silent is a program holding the
+        // port. One never accepted is not: on WSL a free loopback port does not
+        // refuse a connection, it lets the attempt time out.
+        request.on("timeout", () => {
+            request.destroy();
+            resolve({ kind: connected ? "not-http" : "free" });
+        });
+        request.on("error", (error) => {
+            request.destroy();
+            const nothingListening = !connected || ["ECONNREFUSED", "EADDRNOTAVAIL", "EHOSTUNREACH", "ENETUNREACH"].includes(error.code ?? "");
+            resolve({ kind: nothingListening ? "free" : "not-http" });
+        });
+        request.end(options.body);
+    });
+}
+function isProdexHealth(body) {
+    try {
+        const parsed = JSON.parse(body);
+        return parsed.name === "prodex";
     }
     catch {
-        // Nothing is listening, or it refused the connection: the port is free for
-        // prodex to take, which is what this check is about.
-        return undefined;
+        return false;
     }
-    if (response.status === 401 || response.status === 200 || response.status === 400)
-        return undefined;
-    return `port ${port} on ${host} is held by something that is not a prodex server (it answered /mcp with HTTP ${response.status}), so \`prodex start\` cannot bind it.`;
 }
 function defaultIo() {
     return {
@@ -1046,7 +1091,7 @@ async function runDoctor(store, io, sourceCli, setupHintCwd) {
             // Measured here: the configured port was held by an unrelated program,
             // so `prodex start` could never bind it - and doctor called the config
             // ok anyway, which is the one line someone reads before believing it.
-            const portHolder = await describeConfiguredPortHolder(config.host, config.port);
+            const portHolder = await describeConfiguredPortHolder(config.host, config.port, config.token);
             if (portHolder) {
                 io.stdout(`config_warning: ${portHolder} \`${formatSetupCommand(sourceCli, { cwd: setupHintCwd })} --port <free port>\` moves prodex off it.`);
             }

package/dist/http-mcp.js

@@ -6,11 +6,101 @@ import { createServer as createMcpServer } from "./mcp.js";
 import { normalizeLoopbackHttpHost } from "./config.js";
 const DEFAULT_REQUEST_BODY_LIMIT_BYTES = 1_048_576;
 const TRANSPORT_CLOSE_TIMEOUT_MS = 5_000;
+/**
+ * Every initialize used to keep its MCP server and transport until a DELETE
+ * that clients rarely send, about 170 KB each: measured 2026-11-09, RSS went
+ * from 92 MB to 1 GB over 5,000 initializes. The bridge tools answer in
+ * seconds, so a session with no request for half an hour and no stream open
+ * has been left behind; a client that does come back gets 404, which MCP
+ * clients answer by initializing again, at the cost of one round trip.
+ */
+const DEFAULT_SESSION_IDLE_TIMEOUT_MS = 30 * 60_000;
+/**
+ * A personal server sees a few clients at a time (a ChatGPT project, Codex, a
+ * Claude session), so 100 live sessions is far above real use while holding
+ * at most about 17 MB, also against a client that initializes in a loop.
+ */
+const DEFAULT_MAX_SESSIONS = 100;
+const SESSION_SWEEP_INTERVAL_MAX_MS = 60_000;
+/**
+ * The live MCP sessions, kept in least-recently-used order. A session is in
+ * use while a request of its own is open (a GET stream stays open for as long
+ * as the client listens), and idle from when its last request ended.
+ */
+class HttpMcpSessions {
+    limits;
+    entries = new Map();
+    constructor(limits) {
+        this.limits = limits;
+    }
+    /** The session's transport, counted as in use until res closes; undefined when unknown or closed. */
+    use(sessionId, res) {
+        const entry = this.entries.get(sessionId);
+        if (!entry)
+            return undefined;
+        this.entries.delete(sessionId);
+        this.entries.set(sessionId, entry);
+        entry.openRequests += 1;
+        entry.lastActiveMs = this.limits.now();
+        res.once("close", () => {
+            entry.openRequests -= 1;
+            entry.lastActiveMs = this.limits.now();
+        });
+        return entry.transport;
+    }
+    add(sessionId, transport) {
+        this.entries.set(sessionId, { transport, lastActiveMs: this.limits.now(), openRequests: 0 });
+        while (this.entries.size > this.limits.maxSessions) {
+            // The least recently used session without an open request, else the
+            // least recently used of all; never the one just added, which is last.
+            let victim;
+            for (const [id, entry] of this.entries) {
+                if (entry.openRequests === 0) {
+                    victim = id;
+                    break;
+                }
+            }
+            this.close(victim ?? this.entries.keys().next().value);
+        }
+    }
+    remove(sessionId, transport) {
+        if (this.entries.get(sessionId)?.transport === transport)
+            this.entries.delete(sessionId);
+    }
+    sweep() {
+        const now = this.limits.now();
+        for (const [id, entry] of this.entries) {
+            if (entry.openRequests === 0 && now - entry.lastActiveMs >= this.limits.idleTimeoutMs)
+                this.close(id);
+        }
+    }
+    async closeAll() {
+        const transports = Array.from(this.entries.values(), (entry) => entry.transport);
+        this.entries.clear();
+        await Promise.all(transports.map((transport) => closeTransport(transport)));
+    }
+    /** Forgotten at once, so the id answers 404 like any unknown session. */
+    close(sessionId) {
+        const entry = this.entries.get(sessionId);
+        if (!entry)
+            return;
+        this.entries.delete(sessionId);
+        void closeTransport(entry.transport);
+    }
+}
+function closeTransport(transport) {
+    return withTimeout(transport.close(), TRANSPORT_CLOSE_TIMEOUT_MS, "timed out closing HTTP MCP transport").catch(() => undefined);
+}
 export async function startHttpMcpServer(options) {
     const host = normalizeLoopbackHttpHost(options.host ?? "127.0.0.1");
     const token = options.token;
     const requestBodyLimitBytes = options.requestBodyLimitBytes ?? DEFAULT_REQUEST_BODY_LIMIT_BYTES;
-    const transports = new Map();
+    const sessionIdleTimeoutMs = Math.max(1, options.sessionIdleTimeoutMs ?? DEFAULT_SESSION_IDLE_TIMEOUT_MS);
+    const sessions = new HttpMcpSessions({
+        idleTimeoutMs: sessionIdleTimeoutMs,
+        maxSessions: Math.max(1, options.maxSessions ?? DEFAULT_MAX_SESSIONS),
+        now: options.now ?? Date.now
+    });
     const server = http.createServer(async (req, res) => {
         try {
             // Only the path and query are read, so the base is fixed: taking it from
@@ -41,11 +131,11 @@ export async function startHttpMcpServer(options) {
                 return;
             }
             if (req.method === "POST") {
-                await handlePost(req, res, transports, options.cwd, requestBodyLimitBytes, options.registerRoot);
+                await handlePost(req, res, sessions, options.cwd, requestBodyLimitBytes, options.registerRoot);
                 return;
             }
             if (req.method === "GET" || req.method === "DELETE") {
-                await handleSessionRequest(req, res, transports);
+                await handleSessionRequest(req, res, sessions);
                 return;
             }
             writeJson(res, 405, { error: "method_not_allowed" });
@@ -80,6 +170,9 @@ export async function startHttpMcpServer(options) {
             resolve();
         });
     });
+    // Unref'd: an idle sweep is no reason for the process to stay up.
+    const sweepTimer = setInterval(() => sessions.sweep(), Math.min(SESSION_SWEEP_INTERVAL_MAX_MS, sessionIdleTimeoutMs));
+    sweepTimer.unref();
     const address = server.address();
     const port = typeof address === "object" && address ? address.port : options.port ?? 8787;
     const url = `http://${host}:${port}`;
@@ -89,8 +182,8 @@ export async function startHttpMcpServer(options) {
         url,
         mcp_url: token ? `${url}/mcp?prodex_token=${encodeURIComponent(token)}` : `${url}/mcp`,
         close: async (closeOptions = {}) => {
-            await Promise.all(Array.from(transports.values()).map((entry) => withTimeout(entry.transport.close(), TRANSPORT_CLOSE_TIMEOUT_MS, "timed out closing HTTP MCP transport").catch(() => undefined)));
-            transports.clear();
+            clearInterval(sweepTimer);
+            await sessions.closeAll();
             await closeHttpServer(server, closeOptions);
         }
     };
@@ -140,16 +233,16 @@ async function withTimeout(promise, timeoutMs, message) {
             clearTimeout(timeout);
     }
 }
-async function handlePost(req, res, transports, cwd, requestBodyLimitBytes, registerRoot) {
+async function handlePost(req, res, sessions, cwd, requestBodyLimitBytes, registerRoot) {
     const body = await readJsonBody(req, requestBodyLimitBytes);
     const sessionId = headerValue(req.headers["mcp-session-id"]);
     if (sessionId) {
-        const entry = transports.get(sessionId);
-        if (!entry) {
+        const transport = sessions.use(sessionId, res);
+        if (!transport) {
             writeJson(res, 404, { error: "session_not_found" });
             return;
         }
-        await entry.transport.handleRequest(req, res, body);
+        await transport.handleRequest(req, res, body);
         return;
     }
     if (!sessionId && isInitializeRequest(body)) {
@@ -159,13 +252,13 @@ async function handlePost(req, res, transports, cwd, requestBodyLimitBytes, regi
             enableJsonResponse: true,
             onsessioninitialized: (newSessionId) => {
                 initializedSessionId = newSessionId;
-                transports.set(newSessionId, { transport });
+                sessions.add(newSessionId, transport);
             }
         });
         transport.onclose = () => {
             const id = transport.sessionId || initializedSessionId;
             if (id)
-                transports.delete(id);
+                sessions.remove(id, transport);
         };
         const mcpServer = createMcpServer(cwd, {
             source: "chatgpt_project",
@@ -182,17 +275,18 @@ async function handlePost(req, res, transports, cwd, requestBodyLimitBytes, regi
         id: null
     });
 }
-async function handleSessionRequest(req, res, transports) {
+async function handleSessionRequest(req, res, sessions) {
     const sessionId = headerValue(req.headers["mcp-session-id"]);
     if (!sessionId) {
         writeJson(res, 400, { error: "invalid_or_missing_session" });
         return;
     }
-    if (!transports.has(sessionId)) {
+    const transport = sessions.use(sessionId, res);
+    if (!transport) {
         writeJson(res, 404, { error: "session_not_found" });
         return;
     }
-    await transports.get(sessionId).transport.handleRequest(req, res);
+    await transport.handleRequest(req, res);
 }
 async function readJsonBody(req, limitBytes) {
     const contentLength = parseContentLength(req.headers["content-length"]);