pi-oracle 0.6.10 → 0.6.12

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 ## Unreleased
 
+## 0.6.12 - 2026-05-01
+
+### Changed
+- updated the local pi development baseline to `@mariozechner/pi-coding-agent` `0.71.1` and refreshed the TypeBox development dependency
+- regenerated the npm lockfile against the current stable dependency graph
+
+### Compatibility
+- reviewed the pi `0.71.1` changelog and confirmed the oracle extension remains compatible with current extension lifecycle, package install/update, and TypeBox 1.x guidance
+
+
+## 0.6.11 - 2026-04-30
+
+### Fixed
+- updated ChatGPT auth/readiness detection and model preset selection for the current ChatGPT UI, including bare effort chips like `Light` and current `Model` controls
+- restored generated artifact capture for ChatGPT's current `Download the file` behavior buttons by associating response-local filenames with generic download controls and following the JSON `download_url` indirection to the final file bytes
+- reduced false-positive artifact reporting from response text labels that look like filenames but do not have a confirmed downloadable control
+
+### Validation
+- verified live `instant`, `thinking_light`, `instant_auto_switch`, `pro_standard`, follow-up, and isolated local-extension oracle runs against the changed ChatGPT UI
+- verified byte-correct generated artifact downloads in both live and isolated local-extension runs
+
 ## 0.6.10 - 2026-04-23
 
 ### Changed

package/extensions/oracle/worker/artifact-heuristics.d.mts

@@ -22,6 +22,7 @@ export interface StructuralArtifactCandidateInput {
   focusableInteractiveCount?: number;
   focusableArtifactLabelCount?: number;
   focusableOtherTextLength?: number;
+  fromResponseTextLabel?: boolean;
 }
 
 export interface StructuralArtifactCandidate {

package/extensions/oracle/worker/artifact-heuristics.mjs

@@ -8,6 +8,7 @@ const FILE_LABEL_PATTERN = new RegExp(FILE_LABEL_PATTERN_SOURCE, "g");
 export const GENERIC_ARTIFACT_LABELS = ["ATTACHED", "DONE"];
 const GENERIC_ARTIFACT_LABEL_SET = new Set(GENERIC_ARTIFACT_LABELS);
 const GENERIC_DOWNLOAD_CONTROL_PATTERN = /(?:^|\b)(?:download|save)(?:\b|$)/i;
+const CODE_MEMBER_CALL_LABEL_PATTERN = /^[A-Za-z_$][\w$]*\.(?:catch|close|filter|join|json|map|match|open|read|slice|split|text|then|trim|write)$/;
 
 export function parseSnapshotEntries(snapshot) {
   return String(snapshot || "")
@@ -47,7 +48,7 @@ export function extractArtifactLabels(value) {
   const labels = [];
   for (const match of String(value || "").matchAll(FILE_LABEL_PATTERN)) {
     const normalized = sanitizeArtifactLabel(match[1] || match[0] || "");
-    if (!normalized || seen.has(normalized)) continue;
+    if (!normalized || CODE_MEMBER_CALL_LABEL_PATTERN.test(normalized) || seen.has(normalized)) continue;
     seen.add(normalized);
     labels.push(normalized);
   }
@@ -118,6 +119,10 @@ export function isStructuralArtifactCandidate(candidate) {
     return true;
   }
 
+  if (candidate?.fromResponseTextLabel === true && hasGenericDownloadControl(candidate?.controlLabel)) {
+    return true;
+  }
+
   return false;
 }
 

package/extensions/oracle/worker/auth-flow-helpers.mjs

@@ -4,6 +4,8 @@
 // Usage: Imported by auth-bootstrap.mjs and sanity tests to exercise auth classification behavior without driving a browser.
 // Invariants/Assumptions: Inputs are already captured snapshots/probe results from the live browser session; outputs are deterministic and side-effect free.
 
+import { snapshotHasUsableComposerControls } from "./chatgpt-ui-helpers.mjs";
+
 /** @typedef {import("./auth-flow-helpers.d.mts").OracleAuthLoginProbe} OracleAuthLoginProbe */
 /** @typedef {import("./auth-flow-helpers.d.mts").OracleAuthPageClassification} OracleAuthPageClassification */
 
@@ -67,9 +69,9 @@ export function classifyChatAuthPage(args) {
   const onAllowedOrigin = args.allowedOrigins.some((origin) => args.url.startsWith(origin));
   const hasComposer = args.snapshot.includes(`textbox "${composerLabel}"`);
   const hasAddFiles = args.snapshot.includes(`button "${addFilesLabel}"`);
-  const hasModelControl =
-    args.snapshot.includes('button "Model selector"') ||
-    /button "(?:Instant|(?:(?:Light|Standard|Extended|Heavy) )?Thinking|(?:(?:Light|Standard|Extended|Heavy) )?Pro)(?:, click to remove)?"/i.test(args.snapshot);
+  const hasUsableComposer = composerLabel === DEFAULT_COMPOSER_LABEL && addFilesLabel === DEFAULT_ADD_FILES_LABEL
+    ? snapshotHasUsableComposerControls(args.snapshot)
+    : hasComposer && hasAddFiles;
 
   const challengePatterns = [
     /just a moment/i,
@@ -107,7 +109,7 @@ export function classifyChatAuthPage(args) {
     return { state: "transient_outage_error", message: `ChatGPT is showing a transient outage/error page. Logs: ${args.logPath}` };
   }
 
-  if (args.probe?.status === 401 || args.probe?.status === 403) {
+  if (args.probe?.status === 401 || (args.probe?.status === 403 && (!onAllowedOrigin || !hasUsableComposer || args.probe?.domLoginCta))) {
     return {
       state: "login_required",
       message:
@@ -133,7 +135,7 @@ export function classifyChatAuthPage(args) {
     };
   }
 
-  if (onAllowedOrigin && args.probe?.status === 200 && hasComposer && hasAddFiles && hasModelControl) {
+  if (onAllowedOrigin && (args.probe?.status === 200 || args.probe?.status === 403) && hasUsableComposer) {
     if (!args.probe?.domLoginCta) {
       return {
         state: "authenticated_and_ready",
@@ -150,7 +152,7 @@ export function classifyChatAuthPage(args) {
     };
   }
 
-  if (onAllowedOrigin && args.probe?.ok && hasComposer && hasAddFiles && hasModelControl) {
+  if (onAllowedOrigin && args.probe?.ok && hasUsableComposer) {
     return {
       state: "authenticated_and_ready",
       message: `Imported ChatGPT auth from ${args.cookieSourceLabel} into the isolated oracle profile. Logs: ${args.logPath}`,

package/extensions/oracle/worker/chatgpt-ui-helpers.d.mts

@@ -15,6 +15,8 @@ export declare function requestedEffortLabel(selection: OracleUiSelection): stri
 export declare function effortSelectionVisible(snapshot: string, effortLabel: string | undefined): boolean;
 export declare function thinkingChipVisible(snapshot: string): boolean;
 export declare function snapshotHasModelConfigurationUi(snapshot: string): boolean;
+export declare function snapshotHasUsableComposerControls(snapshot: string): boolean;
+export declare function snapshotHasModelOpener(snapshot: string): boolean;
 export declare function autoSwitchToThinkingSelectionVisible(snapshot: string): boolean | undefined;
 export declare function snapshotCanSafelySkipModelConfiguration(snapshot: string, selection: OracleUiSelection): boolean;
 export declare function snapshotStronglyMatchesRequestedModel(snapshot: string, selection: OracleUiSelection): boolean;

package/extensions/oracle/worker/chatgpt-ui-helpers.mjs

@@ -28,6 +28,8 @@ const MODEL_FAMILY_PREFIX = {
 const AUTO_SWITCH_LABEL = "Auto-switch to Thinking";
 const THINKING_EFFORT_COMBOBOX_LABEL = "Thinking effort";
 const PRO_THINKING_EFFORT_COMBOBOX_LABEL = "Pro thinking effort";
+const EFFORT_LABELS = new Set(["Light", "Standard", "Extended", "Heavy"]);
+const BARE_EFFORT_PATTERN = /^(light|standard|extended|heavy)(?:, click to remove)?$/i;
 const THINKING_CHIP_PATTERN = /^(?:(light|standard|extended|heavy)\s+)?thinking(?:, click to remove)?$/i;
 const PRO_CHIP_PATTERN = /^(?:(light|standard|extended|heavy)\s+)?pro(?:, click to remove)?$/i;
 const MODEL_FAMILY_CONTROL_KINDS = new Set(["button", "radio", "menuitemradio"]);
@@ -115,6 +117,14 @@ function parseComposerChipSelection(label) {
   const normalized = normalizeChipLabel(label).toLowerCase();
   if (!normalized) return undefined;
 
+  const bareEffortMatch = normalized.match(BARE_EFFORT_PATTERN);
+  if (bareEffortMatch) {
+    return {
+      modelFamily: /** @type {OracleUiModelFamily} */ ("thinking"),
+      effort: /** @type {import("./chatgpt-ui-helpers.d.mts").OracleUiEffort} */ (bareEffortMatch[1].toLowerCase()),
+    };
+  }
+
   const thinkingMatch = normalized.match(THINKING_CHIP_PATTERN);
   if (thinkingMatch) {
     return {
@@ -158,6 +168,11 @@ function detectSelectedModelFamily(entries) {
     }
   }
 
+  const hasLatestModelCombobox = entries.some(
+    (entry) => !entry.disabled && entry.kind === "combobox" && normalizeText(entry.label).toLowerCase() === "model" && /^latest\b/i.test(normalizeText(entry.value)),
+  );
+  if (hasLatestModelCombobox) return undefined;
+
   const hasProEffortCombobox = entries.some(
     (entry) => !entry.disabled && entry.kind === "combobox" && normalizeText(entry.label).toLowerCase() === PRO_THINKING_EFFORT_COMBOBOX_LABEL.toLowerCase(),
   );
@@ -227,11 +242,42 @@ export function snapshotHasModelConfigurationUi(snapshot) {
   );
   const hasCloseButton = entries.some((entry) => entry.kind === "button" && entry.label === "Close" && !entry.disabled);
   const hasEffortCombobox = entries.some(
-    (entry) => entry.kind === "combobox" && ["Light", "Standard", "Extended", "Heavy"].includes(entry.value || "") && !entry.disabled,
+    (entry) => entry.kind === "combobox" && EFFORT_LABELS.has(entry.value || "") && !entry.disabled,
   );
   return visibleFamilies.size >= 2 || hasCloseButton || hasEffortCombobox;
 }
 
+/**
+ * @param {string} snapshot
+ * @returns {boolean}
+ */
+export function snapshotHasUsableComposerControls(snapshot) {
+  /** @type {SnapshotEntry[]} */
+  const entries = parseSnapshotEntries(snapshot);
+  const hasComposer = entries.some((entry) => entry.kind === "textbox" && entry.label === "Chat with ChatGPT" && !entry.disabled);
+  const hasAddFiles = entries.some((entry) => entry.kind === "button" && entry.label === "Add files and more" && !entry.disabled);
+  return hasComposer && hasAddFiles;
+}
+
+/**
+ * @param {string} snapshot
+ * @returns {boolean}
+ */
+export function snapshotHasModelOpener(snapshot) {
+  /** @type {SnapshotEntry[]} */
+  const entries = parseSnapshotEntries(snapshot);
+  return entries.some((entry) => {
+    if (entry.disabled || entry.kind !== "button" || typeof entry.label !== "string") return false;
+    const label = normalizeChipLabel(entry.label);
+    return label === "Model"
+      || label === "Model selector"
+      || EFFORT_LABELS.has(label)
+      || ["instant", "thinking", "pro"].some((family) => matchesModelFamilyLabel(label, /** @type {OracleUiModelFamily} */ (family)))
+      || THINKING_CHIP_PATTERN.test(label)
+      || PRO_CHIP_PATTERN.test(label);
+  });
+}
+
 /**
  * @param {string} snapshot
  * @returns {boolean | undefined}

package/extensions/oracle/worker/run-job.mjs

@@ -28,6 +28,7 @@ import {
   effortSelectionVisible,
   snapshotCanSafelySkipModelConfiguration,
   snapshotHasModelConfigurationUi,
+  snapshotHasUsableComposerControls,
   snapshotStronglyMatchesRequestedModel,
   snapshotWeaklyMatchesRequestedModel,
   autoSwitchToThinkingSelectionVisible,
@@ -257,8 +258,18 @@ async function cloneSeedProfileToRuntime(job) {
   await withLock(ORACLE_STATE_DIR, "auth", "global", { jobId: job.id, processPid: process.pid, action: "cloneSeedProfile" }, async () => {
     await rm(job.runtimeProfileDir, { recursive: true, force: true }).catch(() => undefined);
     await ensurePrivateDir(dirname(job.runtimeProfileDir));
-    const cloneArgs = job.config.browser.cloneStrategy === "apfs-clone" ? ["-cR", seedDir, job.runtimeProfileDir] : ["-R", seedDir, job.runtimeProfileDir];
-    await spawnCommand("cp", cloneArgs, { timeoutMs: PROFILE_CLONE_TIMEOUT_MS });
+    if (job.config.browser.cloneStrategy === "apfs-clone") {
+      try {
+        await spawnCommand("/bin/cp", ["-cR", seedDir, job.runtimeProfileDir], { timeoutMs: PROFILE_CLONE_TIMEOUT_MS });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        await log(`APFS clone copy failed; falling back to recursive copy: ${message}`);
+        await rm(job.runtimeProfileDir, { recursive: true, force: true }).catch(() => undefined);
+        await spawnCommand("/bin/cp", ["-R", seedDir, job.runtimeProfileDir], { timeoutMs: PROFILE_CLONE_TIMEOUT_MS });
+      }
+    } else {
+      await spawnCommand("/bin/cp", ["-R", seedDir, job.runtimeProfileDir], { timeoutMs: PROFILE_CLONE_TIMEOUT_MS });
+    }
   }, 10 * 60 * 1000);
 
   return seedGeneration;
@@ -686,7 +697,9 @@ function matchesModelFamilyControl(candidate, family) {
 function matchesModelConfigurationOpener(candidate) {
   if (candidate.kind !== "button" || typeof candidate.label !== "string" || candidate.disabled) return false;
   const label = String(candidate.label || "");
-  return candidate.label === "Model selector"
+  return candidate.label === "Model"
+    || candidate.label === "Model selector"
+    || /^(?:Light|Standard|Extended|Heavy)(?:, click to remove)?$/i.test(label)
     || ["instant", "thinking", "pro"].some((family) => matchesModelFamilyLabel(label, /** @type {import("./chatgpt-ui-helpers.d.mts").OracleUiModelFamily} */ (family)))
     || /^(?:(?:Light|Standard|Extended|Heavy) )?Thinking(?:, click to remove)?$/i.test(label)
     || /^(?:(?:Light|Standard|Extended|Heavy) )?Pro(?:, click to remove)?$/i.test(label);
@@ -787,11 +800,9 @@ function classifyChatPage({ job, url, snapshot, body, probe }) {
   const allowedOrigins = buildAllowedChatGptOrigins(job.config.browser.chatUrl, job.config.browser.authUrl);
   const onAllowedOrigin = typeof url === "string" && allowedOrigins.some((origin) => url.startsWith(origin));
   const onAuthPath = typeof url === "string" && url.includes("/auth/");
-  const hasComposer = snapshot.includes(`textbox "${CHATGPT_LABELS.composer}"`);
-  const hasAddFiles = snapshot.includes(`button "${CHATGPT_LABELS.addFiles}"`);
-  const hasModelControl = snapshot.includes('button "Model selector"') || /button "(?:Instant|(?:(?:Light|Standard|Extended|Heavy) )?Thinking|(?:(?:Light|Standard|Extended|Heavy) )?Pro)(?:, click to remove)?"/i.test(snapshot);
+  const hasUsableComposer = snapshotHasUsableComposerControls(snapshot);
 
-  if (probe?.status === 401 || probe?.status === 403) {
+  if (probe?.status === 401 || (probe?.status === 403 && (!onAllowedOrigin || !hasUsableComposer || probe?.domLoginCta))) {
     return { state: "login_required", message: "ChatGPT login is required. Run /oracle-auth." };
   }
 
@@ -805,7 +816,7 @@ function classifyChatPage({ job, url, snapshot, body, probe }) {
     return { state: "login_required", message: "ChatGPT login is required. Run /oracle-auth." };
   }
 
-  if (onAllowedOrigin && probe?.status === 200 && hasComposer && hasAddFiles && hasModelControl) {
+  if (onAllowedOrigin && (probe?.status === 200 || probe?.status === 403) && hasUsableComposer) {
     if (probe?.domLoginCta && (probe?.bodyHasId || probe?.bodyHasEmail)) {
       return {
         state: "auth_transitioning",
@@ -1314,10 +1325,125 @@ function preferredArtifactName(label, index) {
   return `artifact-${String(index + 1).padStart(2, "0")}`;
 }
 
+async function downloadArtifactViaBrowserEval(job, selector, destinationPath) {
+  const result = await evalPage(job, toAsyncJsonScript(`
+    const selector = ${JSON.stringify(selector)};
+    const maxBytes = 25 * 1024 * 1024;
+    const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+    const element = document.querySelector(selector);
+    if (!element) return { ok: false, error: 'artifact selector not found' };
+
+    const urls = [];
+    const captures = [];
+    const originalOpen = window.open;
+    const originalFetch = window.fetch?.bind(window);
+    const originalAnchorClick = HTMLAnchorElement.prototype.click;
+
+    const arrayBufferToBase64 = (buffer) => {
+      const bytes = new Uint8Array(buffer);
+      let binary = '';
+      const chunkSize = 0x8000;
+      for (let index = 0; index < bytes.length; index += chunkSize) {
+        binary += String.fromCharCode(...bytes.subarray(index, index + chunkSize));
+      }
+      return btoa(binary);
+    };
+
+    const shouldCapture = (url, headers) => {
+      const contentDisposition = headers?.get?.('content-disposition') || '';
+      const contentType = headers?.get?.('content-type') || '';
+      const signal = [url, contentDisposition, contentType].join(' ').toLowerCase();
+      return /download|files|oaiusercontent|attachment/i.test(signal) || signal.includes('estuary/content');
+    };
+
+    const captureResponse = async (response, source) => {
+      if (!response || captures.length > 0 || !shouldCapture(response.url || '', response.headers)) return;
+      const contentLength = Number(response.headers.get('content-length') || 0);
+      if (contentLength > maxBytes) {
+        captures.push({ ok: false, error: 'artifact response too large for browser-eval fallback', url: response.url || '', source });
+        return;
+      }
+      const clone = response.clone();
+      const buffer = await clone.arrayBuffer();
+      if (buffer.byteLength > maxBytes) {
+        captures.push({ ok: false, error: 'artifact response too large for browser-eval fallback', url: response.url || '', source });
+        return;
+      }
+      const contentType = response.headers.get('content-type') || '';
+      if (contentType.toLowerCase().includes('application/json') && originalFetch) {
+        try {
+          const text = new TextDecoder().decode(buffer);
+          const payload = JSON.parse(text);
+          const downloadUrl = typeof payload?.download_url === 'string' ? payload.download_url : undefined;
+          if (downloadUrl) {
+            const fileResponse = await originalFetch(downloadUrl, { credentials: 'include' });
+            await captureResponse(fileResponse, 'download_url');
+            if (captures.length > 0) return;
+          }
+        } catch (_error) {
+          // Fall through and preserve the JSON payload as last-resort evidence.
+        }
+      }
+      captures.push({
+        ok: true,
+        url: response.url || '',
+        source,
+        contentType,
+        contentDisposition: response.headers.get('content-disposition') || '',
+        bytesBase64: arrayBufferToBase64(buffer),
+      });
+    };
+
+    try {
+      window.open = (url, ...args) => {
+        if (url) urls.push(String(url));
+        return originalOpen.call(window, url, ...args);
+      };
+      HTMLAnchorElement.prototype.click = function patchedAnchorClick() {
+        if (this.href) urls.push(this.href);
+        return originalAnchorClick.call(this);
+      };
+      if (originalFetch) {
+        window.fetch = async (...args) => {
+          const response = await originalFetch(...args);
+          const requestUrl = String(args[0]?.url || args[0] || response?.url || '');
+          if (shouldCapture(requestUrl, response?.headers) || shouldCapture(response?.url || '', response?.headers)) {
+            await captureResponse(response, 'fetch');
+          }
+          return response;
+        };
+      }
+
+      element.click();
+      await sleep(3000);
+      for (const url of urls) {
+        if (captures.length > 0 || !url || !originalFetch) continue;
+        try {
+          const response = await originalFetch(url, { credentials: 'include' });
+          await captureResponse(response, 'url');
+        } catch (_error) {
+          // Keep trying any other captured URLs.
+        }
+      }
+      return captures[0] || { ok: false, error: 'click did not expose a downloadable artifact response', urls };
+    } finally {
+      window.open = originalOpen;
+      HTMLAnchorElement.prototype.click = originalAnchorClick;
+      if (originalFetch) window.fetch = originalFetch;
+    }
+  `));
+
+  if (!result?.ok || typeof result.bytesBase64 !== "string") {
+    throw new Error(result?.error || "browser-eval artifact fallback did not capture a file");
+  }
+
+  await writeFile(destinationPath, Buffer.from(result.bytesBase64, "base64"), { mode: 0o600 });
+  return result;
+}
+
 async function collectArtifactCandidates(job, responseIndex, responseText = "") {
   const snapshot = await snapshotText(job);
-  const targetSlice = assistantSnapshotSlice(snapshot, CHATGPT_LABELS.composer, responseIndex);
-  if (!targetSlice) return { snapshot, targetSlice, candidates: [], suspiciousLabels: [] };
+  const targetSlice = assistantSnapshotSlice(snapshot, CHATGPT_LABELS.composer, responseIndex) || snapshot;
 
   const structural = await evalPage(
     job,
@@ -1355,7 +1481,7 @@ async function collectArtifactCandidates(job, responseIndex, responseText = "")
       const isDownloadControl = (value) => downloadControlPattern.test(normalize(value));
       const headings = Array.from(document.querySelectorAll('h1,h2,h3,h4,h5,h6,[role="heading"]'))
         .filter((el) => normalize(el.textContent) === 'ChatGPT said:');
-      const host = headings[${responseIndex}]?.nextElementSibling;
+      const host = headings[${responseIndex}]?.nextElementSibling || document.querySelector('main') || document.body;
       if (!host) return { candidates: [] };
 
       const interactiveElements = (node) => node ? Array.from(node.querySelectorAll('button, a')) : [];
@@ -1380,6 +1506,7 @@ async function collectArtifactCandidates(job, responseIndex, responseText = "")
         return undefined;
       };
 
+      const responseTextArtifactLabels = ${JSON.stringify(extractArtifactLabels(responseText))};
       const candidates = interactiveElements(host)
         .map((button, index) => {
           const controlLabel = normalize(button.textContent || button.getAttribute('aria-label') || button.getAttribute('title'));
@@ -1390,7 +1517,13 @@ async function collectArtifactCandidates(job, responseIndex, responseText = "")
           const paragraphArtifactLabels = artifactLabelsForNode(paragraph);
           const listItemArtifactLabels = artifactLabelsForNode(listItem);
           const focusableArtifactLabels = artifactLabelsForNode(focusable);
-          const label = uniqueLabel(ownArtifactLabels, listItemArtifactLabels, paragraphArtifactLabels, focusableArtifactLabels);
+          const label = uniqueLabel(
+            ownArtifactLabels,
+            listItemArtifactLabels,
+            paragraphArtifactLabels,
+            focusableArtifactLabels,
+            isDownloadControl(controlLabel) && responseTextArtifactLabels.length > 0 ? [responseTextArtifactLabels.at(-1)] : [],
+          );
           if (!label && !isFileLabel(controlLabel) && !isDownloadControl(controlLabel)) return null;
           if (!label) return null;
           const marker = artifactPrefix + index;
@@ -1409,6 +1542,7 @@ async function collectArtifactCandidates(job, responseIndex, responseText = "")
             focusableInteractiveCount: interactiveElements(focusable).length,
             focusableArtifactLabelCount: Array.from(new Set(focusableArtifactLabels)).length,
             focusableOtherTextLength: otherTextLength(focusable?.textContent, [...focusableArtifactLabels, ...interactiveLabels(focusable)]),
+            fromResponseTextLabel: responseTextArtifactLabels.includes(label),
           };
         })
         .filter(Boolean);
@@ -1510,12 +1644,6 @@ async function downloadArtifacts(job, responseIndex, responseText = "") {
   }
 
   let { targetSlice, candidates, suspiciousLabels } = await reopenConversationForArtifacts(job, responseIndex, responseText, "initial");
-  if (!targetSlice) {
-    await log(`No assistant response found in snapshot for response index ${responseIndex}`);
-    await secureWriteText(`${jobDir}/artifacts.json`, "[]\n");
-    await mutateJob((current) => ({ ...current, artifactPaths: [] }));
-    return [];
-  }
 
   await log(`Artifact candidates: ${candidates.map((candidate) => candidate.label).join(", ") || "(none)"}`);
   if (suspiciousLabels.length > 0) {
@@ -1542,11 +1670,17 @@ async function downloadArtifacts(job, responseIndex, responseText = "") {
       await rm(destinationPath, { force: true }).catch(() => undefined);
       try {
         await log(`Artifact "${originalCandidate.label}" download attempt ${attempt}/${ARTIFACT_DOWNLOAD_MAX_ATTEMPTS} using selector ${activeCandidate.selector}`);
-        await withHeartbeatWhile(() =>
-          agentBrowser(job, "download", activeCandidate.selector, destinationPath, {
-            timeoutMs: ARTIFACT_DOWNLOAD_TIMEOUT_MS,
-          }),
-        );
+        try {
+          const fallback = await downloadArtifactViaBrowserEval(job, activeCandidate.selector, destinationPath);
+          await log(`Artifact "${originalCandidate.label}" captured via browser-eval fallback (${fallback.source || "unknown"}${fallback.contentType ? `, ${fallback.contentType}` : ""})`);
+        } catch (fallbackError) {
+          await log(`Artifact "${originalCandidate.label}" browser-eval fallback did not capture file: ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}`);
+          await withHeartbeatWhile(() =>
+            agentBrowser(job, "download", activeCandidate.selector, destinationPath, {
+              timeoutMs: ARTIFACT_DOWNLOAD_TIMEOUT_MS,
+            }),
+          );
+        }
         await heartbeat(undefined, { force: true });
         await chmod(destinationPath, 0o600).catch(() => undefined);
         const [size, checksum, detectedType] = await Promise.all([
@@ -1584,7 +1718,8 @@ async function downloadArtifacts(job, responseIndex, responseText = "") {
   }
 
   const capturedArtifactLabels = new Set(artifacts.map((artifact) => artifact.displayName).filter(Boolean));
-  const missedArtifactLabels = suspiciousLabels.filter((label) => !capturedArtifactLabels.has(label));
+  const capturedArtifactKeys = new Set([...capturedArtifactLabels].map((label) => String(label).replace(/\s+/g, "")));
+  const missedArtifactLabels = suspiciousLabels.filter((label) => !capturedArtifactLabels.has(label) && !capturedArtifactKeys.has(String(label).replace(/\s+/g, "")));
   if (missedArtifactLabels.length > 0) {
     await log(`Marking missed artifact signals as unconfirmed: ${missedArtifactLabels.join(", ")}`);
     for (const label of missedArtifactLabels) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-oracle",
-  "version": "0.6.10",
+  "version": "0.6.12",
   "description": "ChatGPT web-oracle extension for pi with isolated browser auth, async jobs, and project-context archives.",
   "private": false,
   "license": "MIT",
@@ -62,11 +62,11 @@
     "protobufjs": "7.5.5"
   },
   "devDependencies": {
-    "@mariozechner/pi-coding-agent": "^0.70.0",
+    "@mariozechner/pi-coding-agent": "^0.71.1",
     "@types/node": "^25.6.0",
     "esbuild": "^0.28.0",
     "tsx": "^4.21.0",
-    "typebox": "^1.1.33",
+    "typebox": "^1.1.37",
     "typescript": "^6.0.3"
   },
   "engines": {