@youdie006/prodex 0.38.0 → 0.39.0

package/dist/chatgpt-browser.js

@@ -6,7 +6,7 @@ import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { captureBrowserDiagnostics, diagnosticsEnabled, diagnosticsNote } from "./browser-diagnostics.js";
 import os from "node:os";
-import { readPowerSliderSelection } from "./picker-interaction.js";
+import { menuKeyboardStep, readPowerSliderSelection } from "./picker-interaction.js";
 export class ChatGptBrowserBlockerError extends Error {
     blocker;
     constructor(blocker) {
@@ -20,7 +20,13 @@ export class ChatGptBrowserBlockerError extends Error {
 // of this control rather than a model. Leaving it out meant --effort could not
 // reach the top of the slider at all, and the only route there - --model Pro -
 // answered with advice to "say --effort Pro", which then failed.
-const REASONING_EFFORTS = ["즉시", "중간", "높음", "매우 높음", "Pro"];
+/** A full trip round the menu is far more than any real picker needs. */
+const MENU_KEYBOARD_WALK_LIMIT = 16;
+// Two more rungs than before. Measured live: with the model row chosen rather
+// than the recommended set, the slider reads Light / Medium / High / Extra High
+// / Max / Ultra, and Ultra is the top of the machine. Pro is kept because older
+// pickers still name the top step that way.
+const REASONING_EFFORTS = ["즉시", "중간", "높음", "매우 높음", "Max", "Ultra", "Pro"];
 const PRO_MODES = ["기본", "확장"];
 // Aliases map friendly CLI input onto the exact Korean menu labels the picker
 // clicks by text. Keys are lowercased and space-stripped before lookup.
@@ -29,19 +35,26 @@ const REASONING_EFFORT_ALIASES = {
     instant: "즉시",
     medium: "중간",
     high: "높음",
-    max: "매우 높음",
     extrahigh: "매우 높음",
+    max: "매우 높음",
+    light: "즉시",
+    "가벼움": "즉시",
+    "최대": "Max",
+    ultra: "Ultra",
+    "울트라": "Ultra",
     pro: "Pro",
     "프로": "Pro"
 };
 // Menu labels per canonical value, verified live in both the Korean and the
 // English (US) ChatGPT UI. Matching tries every candidate so either UI works.
 const EFFORT_MENU_LABELS = {
-    "즉시": ["즉시", "Instant"],
+    "즉시": ["즉시", "Instant", "Light"],
     "중간": ["중간", "Medium"],
     "높음": ["높음", "High"],
     "매우 높음": ["매우 높음", "Extra High"],
-    Pro: ["Pro", "프로"]
+    Max: ["Max", "최대"],
+    Ultra: ["Ultra", "울트라"],
+    Pro: ["Pro", "프로", "6-pro", "GPT-6 Pro", "6 Pro"]
 };
 const PRO_MODE_SUBMENU_LABELS = {
     "기본": ["Pro 기본", "Pro Standard", "Standard", "기본"],
@@ -60,7 +73,7 @@ export function parseReasoningEffort(raw) {
     const alias = REASONING_EFFORT_ALIASES[trimmed.toLowerCase().replace(/\s+/g, "")];
     if (alias)
         return alias;
-    throw new Error(`--effort must be one of ${REASONING_EFFORTS.join(", ")} (English aliases: instant, medium, high, max)`);
+    throw new Error(`--effort must be one of ${REASONING_EFFORTS.join(", ")} (English aliases: instant/light, medium, high, extrahigh, max, ultra)`);
 }
 /** Normalize a CLI Pro sub-mode value onto the exact ChatGPT menu label. */
 export function parseProMode(raw) {
@@ -1422,6 +1435,38 @@ export function powerSliderStateExpression() {
     };
   })()`;
 }
+export function activeMenuItemExpression() {
+    return `(() => {
+    const a = document.activeElement;
+    if (!a) return null;
+    const menu = document.querySelector('[data-testid="composer-intelligence-picker-content"]');
+    if (menu && !menu.contains(a)) return null;
+    const label = ((a.innerText || a.textContent || "").trim().split(String.fromCharCode(10))[0] || "").trim();
+    return { role: a.getAttribute("role"), label };
+  })()`;
+}
+export function powerSliderPresentExpression() {
+    return `Boolean(document.querySelector('[data-testid="composer-intelligence-picker-content"] [role="slider"]'))`;
+}
+export function pickerClosedExpression() {
+    return `!document.querySelector('[data-testid="composer-intelligence-picker-content"]')`;
+}
+export function focusPickerMenuExpression() {
+    return `(() => {
+    const menu = document.querySelector('[data-testid="composer-intelligence-picker-content"]');
+    if (!menu) return { ok: false, reason: "picker menu not open" };
+    // Leave the focus the menu gave itself. It opens on the checked model row,
+    // and ArrowDown from there walks the model list. Focusing the first item
+    // instead lands on the label row above the slider, where ArrowDown only
+    // cycles that row's own widgets - measured as four steps that repeat
+    // forever and never reach a radio.
+    if (menu.contains(document.activeElement)) return { ok: true };
+    const radios = [...menu.querySelectorAll('[role="menuitemradio"]')];
+    const target = radios.find((r) => r.getAttribute("aria-checked") === "true") || radios[0];
+    if (target && typeof target.focus === "function") target.focus();
+    return { ok: menu.contains(document.activeElement) };
+  })()`;
+}
 export function focusPowerSliderExpression() {
     return `(() => {
     const slider = document.querySelector('[role="slider"]');
@@ -1680,7 +1725,45 @@ export function stepSelectionUnavailableWarning(requested, offered) {
     return (`step_not_applied: this ChatGPT picker has no "${requested}" step, so the send used the slider's current setting.${list} ` +
         'Pick one of those with --effort, or clear a saved default with `prodex setup --clear-model`.');
 }
+/**
+ * Choose a model row through the menu's roving focus.
+ *
+ * The rows carry pointer-events: none and sit outside the menu's box, so
+ * verifiedClickAt refuses them and .focus() is declined. ArrowDown from the row
+ * the menu opens on does reach them, and Enter commits. Doing this BEFORE the
+ * slider matters: with the recommended set active the slider walks a short
+ * mixed ladder ending at Extra High, and picking the model swaps in that
+ * model's own ladder, which continues past it.
+ */
+async function selectPickerModelByKeyboard(cdp, candidates) {
+    const focused = await cdp.evaluate(focusPickerMenuExpression());
+    if (!focused?.ok)
+        return false;
+    const limit = MENU_KEYBOARD_WALK_LIMIT;
+    for (let pressed = 0;; pressed += 1) {
+        const active = await cdp.evaluate(activeMenuItemExpression());
+        const move = menuKeyboardStep({ active, requested: candidates, pressed, limit });
+        if (move === "exhausted")
+            return false;
+        if (move === "select") {
+            await dispatchMenuKey(cdp, "Enter", 13);
+            // Committing closes the menu. Waiting for it to finish closing keeps the
+            // reopen below from landing mid-animation and toggling it shut again.
+            await waitForExpressionTrue(cdp, pickerClosedExpression(), 3_000);
+            return true;
+        }
+        await dispatchMenuKey(cdp, "ArrowDown", 40);
+        await sleep(140);
+    }
+}
+async function dispatchMenuKey(cdp, key, code) {
+    for (const type of ["keyDown", "keyUp"]) {
+        await cdp.send("Input.dispatchKeyEvent", { type, key, code: key, windowsVirtualKeyCode: code });
+    }
+}
 async function selectPickerModel(cdp, requested, warnings = []) {
+    if (await selectPickerModelByKeyboard(cdp, [requested]))
+        return;
     const hit = await cdp.evaluate(menuItemRectExpression(requested));
     if (!hit.ok || hit.x === undefined || hit.y === undefined) {
         const unavailable = modelSelectionUnavailableWarning(requested, hit.reason ?? "", hit.available);
@@ -1692,6 +1775,29 @@ async function selectPickerModel(cdp, requested, warnings = []) {
     }
     await verifiedClickWithRetry(cdp, () => cdp.evaluate(menuItemRectExpression(requested)), requested);
 }
+/**
+ * Make sure the composer picker is open, reopening it if it is not.
+ *
+ * Committing a model row closes the menu, and the slider lives inside it - so
+ * without this the step that follows reported "the picker did not expose its
+ * power slider" on a picker that was simply shut.
+ */
+async function ensurePickerOpen(cdp) {
+    // The slider, not the menu, is what the caller needs - and an open menu that
+    // has not painted its slider yet looks identical to one that has.
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+        if (await cdp.evaluate(powerSliderPresentExpression()))
+            return true;
+        await waitForExpressionTrue(cdp, pickerClosedExpression(), 1_500);
+        const button = await cdp.evaluate(modelButtonRectExpression());
+        if (!button.ok || button.x === undefined || button.y === undefined)
+            return false;
+        await verifiedClickAt(cdp, button.x, button.y, "model selector");
+        if (await waitForExpressionTrue(cdp, powerSliderPresentExpression(), MENU_OPEN_TIMEOUT_MS))
+            return true;
+    }
+    return false;
+}
 async function selectPowerStep(cdp, requested) {
     // The menu paints a moment after it opens, and on a page that has just been
     // built - a project created seconds ago - that moment is longer. Failing the
@@ -1800,7 +1906,11 @@ async function selectModelReasoning(cdp, options, selectionWarnings = []) {
         // the whole send). Retry briefly with FRESH coordinates; a persistent
         // cover still fails with the refusal message.
         const clickDeadline = Date.now() + 5_000;
-        for (;;) {
+        // Clicking the trigger TOGGLES the picker, so clicking one that is already
+        // open shuts it and the next step reports "power slider not found" about a
+        // control that was on screen a moment earlier.
+        const alreadyOpen = await cdp.evaluate(powerSliderPresentExpression());
+        for (; !alreadyOpen;) {
             try {
                 await verifiedClickAt(cdp, button.x, button.y, "model selector");
                 break;
@@ -1832,7 +1942,16 @@ async function selectModelReasoning(cdp, options, selectionWarnings = []) {
             });
             if (plan.warning)
                 selectionWarnings.push(plan.warning);
+            // The model goes first: choosing it replaces the ladder the slider walks,
+            // so a step picked before it would be a step of the old ladder.
+            if (plan.modelLabel) {
+                await selectPickerModel(cdp, plan.modelLabel, selectionWarnings);
+            }
             if (plan.sliderLabel) {
+                // Committing the model closed the menu; the slider is inside it.
+                if (!(await ensurePickerOpen(cdp))) {
+                    throw new Error("ChatGPT's model picker would not reopen after the model was chosen.");
+                }
                 try {
                     await selectPowerStep(cdp, plan.sliderLabel);
                 }
@@ -1847,9 +1966,6 @@ async function selectModelReasoning(cdp, options, selectionWarnings = []) {
                     selectionWarnings.push(stepSelectionUnavailableWarning(plan.sliderLabel, offered));
                 }
             }
-            if (plan.modelLabel) {
-                await selectPickerModel(cdp, plan.modelLabel, selectionWarnings);
-            }
             // This branch cannot honour a sub-mode, and used to return without
             // saying so - the caller got a clean receipt for a 확장 it never got.
             const proModeWarning = proModeNotAppliedWarning(options.proMode, sliderState.effort ?? undefined);
@@ -2839,7 +2955,11 @@ export function modelMenuOptionsExpression() {
     return `(() => {
     const m = document.querySelector('[data-testid="composer-intelligence-picker-content"]');
     if (!m) return [];
-    return [...m.querySelectorAll('[role="menuitemradio"],[role="menuitem"]')]
+    // Only the radios are models. The plain menuitems above them are the power
+    // slider's own rows - its track, and the label pair naming the current model
+    // and effort - and listing those put GPT-6 Astra in twice and Extra High in
+    // as if it were a model.
+    return [...m.querySelectorAll('[role="menuitemradio"]')]
       .map((it) => {
         // A submenu row renders as label over value ("Model" / "GPT-5.6 Sol"),
         // and the value is the part a person actually wants to read.
@@ -3275,17 +3395,24 @@ async function readEffortSteps(cdp) {
             await dispatchArrowKey(cdp, "ArrowLeft");
             await sleep(120);
         }
-        const labels = [];
+        // Every position is recorded, including repeats. One slider now walks a
+        // ladder of model-and-effort pairs, so "Light" is three different rungs -
+        // collapsing by label turned six positions into three and lost which model
+        // each one sends with.
+        const rungs = [];
         const record = async () => {
             const state = await cdp.evaluate(powerSliderStateExpression());
-            const label = state?.effort?.trim();
-            if (label && !labels.includes(label))
-                labels.push(label);
+            if (!state?.ok)
+                return;
+            const effort = state.effort?.trim();
+            if (!effort)
+                return;
+            rungs.push({ position: state.position ?? rungs.length, model: state.model?.trim() || null, effort });
         };
         await record();
         for (let i = 0; i < plan.climb; i += 1) {
             await dispatchArrowKey(cdp, "ArrowRight");
-            await sleep(120);
+            await sleep(220);
             await record();
         }
         // Put it back. Reading someone's setting must not change it.
@@ -3293,7 +3420,7 @@ async function readEffortSteps(cdp) {
             await dispatchArrowKey(cdp, "ArrowLeft");
             await sleep(120);
         }
-        return labels.length > 0 ? { labels, current } : undefined;
+        return rungs.length > 0 ? { rungs, current } : undefined;
     }
     catch {
         return undefined;

package/dist/cli-pro.js

@@ -449,11 +449,18 @@ export async function runProCommand(rest, io, runCliFn) {
             }
             if (listed.effortSteps) {
                 io.stdout("");
-                io.stdout("Effort steps on this account (the slider was walked and put back):");
-                for (const label of listed.effortSteps.labels) {
-                    io.stdout(`${label === listed.effortSteps.current ? "*" : " "} ${label}`);
+                // One slider walks a ladder of model-and-effort pairs, so the same
+                // effort name appears at more than one rung with a different model
+                // behind it. Printing bare names hid that.
+                io.stdout("Power slider on this account (the slider was walked and put back):");
+                const rungs = listed.effortSteps.rungs;
+                const width = String(rungs.length).length;
+                for (const rung of rungs) {
+                    const here = rung.effort === listed.effortSteps.current ? "*" : " ";
+                    const step = String(rung.position + 1).padStart(width, " ");
+                    io.stdout(`${here} ${step}/${rungs.length}  ${rung.model ?? "?"}  -  ${rung.effort}`);
                 }
-                io.stdout("Pass any of these to --effort. The list is complete: the slider shows one step at a time, so reading it any other way sees only the current one.");
+                io.stdout("Each row is one position of that single slider: it sets the model and the effort together, so they cannot be chosen apart. The list is complete - the slider shows one position at a time, so reading it any other way sees only the current one.");
             }
             else {
                 io.stdout("An arrow shows what that row is set to now; --model / --effort reach into those submenus (e.g. --model Pro).");

package/dist/config.js

@@ -11,7 +11,7 @@ const BrowserDefaultsSchema = z.object({
     model: z.string().min(1).optional(),
     pro_mode: z.enum(["기본", "확장"]).optional(),
     // Pro is the slider's fifth step, so a saved default may name it.
-    effort: z.enum(["즉시", "중간", "높음", "매우 높음", "Pro"]).optional(),
+    effort: z.enum(["즉시", "중간", "높음", "매우 높음", "Max", "Ultra", "Pro"]).optional(),
     project: z.string().min(1).optional()
 });
 const LocalConfigSchema = z.object({

package/dist/picker-interaction.js

@@ -10,6 +10,7 @@ export function readPowerSliderSelection(snapshot) {
     }));
     const powerLabels = new Set([
         "instant",
+        "light",
         "즉시",
         "빠름",
         "fast",
@@ -29,12 +30,43 @@ export function readPowerSliderSelection(snapshot) {
     const legacyModel = items.find((item) => item.lines[0] === "Model")?.lines[1] ?? null;
     const legacyEffort = items.find((item) => item.lines[0] === "Effort")?.lines[1] ?? null;
     const checkedModel = items.find((item) => item.role === "menuitemradio" && item.checked)?.lines[0] ?? null;
-    const sliderOwner = items.find((item) => item.role === "menuitem" && item.containsSlider)?.lines[0] ?? null;
+    // The slider stopped being an effort control: one slider now walks a ladder of
+    // model-and-effort pairs, and a row above the track reads "<model>" then
+    // "<effort>". Measured live, that pair sits in a SIBLING row - the row that
+    // literally contains the slider carries no text - so the pair is found by its
+    // shape rather than by ownership of the track. Reading the pair's first line
+    // as the effort is what made the listing announce "Extra High" as a model.
+    const pairRow = items.find((item) => item.role === "menuitem" && item.lines.length >= 2 && item.lines[0] !== "Model" && item.lines[0] !== "Effort");
+    const owner = items.find((item) => item.role === "menuitem" && item.containsSlider);
+    const sliderOwnerModel = pairRow?.lines[0] ?? null;
+    // A single-line row is the older form, where it carried only the step name.
+    const sliderOwner = pairRow?.lines[1] ?? (owner && owner.lines.length === 1 ? owner.lines[0] : null) ?? null;
     const visiblePowerLabel = items.find((item) => item.role === "menuitem" && powerLabels.has((item.lines[0] ?? "").toLowerCase()))?.lines[0] ?? null;
     const accessibleCandidate = snapshot.sliderValueText?.trim() || null;
     const accessibleValue = accessibleCandidate && powerLabels.has(accessibleCandidate.toLowerCase()) ? accessibleCandidate : null;
     return {
-        model: legacyModel ?? checkedModel,
+        // The checked radio is "Default" - the recommended set - while the slider
+        // decides the model a send actually uses, so the slider's row wins.
+        model: legacyModel ?? sliderOwnerModel ?? checkedModel,
         effort: accessibleValue ?? legacyEffort ?? sliderOwner ?? visiblePowerLabel
     };
 }
+/**
+ * Decide the next move when walking the composer picker's menu by keyboard.
+ *
+ * The model rows carry pointer-events: none and refuse focus(), so the menu's
+ * own roving focus is the only way to reach them. Only a radio counts as the
+ * target: the row above the slider repeats the model name as its first line,
+ * and committing there selects nothing.
+ */
+export function menuKeyboardStep(input) {
+    const { active, requested, pressed, limit } = input;
+    if (!active)
+        return "exhausted";
+    if (active.role === "menuitemradio") {
+        const label = active.label.trim().toLowerCase();
+        if (requested.some((candidate) => candidate.trim().toLowerCase() === label))
+            return "select";
+    }
+    return pressed < limit ? "down" : "exhausted";
+}

package/dist/store-writer.js

@@ -0,0 +1,210 @@
+// Write a bridge record into a directory the kernel has pinned for us.
+//
+// The store's normal path renders an open directory handle as /proc/self/fd/N
+// and joins the file name onto it, so the write lands in the directory that was
+// validated rather than in one a symlink swap redirected. macOS has no
+// traversable equivalent - /dev/fd/N stands in for the descriptor, not for a
+// walkable directory - so that path fails there with a bare ENOENT and takes the
+// whole ledger with it.
+//
+// This process buys the same guarantee a different way. It is spawned with its
+// cwd already set to the directory to descend from, it refuses to continue
+// unless "." is the very inode the parent validated, and it descends by chdir
+// one no-symlink segment at a time, re-checking the inode after each step. The
+// kernel holds the cwd's vnode, so once a step is confirmed nothing can redirect
+// the relative paths that follow. That is precisely what the fd path bought.
+//
+// Everything after the anchoring uses the same helpers the in-process path uses,
+// on relative names.
+import { closeSync, constants, fstatSync, openSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import { link, lstat, readdir, rename, rm } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { writeVerifiedUtf8File } from "./safe-file.js";
+function identityOfOpenDirectory(fd) {
+    const stat = fstatSync(fd, { bigint: true });
+    if (!stat.isDirectory())
+        throw new Error("Anchored writer expected a directory");
+    return { dev: stat.dev.toString(), ino: stat.ino.toString() };
+}
+function sameIdentity(a, b) {
+    return a.dev === b.dev && a.ino === b.ino;
+}
+/** Open a name relative to the cwd, refusing symlinks and non-directories. */
+function openDirectoryHere(name) {
+    const directoryFlag = typeof constants.O_DIRECTORY === "number" ? constants.O_DIRECTORY : 0;
+    const noFollowFlag = typeof constants.O_NOFOLLOW === "number" ? constants.O_NOFOLLOW : 0;
+    return openSync(name, constants.O_RDONLY | directoryFlag | noFollowFlag);
+}
+function currentDirectoryIdentity() {
+    const fd = openDirectoryHere(".");
+    try {
+        return identityOfOpenDirectory(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/**
+ * Confirm the cwd is the directory the parent meant, then descend the segments
+ * so that the cwd ends up pinned to the directory the record belongs in.
+ */
+export function anchorCurrentDirectory(anchor, segments) {
+    let here = currentDirectoryIdentity();
+    if (!sameIdentity(here, anchor)) {
+        throw new Error("Anchored writer was not started in the directory the caller validated");
+    }
+    for (const segment of segments) {
+        if (segment.length === 0 || segment === "." || segment === ".." || segment.includes("/")) {
+            throw new Error(`Anchored writer refuses to descend into ${JSON.stringify(segment)}`);
+        }
+        // O_NOFOLLOW proves the name is a real directory rather than a symlink, and
+        // the identity check after chdir proves we landed on that same directory
+        // and not on something swapped in between the two calls.
+        const fd = openDirectoryHere(segment);
+        let expected;
+        try {
+            expected = identityOfOpenDirectory(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
+        process.chdir(segment);
+        here = currentDirectoryIdentity();
+        if (!sameIdentity(here, expected)) {
+            throw new Error(`Anchored writer landed somewhere other than ${JSON.stringify(segment)}`);
+        }
+    }
+    return here;
+}
+async function assertRegularFileIfExists(name) {
+    try {
+        const stat = await lstat(name);
+        if (stat.isSymbolicLink() || !stat.isFile()) {
+            throw new Error("Bridge record path must be a regular file and must not be a symlink");
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+}
+function temporaryName(fileName) {
+    return `.${fileName}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
+}
+export async function runAnchoredJob(job) {
+    const pinned = anchorCurrentDirectory(job.anchor, job.segments);
+    const stillPinned = async () => {
+        if (!sameIdentity(currentDirectoryIdentity(), pinned)) {
+            throw new Error("Anchored writer's directory changed underneath it");
+        }
+    };
+    const { fileName } = job;
+    if (fileName.length === 0 || fileName.includes("/") || fileName === "." || fileName === "..") {
+        throw new Error(`Anchored writer refuses the file name ${JSON.stringify(fileName)}`);
+    }
+    if (job.op === "deleteIfPresent") {
+        let stat;
+        try {
+            stat = await lstat(fileName);
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return { ok: true };
+            throw error;
+        }
+        if (stat.isSymbolicLink() || !stat.isFile()) {
+            throw new Error("Bridge record path must be a regular file and must not be a symlink");
+        }
+        await rm(fileName, { force: true });
+        return { ok: true };
+    }
+    if (job.op === "cleanupTempHardLinks") {
+        let targetStat;
+        try {
+            targetStat = await lstat(fileName);
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return { ok: true };
+            throw error;
+        }
+        if (targetStat.isSymbolicLink() || !targetStat.isFile() || targetStat.nlink <= 1)
+            return { ok: true };
+        const prefix = `.${fileName}.`;
+        for (const entry of await readdir(".", { withFileTypes: true })) {
+            if (!entry.isFile() || !entry.name.startsWith(prefix) || !entry.name.endsWith(".tmp"))
+                continue;
+            const tempStat = await lstat(entry.name).catch(() => undefined);
+            if (!tempStat?.isFile() || tempStat.isSymbolicLink())
+                continue;
+            if (tempStat.dev === targetStat.dev && tempStat.ino === targetStat.ino) {
+                await rm(entry.name, { force: true });
+            }
+        }
+        return { ok: true };
+    }
+    const content = job.content ?? "";
+    const tmpName = temporaryName(fileName);
+    if (job.op === "writeByRename") {
+        await assertRegularFileIfExists(fileName);
+        try {
+            await writeVerifiedUtf8File(tmpName, content, stillPinned, { create: true, mode: job.mode });
+            await rename(tmpName, fileName);
+            await assertRegularFileIfExists(fileName);
+        }
+        catch (error) {
+            await rm(tmpName, { force: true }).catch(() => undefined);
+            throw error;
+        }
+        return { ok: true };
+    }
+    // linkIfAbsent: the hard link is what makes "create only if absent" atomic.
+    let linked = false;
+    try {
+        await writeVerifiedUtf8File(tmpName, content, stillPinned, { create: true, exclusive: true, mode: job.mode });
+        try {
+            await link(tmpName, fileName);
+        }
+        catch (error) {
+            if (error.code === "EEXIST") {
+                await rm(tmpName, { force: true }).catch(() => undefined);
+                return { ok: true, created: false };
+            }
+            throw error;
+        }
+        linked = true;
+        await rm(tmpName, { force: true });
+        await assertRegularFileIfExists(fileName);
+    }
+    catch (error) {
+        if (!linked)
+            await rm(tmpName, { force: true }).catch(() => undefined);
+        throw error;
+    }
+    return { ok: true, created: true };
+}
+async function readAllStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(Buffer.from(chunk));
+    return Buffer.concat(chunks).toString("utf8");
+}
+async function main() {
+    let outcome;
+    try {
+        outcome = await runAnchoredJob(JSON.parse(await readAllStdin()));
+    }
+    catch (error) {
+        const maybe = error;
+        outcome = { ok: false, error: maybe.message ?? String(error), code: maybe.code };
+    }
+    process.stdout.write(`${JSON.stringify(outcome)}\n`);
+    if (!outcome.ok)
+        process.exitCode = 1;
+}
+// Only run when this file is the entry point, so the exported pieces stay
+// importable from tests without the process trying to read stdin.
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    await main();
+}

package/dist/store.js

@@ -1,8 +1,12 @@
 import { createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
+import { createRequire } from "node:module";
 import { registerBridgeRoot } from "./registry.js";
-import { constants, existsSync } from "node:fs";
+import { closeSync, constants, existsSync, openSync, readdirSync } from "node:fs";
+import { tmpdir } from "node:os";
 import { link, lstat, mkdir, open, readdir, realpath, rename, rm, stat } from "node:fs/promises";
 import path from "node:path";
+import { spawn } from "node:child_process";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { assertRepoRelativePath } from "./repo.js";
 import { readVerifiedUtf8File, writeVerifiedUtf8File } from "./safe-file.js";
 import { makeBridgeId, nowIso, ReceiptSchema, ResultSchema, SCHEMA_VERSION, SessionSchema, TaskSchema } from "./schema.js";
@@ -656,6 +660,16 @@ export class BridgeStore {
         const artifactPath = this.resolveArtifactPath(relativePath);
         const parentPath = path.dirname(artifactPath);
         await this.assertArtifactParentDirectory(parentPath);
+        if (!hasStableDirectoryFdPaths()) {
+            const segments = path.relative(this.bridgeDir, parentPath).split(path.sep).filter((part) => part.length > 0);
+            await runAnchoredWrite(this.bridgeDir, segments, {
+                op: "deleteIfPresent",
+                fileName: path.basename(artifactPath),
+                mode: BRIDGE_FILE_MODE
+            });
+            await this.assertArtifactParentDirectory(parentPath);
+            return;
+        }
         const parentHandle = await openNoFollowDirectory(parentPath, "Artifact directory");
         try {
             const targetPath = path.join(directoryFdPath(parentHandle.fd), path.basename(artifactPath));
@@ -975,13 +989,31 @@ export class BridgeStore {
             await this.writeTextByStableStorageRename(kind, filePath, content);
             return;
         }
-        throw new Error("Bridge record writes require stable directory file descriptor paths on this platform.");
+        await this.runAnchoredRecordJob(kind, filePath, { op: "writeByRename", content });
     }
     async writeTextByCreateExclusive(kind, filePath, content) {
         if (hasStableDirectoryFdPaths()) {
             return await this.writeTextByStableStorageLinkIfAbsent(kind, filePath, content);
         }
-        throw new Error("Bridge record writes require stable directory file descriptor paths on this platform.");
+        const outcome = await this.runAnchoredRecordJob(kind, filePath, { op: "linkIfAbsent", content });
+        return outcome.created !== false;
+    }
+    /**
+     * Run one record operation in the anchored child, with the same storage
+     * directory checks the in-process path makes on either side of it.
+     */
+    async runAnchoredRecordJob(kind, filePath, job) {
+        if (path.dirname(filePath) !== this.dir(kind)) {
+            throw new Error(`Bridge record path must stay under .bridge/${kind}`);
+        }
+        await this.assertStorageDirIsRealDirectory(kind);
+        const outcome = await runAnchoredWrite(this.bridgeDir, [kind], {
+            ...job,
+            fileName: path.basename(filePath),
+            mode: BRIDGE_FILE_MODE
+        });
+        await this.assertStorageDirIsRealDirectory(kind);
+        return outcome.ok ? outcome : {};
     }
     async deleteRecordIfPresent(kind, id) {
         const filePath = this.pathFor(kind, id);
@@ -990,6 +1022,10 @@ export class BridgeStore {
         if (path.dirname(filePath) !== expectedDir) {
             throw new Error(`Bridge record path must stay under .bridge/${kind}`);
         }
+        if (!hasStableDirectoryFdPaths()) {
+            await this.runAnchoredRecordJob(kind, filePath, { op: "deleteIfPresent" });
+            return;
+        }
         const bridgeHandle = await openNoFollowDirectory(this.bridgeDir, "Bridge directory");
         try {
             const storageHandle = await openNoFollowDirectory(path.join(directoryFdPath(bridgeHandle.fd), kind), `Bridge storage directory .bridge/${kind}`);
@@ -1115,6 +1151,10 @@ export class BridgeStore {
         if (path.dirname(filePath) !== expectedDir) {
             throw new Error(`Bridge record path must stay under .bridge/${kind}`);
         }
+        if (!hasStableDirectoryFdPaths()) {
+            await this.runAnchoredRecordJob(kind, filePath, { op: "cleanupTempHardLinks" });
+            return;
+        }
         const bridgeHandle = await openNoFollowDirectory(this.bridgeDir, "Bridge directory");
         try {
             const storageHandle = await openNoFollowDirectory(path.join(directoryFdPath(bridgeHandle.fd), kind), `Bridge storage directory .bridge/${kind}`);
@@ -1552,14 +1592,112 @@ function directoryFdPath(fd) {
     }
     return `${base}/${fd}`;
 }
+// Whether a base can be USED, not merely whether it exists. macOS has /dev/fd,
+// so an existence check accepted it, and every record write then failed with
+// ENOENT on a path like /dev/fd/12/receipts - measured there, /dev/fd exists and
+// is not traversable, which took down the whole bridge write surface while the
+// same checks pass on Linux. Existence was never the property being relied on.
+let directoryFdBaseProbe;
+function probeDirectoryFdBase() {
+    for (const base of ["/proc/self/fd", "/dev/fd"]) {
+        if (!existsSync(base))
+            continue;
+        let fd;
+        try {
+            fd = openSync(tmpdir(), constants.O_RDONLY | (constants.O_DIRECTORY ?? 0));
+            // Reading the directory THROUGH the rendered path is exactly what the
+            // writes do, so that is what gets tested.
+            readdirSync(`${base}/${fd}`);
+            return base;
+        }
+        catch {
+            // this base cannot be walked here; try the next
+        }
+        finally {
+            if (fd !== undefined) {
+                try {
+                    closeSync(fd);
+                }
+                catch {
+                    // best effort
+                }
+            }
+        }
+    }
+    return undefined;
+}
+/** Exported so a test can hold the probe to what the running platform can do. */
+export function directoryFdPathsUsable() {
+    return hasStableDirectoryFdPaths();
+}
+// Running the write in a child process whose cwd the kernel has pinned is how
+// platforms without a traversable /proc/self/fd keep the guarantee the fd path
+// gives everywhere else. See src/store-writer.ts for what the child checks.
+function anchoredWriterCommand() {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const built = path.join(here, "store-writer.js");
+    if (existsSync(built))
+        return { command: process.execPath, args: [built] };
+    const source = path.join(here, "store-writer.ts");
+    if (existsSync(source)) {
+        // Only reachable when running from TypeScript sources. The child's cwd is
+        // the bridge directory, so tsx has to be named by absolute URL or Node
+        // looks for it next to the records.
+        const tsx = pathToFileURL(createRequire(import.meta.url).resolve("tsx/esm")).href;
+        return { command: process.execPath, args: ["--import", tsx, source] };
+    }
+    throw new Error("Bridge record writes need the anchored writer, which is missing from this installation.");
+}
+async function runAnchoredWrite(bridgeDir, segments, job) {
+    const bridgeHandle = await openNoFollowDirectory(bridgeDir, "Bridge directory");
+    let anchor;
+    try {
+        const stat = await bridgeHandle.stat({ bigint: true });
+        anchor = { dev: stat.dev.toString(), ino: stat.ino.toString() };
+    }
+    finally {
+        await bridgeHandle.close();
+    }
+    const { command, args } = anchoredWriterCommand();
+    // cwd is resolved by path here, which is exactly the lookup an attacker could
+    // redirect - so the child refuses to proceed unless the directory it landed in
+    // is the inode just measured through the no-follow handle.
+    const child = spawn(command, args, { cwd: bridgeDir, stdio: ["pipe", "pipe", "pipe"] });
+    const stdout = [];
+    const stderr = [];
+    child.stdout.on("data", (chunk) => stdout.push(chunk));
+    child.stderr.on("data", (chunk) => stderr.push(chunk));
+    const finished = new Promise((resolve, reject) => {
+        child.once("error", reject);
+        child.once("close", () => resolve());
+    });
+    child.stdin.end(JSON.stringify({ ...job, anchor, segments }));
+    await finished;
+    const text = Buffer.concat(stdout).toString("utf8").trim();
+    let outcome;
+    try {
+        outcome = text.length > 0 ? JSON.parse(text) : undefined;
+    }
+    catch {
+        outcome = undefined;
+    }
+    if (!outcome) {
+        const detail = Buffer.concat(stderr).toString("utf8").trim() || text || "no output";
+        throw new Error(`Bridge record write helper failed: ${detail}`);
+    }
+    if (!outcome.ok) {
+        const error = new Error(outcome.error);
+        if (outcome.code)
+            error.code = outcome.code;
+        throw error;
+    }
+    return outcome;
+}
 function directoryFdPathBase() {
     if (storeTestHooks.disableDirectoryFdPaths)
         return undefined;
-    if (existsSync("/proc/self/fd"))
-        return "/proc/self/fd";
-    if (existsSync("/dev/fd"))
-        return "/dev/fd";
-    return undefined;
+    directoryFdBaseProbe ??= { base: probeDirectoryFdBase() };
+    return directoryFdBaseProbe.base;
 }
 function assertBridgeRecordId(kind, id) {
     if (!isBridgeRecordId(kind, id)) {

package/package.json

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