@youdie006/prodex 0.40.44 → 0.40.45

package/dist/browser-send-lock.js

@@ -12,6 +12,14 @@ function lockPath() {
         return override;
     return path.join(os.homedir(), ".local", "share", "prodex", "browser-send.lock");
 }
+/**
+ * When the last visible-browser send on this machine started. It sits beside
+ * the send lock because it paces the same shared browser: kept per repo, sends
+ * from two repos (or two worktrees of one) were never paced against each other.
+ */
+export function sendPacingMarkerPath() {
+    return path.join(path.dirname(lockPath()), "last-browser-send");
+}
 /**
  * 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

package/dist/chatgpt-browser.js

@@ -1337,13 +1337,27 @@ export function chatGptBusyBlocker(state) {
     // away from ready into a full send budget spent on "still generating".
     if (!state.generating || state.awaitingResponseChoice === true)
         return undefined;
+    // The thread on screen is the one generating. It goes into the advice only:
+    // `thread` on a blocker means where THIS send's prompt landed, and it landed
+    // nowhere.
+    let generatingThread = "<thread-url>";
+    try {
+        if (state.url)
+            generatingThread = normalizeChatGptThreadUrl(state.url);
+    }
+    catch {
+        // Not a conversation page; keep the placeholder.
+    }
     return {
         code: "response_in_progress",
         message: "ChatGPT is still generating a previous response in this thread.",
         retryable: true,
+        // It used to end "A new topic can go to a new chat instead", which a send
+        // already started with --new-chat had just done: every send waits for the
+        // shared tab, since leaving a thread mid-answer could lose that answer.
         next_step: "Wait for it to finish and retry (pass --busy-wait-ms to queue behind it longer). " +
-            "If that in-flight answer is the one you need, fetch it once it settles: `prodex pro browser recover --target-url <thread-url>`. " +
-            "A new topic can go to a new chat instead."
+            "A new chat waits as well: the browser tab is shared, and leaving a thread mid-answer could lose that answer. " +
+            `If that in-flight answer is the one you need, fetch it once it settles: \`prodex pro browser recover --target-url ${generatingThread}\`.`
     };
 }
 /**

package/dist/cli-pro.js

@@ -11,7 +11,7 @@ import { listRawResultsForInspection, listTasksForInspection } from "./cli-ledge
 import { formatBrowserDefaults, redactServerUrl } from "./cli-server.js";
 import { errorMessage, firstLine, formatBlockedConsultRecordedMessage, formatProLatestCommand, formatBrowserCheckCommand, formatBrowserLoginCommand, formatBrowserSmokeCommand, formatBrowserTargetAskCommand, formatInitCommand, formatSetupCommand, isMissingFileError, computeSendPacingWaitMs, isUntrustedResultError, resolveMinSendIntervalMs, sourceAwareBrowserBlocker, sourceAwareBrowserNextStep, sourceAwareResultError, sourceAwareResultMessage, sourceAwareSetupMessage } from "./cli-shared.js";
 import { getTokenExpiryStatus, loadBrowserDefaults, loadLocalConfig } from "./config.js";
-import { withBrowserSendLock } from "./browser-send-lock.js";
+import { sendPacingMarkerPath, withBrowserSendLock } from "./browser-send-lock.js";
 import { blockerCause, buildBlockerReport, CATCH_ALL_CODES } from "./blocker-report.js";
 import { isChatGptConversationUrl, projectIdFromSidebar, resolveContinuationThread } from "./continue-thread.js";
 import { FollowupApprovalRequired, reserveFollowup, resolveMaxAutoFollowups } from "./followup-budget.js";
@@ -842,10 +842,13 @@ export async function runProCommand(rest, io, runCliFn) {
             if (!target.ok)
                 throw new Error(target.reason);
             // Deleting a project is not undoable from here, so the default is a
-            // preview: say exactly what would go, and delete nothing.
+            // preview: say exactly what would go, and delete nothing. The browser
+            // layer does not automate deletion at all, so the preview must not
+            // promise that --confirm-delete would carry it out - it used to, and
+            // the confirmed run then failed as unsupported.
             if (!browserArgs.includes("--confirm-delete")) {
-                io.stdout(`Would delete project "${target.name}" (${target.id}) and everything filed under it.`);
-                io.stdout("Nothing was deleted. Re-run with --confirm-delete to go ahead.");
+                io.stdout(`Deleting project "${target.name}" (${target.id}) would remove everything filed under it.`);
+                io.stdout("Nothing was deleted. prodex does not delete projects itself: delete it from its menu in the ChatGPT UI.");
                 return 0;
             }
             await deleteChatGptProject({
@@ -1109,11 +1112,14 @@ function legacyBrowserSubcommandReplacement(subcommand) {
     return "check";
 }
 // File marker + human-pacing gate for visible-browser sends. Reads the previous
-// send's start time from .bridge/last-browser-send, waits out any remaining
-// minimum interval (auto-throttle, not an error), then stamps the new send.
-async function enforceVisibleBrowserSendPacing(cwd, stderr) {
+// send's start time from the machine-wide marker beside the send lock, waits
+// out any remaining minimum interval (auto-throttle, not an error), then stamps
+// the new send. Runs while the send lock is held: run before it, a send queued
+// behind another posted the moment the lock freed, and the start it stamped was
+// when it began waiting rather than when it sent.
+async function enforceVisibleBrowserSendPacing(stderr) {
     const intervalMs = resolveMinSendIntervalMs();
-    const markerPath = path.join(cwd, ".bridge", "last-browser-send");
+    const markerPath = sendPacingMarkerPath();
     let lastSendAtMs;
     try {
         const parsed = Date.parse((await readFile(markerPath, "utf8")).trim());
@@ -1308,6 +1314,7 @@ export async function runAskProCommand(rest, io, beforeSend) {
         // Scope by the project this send would have used, so a follow-up cannot
         // land in another project's conversation.
         const continuationProject = explicitProject ?? (suppressProject ? undefined : browserDefaults?.project);
+        assertSavedProjectNotBlank(continuationProject);
         // The name alone cannot identify a project written in another script -
         // measured, two of this account's projects slug to nothing - so the id
         // is read off the live sidebar. A sidebar that cannot be read leaves
@@ -1414,6 +1421,7 @@ export async function runAskProCommand(rest, io, beforeSend) {
             (normalizedTargetUrl || selectionProjectNew !== undefined || suppressProject || temporary
                 ? undefined
                 : browserDefaults?.project);
+    assertSavedProjectNotBlank(selectionProject);
     const selectionProMode = selectionAxes.proMode;
     const selectionEffort = selectionAxes.effort;
     const continuationScopeProject = continuedFromTaskId
@@ -1464,7 +1472,6 @@ export async function runAskProCommand(rest, io, beforeSend) {
             ...(normalizedTargetUrl ? { thread: normalizedTargetUrl } : {}),
             ...(continuedFromTaskId ? { continuedFrom: continuedFromTaskId } : {})
         });
-        await enforceVisibleBrowserSendPacing(targetCwd, io.stderr);
         const browserCommandOptions = {
             cwd: targetCwd,
             port: parsedAskPro.optionArgs.includes("--port") ? browserPort : undefined
@@ -1521,28 +1528,31 @@ export async function runAskProCommand(rest, io, beforeSend) {
         // fail-fast default made pro_consult die instantly with advice the
         // caller had no way to follow; --busy-wait-ms 0 opts back into failing
         // fast. A dead holder is still reaped immediately.
-        const sendOnce = () => withBrowserSendLock(busyWaitMs ?? browserTimeoutMs ?? 0, (detail) => io.stderr(`progress: ${detail}`), () => sendChatGptPrompt({
-            port: browserPort,
-            prompt: bundle.sendText,
-            targetUrl: normalizedTargetUrl,
-            // Continuations and explicit TUI picks navigate while this lock is
-            // held. Direct CLI targets keep their existing verification-only semantics.
-            ...(continuedFromTaskId || (io.navigateInteractiveTarget === true && normalizedTargetUrl) ? { navigateToTargetUrl: true } : {}),
-            timeoutMs: browserTimeoutMs,
-            ...(attachments.length > 0 ? { attachments } : {}),
-            ...(tools.length > 0 ? { tools } : {}),
-            ...(newChat ? { newChat: true } : {}),
-            ...(temporary ? { temporary: true } : {}),
-            diagnosticsCwd: targetCwd,
-            ...(busyWaitMs !== undefined ? { busyWaitMs } : {}),
-            project: selectionProject,
-            projectNew: selectionProjectNew,
-            model: selectionModel,
-            proMode: selectionProMode,
-            effort: selectionEffort,
-            ...(allowSelectionFallback ? { allowSelectionFallback: true } : {}),
-            onProgress: createBrowserSendProgressPrinter(io.stderr)
-        }));
+        const sendOnce = () => withBrowserSendLock(busyWaitMs ?? browserTimeoutMs ?? 0, (detail) => io.stderr(`progress: ${detail}`), async () => {
+            await enforceVisibleBrowserSendPacing(io.stderr);
+            return sendChatGptPrompt({
+                port: browserPort,
+                prompt: bundle.sendText,
+                targetUrl: normalizedTargetUrl,
+                // Continuations and explicit TUI picks navigate while this lock is
+                // held. Direct CLI targets keep their existing verification-only semantics.
+                ...(continuedFromTaskId || (io.navigateInteractiveTarget === true && normalizedTargetUrl) ? { navigateToTargetUrl: true } : {}),
+                timeoutMs: browserTimeoutMs,
+                ...(attachments.length > 0 ? { attachments } : {}),
+                ...(tools.length > 0 ? { tools } : {}),
+                ...(newChat ? { newChat: true } : {}),
+                ...(temporary ? { temporary: true } : {}),
+                diagnosticsCwd: targetCwd,
+                ...(busyWaitMs !== undefined ? { busyWaitMs } : {}),
+                project: selectionProject,
+                projectNew: selectionProjectNew,
+                model: selectionModel,
+                proMode: selectionProMode,
+                effort: selectionEffort,
+                ...(allowSelectionFallback ? { allowSelectionFallback: true } : {}),
+                onProgress: createBrowserSendProgressPrinter(io.stderr)
+            });
+        });
         // 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.
@@ -2659,6 +2669,18 @@ export function resolveSelectionAxes(input) {
         ...(effort !== undefined ? { effort } : {})
     };
 }
+/**
+ * A blank project here can only be the repo's saved default: explicit flags are
+ * refused as blank before this. setup accepted one until 0.40.43, and a send
+ * then searched the shared browser's sidebar for a project with no name before
+ * failing as project_not_found (measured 2026-10-28).
+ */
+function assertSavedProjectNotBlank(project) {
+    if (project !== undefined && !project.trim()) {
+        throw new Error("The default project saved for this repo in .bridge/config.local.json is blank, so there is no project to send into. " +
+            'Clear it with `prodex setup --clear-project` (or pin one with `prodex setup --project "name"`), or pass --project or --no-project for this send.');
+    }
+}
 /**
  * Scrub project names out of text that gets persisted.
  *
@@ -2671,9 +2693,16 @@ export function resolveSelectionAxes(input) {
 export function redactProjectNames(text, names) {
     let redacted = text;
     // Longest first: a project named "Notes" inside "Notes Archive" would
-    // otherwise leave "<project> Archive" behind.
-    for (const name of [...names].filter((name) => Boolean(name)).sort((a, b) => b.length - a.length)) {
-        redacted = redacted.split(name).join("<project>");
+    // otherwise leave "<project> Archive" behind. A blank name names nothing;
+    // replacing it turned every space of a record into "<project>".
+    for (const name of [...names].filter((name) => Boolean(name?.trim())).sort((a, b) => b.length - a.length)) {
+        // As a word: a plain substring replacement read "Go" inside "Google". The
+        // boundary applies only at an ASCII word character, since a name in a
+        // script like Korean takes its particles directly ("회의록에서").
+        const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const before = /^[A-Za-z0-9_]/.test(name) ? "(?<![A-Za-z0-9_])" : "";
+        const after = /[A-Za-z0-9_]$/.test(name) ? "(?![A-Za-z0-9_])" : "";
+        redacted = redacted.replace(new RegExp(`${before}${escaped}${after}`, "g"), "<project>");
     }
     return redacted;
 }

package/dist/config.js

@@ -94,6 +94,11 @@ export function normalizeLoopbackHttpHost(host) {
     const isIpv4Loopback = isIP(normalized) === 4 && normalized.startsWith("127.");
     if (isLocalhost || isIpv4Loopback)
         return normalized;
+    // ::1 IS loopback; it was refused as if it were not. The listener and every
+    // URL prodex prints are IPv4-shaped, so say that rather than "loopback-only".
+    if (normalized.replace(/^\[|\]$/g, "") === "::1") {
+        throw new Error("HTTP MCP host ::1 (IPv6 loopback) is not supported: prodex prints and serves IPv4 URLs. Use --host 127.0.0.1 or localhost.");
+    }
     throw new Error("HTTP MCP host must be loopback-only, such as 127.0.0.1 or localhost. Keep prodex local and put your own tunnel in front of it when needed.");
 }
 export function assertLoopbackHttpHost(host) {

package/dist/store.js

@@ -517,6 +517,13 @@ export class BridgeStore {
     // fields; throws if the session does not exist.
     async cancelSession(sessionId) {
         const existing = await this.getSession(sessionId);
+        // Cancel marks a session left running (or a preview) as abandoned. A
+        // finished one was rewritten too, so a consult that had answered read
+        // "cancelled" here while its task said done.
+        if (existing.status === "done" || existing.status === "blocked") {
+            const why = existing.blocker?.code === "cancelled" ? "it was cancelled before" : "its outcome is recorded";
+            throw new Error(`Session ${existing.id} is already ${existing.status}; ${why}, so there is nothing to cancel.`);
+        }
         return this.writeSession({
             id: existing.id,
             direction: existing.direction,

package/docs/releasing.md

@@ -35,6 +35,25 @@ The release adds a guarded, opt-in transition and more accurate blocker reportin
 **Open**
 - A long-running headless browser ends up behind Cloudflare's check (also noted on WSL, where the Xvfb display is used instead). On macOS there is no virtual display, and a minimized window counts as hidden, so the remaining no-headless option there is a window kept behind others. Changing the headless preference is a design decision that was not made here.
 
+## 0.40.44 Release Record
+
+Release commit `060d71c` on `main` (cut after PRs #60-#62, last merge `95c5ddc`); tag `v0.40.44`. Released promptly because of #61: 0.40.43's stale-lock check (#54) derived a holder's wall-clock start from `/proc/stat` btime, which drifts on WSL2 (measured 2026-10-27: 3 to 4 seconds every 30 seconds, 30 minutes over a day), so a send a few minutes into another session's consult freed the live lock and drove the same tab. #60 (picker paths with escaped spaces) went out with it; #62 changes CI only. #59 (machine-wide send pacing) was not ready and is not in this release.
+
+**Publishing**
+- The first local `release:verify` failed on `tests/browser-slow-vs-dead.test.ts` "tiny timeout on a closed port" while other tests loaded the machine; it passed alone (8/8), the uncommitted release edits were discarded and the release rerun passed `release:verify`.
+- `publish.yml` run 40618706024 passed all six platforms, then npm publish with SLSA v1 provenance and the GitHub Release, which lists the two entries from `CHANGELOG.md`.
+
+**Installed**
+- WSL, M3, Mac mini: `prodex --version` reports 0.40.44. Running services were not restarted: no host stdio MCP servers on WSL, 1 on M3, none on the Mac mini.
+- The maintainer watchdog checkout was pulled to `060d71c` and rebuilt.
+
+**Container**
+- `container/redesign-patches` `1258052` ports #61 (tsc, build, lock/send/follow-up tests and `release:verify` pass on it).
+- The images were not rebuilt: the agent's permission classifier refused the `docker compose build` on WSL and the build over ssh on M3. The WSL container still runs image `1d48d753fbf7` (the #49-#58 port, with the drifting check) and the M3 container the 0.40.42 port, until someone with access rebuilds them.
+
+**Verified live on installed 0.40.44 (WSL)**
+- A live `sleep` holding a lock that records its start ticks, with `started_at` set 40 minutes back to stand in for a clock step: the send waited ("another prodex send holds the browser"); installed 0.40.43 had reaped the same lock and sent.
+
 ## 0.40.43 Release Record
 
 Release commit `834e3e2` on `main` (cut after PRs #49-#58, last merge `a6bbf85`); tag `v0.40.43`. Ten fixes, including two that block or corrupt work: a send lock left by a dead send whose pid was reused blocked every later send (#54), and two processes opening a fresh repo could fail one with a false "receipt-key.local is corrupt" (#58).

package/package.json

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