codex-chatgpt-control 0.5.1-alpha.2 → 0.5.1-alpha.3

package/dist/src/commands/project-sources.js

@@ -3,9 +3,17 @@ import { resultError, resultOk } from "../errors.js";
 import { contextFromPage } from "./context.js";
 import { preflightFiles } from "./files.js";
 import { bootstrap } from "./session.js";
+import { coordinatedEventRegistrationBarrier } from "../runtime/coordinated-page.js";
 const CHATGPT_ORIGIN = "https://chatgpt.com";
 const DEFAULT_PROJECT_SOURCE_BATCH_SIZE = 10;
 const PROJECT_SOURCE_CANDIDATE_LIMIT = 20;
+// The chooser transition is a short UI handoff. It must not inherit the much
+// longer file-handoff/refresh timeout: doing so can leave a rejected browser
+// event pending for minutes and can make us try a second UI path after an
+// ambiguous first action. The public timeout can shorten this budget, but
+// never extend it.
+const PROJECT_SOURCE_CHOOSER_TRANSITION_TIMEOUT_MS = 2500;
+const PROJECT_SOURCE_CHOOSER_POLL_INTERVAL_MS = 25;
 export function normalizeProjectSourcesUrl(value) {
     let parsed;
     try {
@@ -415,16 +423,97 @@ async function uploadProjectSourceBatch(page, batch, timeoutMs) {
         if (typeof page.waitForEvent !== "function") {
             throw new Error("The active Project Sources page does not expose file chooser events.");
         }
-        let chooserPromise = waitForFileChooser(page, timeoutMs);
-        await clickProjectSourceControl(page, localeLabels.projectSourcesAddSource, "button", timeoutMs);
-        const opened = await raceFileChooserOpen(chooserPromise, page, 300);
-        if (!opened) {
-            chooserPromise = waitForFileChooser(page, timeoutMs);
-            await clickProjectSourceControl(page, localeLabels.projectSourcesUploadFiles, "button", timeoutMs);
+        const chooserTransitionTimeoutMs = Math.min(timeoutMs, PROJECT_SOURCE_CHOOSER_TRANSITION_TIMEOUT_MS);
+        const chooserDeadline = Date.now() + chooserTransitionTimeoutMs;
+        // Validate the first visible mutation before subscribing to the chooser.
+        // A missing or ambiguous control must not leave a 2.5s bridge waiter alive.
+        const addSource = await waitForUniqueVisibleProjectSourceControl(page, localeLabels.projectSourcesAddSource, "button", chooserDeadline);
+        if (addSource.kind !== "ready") {
+            throw new Error(projectSourceControlDiscoveryMessage(addSource, "button", localeLabels.projectSourcesAddSource));
         }
-        const chooser = await chooserPromise;
-        await chooser.setFiles(paths);
-        return resultOk({ files: batch.files.map(file => ({ name: file.name, bytes: file.bytes })) }, await contextFromPage(page));
+        const remainingChooserTimeoutMs = chooserDeadline - Date.now();
+        if (remainingChooserTimeoutMs <= 0) {
+            throw new Error("Project Sources Add source control was not ready before the chooser transition deadline.");
+        }
+        // Start exactly one handled waiter synchronously immediately before the
+        // first visible mutation. The listener is therefore installed before the
+        // click can deliver a chooser event, while synchronous bridge throws are
+        // converted into an already-handled terminal outcome.
+        const chooserWait = startFileChooserWait(page, remainingChooserTimeoutMs);
+        // Fence coordinated provider registration and drain already-scheduled
+        // settlement before crossing the first visible mutation boundary.
+        const beforeAddOutcome = await settleChooserBeforeMutation(chooserWait, chooserDeadline);
+        if (beforeAddOutcome !== undefined) {
+            throw chooserOutcomeError(beforeAddOutcome, undefined, "Add source");
+        }
+        let addSourceError;
+        try {
+            await clickProjectSourceControlLocator(page, addSource.locator, chooserDeadline);
+        }
+        catch (error) {
+            addSourceError = error;
+        }
+        // A click can deliver the browser gesture and still reject at the bridge
+        // boundary. Reconcile a late chooser success instead of issuing a second
+        // Add/Upload action. A rejection is returned deterministically as the
+        // chooser outcome, with the click failure retained as context.
+        if (addSourceError !== undefined) {
+            const outcome = await awaitFileChooserOutcome(chooserWait, chooserDeadline);
+            if (outcome.kind === "success") {
+                await setProjectSourceChooserFiles(outcome.chooser, paths, timeoutMs);
+                return resultOk({ files: batch.files.map(file => ({ name: file.name, bytes: file.bytes })) }, await contextFromPage(page));
+            }
+            throw chooserOutcomeError(outcome, addSourceError, "Add source");
+        }
+        // Let a chooser event delivered during the Add click finish its handled
+        // microtask before deciding whether the optional menu path is necessary.
+        await Promise.resolve();
+        const afterAddOutcome = chooserWait.outcome;
+        if (afterAddOutcome?.kind === "success") {
+            await setProjectSourceChooserFiles(afterAddOutcome.chooser, paths, timeoutMs);
+            return resultOk({ files: batch.files.map(file => ({ name: file.name, bytes: file.bytes })) }, await contextFromPage(page));
+        }
+        if (afterAddOutcome?.kind === "rejected") {
+            throw chooserOutcomeError(afterAddOutcome, undefined, "Add source");
+        }
+        const uploadControl = await waitForChooserOrUploadControl(page, localeLabels.projectSourcesUploadFiles, "button", chooserWait, chooserDeadline);
+        if (uploadControl.kind === "chooser") {
+            if (uploadControl.outcome.kind === "success") {
+                await setProjectSourceChooserFiles(uploadControl.outcome.chooser, paths, timeoutMs);
+                return resultOk({ files: batch.files.map(file => ({ name: file.name, bytes: file.bytes })) }, await contextFromPage(page));
+            }
+            throw chooserOutcomeError(uploadControl.outcome, undefined, "Add source");
+        }
+        if (uploadControl.kind !== "ready") {
+            throw new Error(uploadControl.kind === "timeout"
+                ? uploadControl.message
+                : projectSourceControlDiscoveryMessage(uploadControl, "button", localeLabels.projectSourcesUploadFiles));
+        }
+        // Final settled-outcome gate: discovery may have yielded while the
+        // chooser promise settled. Do not click Upload when the original waiter
+        // has already produced either terminal outcome.
+        await Promise.resolve();
+        const settledBeforeUpload = chooserWait.outcome;
+        if (settledBeforeUpload?.kind === "success") {
+            await setProjectSourceChooserFiles(settledBeforeUpload.chooser, paths, timeoutMs);
+            return resultOk({ files: batch.files.map(file => ({ name: file.name, bytes: file.bytes })) }, await contextFromPage(page));
+        }
+        if (settledBeforeUpload?.kind === "rejected") {
+            throw chooserOutcomeError(settledBeforeUpload, undefined, "Add source");
+        }
+        let uploadError;
+        try {
+            await clickProjectSourceControlLocator(page, uploadControl.locator, chooserDeadline);
+        }
+        catch (error) {
+            uploadError = error;
+        }
+        const outcome = await awaitFileChooserOutcome(chooserWait, chooserDeadline);
+        if (outcome.kind === "success") {
+            await setProjectSourceChooserFiles(outcome.chooser, paths, timeoutMs);
+            return resultOk({ files: batch.files.map(file => ({ name: file.name, bytes: file.bytes })) }, await contextFromPage(page));
+        }
+        throw chooserOutcomeError(outcome, uploadError, "Upload files");
     }
     catch (error) {
         return {
@@ -457,36 +546,241 @@ async function clickSourcesTabIfAvailable(page, timeoutMs) {
     }
 }
 async function clickProjectSourceControl(page, labels, role, timeoutMs) {
-    const locator = page.getByRole?.(role, { name: anyLabelPattern(labels) });
-    if (locator !== undefined && await locatorCount(locator) > 0) {
-        await (locator.first?.() ?? locator).click?.({ timeout: Math.min(timeoutMs, 10000) });
+    const deadline = Date.now() + Math.max(0, timeoutMs);
+    // The Sources tab is a navigation aid, not part of the chooser transition.
+    // Keep its best-effort lookup bounded to one DOM observation so a page that
+    // lacks the tab still reaches the existing selector-drift fallback promptly.
+    const candidate = await discoverUniqueVisibleProjectSourceControl(page, labels, role);
+    if (candidate.kind !== "ready") {
+        throw new Error(projectSourceControlDiscoveryMessage(candidate, role, labels));
+    }
+    await clickProjectSourceControlLocator(page, candidate.locator, deadline);
+    if (role === "tab") {
         await page.waitForTimeout?.(250);
-        return;
     }
-    const selector = labels
-        .map(label => `button[aria-label*='${cssString(label)}'], [role='${role}'][aria-label*='${cssString(label)}']`)
-        .join(", ");
-    const fallback = page.locator?.(selector);
-    if (fallback !== undefined && await locatorCount(fallback) > 0) {
-        await (fallback.first?.() ?? fallback).click?.({ timeout: Math.min(timeoutMs, 10000) });
-        await page.waitForTimeout?.(250);
-        return;
+}
+function startFileChooserWait(page, timeoutMs) {
+    const wait = {
+        promise: Promise.resolve({
+            kind: "rejected",
+            error: new Error("Project Sources file chooser wait was not initialized.")
+        })
+    };
+    let rawWait;
+    try {
+        // Invoke waitForEvent in this call stack. Deferring registration through a
+        // Promise.resolve().then() can let an immediately-triggered Add click race
+        // the listener and lose the chooser event.
+        rawWait = page.waitForEvent?.("filechooser", { timeout: timeoutMs, timeoutMs });
+    }
+    catch (error) {
+        const outcome = { kind: "rejected", error };
+        wait.outcome = outcome;
+        wait.promise = Promise.resolve(outcome);
+        return wait;
+    }
+    const registration = coordinatedEventRegistrationBarrier(rawWait);
+    if (registration !== undefined)
+        wait.registration = registration;
+    wait.promise = Promise.resolve(rawWait).then(rawChooser => {
+        const outcome = isProjectSourceFileChooserLike(rawChooser)
+            ? { kind: "success", chooser: rawChooser }
+            : {
+                kind: "rejected",
+                error: new Error("Project Sources file chooser did not expose setFiles().")
+            };
+        wait.outcome = outcome;
+        return outcome;
+    }, error => {
+        const outcome = { kind: "rejected", error };
+        wait.outcome = outcome;
+        return outcome;
+    });
+    return wait;
+}
+/**
+ * Prove that a coordinated event listener finished registration before a
+ * click. One host turn then drains any outcome that was already scheduled;
+ * such an outcome cannot causally belong to the not-yet-issued click and
+ * therefore blocks the handoff.
+ */
+async function settleChooserBeforeMutation(chooserWait, deadline) {
+    if (chooserWait.outcome !== undefined)
+        return chooserWait.outcome;
+    if (chooserWait.registration !== undefined) {
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0)
+            return { kind: "timeout" };
+        let timer;
+        const registered = await Promise.race([
+            chooserWait.registration.then(() => true),
+            new Promise(resolve => { timer = setTimeout(() => resolve(false), remainingMs); })
+        ]).finally(() => {
+            if (timer !== undefined)
+                clearTimeout(timer);
+        });
+        if (!registered)
+            return { kind: "timeout" };
+    }
+    if (chooserWait.outcome !== undefined)
+        return chooserWait.outcome;
+    if (deadline <= Date.now())
+        return { kind: "timeout" };
+    await new Promise(resolve => setTimeout(resolve, 0));
+    if (chooserWait.outcome !== undefined)
+        return chooserWait.outcome;
+    return deadline <= Date.now() ? { kind: "timeout" } : undefined;
+}
+async function awaitFileChooserOutcome(chooserWait, deadline) {
+    if (chooserWait.outcome !== undefined) {
+        return chooserWait.outcome;
+    }
+    const remainingMs = Math.max(0, deadline - Date.now());
+    if (remainingMs === 0) {
+        return { kind: "timeout" };
+    }
+    return new Promise(resolve => {
+        let finished = false;
+        const finish = (outcome) => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(timer);
+            resolve(outcome);
+        };
+        const timer = setTimeout(() => finish({ kind: "timeout" }), remainingMs);
+        // The chooser promise is always handled and never rejects. The timer is
+        // cleared when the event wins, avoiding a dangling transition timer.
+        void chooserWait.promise.then(outcome => finish(outcome));
+    });
+}
+function projectSourceControlDiscoveryMessage(discovery, role, labels) {
+    if (discovery.kind === "invalid") {
+        return discovery.message;
+    }
+    return `Project Sources ${role} was not uniquely visible for labels: ${labels.join(", ")}`;
+}
+async function waitForUniqueVisibleProjectSourceControl(page, labels, role, deadline) {
+    while (true) {
+        const candidate = await discoverUniqueVisibleProjectSourceControl(page, labels, role);
+        if (candidate.kind !== "absent") {
+            return candidate;
+        }
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0) {
+            return {
+                kind: "invalid",
+                message: `Project Sources ${role} was not uniquely visible before the chooser transition deadline for labels: ${labels.join(", ")}`
+            };
+        }
+        await waitForProjectSourceTransitionTick(page, Math.min(PROJECT_SOURCE_CHOOSER_POLL_INTERVAL_MS, remainingMs));
+    }
+}
+async function discoverUniqueVisibleProjectSourceControl(page, labels, role) {
+    const pattern = anyLabelPattern(labels);
+    const primary = page.getByRole?.(role, { name: pattern });
+    const candidate = primary !== undefined && await locatorCount(primary) > 0
+        ? primary
+        : page.locator?.(labels
+            .map(label => `button[aria-label*='${cssString(label)}'], [role='${role}'][aria-label*='${cssString(label)}']`)
+            .join(", "));
+    if (candidate === undefined) {
+        return { kind: "absent" };
+    }
+    const count = await locatorCount(candidate);
+    if (count === 0) {
+        return { kind: "absent" };
+    }
+    if (count !== 1) {
+        return {
+            kind: "invalid",
+            message: `Project Sources ${role} was not uniquely available for labels: ${labels.join(", ")} (found ${count} controls).`
+        };
+    }
+    if (typeof candidate.isVisible !== "function") {
+        return {
+            kind: "invalid",
+            message: `Project Sources ${role} visibility could not be verified for labels: ${labels.join(", ")}.`
+        };
+    }
+    if (!await candidate.isVisible().catch(() => false)) {
+        return {
+            kind: "invalid",
+            message: `Project Sources ${role} was present but hidden for labels: ${labels.join(", ")}.`
+        };
     }
-    throw new Error(`Project Sources ${role} was not available for labels: ${labels.join(", ")}`);
+    return { kind: "ready", locator: candidate };
 }
-async function waitForFileChooser(page, timeoutMs) {
-    const rawChooser = await page.waitForEvent?.("filechooser", { timeout: timeoutMs, timeoutMs });
-    if (rawChooser === null || typeof rawChooser !== "object" || typeof rawChooser.setFiles !== "function") {
-        throw new Error("Project Sources file chooser did not expose setFiles().");
+async function waitForChooserOrUploadControl(page, labels, role, chooserWait, deadline) {
+    while (true) {
+        if (chooserWait.outcome !== undefined) {
+            return { kind: "chooser", outcome: chooserWait.outcome };
+        }
+        const candidate = await discoverUniqueVisibleProjectSourceControl(page, labels, role);
+        if (candidate.kind !== "absent") {
+            // A chooser rejection may race the final control observation. Prefer the
+            // already-settled browser outcome over reporting stale menu ambiguity.
+            if (chooserWait.outcome !== undefined) {
+                return { kind: "chooser", outcome: chooserWait.outcome };
+            }
+            return candidate;
+        }
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0) {
+            return {
+                kind: "timeout",
+                message: `Project Sources file chooser did not settle and Upload control did not become uniquely visible before the ${PROJECT_SOURCE_CHOOSER_TRANSITION_TIMEOUT_MS}ms chooser transition deadline.`
+            };
+        }
+        await waitForChooserOrTransitionTick(page, chooserWait, Math.min(PROJECT_SOURCE_CHOOSER_POLL_INTERVAL_MS, remainingMs));
     }
-    return rawChooser;
 }
-async function raceFileChooserOpen(chooserPromise, page, waitMs) {
-    return Promise.race([
-        chooserPromise.then(() => true, () => false),
-        (page.waitForTimeout?.(waitMs) ?? new Promise(resolve => setTimeout(resolve, waitMs))).then(() => false)
+async function waitForChooserOrTransitionTick(page, chooserWait, waitMs) {
+    if (chooserWait.outcome !== undefined)
+        return;
+    await Promise.race([
+        chooserWait.promise.then(() => undefined),
+        waitForProjectSourceTransitionTick(page, waitMs)
     ]);
 }
+async function waitForProjectSourceTransitionTick(page, waitMs) {
+    if (typeof page.waitForTimeout === "function") {
+        await page.waitForTimeout(waitMs);
+        return;
+    }
+    await new Promise(resolve => setTimeout(resolve, waitMs));
+}
+async function clickProjectSourceControlLocator(page, locator, deadline) {
+    if (typeof locator.click !== "function") {
+        throw new Error("Project Sources control does not expose click().");
+    }
+    const remainingMs = Math.max(1, deadline - Date.now());
+    await locator.click({ timeout: Math.min(remainingMs, 10_000) });
+}
+async function setProjectSourceChooserFiles(chooser, paths, timeoutMs) {
+    await chooser.setFiles(paths, { timeoutMs });
+}
+function chooserOutcomeError(outcome, clickError, controlLabel) {
+    if (outcome.kind === "rejected") {
+        const chooserMessage = outcome.error instanceof Error ? outcome.error.message : String(outcome.error);
+        const clickMessage = clickError === undefined
+            ? ""
+            : ` ${controlLabel} click also failed: ${clickError instanceof Error ? clickError.message : String(clickError)}`;
+        return new Error(`Project Sources file chooser was rejected: ${chooserMessage}.${clickMessage}`);
+    }
+    if (outcome.kind === "timeout") {
+        const clickMessage = clickError === undefined
+            ? ""
+            : ` ${controlLabel} click failed: ${clickError instanceof Error ? clickError.message : String(clickError)}.`;
+        return new Error(`Project Sources file chooser did not settle before the ${PROJECT_SOURCE_CHOOSER_TRANSITION_TIMEOUT_MS}ms chooser transition deadline.${clickMessage}`);
+    }
+    return new Error(`Project Sources file chooser settled before the ${controlLabel} click; no file handoff was attempted.`);
+}
+function isProjectSourceFileChooserLike(value) {
+    return value !== null
+        && typeof value === "object"
+        && typeof value.setFiles === "function";
+}
 async function locatorCount(locator) {
     if (typeof locator.count !== "function") {
         return 0;

package/dist/src/commands/sequence.js

@@ -1,3 +1,5 @@
+import { resultError } from "../errors.js";
+import { assertOperationAwareDispatchAllowed, CommandRoutingError, classifyCommandRouting, routeCommandRuntimeEnv } from "../runtime/command-routing.js";
 import { downloadLatestArtifact, listLatestArtifacts, waitForArtifact } from "./artifacts.js";
 import { applyConfiguration, inspectConfiguration } from "./configuration.js";
 import { detectExperience, openExperience } from "./experience.js";
@@ -43,71 +45,96 @@ export async function runSequenceWithExecutor(plan, executor, env = {}) {
     return withCommandOutputText({ ...finalResult, steps: stepResults });
 }
 export async function executeStep(step, env, previousResults) {
+    // The sequence executor is a direct dispatch seam as well as a helper for
+    // backend workflows. Keep it fail-closed if a runtime caller supplies a
+    // command outside the explicit inventory. This guard does not acquire a
+    // coordinator: legacy commands retain their existing behavior, while an
+    // operation-aware request may use only an explicitly migrated facade seam.
+    if (classifyCommandRouting(step.command) === undefined) {
+        return resultError(new CommandRoutingError("unclassified_command"));
+    }
+    try {
+        assertOperationAwareDispatchAllowed(step.command, step.args);
+    }
+    catch (error) {
+        return resultError(error instanceof Error ? error : new Error(String(error)));
+    }
+    let routedEnv;
+    try {
+        // Legacy sequence steps receive a fresh coordinated facade. The facade
+        // routes each browser/page method through the process-scoped coordinator;
+        // this function never wraps the complete step, so waits, polling, report
+        // work, and caller callbacks do not retain a tab actor.
+        routedEnv = routeCommandRuntimeEnv(step.command, env);
+    }
+    catch (error) {
+        return resultError(error instanceof Error ? error : new Error(String(error)));
+    }
     switch (step.command) {
         case "session.bootstrap":
-            return bootstrap(env, step.args);
+            return bootstrap(routedEnv, step.args);
         case "experience.detect":
-            return detectExperience(env, step.args);
+            return detectExperience(routedEnv, step.args);
         case "experience.open":
-            return openExperience(env, step.args);
+            return openExperience(routedEnv, step.args);
         case "configuration.inspect":
-            return inspectConfiguration(env, step.args);
+            return inspectConfiguration(routedEnv, step.args);
         case "configuration.apply":
-            return applyConfiguration(env, step.args);
+            return applyConfiguration(routedEnv, step.args);
         case "work.start":
-            return startWork(env, step.args);
+            return startWork(routedEnv, step.args);
         case "work.status":
-            return workStatus(env, step.args);
+            return workStatus(routedEnv, step.args);
         case "work.wait":
-            return waitForWork(env, step.args);
+            return waitForWork(routedEnv, step.args);
         case "work.steer":
-            return steerWork(env, step.args);
+            return steerWork(routedEnv, step.args);
         case "work.readLatest":
-            return readLatestWork(env, step.args);
+            return readLatestWork(routedEnv, step.args);
         case "threads.search":
-            return searchThreads(env, step.args);
+            return searchThreads(routedEnv, step.args);
         case "threads.open":
-            return openThread(env, step.args, previousResults);
+            return openThread(routedEnv, step.args, previousResults);
         case "threads.new":
-            return newThread(env, step.args);
+            return newThread(routedEnv, step.args);
         case "messages.compose":
-            return composeMessage(env, step.args);
+            return composeMessage(routedEnv, step.args);
         case "messages.submit":
-            return submitMessage(env, step.args);
+            return submitMessage(routedEnv, step.args);
         case "messages.ask":
-            return askMessage(env, step.args);
+            return askMessage(routedEnv, step.args);
         case "messages.wait":
-            return waitForMessage(env, step.args);
+            return waitForMessage(routedEnv, step.args);
         case "messages.readLatest":
-            return readLatest(env, step.args);
+            return readLatest(routedEnv, step.args);
         case "messages.status":
-            return messageStatus(env, step.args);
+            return messageStatus(routedEnv, step.args);
         case "messages.stop":
-            return stopGeneration(env, step.args);
+            return stopGeneration(routedEnv, step.args);
         case "messages.waitAndRead":
-            return waitAndRead(env, step.args);
+            return waitAndRead(routedEnv, step.args);
         case "artifacts.listLatest":
-            return listLatestArtifacts(env, step.args);
+            return listLatestArtifacts(routedEnv, step.args);
         case "artifacts.wait":
-            return waitForArtifact(env, step.args);
+            return waitForArtifact(routedEnv, step.args);
         case "artifacts.downloadLatest":
-            return downloadLatestArtifact(env, step.args);
+            return downloadLatestArtifact(routedEnv, step.args);
         case "files.attach":
-            return attachFiles(env, step.args);
+            return attachFiles(routedEnv, step.args);
         case "files.downloadLatest":
-            return downloadLatestFile(env, step.args);
+            return downloadLatestFile(routedEnv, step.args);
         case "projects.sources.list":
-            return listProjectSources(env, step.args);
+            return listProjectSources(routedEnv, step.args);
         case "projects.sources.planAdd":
-            return buildProjectSourceAddPlan(env, step.args);
+            return buildProjectSourceAddPlan(routedEnv, step.args);
         case "projects.sources.add":
-            return addProjectSources(env, step.args);
+            return addProjectSources(routedEnv, step.args);
         case "response.copy":
-            return copyResponse(env, step.args);
+            return copyResponse(routedEnv, step.args);
         case "modes.set":
-            return setMode(env, step.args);
+            return setMode(routedEnv, step.args);
         case "tools.select":
-            return selectTool(env, step.args);
+            return selectTool(routedEnv, step.args);
     }
 }
 export function normalizePolicy(policy) {

package/dist/src/commands/session.js

@@ -1,6 +1,7 @@
 import { attachChatGPTBrowser, isChatGPTUrl, tabIdFromPage } from "../browser/attach.js";
 import { readPageState } from "../browser/page-state.js";
 import { resultError, resultOk } from "../errors.js";
+import { unwrapCoordinatedPage } from "../runtime/coordinated-page.js";
 import { contextFromPage } from "./context.js";
 export async function bootstrap(env, args = {}) {
     try {
@@ -71,7 +72,11 @@ export async function verifyTabAffinity(env) {
     if (env.expectedTabId === undefined || env.page === undefined) {
         return undefined;
     }
-    const actualTabId = tabIdFromPage(env.page);
+    // The coordinated facade intentionally snapshots its public identity when
+    // it is created so its coordinator key cannot drift underneath queued work.
+    // Affinity verification has a different job: it must inspect the provider
+    // page that the facade protects and detect a changed/reused tab claim.
+    const actualTabId = tabIdFromPage(unwrapCoordinatedPage(env.page));
     if (actualTabId === env.expectedTabId) {
         return undefined;
     }
@@ -99,7 +104,7 @@ export async function verifyTabAffinity(env) {
         context: await contextFromPage(env.page, tabContext(env, actualTabId))
     };
 }
-function tabContext(env, actualTabId = tabIdFromPage(env.page)) {
+function tabContext(env, actualTabId = tabIdFromPage(unwrapCoordinatedPage(env.page))) {
     const tabId = actualTabId ?? env.expectedTabId;
     return tabId === undefined ? {} : { tabId };
 }

package/dist/src/commands/work.js

@@ -10,6 +10,9 @@ import { askMessage, composeMessage, messageStatus, readLatest, submitMessage, w
 import { ensurePage } from "./session.js";
 const NEW_WORK_LABELS = localeLabels.newWork;
 export async function startWork(env, args) {
+    if (args.operationId !== undefined) {
+        return transactionalWorkRoutingBlocker(args.operationId, "start");
+    }
     const prompt = args.prompt.trim();
     if (prompt.length === 0) {
         return {
@@ -172,6 +175,9 @@ export async function waitForWork(env, args = {}) {
     return markWorkResult(await waitForMessage(env, args), ready.data?.selectorProfile);
 }
 export async function steerWork(env, args) {
+    if (args.operationId !== undefined || args.handle !== undefined || args.controlActionId !== undefined || args.expectedAssistantTurnId !== undefined) {
+        return transactionalWorkRoutingBlocker(args.operationId ?? args.handle?.operationId, "steer");
+    }
     const ready = await requireWork(env);
     if (!ready.ok)
         return forwardCommandFailure(ready);
@@ -182,6 +188,31 @@ export async function steerWork(env, args) {
         ...(args.timeoutMs === undefined ? {} : { timeoutMs: args.timeoutMs })
     }), ready.data?.selectorProfile);
 }
+function transactionalWorkRoutingBlocker(operationId, action) {
+    const message = `Transactional Work ${action} must be invoked through chatgpt.work.${action}; the low-level command has no operations facade.`;
+    const data = action === "start"
+        ? {
+            task: {},
+            submitted: { submitted: false, submissionState: "not_submitted" },
+            ...(operationId === undefined ? {} : { operationId })
+        }
+        : operationId === undefined ? {} : { operationId };
+    return {
+        ok: false,
+        status: "unsupported",
+        data,
+        warnings: [],
+        error: { name: "OperationRoutingError", message, recoverable: false },
+        blocker: {
+            kind: "unknown",
+            code: "transactional_work_requires_client",
+            fieldPath: action === "start" ? "operationId" : "handle",
+            message,
+            resumable: false
+        },
+        context: { timestamp: new Date().toISOString(), experience: "work" }
+    };
+}
 export async function readLatestWork(env, args = {}) {
     const ready = await requireWork(env);
     if (!ready.ok)

package/dist/src/errors.d.ts

@@ -2,6 +2,15 @@ import type { BlockerKind, CommandContext, CommandResult } from "./types.js";
 type BlockerDetails = Partial<Omit<NonNullable<CommandResult["blocker"]>, "kind" | "message" | "visibleText">>;
 export declare const BROWSER_BRIDGE_UNAVAILABLE_MESSAGE = "Codex cannot access the ChatGPT browser bridge from this backend process. In an ordinary shell this is expected; for a live Codex Chrome run, assign the Chrome plugin runtime returned by setupBrowserRuntime() to globalThis.agent before using it.";
 export declare const BROWSER_BRIDGE_REMEDIATION: NonNullable<NonNullable<CommandResult["blocker"]>["remediation"]>;
+/**
+ * Read a Node-style errno code without relying on realm-sensitive
+ * `instanceof Error` checks or invoking an untrusted accessor.
+ *
+ * Browser-hosted modules can receive filesystem errors created by the host
+ * realm. Those values are genuine Node errno objects but are not necessarily
+ * instances of this bundle's `Error` constructor.
+ */
+export declare function nodeErrorCode(error: unknown): string | undefined;
 export declare class ChatGPTControlError extends Error {
     readonly kind: BlockerKind;
     readonly recoverable: boolean;

package/dist/src/errors.js

@@ -21,6 +21,28 @@ export const BROWSER_BRIDGE_REMEDIATION = [
         userActionRequired: true
     }
 ];
+/**
+ * Read a Node-style errno code without relying on realm-sensitive
+ * `instanceof Error` checks or invoking an untrusted accessor.
+ *
+ * Browser-hosted modules can receive filesystem errors created by the host
+ * realm. Those values are genuine Node errno objects but are not necessarily
+ * instances of this bundle's `Error` constructor.
+ */
+export function nodeErrorCode(error) {
+    if (error === null || (typeof error !== "object" && typeof error !== "function"))
+        return undefined;
+    try {
+        const descriptor = Object.getOwnPropertyDescriptor(error, "code");
+        if (descriptor === undefined || !("value" in descriptor) || typeof descriptor.value !== "string") {
+            return undefined;
+        }
+        return descriptor.value;
+    }
+    catch {
+        return undefined;
+    }
+}
 export class ChatGPTControlError extends Error {
     kind;
     recoverable;