pi-oracle 0.7.22 → 0.7.23

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## Unreleased
+
+## 0.7.23 - 2026-11-02
+
+<!-- npm-release:unreleased:start -->
+### Changed
+- update the `basic-ftp` dependency override to the patched stable release
+- publish versioned npm candidates automatically after reviewed changes merge to `main` and pass Pi compatibility checks
+- support target-specific platform preflight for distributed release checks
+- qualify retained Oracle release candidates across hosted macOS, Ubuntu, and native Windows Crabbox targets before publication
+
+### Fixed
+- recognize ChatGPT's current model selector, send button, and completed response state
+<!-- npm-release:unreleased:end -->
+
+- Automate qualified Oracle releases (3/3) (#72) ([596d8b7](https://github.com/fitchmultz/pi-oracle/commit/596d8b7c2c0591d80bdb1e8c260bc04b3cf16310))
+
+### What's Changed
+* ci: publish npm releases automatically on merge by @fitchmultz in https://github.com/fitchmultz/pi-oracle/pull/64
+* chore(deps): update dependency basic-ftp to v6.2.3 by @renovate[bot] in https://github.com/fitchmultz/pi-oracle/pull/55
+* Restore Oracle ChatGPT flow and prepare release (1/2) by @fitchmultz in https://github.com/fitchmultz/pi-oracle/pull/68
+* Qualify retained candidates on native SSH targets (2/2) by @fitchmultz in https://github.com/fitchmultz/pi-oracle/pull/69
+* Support target-specific platform preflight (1/3) by @fitchmultz in https://github.com/fitchmultz/pi-oracle/pull/70
+* Qualify retained Oracle packages on hosted platforms (2/3) by @fitchmultz in https://github.com/fitchmultz/pi-oracle/pull/71
+* Automate qualified Oracle releases (3/3) by @fitchmultz in https://github.com/fitchmultz/pi-oracle/pull/72
+
+
+**Full Changelog**: https://github.com/fitchmultz/pi-oracle/compare/v0.7.22...v0.7.23
+
 ## 0.7.22 - 2026-10-12
 
 ### Documentation

package/README.md

@@ -6,9 +6,9 @@ pi-oracle sends project files and questions from [Pi](https://github.com/earendi
 
 ## Install
 
-Use Node.js 22.19.0 or newer on macOS, Linux, or Windows native. Use a current Pi release and a Chromium-family browser.
+Use a supported Node.js release on macOS, Linux, or Windows native. Use a current Pi release and a Chromium-family browser.
 
-Install `agent-browser` and `tar`. Install `zstd` for ChatGPT jobs. Check the [platform requirements](docs/reference.md#requirements) for profile copies and encrypted cookies.
+Install `agent-browser` and `tar`. Install `zstd` for ChatGPT jobs. Check the [platform requirements](docs/reference.md#requirements) for the Node.js minimum, profile copies, and encrypted cookies.
 
 Install Oracle:
 

package/docs/development.md

@@ -12,11 +12,11 @@ Production hardening should keep focusing on UI drift detection, auth recovery,
 
 ## Automatic npm releases (maintainers)
 
-Follow the [shared release procedure](https://github.com/fitchmultz/.github#automatic-npm-releases): merge a reviewed PR into `main` with an intentional `package.json` version bump and a matching versioned `CHANGELOG.md` section. Automation never bumps versions, overwrites releases, or republishes an existing version. Once configured and enabled, it runs existing offline compatibility checks, qualifies one candidate tarball, then waits for `fitchmultz` approval in the `npm` environment.
+The [shared release procedure](https://github.com/fitchmultz/.github#automatic-npm-releases) creates a reviewed patch-version PR after changes merge to `main`, then qualifies one retained candidate tarball across compatibility checks and hosted macOS, Ubuntu, and native Windows Crabbox suites before publishing the same version on npm and GitHub.
 
-Approve only after checking the exact source commit, version, downloaded candidate tarball and summary against [the existing `release:check` requirements](#verification) and [packed platform proof](platform-smoke.md). Fresh all-preset ChatGPT proof must match that commit/version, satisfy the proof checker's timing and saved-response requirements, and accompany the required doctor-first macOS/Ubuntu/native-Windows evidence. Old-commit proof is not sufficient. Approval attests genuine satisfaction of these gates; it does not create proof or waive `release:check`. Authenticated and paid checks remain outside CI. Automated publication disables npm hooks to publish the checked bytes; manual `npm publish` still runs its existing `prepublishOnly` gate.
+Before releasing runtime or prompt changes, verify [the `release:check` requirements](#verification) and [packed platform proof](platform-smoke.md). Fresh all-preset ChatGPT proof must match `HEAD` or an ancestor commit whose `extensions/` and `prompts/` trees are byte-identical to `HEAD`, satisfy the proof checker's 72-hour timing and saved-response requirements, and accompany the required doctor-first macOS/Ubuntu/native-Windows evidence. Authenticated and paid checks remain outside CI. Automated publication disables npm hooks to publish the checked bytes; manual `npm publish` still runs its existing `prepublishOnly` gate.
 
-Failed/unpublished candidates can retry daily at 12:17 UTC or via manual dispatch of `npm release` on `main`, without another bump. Set repository variable `NPM_RELEASE_ENABLED` to anything other than `true` to stop new release plans; cancel pending runs separately when needed. Workflow validation is not evidence of a completed real OIDC publication.
+Set repository variable `NPM_RELEASE_ENABLED` to anything other than `true` to stop new version and release plans; cancel pending runs separately when needed. Follow the shared procedure to retry an unpublished candidate. Workflow validation is not evidence of a completed real OIDC publication.
 
 ## Verification
 
@@ -66,7 +66,7 @@ node scripts/oracle-chatgpt-preset-proof.mjs template > .artifacts/chatgpt-prese
 npm run release:proof:chatgpt-presets
 ```
 
-The proof checker is intentionally part of `release:check`; it fails if the proof is missing, stale, tied to a different package version/git head, references jobs that completed before the current commit, or lacks actual persisted ChatGPT `.tar.zst` job state and response text for any canonical preset.
+The proof checker is intentionally part of `release:check`; it fails if the proof is missing, stale, tied to a commit whose `extensions/` or `prompts/` differ from `HEAD`, references jobs that completed before the proven commit, or lacks actual persisted ChatGPT `.tar.zst` job state and response text for any canonical preset.
 
 The real runtime suite defaults to deterministic installed-tool execution so platform proof stays bounded. Provider/model defaults remain `zai/glm-5.2` for doctor/config and for optional model-agent debugging; override with `PI_ORACLE_REAL_TEST_PROVIDER` and `PI_ORACLE_REAL_TEST_MODEL` when needed. For inner-loop source loading only, use `npm run smoke:real:source`; it is not release proof. Set `PI_ORACLE_REAL_TEST_MODEL_AGENT=1` only when debugging the slower model-agent path. The optional second real-agent negative symlink check is opt-in via `PI_ORACLE_REAL_TEST_NEGATIVE_SYMLINK=1`; `npm run sanity:oracle` covers archive/symlink rejection by default without adding another model-agent turn to the platform release gate.
 

package/docs/platform-smoke.md

@@ -29,9 +29,10 @@ crabbox providers
 
 Target setup:
 
-- macOS: Remote Login enabled; noninteractive `ssh $USER@localhost` works; `node`, `npm`, `git`, `tar`, `rsync`, `zstd`, and `agent-browser` are on the SSH PATH.
+- macOS: Remote Login enabled; noninteractive `ssh $USER@localhost` works; `node`, `npm`, `git`, `tar`, `rsync`, `zstd`, and `agent-browser` are on the SSH PATH. Use `PI_ORACLE_SMOKE_MAC_PORT` or `PLATFORM_SMOKE_MAC_PORT` for a non-default SSH port.
 - Ubuntu: Docker is running and the configured image (`PI_ORACLE_SMOKE_UBUNTU_IMAGE`, default `pi-oracle-platform-smoke:node24`) has `node`, `npm`, `git`, `tar`, `rsync`, `zstd`, and `agent-browser` on PATH. Build the local image when needed with `docker build -t pi-oracle-platform-smoke:node24 -f scripts/platform-smoke/Dockerfile.ubuntu .`.
-- Windows native: Parallels has stopped source VM `pi-extension-windows-template` and the configured power-off snapshot (`crabbox-ready` by default for this repo). The template must have OpenSSH, PowerShell, Git, Node/npm, `tar`, `zstd`, and `agent-browser` on PATH. Do not bake API keys, browser sessions, project checkouts, `.pi` state, artifacts, or secrets into the template.
+- Windows native: by default, Parallels has stopped source VM `pi-extension-windows-template` and the configured power-off snapshot (`crabbox-ready` by default for this repo). The template must have OpenSSH, PowerShell, Git, Node/npm, `tar`, `zstd`, and `agent-browser` on PATH. Do not bake API keys, browser sessions, project checkouts, `.pi` state, artifacts, or secrets into the template.
+- Alternatively, set `PI_ORACLE_SMOKE_WINDOWS_HOST` to a native Windows SSH host, and set `PI_ORACLE_SMOKE_WINDOWS_USER`, `PI_ORACLE_SMOKE_WINDOWS_PORT` (default 22), and `PI_ORACLE_SMOKE_WINDOWS_NATIVE_WORK_ROOT` for that target as needed. Crabbox uses its SSH provider instead of Parallels; the target needs the same tools on its SSH PATH. The `PLATFORM_SMOKE_WINDOWS_*` aliases also work.
 
 Real runtime suite auth:
 
@@ -47,7 +48,7 @@ Use the narrowest workflow that proves the change. Do not run the full platform
 | Situation | Canonical command(s) | What it proves |
 | --- | --- | --- |
 | Everyday local iteration | `npm run verify:oracle` | Syntax, bundle, platform-smoke invariants, type checks, oracle sanity, and package dry-run pass locally. |
-| Platform-sensitive change | `npm run smoke:platform:doctor`, then `node scripts/platform-smoke.mjs run --target <target> --suite <suite>` | Target setup is ready and the affected platform/suite works without paying for unrelated targets. |
+| Platform-sensitive change | `node scripts/platform-smoke.mjs doctor --target <target>`, then `node scripts/platform-smoke.mjs run --target <target> --suite <suite>` | Target setup is ready and the affected platform/suite works without paying for unrelated targets. |
 | Platform matrix proof | `npm run smoke:platform:all` | Doctor-first packed-install proof passes on every required target and suite. |
 | ChatGPT preset release proof | `npm run release:proof:chatgpt-presets` | Fresh loaded-extension proof exists for every canonical ChatGPT preset. |
 | Publish/release gate | `npm run release:check` | Local verification (`verify:oracle`) passes, fresh ChatGPT preset proof exists, then the doctor-first platform matrix passes. |
@@ -65,13 +66,19 @@ npm run smoke:platform:all
 Focused commands:
 
 ```bash
-npm run smoke:platform:doctor
+node scripts/platform-smoke.mjs doctor --target macos
 npm run smoke:platform:macos
+node scripts/platform-smoke.mjs doctor --target ubuntu
 npm run smoke:platform:ubuntu
+node scripts/platform-smoke.mjs doctor --target windows-native
 npm run smoke:platform:windows-native
 node scripts/platform-smoke.mjs run --target windows-native --suite real-extension
 ```
 
+`doctor --target` checks the selected targets' providers and tools; without it,
+doctor still checks every required target. In split hosted jobs, run a scoped
+doctor on each target before its suites.
+
 Full release gate:
 
 ```bash
@@ -80,6 +87,10 @@ npm run release:check
 
 `release:check` runs `verify:oracle`, then `release:proof:chatgpt-presets`, then `smoke:platform:all`, matching the release order: cheap harness checks, fresh live ChatGPT preset proof, doctor, full matrix, then artifact review. `prepublishOnly` runs `npm run release:check`.
 
+For an already prepared release candidate, set `PI_ORACLE_RELEASE_TARBALL` to its local tarball before running the matrix. Set `PI_ORACLE_RELEASE_SHA256` to the prepared candidate's SHA-256 when one is available; the runner checks it before transfer. Each suite still checks that the source packs, but installs the retained candidate. Crabbox transfers a temporary copy and each target verifies its SHA-256 before use; the suite evidence records the verified hash.
+
+The reusable [hosted platform qualification](../.github/workflows/release-platform.yml) runs each target on its native GitHub-hosted OS. It verifies the shared candidate receipt and source before and after both suites, and retains the per-target evidence. This is the platform portion of release qualification; the live ChatGPT preset proof is a separate required gate.
+
 ## What `platform-build` proves
 
 On each required target, `platform-build`:

package/docs/reference.md

@@ -26,6 +26,13 @@ You need:
 - a normal persisted `pi` session, not `pi --no-session`
 - on Linux, encrypted Chromium cookies may also require `secret-tool` (GNOME/libsecret) or `kwallet-query` + `dbus-send` (KDE), unless a Chrome/Brave safe-storage password override is set for the auth run
 
+`agent-browser` has its own Node.js requirements, which may be newer than Oracle's package minimum.
+If npm blocks `agent-browser`'s install script, allow it when installing the global package:
+
+```bash
+npm install -g --allow-scripts=agent-browser agent-browser
+```
+
 ## What a successful run looks like
 
 ```text

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

@@ -16,6 +16,7 @@ export declare function matchesModelFamilyLabel(label: string | undefined, famil
 export declare function matchesRequestedModelControlLabel(label: string | undefined, selection: OracleUiSelection): boolean;
 export declare function matchesCompactIntelligenceControlLabel(label: string | undefined): boolean;
 export declare function matchesCompactIntelligenceOpenerLabel(label: string | undefined): boolean;
+export declare function matchesModelConfigurationOpener(entry: import("./artifact-heuristics.mjs").SnapshotEntry): boolean;
 export declare function requestedEffortLabel(selection: OracleUiSelection): string | undefined;
 export declare function effortSelectionVisible(snapshot: string, effortLabel: string | undefined): boolean;
 export declare function thinkingChipVisible(snapshot: string): boolean;

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

@@ -522,24 +522,29 @@ export function snapshotHasUsableComposerControls(snapshot) {
   return hasComposer && hasAddFiles;
 }
 
+/**
+ * @param {SnapshotEntry} entry
+ * @returns {boolean}
+ */
+export function matchesModelConfigurationOpener(entry) {
+  if (entry.disabled || entry.kind !== "button" || typeof entry.label !== "string") return false;
+  const label = normalizeChipLabel(entry.label);
+  return label === "Model"
+    || label === "Model selector"
+    || label === "Select ChatGPT model"
+    || matchesCompactIntelligenceOpenerLabel(label)
+    || BARE_EFFORT_PATTERN.test(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}
  */
 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"
-      || COMPACT_INTELLIGENCE_OPENER_PATTERN.test(label)
-      || EFFORT_LABELS.has(label)
-      || ["instant", "thinking", "pro"].some((family) => matchesModelFamilyLabel(label, /** @type {OracleUiModelFamily} */ (family)))
-      || THINKING_CHIP_PATTERN.test(label)
-      || PRO_CHIP_PATTERN.test(label);
-  });
+  return parseSnapshotEntries(snapshot).some(matchesModelConfigurationOpener);
 }
 
 /**

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

@@ -26,7 +26,7 @@ import {
   CHATGPT_COMPOSER_LABELS,
   deriveAssistantCompletionSignature,
   matchesCompactIntelligenceControlLabel,
-  matchesCompactIntelligenceOpenerLabel,
+  matchesModelConfigurationOpener,
   matchesModelFamilyLabel,
   matchesRequestedModelControlLabel,
   requestedEffortLabel,
@@ -58,7 +58,7 @@ const jobPath = `${jobDir}/job.json`;
 const CHATGPT_LABELS = {
   composer: "Chat with ChatGPT",
   addFiles: "Add files and more",
-  send: "Send prompt",
+  send: ["Send prompt", "Send"],
   close: "Close",
   autoSwitchToThinking: "Auto-switch to Thinking",
   configure: "Configure...",
@@ -66,7 +66,7 @@ const CHATGPT_LABELS = {
 const GROK_LABELS = {
   composer: "Ask Grok anything",
   addFiles: "Attach",
-  send: "Submit",
+  send: ["Submit"],
   modelSelect: "Model select",
   stop: "Stop model response",
 };
@@ -916,18 +916,6 @@ function matchesRequestedModelControl(candidate, selection, options = {}) {
   return matchesRequestedModelControlLabel(candidate.label, selection);
 }
 
-function matchesModelConfigurationOpener(candidate) {
-  if (candidate.kind !== "button" || typeof candidate.label !== "string" || candidate.disabled) return false;
-  const label = String(candidate.label || "");
-  return candidate.label === "Model"
-    || candidate.label === "Model selector"
-    || matchesCompactIntelligenceOpenerLabel(label)
-    || /^(?: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);
-}
-
 function canUseOpenModelMenuForSelection(snapshot, selection) {
   if (selection.modelFamily !== "instant" || selection.autoSwitchToThinking === true) return false;
   return Boolean(findEntry(
@@ -1312,7 +1300,7 @@ async function waitForUploadConfirmed(job, fileLabel, baselineCount) {
     const labels = labelsForJob(job);
     const sendEntry = findEntry(
       snapshot,
-      (candidate) => candidate.kind === "button" && candidate.label === labels.send && !candidate.disabled,
+      (candidate) => candidate.kind === "button" && labels.send.includes(candidate.label || "") && !candidate.disabled,
     );
     const fileCount = isGrokJob(job) && snapshot.includes(fileLabel)
       ? baselineCount + 1
@@ -1346,12 +1334,12 @@ async function waitForSendReady(job) {
     const labels = labelsForJob(job);
     const entry = findEntry(
       snapshot,
-      (candidate) => candidate.kind === "button" && candidate.label === labels.send && !candidate.disabled,
+      (candidate) => candidate.kind === "button" && labels.send.includes(candidate.label || "") && !candidate.disabled,
     );
     if (entry) return entry;
     await sleep(1000);
   }
-  throw new Error(`Timed out waiting for ${labelsForJob(job).send} to become enabled`);
+  throw new Error(`Timed out waiting for ${labelsForJob(job).send.join(" or ")} to become enabled`);
 }
 
 async function activateSendButton(job) {
@@ -1360,12 +1348,12 @@ async function activateSendButton(job) {
     const buttons = Array.from(document.querySelectorAll('button'));
     const button = buttons.find((candidate) => {
       const label = (candidate.getAttribute('aria-label') || candidate.textContent || '').trim();
-      return label === labels.send;
+      return labels.send.includes(label);
     });
     if (!button) return { ok: false, reason: 'send button not found' };
     if (button.disabled || button.getAttribute('aria-disabled') === 'true') return { ok: false, reason: 'send button disabled' };
     button.click();
-    return { ok: true };
+    return { ok: true, label: (button.getAttribute('aria-label') || button.textContent || '').trim() };
   `));
   return result;
 }
@@ -1380,7 +1368,7 @@ async function sendAcceptanceState(job, baselineAssistantCount) {
     url: urlResult.url,
     urlKnown: urlResult.ok,
     assistantCount: Math.max(baselineAssistantCount, messages.length),
-    stopStreaming: isGrokJob(job) ? snapshot.includes(GROK_LABELS.stop) : snapshot.includes("Stop streaming"),
+    stopStreaming: isGrokJob(job) ? snapshot.includes(GROK_LABELS.stop) : snapshot.includes("Stop streaming") || snapshot.includes('button "Stop"'),
     transientErrorText: detectProviderVisibleBlockerText(snapshot) || "",
   };
 }
@@ -1389,12 +1377,13 @@ async function clickSend(job, baselineAssistantCount) {
   await waitForSendReady(job);
   const beforeSend = await sendAcceptanceState(job, baselineAssistantCount);
   const activation = await activateSendButton(job);
-  if (!activation?.ok) throw new Error(`Could not activate ${labelsForJob(job).send}: ${activation?.reason || "DOM activation failed"}`);
-  await log(`Activated ${labelsForJob(job).send}; waiting for provider acceptance evidence`);
+  const sendLabel = activation?.label || labelsForJob(job).send.join(" or ");
+  if (!activation?.ok) throw new Error(`Could not activate ${sendLabel}: ${activation?.reason || "DOM activation failed"}`);
+  await log(`Activated ${sendLabel}; waiting for provider acceptance evidence`);
   if (await waitForSendAccepted(job, beforeSend, { timeoutMs: 20_000 })) return;
 
   await captureDiagnostics(job, "send-not-accepted");
-  throw new Error(`${isGrokJob(job) ? "Grok" : "ChatGPT"} message did not leave the composer after activating ${labelsForJob(job).send}`);
+  throw new Error(`${isGrokJob(job) ? "Grok" : "ChatGPT"} message did not leave the composer after activating ${sendLabel}`);
 }
 
 async function waitForSendAccepted(job, beforeSend, options = {}) {
@@ -1781,7 +1770,7 @@ async function assistantMessages(job) {
     job,
     toJsonScript(`
       const headings = Array.from(document.querySelectorAll('h1,h2,h3,h4,h5,h6,[role="heading"]'))
-        .filter((el) => (el.textContent || '').trim() === 'ChatGPT said:');
+        .filter((el) => el.getAttribute('data-conversation-role') === 'assistant' || (el.textContent || '').trim() === 'ChatGPT said:');
       const renderText = (node) => {
         if (!node) return '';
         const clone = node.cloneNode(true);
@@ -1807,7 +1796,10 @@ async function assistantMessages(job) {
           .trim();
         return text;
       };
-      const headingMessages = headings.map((heading) => ({ text: renderText(heading.nextElementSibling) }));
+      const headingMessages = headings.map((heading) => ({
+        text: renderText(heading.nextElementSibling),
+        turnComplete: heading.closest('[data-talvt-turn-state]')?.getAttribute('data-talvt-turn-state') === 'complete',
+      }));
       const messageNodes = Array.from(document.querySelectorAll('[data-testid="assistant-message"], [data-message-author-role="assistant"]'));
       const nodeMessages = messageNodes.map((node) => ({ text: renderText(node) }));
       return {
@@ -1817,7 +1809,10 @@ async function assistantMessages(job) {
   );
 
   if (!Array.isArray(result?.messages)) return [];
-  return result.messages.map((message) => ({ text: typeof message?.text === "string" ? message.text : "" }));
+  return result.messages.map((message) => ({
+    text: typeof message?.text === "string" ? message.text : "",
+    turnComplete: message?.turnComplete === true,
+  }));
 }
 
 async function grokAssistantMessages(job) {
@@ -1886,7 +1881,7 @@ async function waitForChatCompletion(job, baselineAssistantCount) {
   while (Date.now() < timeoutAt) {
     await heartbeat();
     const [snapshot, body] = await Promise.all([snapshotText(job), pageText(job).catch(() => "")]);
-    const hasStopStreaming = isGrokJob(job) ? snapshot.includes(GROK_LABELS.stop) : snapshot.includes("Stop streaming");
+    const hasStopStreaming = isGrokJob(job) ? snapshot.includes(GROK_LABELS.stop) : snapshot.includes("Stop streaming") || snapshot.includes('button "Stop"');
     const hasRetryButton = snapshot.includes('button "Retry"');
     const copyResponseCount = isGrokJob(job) ? (snapshot.match(/button "Copy"/g) || []).length : (snapshot.match(/Copy response/g) || []).length;
     throwIfProviderTransientError(job, snapshot, "waiting for response completion");
@@ -1894,7 +1889,7 @@ async function waitForChatCompletion(job, baselineAssistantCount) {
     const messages = await assistantMessages(job);
     const targetMessage = messages[baselineAssistantCount];
     const targetText = targetMessage?.text || "";
-    const hasTargetCopyResponse = copyResponseCount > baselineAssistantCount;
+    const hasTargetCopyResponse = copyResponseCount > baselineAssistantCount || targetMessage?.turnComplete === true;
 
     if (!hasStopStreaming && hasRetryButton && responseFailureText) {
       if (!retriedAfterFailure) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-oracle",
-  "version": "0.7.22",
+  "version": "0.7.23",
   "description": "ChatGPT and Grok web-oracle extension for pi with isolated browser auth, async jobs, and project-context archives.",
   "private": false,
   "license": "MIT",
@@ -87,7 +87,7 @@
     "typebox": "*"
   },
   "overrides": {
-    "basic-ftp": "6.2.1",
+    "basic-ftp": "6.2.3",
     "protobufjs": "7.6.6"
   },
   "devDependencies": {

package/scripts/oracle-chatgpt-preset-proof.mjs

@@ -61,8 +61,25 @@ function currentGitHead() {
   return git(["rev-parse", "HEAD"]);
 }
 
-function currentGitHeadCommittedAt() {
-  return git(["show", "-s", "--format=%cI", "HEAD"]);
+function gitCommitCommittedAt(ref = "HEAD") {
+  return git(["show", "-s", "--format=%cI", ref]);
+}
+
+function isRuntimeIdenticalAncestor(candidateHead, currentHead) {
+  if (typeof candidateHead !== "string" || !/^[0-9a-f]{40}$/i.test(candidateHead)) return false;
+  if (candidateHead === currentHead) return true;
+  try {
+    execFileSync("git", ["merge-base", "--is-ancestor", candidateHead, currentHead], { cwd: REPO_ROOT, stdio: "ignore" });
+    execFileSync("git", ["diff", "--exit-code", candidateHead, currentHead, "--", "extensions", "prompts"], { cwd: REPO_ROOT, stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function packageMetadataAtCommit(ref) {
+  const pkg = JSON.parse(git(["show", `${ref}:package.json`]));
+  return { name: pkg.name, version: pkg.version };
 }
 
 function currentGitStatus() {
@@ -230,8 +247,6 @@ function validateProof(proof, path) {
   const errors = [];
   const { name, version } = packageMetadata();
   const gitHead = currentGitHead();
-  const gitHeadCommittedAt = currentGitHeadCommittedAt();
-  const gitHeadCommittedAtMs = Date.parse(gitHeadCommittedAt);
   const gitStatus = currentGitStatus();
   const presetRegistry = canonicalPresets();
   const requiredPresets = Object.keys(presetRegistry);
@@ -246,10 +261,17 @@ function validateProof(proof, path) {
     return errors;
   }
 
+  const proofGitHead = typeof proof.gitHead === "string" ? proof.gitHead : "";
+  const validProofHead = isRuntimeIdenticalAncestor(proofGitHead, gitHead);
+  const expectedProofHead = validProofHead ? proofGitHead : gitHead;
+  const expectedVersion = validProofHead ? packageMetadataAtCommit(expectedProofHead).version : version;
+  const gitHeadCommittedAt = gitCommitCommittedAt(expectedProofHead);
+  const gitHeadCommittedAtMs = Date.parse(gitHeadCommittedAt);
+
   if (proof.schemaVersion !== 1) errors.push("schemaVersion must be 1");
   if (proof.packageName !== name) errors.push(`packageName must be ${name}`);
-  if (proof.packageVersion !== version) errors.push(`packageVersion must match package.json version ${version}`);
-  if (proof.gitHead !== gitHead) errors.push(`gitHead must match current HEAD ${gitHead}`);
+  if (proof.packageVersion !== expectedVersion) errors.push(`packageVersion must match package.json version ${expectedVersion}`);
+  if (!validProofHead) errors.push(`gitHead must match current HEAD ${gitHead} or a runtime-identical ancestor commit`);
   if (proof.provider !== "chatgpt") errors.push('provider must be "chatgpt"');
   if (proof.extensionUnderTest !== "loaded-extension") errors.push('extensionUnderTest must be "loaded-extension"');
 
@@ -262,7 +284,7 @@ function validateProof(proof, path) {
     const maxAgeMs = maxAgeHours() * 60 * 60 * 1000;
     if (ageMs < 0) errors.push("validatedAt must not be in the future");
     if (ageMs > maxAgeMs) errors.push(`validatedAt is older than ${maxAgeHours()} hours`);
-    if (proofValidatedAtMs <= gitHeadCommittedAtMs) errors.push("validatedAt must be after current git HEAD commit time");
+    if (proofValidatedAtMs <= gitHeadCommittedAtMs) errors.push("validatedAt must be after proven git commit time");
   }
 
   const jobs = proof.jobs;
@@ -277,8 +299,8 @@ function validateProof(proof, path) {
       canonicalPreset: presetRegistry[preset],
       proofJob: jobs[preset],
       packageName: name,
-      packageVersion: version,
-      gitHead,
+      packageVersion: expectedVersion,
+      gitHead: expectedProofHead,
       gitHeadCommittedAtMs,
       proofValidatedAtMs,
       errors,

package/scripts/oracle-model.test.mjs

@@ -15,20 +15,21 @@ const functions = names.flatMap((name) => {
   return `${worker.slice(start - 6, start) === "async " ? "async " : ""}${worker.slice(start, end)}`;
 }).join("\n");
 
-function harness({ initial = 3, max = "4", wrongLabel = false, stuck = false, mountingReads = 0 } = {}) {
+function harness({ initial = 3, max = "4", wrongLabel = false, stuck = false, mountingReads = 0, openerLabel } = {}) {
   const labels = ["Instant", "Medium", "High", "Extra High", "Pro"];
   let value = initial;
   let open = false;
   let verified = false;
+  let now = 0;
   const snapshot = () => open
     ? '- button "Thinking effort" [expanded=true, ref=e1]\n- menu "Thinking effort" [ref=e2]\n- menuitem "Select model" [ref=e3]\n- menuitem "Power" [ref=e4]'
-    : `- button "${value === 4 ? "6 Pro" : labels[value]}" [expanded=false, ref=e1]\n- textbox "Ask ChatGPT" [ref=e5]\n- button "Add files and more" [ref=e6]`;
+    : `- button "${openerLabel ?? (value === 4 ? "6 Pro" : labels[value])}" [expanded=false, ref=e1]\n- textbox "Ask ChatGPT" [ref=e5]\n- button "Add files and more" [ref=e6]`;
   const control = {
     closest: () => null,
     getAttribute: () => "description",
     querySelector: () => mountingReads-- > 0 ? null : ({ getAttribute: (name) => ({ "aria-valuemin": "0", "aria-valuemax": max, "aria-valuenow": String(value) })[name] }),
   };
-  const context = vm.createContext({ ...ui, parseSnapshotEntries, Date, Error, JSON, Number,
+  const context = vm.createContext({ ...ui, parseSnapshotEntries, Date: { now: () => now++ }, Error, JSON, Number,
     CHATGPT_LABELS: { configure: "Configure..." },
     MODEL_CONFIGURATION_OPEN_TIMEOUT_MS: 30, MODEL_CONFIGURATION_SETTLE_TIMEOUT_MS: 30,
     MODEL_CONFIGURATION_CLOSE_RETRY_MS: 1, MODEL_CONFIGURATION_SETTLE_POLL_MS: 0,
@@ -58,19 +59,21 @@ function harness({ initial = 3, max = "4", wrongLabel = false, stuck = false, mo
 }
 
 test("worker configures every preset through the current Power picker and closes it", async () => {
-  for (const [selection, expected] of [
-    [{ modelFamily: "instant", autoSwitchToThinking: false }, 0],
-    [{ modelFamily: "instant", autoSwitchToThinking: true }, 0],
-    [{ modelFamily: "thinking", effort: "light" }, 1],
-    [{ modelFamily: "thinking", effort: "standard" }, 1],
-    [{ modelFamily: "thinking", effort: "extended" }, 2],
-    [{ modelFamily: "thinking", effort: "heavy" }, 3],
-    [{ modelFamily: "pro", effort: "standard" }, 4],
-    [{ modelFamily: "pro", effort: "extended" }, 4],
-  ]) {
-    const h = harness({ initial: expected === 4 ? 0 : 4, mountingReads: 2 });
-    await h.configure(selection);
-    assert.deepEqual(h.state, { value: expected, open: false, verified: true });
+  for (const openerLabel of [undefined, "Select ChatGPT model"]) {
+    for (const [selection, expected] of [
+      [{ modelFamily: "instant", autoSwitchToThinking: false }, 0],
+      [{ modelFamily: "instant", autoSwitchToThinking: true }, 0],
+      [{ modelFamily: "thinking", effort: "light" }, 1],
+      [{ modelFamily: "thinking", effort: "standard" }, 1],
+      [{ modelFamily: "thinking", effort: "extended" }, 2],
+      [{ modelFamily: "thinking", effort: "heavy" }, 3],
+      [{ modelFamily: "pro", effort: "standard" }, 4],
+      [{ modelFamily: "pro", effort: "extended" }, 4],
+    ]) {
+      const h = harness({ initial: expected === 4 ? 0 : 4, mountingReads: 2, openerLabel });
+      await h.configure(selection);
+      assert.deepEqual(h.state, { value: expected, open: false, verified: true });
+    }
   }
 });
 

package/scripts/oracle-real-smoke.mjs

@@ -3,7 +3,8 @@
 // Default mode is packed-install release proof. Source mode is inner-loop/debug only.
 
 import { spawn } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { mkdtempSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
@@ -25,6 +26,8 @@ Modes:
 Environment:
   PI_HOST_CLI                  selected Pi manifest bin entry, invoked with this Node executable (default: pi on PATH)
   PI_COMPAT_EXPECTED_VERSION   expected Pi version (default: package development baseline)
+  PI_ORACLE_RELEASE_TARBALL   retained tarball to install instead of the newly packed archive
+  PI_ORACLE_RELEASE_SHA256    expected retained tarball SHA-256, when supplied
   PI_ORACLE_REAL_TEST_PROVIDER   pi provider for the test agent (default: ${DEFAULT_PROVIDER})
   PI_ORACLE_REAL_TEST_MODEL      pi model for the test agent (default: ${DEFAULT_MODEL})
   PI_ORACLE_REAL_TEST_TIMEOUT_MS per-agent timeout in ms (default: ${DEFAULT_TIMEOUT_MS})
@@ -262,8 +265,16 @@ async function preparePackedProject({ runDir, provider, model, timeoutMs }) {
     timeoutMs: 120_000,
   });
   const tarballName = pack.stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).at(-1);
-  const tarballPath = tarballName ? join(packDir, tarballName) : undefined;
+  let tarballPath = tarballName ? join(packDir, tarballName) : undefined;
   if (!tarballPath || !existsSync(tarballPath)) throw new Error(`npm pack did not produce a tarball in ${packDir}`);
+  if (env("PI_ORACLE_RELEASE_TARBALL")) {
+    tarballPath = join(packDir, "release-candidate.tgz");
+    copyFileSync(resolve(env("PI_ORACLE_RELEASE_TARBALL")), tarballPath);
+    const hash = createHash("sha256").update(readFileSync(tarballPath)).digest("hex");
+    const expected = env("PI_ORACLE_RELEASE_SHA256");
+    if (expected && hash !== expected) throw new Error("Retained release candidate checksum changed");
+    console.log(`ORACLE_RELEASE_CANDIDATE_SHA256=${hash}`);
+  }
   writeFileSync(join(installDir, "packed-tarball.txt"), `${tarballPath}\n`);
 
   await mustRun(installDir, "npm-init", npm, ["init", "-y"], { cwd: piProject, env: process.env, timeoutMs: 60_000 });

package/scripts/platform-smoke/Dockerfile.ubuntu

@@ -4,6 +4,6 @@ USER root
 RUN apt-get update \
   && apt-get install -y --no-install-recommends zstd rsync \
   && rm -rf /var/lib/apt/lists/*
-RUN npm install -g npm@11.21.0 \
-  && npm install -g agent-browser@0.29.1
+RUN npm install -g npm \
+  && npm install -g --allow-scripts=agent-browser agent-browser
 USER circleci

package/scripts/platform-smoke/crabbox-runner.mjs

@@ -58,6 +58,7 @@ export function buildTargetBaseArgs(targetName, config = {}) {
   switch (targetName) {
     case "macos": {
       const host = env("PI_ORACLE_SMOKE_MAC_HOST") || env("PLATFORM_SMOKE_MAC_HOST") || "localhost";
+      const port = env("PI_ORACLE_SMOKE_MAC_PORT") || env("PLATFORM_SMOKE_MAC_PORT") || "22";
       const user = env("PI_ORACLE_SMOKE_MAC_USER") || env("PLATFORM_SMOKE_MAC_USER") || env("USER");
       const workRoot = env("PI_ORACLE_SMOKE_MAC_WORK_ROOT") || env("PLATFORM_SMOKE_MAC_WORK_ROOT") || `/Users/${env("USER")}/crabbox/${config.packageName ?? "pi-oracle"}`;
       return [
@@ -65,7 +66,7 @@ export function buildTargetBaseArgs(targetName, config = {}) {
         "--target", "macos",
         "--static-host", host,
         "--static-user", user,
-        "--static-port", "22",
+        "--static-port", port,
         "--static-work-root", workRoot,
       ];
     }
@@ -82,6 +83,19 @@ export function buildTargetBaseArgs(targetName, config = {}) {
       const snapshot = env("PI_ORACLE_SMOKE_WINDOWS_SNAPSHOT") || env("PLATFORM_SMOKE_WINDOWS_SNAPSHOT") || config.windowsParallels?.snapshot || "crabbox-ready";
       const user = env("PI_ORACLE_SMOKE_WINDOWS_USER") || env("PLATFORM_SMOKE_WINDOWS_USER") || env("USER");
       const workRoot = env("PI_ORACLE_SMOKE_WINDOWS_NATIVE_WORK_ROOT") || env("PLATFORM_SMOKE_WINDOWS_WORK_ROOT") || `C:\\crabbox\\${config.packageName ?? "pi-oracle"}`;
+      const host = env("PI_ORACLE_SMOKE_WINDOWS_HOST") || env("PLATFORM_SMOKE_WINDOWS_HOST");
+      if (host) {
+        const port = env("PI_ORACLE_SMOKE_WINDOWS_PORT") || env("PLATFORM_SMOKE_WINDOWS_PORT") || "22";
+        return [
+          "--provider", "ssh",
+          "--target", "windows",
+          "--windows-mode", "normal",
+          "--static-host", host,
+          "--static-user", user,
+          "--static-port", port,
+          "--static-work-root", workRoot,
+        ];
+      }
       return [
         "--provider", "parallels",
         "--target", "windows",

package/scripts/platform-smoke/doctor.mjs

@@ -1,8 +1,8 @@
 // Preflight checks for the pi-oracle Crabbox platform smoke gate.
 
 import { execFileSync, execSync } from "node:child_process";
-import { accessSync, constants, existsSync, mkdirSync, unlinkSync, writeFileSync } from "node:fs";
-import { resolve } from "node:path";
+import { accessSync, constants, mkdirSync, readdirSync, unlinkSync, writeFileSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
 import { buildTargetBaseArgs } from "./crabbox-runner.mjs";
 
 let failures = 0;
@@ -131,28 +131,53 @@ function verifyPackageExclusions() {
   forbidden.length ? fail(`forbidden files in package: ${forbidden.join(", ")}`) : ok("package excludes local env/artifact/debug state");
 }
 
+function findForbiddenFiles(dir, depth = 0) {
+  return readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+    const path = join(dir, entry.name);
+    const matches = entry.name === ".env" || entry.name.startsWith(".env.") || entry.name.endsWith(".tgz");
+    return [
+      ...(matches ? [relative(process.cwd(), path)] : []),
+      ...(entry.isDirectory() && depth < 2 ? findForbiddenFiles(path, depth + 1) : []),
+    ];
+  });
+}
+
 function verifyRepoForbiddenFiles() {
-  const forbidden = shell("find . -maxdepth 3 \\( -name '.env' -o -name '.env.*' -o -name '*.tgz' \\) -print 2>/dev/null");
-  forbidden ? fail(`forbidden local secret/package artifact(s): ${forbidden}`) : ok("no .env/.env.* or package tarballs at repo root depth");
+  const forbidden = findForbiddenFiles(process.cwd());
+  forbidden.length ? fail(`forbidden local secret/package artifact(s): ${forbidden.join(", ")}`) : ok("no .env/.env.* or package tarballs at repo root depth");
   for (const dir of [".artifacts", ".crabbox", ".debug", ".platform-smoke-runs"]) {
-    const ignored = shell(`git check-ignore -q ${dir}/probe && echo ignored`);
+    const ignored = silent("git", ["check-ignore", "-q", `${dir}/probe`]) !== null;
     ignored ? ok(`${dir}/ is gitignored`) : fail(`${dir}/ must be gitignored`);
   }
-  const trackedForbidden = shell("git ls-files '.env*' '*.tgz' '.artifacts/*' '.crabbox/*' '.debug/*' '.platform-smoke-runs/*'");
+  const trackedForbidden = silent("git", ["ls-files", ".env*", "*.tgz", ".artifacts/*", ".crabbox/*", ".debug/*", ".platform-smoke-runs/*"]);
   trackedForbidden ? fail(`forbidden tracked local state: ${trackedForbidden}`) : ok("no forbidden local state is tracked");
   verifyPackageExclusions();
 }
 
 export async function runDoctor(config) {
   failures = 0;
+  const targets = config.requiredTargets ?? [];
+  const hasMac = targets.includes("macos");
+  const hasUbuntu = targets.includes("ubuntu");
+  const hasWindows = targets.includes("windows-native");
+  const windowsArgs = hasWindows ? buildTargetBaseArgs("windows-native", config) : [];
+  const windowsStatic = windowsArgs.includes("--static-host");
   console.log("\n── Environment ──");
   const cbox = env("PI_ORACLE_SMOKE_CRABBOX") || env("PLATFORM_SMOKE_CRABBOX") || "crabbox";
   ok(`Crabbox binary = ${resolveCommand(cbox) ?? cbox}${env("PI_ORACLE_SMOKE_CRABBOX") || env("PLATFORM_SMOKE_CRABBOX") ? " (env override)" : " (PATH)"}`);
-  ok(`PI_ORACLE_SMOKE_MAC_HOST = ${env("PI_ORACLE_SMOKE_MAC_HOST") || env("PLATFORM_SMOKE_MAC_HOST") || "localhost"}`);
-  ok(`PI_ORACLE_SMOKE_MAC_USER = ${env("PI_ORACLE_SMOKE_MAC_USER") || env("PLATFORM_SMOKE_MAC_USER") || env("USER")}`);
-  ok(`PI_ORACLE_SMOKE_UBUNTU_IMAGE = ${env("PI_ORACLE_SMOKE_UBUNTU_IMAGE") || env("PLATFORM_SMOKE_UBUNTU_IMAGE") || config.ubuntuContainerImage || "pi-oracle-platform-smoke:node24"}`);
-  ok(`PI_ORACLE_SMOKE_WINDOWS_VM = ${windowsVmName(config)}`);
-  ok(`PI_ORACLE_SMOKE_WINDOWS_SNAPSHOT = ${windowsSnapshotName(config)}`);
+  if (hasMac) {
+    ok(`PI_ORACLE_SMOKE_MAC_HOST = ${env("PI_ORACLE_SMOKE_MAC_HOST") || env("PLATFORM_SMOKE_MAC_HOST") || "localhost"}`);
+    ok(`PI_ORACLE_SMOKE_MAC_PORT = ${env("PI_ORACLE_SMOKE_MAC_PORT") || env("PLATFORM_SMOKE_MAC_PORT") || "22"}`);
+    ok(`PI_ORACLE_SMOKE_MAC_USER = ${env("PI_ORACLE_SMOKE_MAC_USER") || env("PLATFORM_SMOKE_MAC_USER") || env("USER")}`);
+  }
+  if (hasUbuntu) ok(`PI_ORACLE_SMOKE_UBUNTU_IMAGE = ${env("PI_ORACLE_SMOKE_UBUNTU_IMAGE") || env("PLATFORM_SMOKE_UBUNTU_IMAGE") || config.ubuntuContainerImage || "pi-oracle-platform-smoke:node24"}`);
+  if (hasWindows && windowsStatic) {
+    ok(`Windows SSH host = ${windowsArgs[windowsArgs.indexOf("--static-host") + 1]}`);
+    ok(`Windows SSH port = ${windowsArgs[windowsArgs.indexOf("--static-port") + 1]}`);
+  } else if (hasWindows) {
+    ok(`PI_ORACLE_SMOKE_WINDOWS_VM = ${windowsVmName(config)}`);
+    ok(`PI_ORACLE_SMOKE_WINDOWS_SNAPSHOT = ${windowsSnapshotName(config)}`);
+  }
 
   console.log("\n── Crabbox ──");
   const resolvedCbox = resolveCommand(cbox);
@@ -166,15 +191,22 @@ export async function runDoctor(config) {
     compareVersions(versionLine, requiredVersion) >= 0 ? ok(`required version: ${requiredVersion}+`) : fail(`Crabbox version mismatch: need ${requiredVersion}+, got ${versionLine}`);
   }
   const providers = silent(cbox, ["providers"], { timeout: 30_000 }) ?? "";
-  for (const provider of ["ssh", "local-container", "parallels"]) {
+  const neededProviders = new Set([
+    ...(hasMac || (hasWindows && windowsStatic) ? ["ssh"] : []),
+    ...(hasUbuntu ? ["local-container"] : []),
+    ...(hasWindows && !windowsStatic ? ["parallels"] : []),
+  ]);
+  for (const provider of neededProviders) {
     new RegExp(`^${provider}$`, "m").test(providers) ? ok(`provider available: ${provider}`) : fail(`crabbox providers missing ${provider}`);
   }
-  runCrabboxDoctor(cbox, "macOS static SSH", buildTargetBaseArgs("macos", config), 120_000);
-  runCrabboxDoctor(cbox, "Windows native Parallels", buildTargetBaseArgs("windows-native", config), 180_000);
-  runCrabboxDoctor(cbox, "local-container", buildTargetBaseArgs("ubuntu", config), 120_000);
+  if (hasMac) runCrabboxDoctor(cbox, "macOS static SSH", buildTargetBaseArgs("macos", config), 120_000);
+  if (hasWindows) runCrabboxDoctor(cbox, windowsStatic ? "Windows native SSH" : "Windows native Parallels", windowsArgs, 180_000);
+  if (hasUbuntu) runCrabboxDoctor(cbox, "local-container", buildTargetBaseArgs("ubuntu", config), 120_000);
 
   console.log("\n── Host tools ──");
-  for (const [name, command] of [["Docker", "docker info --format '{{.ServerVersion}}'"], ["Node", "node --version"], ["npm", "npm --version"], ["git", "git --version"], ["tar", "tar --version"], ["rsync", "rsync --version"]]) {
+  const hostTools = [["Node", "node --version"], ["npm", "npm --version"], ["git", "git --version"], ["tar", "tar --version"], ["rsync", "rsync --version"]];
+  if (hasUbuntu) hostTools.unshift(["Docker", "docker info --format '{{.ServerVersion}}'"]);
+  for (const [name, command] of hostTools) {
     const output = shell(command);
     output ? ok(`${name}: ${output.split("\n")[0]}`) : fail(`${name} not found or unavailable`);
   }
@@ -183,7 +215,7 @@ export async function runDoctor(config) {
     const major = Number(nodeVersion.replace(/^v/, "").split(".")[0]);
     if (major < (config.nodeValidationMajor ?? 24)) fail(`Node ${nodeVersion}; need ${config.nodeValidationMajor ?? 24}+ for smoke validation`);
   }
-  verifyWindowsTemplate(config);
+  if (hasWindows && !windowsStatic) verifyWindowsTemplate(config);
 
   console.log("\n── Auth environment ──");
   const requiredAuth = requiredRealSmokeAuthEnv(config);
@@ -193,7 +225,7 @@ export async function runDoctor(config) {
   }
 
   console.log("\n── Target tools ──");
-  for (const target of config.requiredTargets ?? []) runTargetToolProbe(cbox, target, config);
+  for (const target of targets) runTargetToolProbe(cbox, target, config);
 
   console.log("\n── Artifact root ──");
   const artifactRoot = resolve(process.cwd(), config.artifactRoot ?? ".artifacts/platform-smoke");
@@ -217,8 +249,8 @@ export async function runDoctor(config) {
   console.log(`\n=== Results: ${failures} failure(s) ===`);
   if (failures > 0) {
     process.exitCode = 1;
-    console.log("Fix the failures above before running npm run smoke:platform:all.");
+    console.log("Fix the failures above before running the selected platform suites.");
   } else {
-    console.log("Ready for npm run smoke:platform:all.");
+    console.log(`Ready for platform suites on ${targets.join(", ")}.`);
   }
 }

package/scripts/platform-smoke/invariants.mjs

@@ -28,17 +28,23 @@ function testHelpTextIncludesTargetsAndExamples() {
 }
 
 function testTargetSelection() {
-  const result = runNode(["scripts/platform-smoke.mjs", "run", "--target", "not-a-target", "--suite", "platform-build"]);
-  assert.notEqual(result.status, 0, "unsupported targets should fail before Crabbox runs");
-  assert.ifError(result.error);
-  assert.match(`${result.stdout ?? ""}\n${result.stderr ?? ""}`, /unsupported target: not-a-target/);
+  for (const command of ["doctor", "run"]) {
+    const result = withEnv({ PI_ORACLE_SMOKE_CRABBOX: "/nonexistent/crabbox" }, () =>
+      runNode(["scripts/platform-smoke.mjs", command, "--target", "not-a-target"]));
+    assert.notEqual(result.status, 0, `${command}: unsupported targets should fail before Crabbox runs`);
+    assert.ifError(result.error);
+    assert.match(`${result.stdout ?? ""}\n${result.stderr ?? ""}`, /unsupported target: not-a-target/);
+  }
 }
 
 function testEmptyTargetSelectionRejected() {
-  const result = runNode(["scripts/platform-smoke.mjs", "run", "--target", ",,", "--suite", "platform-build"]);
-  assert.notEqual(result.status, 0, "an --target value that resolves to zero targets must fail instead of running nothing");
-  assert.ifError(result.error);
-  assert.match(`${result.stdout ?? ""}\n${result.stderr ?? ""}`, /--target did not resolve to any targets/);
+  for (const command of ["doctor", "run"]) {
+    const result = withEnv({ PI_ORACLE_SMOKE_CRABBOX: "/nonexistent/crabbox" }, () =>
+      runNode(["scripts/platform-smoke.mjs", command, "--target", ",,"]));
+    assert.notEqual(result.status, 0, `${command}: an empty target selection must fail instead of running nothing`);
+    assert.ifError(result.error);
+    assert.match(`${result.stdout ?? ""}\n${result.stderr ?? ""}`, /--target did not resolve to any targets/);
+  }
 }
 
 function testPackedInstallCommandRendering() {
@@ -93,6 +99,8 @@ function testTargetBaseArgsEnvPrecedence() {
     PLATFORM_SMOKE_UBUNTU_IMAGE: undefined,
     PI_ORACLE_SMOKE_MAC_WORK_ROOT: undefined,
     PLATFORM_SMOKE_MAC_WORK_ROOT: undefined,
+    PI_ORACLE_SMOKE_MAC_PORT: undefined,
+    PLATFORM_SMOKE_MAC_PORT: undefined,
     PI_ORACLE_SMOKE_WINDOWS_NATIVE_WORK_ROOT: undefined,
     PLATFORM_SMOKE_WINDOWS_WORK_ROOT: undefined,
   }, () => {
@@ -122,6 +130,14 @@ function testTargetBaseArgsEnvPrecedence() {
     args = buildTargetBaseArgs("macos", {});
     assert(args.includes("/invariants/private-work") && !args.includes("/invariants/shared-work"), "private PI_ORACLE_SMOKE_MAC_WORK_ROOT alias should win over the shared alias");
 
+    assert.equal(args[args.indexOf("--static-port") + 1], "22", "macOS SSH defaults to port 22");
+    process.env.PLATFORM_SMOKE_MAC_PORT = "2200";
+    args = buildTargetBaseArgs("macos", {});
+    assert.equal(args[args.indexOf("--static-port") + 1], "2200", "shared macOS port reaches Crabbox");
+    process.env.PI_ORACLE_SMOKE_MAC_PORT = "2201";
+    args = buildTargetBaseArgs("macos", {});
+    assert.equal(args[args.indexOf("--static-port") + 1], "2201", "project macOS port takes precedence");
+
     process.env.PLATFORM_SMOKE_WINDOWS_WORK_ROOT = "C:\\invariants\\shared-work";
     args = buildTargetBaseArgs("windows-native", {});
     assert(args.includes("C:\\invariants\\shared-work"), "shared PLATFORM_SMOKE_WINDOWS_WORK_ROOT override should reach target args");

package/scripts/platform-smoke/platform-build-windows.ps1

@@ -1,6 +1,8 @@
 param(
   [string]$PackageName = "pi-oracle",
-  [int]$NodeValidationMajor = 24
+  [int]$NodeValidationMajor = 24,
+  [string]$CandidatePath = "",
+  [string]$CandidateSha256 = ""
 )
 
 $ErrorActionPreference = "Continue"
@@ -77,6 +79,20 @@ Write-Output "PLATFORM_NPM_PACK_EXIT=$PACK_EXIT"
 if ($PackTarball -and (Test-Path -LiteralPath $PackTarball)) {
   Move-Item -LiteralPath $PackTarball -Destination (Join-Path $PackDir $PackTarball) -Force
 }
+if ($CandidatePath) {
+  if (-not (Test-Path -LiteralPath $CandidatePath)) {
+    Write-Output "Retained release candidate is missing"
+    exit 1
+  }
+  $CandidateHash = (Get-FileHash -LiteralPath $CandidatePath -Algorithm SHA256).Hash.ToLowerInvariant()
+  Write-Output "PLATFORM_CANDIDATE_SHA256=$CandidateHash"
+  if ($CandidateHash -ne $CandidateSha256.ToLowerInvariant()) {
+    Write-Output "Retained release candidate checksum changed"
+    exit 1
+  }
+  Copy-Item -LiteralPath $CandidatePath -Destination (Join-Path $PackDir "release-candidate.tgz") -ErrorAction Stop
+  $PackTarball = "release-candidate.tgz"
+}
 Write-Output "PLATFORM_PACKED_TARBALL=$PackTarball"
 Set-Content -Path (Join-Path $PackDir "packed-tarball.txt") -Value $PackTarball
 

package/scripts/platform-smoke/targets.mjs

@@ -95,6 +95,10 @@ export function buildRealExtensionCommand(targetName = "ubuntu", config = {}) {
       `$env:PI_ORACLE_REAL_TEST_PROVIDER = ${powershellSingleQuote(provider)}`,
       `$env:PI_ORACLE_REAL_TEST_MODEL = ${powershellSingleQuote(model)}`,
       `$env:PI_ORACLE_REAL_TEST_MODEL_AGENT = ${powershellSingleQuote(useModelAgent ? "1" : "")}`,
+      ...(config.releaseCandidate ? [
+        `$env:PI_ORACLE_RELEASE_TARBALL = Join-Path (Get-Location) ${powershellSingleQuote(config.releaseCandidate.path)}`,
+        `$env:PI_ORACLE_RELEASE_SHA256 = ${powershellSingleQuote(config.releaseCandidate.sha256)}`,
+      ] : []),
       "$env:PI_ORACLE_REAL_TEST_TIMEOUT_MS = '360000'",
       "if (-not (Test-Path -LiteralPath 'node_modules')) { npm.cmd ci; if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE } }",
       "npm.cmd run smoke:real:doctor",
@@ -108,15 +112,22 @@ export function buildRealExtensionCommand(targetName = "ubuntu", config = {}) {
     `export PI_ORACLE_REAL_TEST_PROVIDER=${shellQuote(provider)}`,
     `export PI_ORACLE_REAL_TEST_MODEL=${shellQuote(model)}`,
     `export PI_ORACLE_REAL_TEST_MODEL_AGENT=${shellQuote(useModelAgent ? "1" : "")}`,
+    ...(config.releaseCandidate ? [
+      `export PI_ORACLE_RELEASE_TARBALL="$PWD"/${shellQuote(config.releaseCandidate.path)}`,
+      `export PI_ORACLE_RELEASE_SHA256=${shellQuote(config.releaseCandidate.sha256)}`,
+    ] : []),
     'if [ ! -d node_modules ]; then npm ci; fi',
     "npm run smoke:real:doctor",
     "npm run smoke:real:packed",
   ].join("\n");
 }
 
-export function buildPlatformBuildCommand(targetName = "ubuntu", packageName = "pi-oracle", nodeValidationMajor = 24) {
+export function buildPlatformBuildCommand(targetName = "ubuntu", packageName = "pi-oracle", nodeValidationMajor = 24, releaseCandidate) {
   if (targetName === "windows-native") {
-    return `powershell.exe -NoLogo -NoProfile -ExecutionPolicy Bypass -File .\\scripts\\platform-smoke\\platform-build-windows.ps1 -PackageName ${packageName} -NodeValidationMajor ${nodeValidationMajor}`;
+    const candidate = releaseCandidate
+      ? ` -CandidatePath ${powershellSingleQuote(releaseCandidate.path)} -CandidateSha256 ${powershellSingleQuote(releaseCandidate.sha256)}`
+      : "";
+    return `powershell.exe -NoLogo -NoProfile -ExecutionPolicy Bypass -File .\\scripts\\platform-smoke\\platform-build-windows.ps1 -PackageName ${packageName} -NodeValidationMajor ${nodeValidationMajor}${candidate}`;
   }
   const lines = [];
   lines.push("set -o pipefail");
@@ -172,6 +183,12 @@ export function buildPlatformBuildCommand(targetName = "ubuntu", packageName = "
   lines.push('cat "$PACK_DIR/npm-pack.stderr.txt"');
   lines.push('echo "PLATFORM_NPM_PACK_EXIT=$PACK_EXIT"');
   lines.push('if [ -n "$PACK_TARBALL" ] && [ -f "$PACK_TARBALL" ]; then mv "$PACK_TARBALL" "$PACK_DIR/$PACK_TARBALL"; fi');
+  if (releaseCandidate) {
+    lines.push(`CANDIDATE="$SOURCE_ROOT"/${shellQuote(releaseCandidate.path)}`);
+    lines.push('CANDIDATE_SHA256=$(node -e \'const {createHash}=require("node:crypto");const {readFileSync}=require("node:fs");console.log(createHash("sha256").update(readFileSync(process.argv[1])).digest("hex"))\' "$CANDIDATE")');
+    lines.push('echo "PLATFORM_CANDIDATE_SHA256=$CANDIDATE_SHA256"');
+    lines.push(`if [ "$CANDIDATE_SHA256" = ${shellQuote(releaseCandidate.sha256)} ]; then cp "$CANDIDATE" "$PACK_DIR/release-candidate.tgz" || exit 1; PACK_TARBALL=release-candidate.tgz; else echo "Retained release candidate checksum changed"; exit 1; fi`);
+  }
   lines.push('echo "PLATFORM_PACKED_TARBALL=$PACK_TARBALL"');
   lines.push('printf "%s\\n" "$PACK_TARBALL" > "$PACK_DIR/packed-tarball.txt"');
   lines.push("");
@@ -213,7 +230,7 @@ export async function runTargetSuite(config, targetName, suiteName, leaseSession
   writeFileSync(resolve(suiteDir, "suite.json"), JSON.stringify({ suiteName, writtenAt: new Date().toISOString() }, null, 2));
 
   const command = suiteName === "platform-build"
-    ? buildPlatformBuildCommand(targetName, config.packageName ?? "pi-oracle", config.nodeValidationMajor ?? 24)
+    ? buildPlatformBuildCommand(targetName, config.packageName ?? "pi-oracle", config.nodeValidationMajor ?? 24, config.releaseCandidate)
     : buildRealExtensionCommand(targetName, config);
   writeCommand(suiteDir, command);
 
@@ -269,6 +286,8 @@ export async function runTargetSuite(config, targetName, suiteName, leaseSession
       { id: "platform-dependencies", fn: () => /PLATFORM_DEPS_EXIT=0/.test(stdout) },
       { id: "platform-verification", fn: () => /PLATFORM_NPM_TEST_EXIT=0/.test(stdout) },
       { id: "npm-pack", fn: () => /PLATFORM_NPM_PACK_EXIT=0/.test(stdout) && /PLATFORM_PACKED_TARBALL=\S+/.test(stdout) },
+      ...(config.releaseCandidate ? [{ id: "release-candidate-sha256",
+        fn: () => markerValue(stdout, "PLATFORM_CANDIDATE_SHA256") === config.releaseCandidate.sha256 }] : []),
       { id: "packed-node-install", fn: () => /PLATFORM_PACKED_NODE_INSTALL_EXIT=0/.test(stdout) },
       { id: "pi-install", fn: () => /PLATFORM_PI_INSTALL_EXIT=0/.test(stdout) },
       { id: "pi-list", fn: () => /PLATFORM_PI_LIST_EXIT=0/.test(stdout) && listOutput.includes(packageName) && packageInstallPattern.test(listOutput) },
@@ -289,6 +308,8 @@ export async function runTargetSuite(config, targetName, suiteName, leaseSession
       { id: "real-smoke-doctor", fn: () => stdout.includes("Oracle real smoke doctor") && stdout.includes(`provider: ${provider}`) },
       { id: "real-smoke-marker", fn: () => stdout.includes("Oracle real smoke passed:") },
       { id: "real-smoke-packed-install", fn: () => stdout.includes("mode=packed") && stdout.includes("extension=./node_modules/pi-oracle") },
+      ...(config.releaseCandidate ? [{ id: "release-candidate-sha256",
+        fn: () => markerValue(stdout, "ORACLE_RELEASE_CANDIDATE_SHA256") === config.releaseCandidate.sha256 }] : []),
       { id: "real-smoke-no-source-extension", fn: () => !command.includes("extensions/oracle/index.ts") && !/\bpi\s+(?:-e|--extension)\s+extensions\/oracle/.test(command) },
       { id: "no-secrets", fn: () => violations.length === 0, error: "redaction violations found" },
     ];

package/scripts/platform-smoke.mjs

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 
+import { createHash } from "node:crypto";
+import { copyFileSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { createRequire } from "node:module";
-import { dirname, resolve } from "node:path";
+import { dirname, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const __filename = fileURLToPath(import.meta.url);
@@ -21,7 +23,7 @@ function printHelp() {
   console.log(`Usage: node scripts/platform-smoke.mjs <command> [options]
 
 Commands:
-  doctor                     Run mandatory Crabbox, host, target-tool, auth, and package preflight checks
+  doctor [--target <names>]   Run preflight checks for required or selected targets
   run --target <names>       Run one or more comma-separated targets concurrently
   run --suite <name>         Run one suite on the configured target(s)
 
@@ -48,14 +50,19 @@ Environment:
   PLATFORM_SMOKE_CRABBOX         Reusable Crabbox binary override (defaults to PATH)
   PI_ORACLE_SMOKE_CRABBOX        Project-specific Crabbox binary override (wins over PLATFORM_SMOKE_CRABBOX)
   PLATFORM_SMOKE_MAC_HOST        macOS SSH host (default: localhost)
+  PLATFORM_SMOKE_MAC_PORT        macOS SSH port (default: 22)
   PLATFORM_SMOKE_MAC_USER        macOS SSH user (default: $USER)
   PLATFORM_SMOKE_MAC_WORK_ROOT   macOS Crabbox work root
   PLATFORM_SMOKE_UBUNTU_IMAGE    Optional local-container image override
   PLATFORM_SMOKE_WINDOWS_VM      Parallels source VM (default from config)
   PLATFORM_SMOKE_WINDOWS_SNAPSHOT Parallels snapshot (default from config)
+  PLATFORM_SMOKE_WINDOWS_HOST    Use a native Windows SSH target instead of Parallels
+  PLATFORM_SMOKE_WINDOWS_PORT    Windows SSH port (default: 22)
   PLATFORM_SMOKE_WINDOWS_USER    Windows SSH user (default: $USER)
   PLATFORM_SMOKE_WINDOWS_WORK_ROOT Windows work root
   PI_ORACLE_SMOKE_*              Project-specific aliases for the PLATFORM_SMOKE_* knobs above
+  PI_ORACLE_RELEASE_TARBALL      Use this retained tarball for the packed platform suites
+  PI_ORACLE_RELEASE_SHA256       Expected SHA-256 of the retained tarball, when supplied
   PI_ORACLE_REAL_TEST_PROVIDER   Real smoke provider (default: zai)
   PI_ORACLE_REAL_TEST_MODEL      Real smoke model (default: glm-5.2)
   ZAI_API_KEY                    Default real-smoke provider API key for optional model-agent debugging
@@ -104,9 +111,9 @@ function validateSelection(targets, suites) {
   }
 }
 
-async function runDoctor() {
+async function runDoctor(targets) {
   const { runDoctor } = await import("./platform-smoke/doctor.mjs");
-  await runDoctor(config);
+  await runDoctor({ ...config, requiredTargets: targets });
 }
 
 async function runTarget(targetName, suites, singleSuite) {
@@ -124,7 +131,10 @@ async function main() {
   if (!config) throw new Error("platform-smoke.config.mjs not found or failed to load");
 
   if (args.command === "doctor") {
-    await runDoctor();
+    const targets = args.target ? splitCsv(args.target) : config.requiredTargets;
+    if (targets.length === 0) throw new Error("--target did not resolve to any targets");
+    validateSelection(targets, config.requiredSuites);
+    await runDoctor(targets);
     return;
   }
 
@@ -134,13 +144,36 @@ async function main() {
     if (targets.length === 0) throw new Error("--target did not resolve to any targets");
     if (suites.length === 0) throw new Error("--suite did not resolve to any suites");
     validateSelection(targets, suites);
-    const results = await Promise.all(targets.map(async (target) => {
-      console.log(`\n=== Target: ${target} ===`);
-      return { target, result: await runTarget(target, suites, Boolean(args.suite)) };
-    }));
-    if (results.some(({ result }) => !result.ok)) {
-      console.log("\nOne or more platform smoke suites failed. Check .artifacts/platform-smoke/ for details.");
-      process.exit(1);
+    let inputDir;
+    try {
+      if (process.env.PI_ORACLE_RELEASE_TARBALL) {
+        // Crabbox syncs nonignored files, but this repository ignores *.tgz.
+        inputDir = mkdtempSync(resolve(repoRoot, ".oracle-release-input-"));
+        const candidate = resolve(inputDir, "candidate");
+        copyFileSync(resolve(process.env.PI_ORACLE_RELEASE_TARBALL), candidate);
+        const sha256 = createHash("sha256").update(readFileSync(candidate)).digest("hex");
+        if (process.env.PI_ORACLE_RELEASE_SHA256 && sha256 !== process.env.PI_ORACLE_RELEASE_SHA256) {
+          throw new Error("Retained release candidate checksum changed");
+        }
+        config.releaseCandidate = {
+          path: relative(repoRoot, candidate).split(sep).join("/"),
+          sha256,
+        };
+        console.log(`Retained release candidate SHA-256: ${config.releaseCandidate.sha256}`);
+      }
+      const outcomes = await Promise.allSettled(targets.map(async (target) => {
+        console.log(`\n=== Target: ${target} ===`);
+        return { target, result: await runTarget(target, suites, Boolean(args.suite)) };
+      }));
+      const failure = outcomes.find((outcome) => outcome.status === "rejected");
+      if (failure) throw failure.reason;
+      const results = outcomes.map((outcome) => outcome.value);
+      if (results.some(({ result }) => !result.ok)) {
+        console.log("\nOne or more platform smoke suites failed. Check .artifacts/platform-smoke/ for details.");
+        process.exitCode = 1;
+      }
+    } finally {
+      if (inputDir) rmSync(inputDir, { recursive: true, force: true });
     }
     return;
   }