@youdie006/prodex 0.40.43 → 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/safe-file.js

@@ -420,6 +420,9 @@ async function tryAcquireFileLock(filePath, parentSnapshot) {
         nonce: randomUUID(),
         started_at: new Date().toISOString()
     };
+    const pidStart = linuxProcessStartTicks(process.pid);
+    if (pidStart !== undefined)
+        owner.pid_start = pidStart;
     const tokenPath = fileLockTokenPath(filePath, owner);
     const handle = await openStableNoFollow(tokenPath, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, "write", parentSnapshot, 0o600);
     try {
@@ -488,7 +491,8 @@ function parseFileLockHolder(content) {
         return {
             pid: Number.isSafeInteger(parsed.pid) && Number(parsed.pid) > 0 ? Number(parsed.pid) : undefined,
             nonce: typeof parsed.nonce === "string" && /^[A-Za-z0-9-]{1,128}$/.test(parsed.nonce) ? parsed.nonce : undefined,
-            started_at: typeof parsed.started_at === "string" ? parsed.started_at : undefined
+            started_at: typeof parsed.started_at === "string" ? parsed.started_at : undefined,
+            pid_start: typeof parsed.pid_start === "string" && /^\d{1,20}$/.test(parsed.pid_start) ? parsed.pid_start : undefined
         };
     }
     catch {
@@ -498,7 +502,12 @@ function parseFileLockHolder(content) {
 function parseFileLockOwner(holder) {
     if (holder.pid === undefined || holder.nonce === undefined)
         return undefined;
-    return { pid: holder.pid, nonce: holder.nonce, started_at: holder.started_at };
+    return {
+        pid: holder.pid,
+        nonce: holder.nonce,
+        started_at: holder.started_at,
+        ...(holder.pid_start !== undefined ? { pid_start: holder.pid_start } : {})
+    };
 }
 async function releaseFileLockLease(filePath, lease, parentSnapshot) {
     try {
@@ -591,36 +600,42 @@ function processIsAlive(pid) {
     }
 }
 /**
- * Whether the holder's pid now names a process that started after the lock was
- * written, so the writer is gone. A send that dies with the machine, the WSL VM
- * or its container leaves the lock behind, and after a restart pids are handed
- * out again: measured, a 2020 lock naming pid 1 held off every send for its
- * whole wait budget because pid 1 was alive - as a different process.
+ * Whether the holder's pid now names a different process than the one that
+ * wrote the lock, so the writer is gone. A send that dies with the machine,
+ * the WSL VM or its container leaves the lock behind, and after a restart pids
+ * are handed out again: measured, a 2020 lock naming pid 1 held off every send
+ * for its whole wait budget because pid 1 was alive - as a different process.
+ *
+ * The lock records its writer's start time in clock ticks since boot, and that
+ * is compared with the pid's start ticks now: boot clock against boot clock.
+ * 0.40.43 converted the start to wall time through /proc/stat btime instead,
+ * and on WSL2 btime moves (measured 30 minutes over one day: the VM's boot
+ * clock stops while the host sleeps, then the wall clock is resynced), so a
+ * live holder looked newer than its own lock and its lock was reaped mid-send.
  */
 function pidReusedSince(holder) {
+    if (holder.pid === undefined)
+        return false;
+    if (holder.pid_start !== undefined) {
+        const current = linuxProcessStartTicks(holder.pid);
+        return current !== undefined && current !== holder.pid_start;
+    }
+    // A lock from a prodex that did not record start ticks: the only safe call is
+    // that nothing alive now was running before the last boot.
     const writtenAt = Date.parse(holder.started_at ?? "");
-    if (holder.pid === undefined || !Number.isFinite(writtenAt))
+    if (!Number.isFinite(writtenAt))
         return false;
-    const processStartedAt = linuxProcessStartMs(holder.pid);
-    // A holder writes the lock after it starts; a few seconds absorb clock steps.
-    if (processStartedAt !== undefined)
-        return processStartedAt > writtenAt + 5_000;
-    // No per-process start time here: nothing alive now predates the boot.
     return writtenAt < Date.now() - os.uptime() * 1000 - 60_000;
 }
-function linuxProcessStartMs(pid) {
+function linuxProcessStartTicks(pid) {
     if (process.platform !== "linux")
         return undefined;
     try {
-        const btime = /^btime (\d+)$/m.exec(readFileSync("/proc/stat", "utf8"))?.[1];
         const stat = readFileSync(`/proc/${pid}/stat`, "utf8");
-        // Field 22 (starttime, in clock ticks since boot) counted after the
-        // parenthesised command name, which may itself contain spaces.
-        const ticks = Number(stat.slice(stat.lastIndexOf(")") + 2).split(" ")[19]);
-        if (!btime || !Number.isFinite(ticks))
-            return undefined;
-        // USER_HZ is 100 on every Linux ABI Node supports.
-        return Number(btime) * 1000 + ticks * 10;
+        // Field 22 (starttime) counted after the parenthesised command name, which
+        // may itself contain spaces.
+        const ticks = stat.slice(stat.lastIndexOf(")") + 2).split(" ")[19];
+        return ticks !== undefined && /^\d+$/.test(ticks) ? ticks : undefined;
     }
     catch {
         return undefined;

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/dist/tui.js

@@ -63,10 +63,15 @@ export function consultArgsFromChoices(choices) {
  */
 export function parseAttachmentLine(line) {
     const out = [];
-    const pattern = /"([^"]*)"|'([^']*)'|(\S+)/g;
+    // An unquoted word may carry backslash escapes: dropping a file onto a macOS
+    // terminal types `My\ File.pdf`, which used to split into two paths that do
+    // not exist. Only a space or shell punctuation counts as escaped, so a
+    // Windows separator (a backslash before a letter or another backslash) stays.
+    const pattern = /"([^"]*)"|'([^']*)'|((?:\\[ ()\[\]{}'"&;!$`*?#~<>|]|\S)+)/g;
     let match;
     while ((match = pattern.exec(line)) !== null) {
-        const value = (match[1] ?? match[2] ?? match[3] ?? "").trim();
+        const unquoted = match[3]?.replace(/\\([ ()\[\]{}'"&;!$`*?#~<>|])/g, "$1");
+        const value = (match[1] ?? match[2] ?? unquoted ?? "").trim();
         if (value.length > 0)
             out.push(value);
     }

package/docs/releasing.md

@@ -35,6 +35,47 @@ 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).
+
+**Publishing**
+- `publish.yml` run 40451563636 first failed on macOS 15 Intel only: `tests/cli.test.ts` "uses an explicit --cwd target for local HTTP MCP start" timed out at 90 s; the same commit passed on the five other platforms and in PR CI. The failed job was rerun and passed, then npm publish with SLSA v1 provenance and the GitHub Release ran. The GitHub Release lists the ten entries from `CHANGELOG.md`.
+- `npm run release:verify` passed on the release commit after a build.
+
+**Installed**
+- WSL, M3, Mac mini: `prodex --version` reports 0.40.43. 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 `834e3e2` and rebuilt.
+
+**Container**
+- `container/redesign-patches` `f72862c` ports #49-#58; full suite (164 files, 2098 tests) and `release:verify` pass on it.
+- WSL: image rebuilt and the container swapped to `1d48d753fbf7`; the in-container send lock was idle before and after.
+- M3: not rebuilt in this release. The build over ssh was refused by the agent's permission classifier; the M3 container still runs the 0.40.42 port.
+
+**Verified live on installed 0.40.43 (WSL)**
+- `pro blockers --since 7` refused: "--since expects a date or an age like 7d or 24h".
+- `pro blockers --json` across the machine: 21 roots and 657 consults (before: 27 roots, about twice the consults, counting case-variant paths of the same repo).
+- `ask --project "  "` refused: "--project is blank".
+
 ## 0.40.42 Release Record
 
 Release commit `9c97a14` on `main` (cut after PR #48, merge `cc129d8`); tag `v0.40.42`. Released on its own: before it, `--attach` and MCP `attach` uploaded `.env`, `.git` contents, key files and outward symlinks.

package/package.json

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