pi-oracle 0.6.13 → 0.6.15

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## Unreleased
 
+## 0.6.15 - 2026-05-03
+
+### Fixed
+- anchored the `oracle_submit.files[]` schema pattern so OpenAI-compatible parsers that require anchored JSON Schema regexes, including llama.cpp, can load the oracle tools
+- made background poller queued-job promotion best-effort under normal global admission-lock contention, avoiding noisy scan failures when multiple pi sessions are live
+- added configured Chromium-family cookie source support for `/oracle-auth`, including macOS Keychain decryption for browser cookie stores not handled by `@steipete/sweet-cookie`
+
+## 0.6.14 - 2026-05-02
+
+### Fixed
+- deduped oracle completion wake-ups by marking one-time best-effort delivery in job state before the poller sends the follow-up turn, preventing repeated identical completion notifications across poller scans
+- clarified completion wake-up guidance so agents treat the wake-up as a read/inspect prompt rather than an automatic auth refresh or resubmission instruction
+
+### Changed
+- `oracle_read` and `/oracle-status` summaries for active jobs now include elapsed time, phase elapsed time, and a poll/backoff hint so manual checks waste fewer turns
+- `oracle_submit` preset schema and prompt guidance now list the canonical preset ids directly for tool callers
+
 ## 0.6.13 - 2026-05-01
 
 ### Changed

package/README.md

@@ -9,7 +9,7 @@ Use it when you want:
 - async background execution
 - durable saved responses/artifacts plus best-effort wake-ups back into `pi`
 
-Normal oracle jobs run in an isolated browser profile, not your active Chrome window.
+Normal oracle jobs run in an isolated browser profile, not your active browser window.
 
 > Status: experimental public beta. Validated primarily on macOS with Google Chrome and `pi` 0.65.0+.
 
@@ -43,12 +43,12 @@ pi install https://github.com/fitchmultz/pi-oracle
 ## Quickstart
 
 1. Start a normal persisted `pi` session. Do not use `pi --no-session` for oracle.
-2. Make sure ChatGPT already works in your local Chrome profile.
+2. Make sure ChatGPT already works in your configured local browser profile.
 3. Make sure these are installed: Google Chrome, `agent-browser`, `tar`, and `zstd`.
 4. Optional: create `~/.pi/agent/extensions/oracle.json` if you want non-default settings.
 5. Run `/oracle-auth`.
 6. Run `/oracle Review the current pending changes. Include the whole repo unless a narrower archive is clearly better.`
-7. Wait for a best-effort wake-up, or check `/oracle-status`.
+7. Wait for the one-time best-effort wake-up, or check `/oracle-status`.
 
 The `/oracle` prompt now runs an early oracle preflight before it gathers repo context, so missing persisted-session or local auth/config blockers fail before the agent spends time reading files.
 
@@ -56,7 +56,7 @@ For explicitly narrow requests, `/oracle` should still prefer a context-rich rel
 
 If a local archive still exceeds the 250 MB limit after default exclusions and automatic whole-repo pruning, the agent should treat that as a retryable archive-selection failure: shrink the archive automatically, retry with a smaller relevant slice, and explain what it cut only if it still cannot fit after the allowed retry budget.
 
-If you miss the wake-up, the result is still saved durably in the oracle job directory and can be read later.
+If you miss the one-time wake-up, the result is still saved durably in the oracle job directory and can be read later.
 
 ## Example requests
 
@@ -87,7 +87,7 @@ flowchart LR
     C --> D["Detached worker starts isolated ChatGPT runtime"]
     D --> E["Archive + prompt sent to ChatGPT.com"]
     E --> F["Response/artifacts saved under oracle job dir"]
-    F --> G["Best-effort wake-up to matching pi session"]
+    F --> G["One-time best-effort wake-up to matching pi session"]
 ```
 
 If concurrency is full, the job is queued and starts automatically later.
@@ -97,7 +97,7 @@ If concurrency is full, the job is queued and starts automatically later.
 User-facing commands:
 - `/oracle <request>` — prompt template that tells the agent to gather context and dispatch an oracle job
 - `/oracle-followup <job-id> <request>` — prompt template that continues an earlier oracle job in the same ChatGPT thread
-- `/oracle-auth` — sync ChatGPT cookies from your real Chrome profile into the isolated oracle auth profile
+- `/oracle-auth` — sync ChatGPT cookies from your configured local browser profile into the isolated oracle auth profile
 - `/oracle-read [job-id]` — inspect job status plus the saved response preview
 - `/oracle-status [job-id]` — inspect job status and list recent job ids when no explicit id is given
 - `/oracle-cancel <job-id>` — cancel a queued or active job by id
@@ -112,7 +112,7 @@ Agent-facing tools:
 
 ## Minimal config
 
-Most users can start with the packaged defaults and only set the Chrome profile if needed.
+Most users can start with the packaged defaults and only set the browser profile if needed.
 
 `~/.pi/agent/extensions/oracle.json`
 
@@ -133,6 +133,41 @@ Notes:
 - If the packaged default is fine, you can omit `defaults.preset` entirely.
 - You usually do not need to set browser paths unless auto-detection fails.
 
+### Custom Chromium cookie sources
+
+Most Chrome-compatible browsers should work through the default cookie importer. Use this alternate path only for a Chromium-family browser that is not one of `@steipete/sweet-cookie`'s built-in Chrome/Brave/Arc/Chromium targets or otherwise cannot import cookies without dependency patching.
+
+Before running `/oracle-auth` with this path:
+
+1. Log into ChatGPT in the target browser profile.
+2. Fully quit the browser so its `Cookies` database is stable.
+3. Find the profile `Cookies` SQLite DB path.
+4. Find the browser's macOS Keychain safe-storage item account and service name.
+5. Configure all of `browser.executablePath`, `auth.chromeCookiePath`, and `auth.chromiumKeychain` in the agent-level config at `~/.pi/agent/extensions/oracle.json`.
+
+Example Helium config:
+
+```json
+{
+  "browser": {
+    "executablePath": "/Applications/Helium.app/Contents/MacOS/Helium"
+  },
+  "auth": {
+    "chromeProfile": "Default",
+    "chromeCookiePath": "/Users/you/Library/Application Support/net.imput.helium/Default/Cookies",
+    "chromiumKeychain": {
+      "account": "Helium",
+      "services": ["Helium Storage Key"],
+      "label": "Helium Storage Key"
+    }
+  }
+}
+```
+
+`auth.chromeCookiePath` remains the cookie database path for backward compatibility. `auth.chromiumKeychain` must be paired with `auth.chromeCookiePath`; partial config is rejected so oracle does not silently fall back to a different browser source. When both are present, `/oracle-auth` uses pi-oracle's repo-owned generic Chromium cookie reader instead of patching `@steipete/sweet-cookie` internals.
+
+If macOS prompts for Keychain access during `/oracle-auth`, allow access for the configured browser safe-storage item. If auth still fails after cookies are synced, the cookie DB may be stale, from the wrong profile, or for an account that is logged out; reopen the configured browser profile, confirm ChatGPT works there, quit the browser, and rerun `/oracle-auth`.
+
 ## Available presets
 
 | Preset id | Description |
@@ -162,7 +197,7 @@ Project config should only override safe, non-privileged settings.
 
 - Jobs persist their response and any artifacts under `${PI_ORACLE_JOBS_DIR:-/tmp}/oracle-<job-id>/` by default.
 - Jobs can queue automatically if runtime capacity is full.
-- Completion delivery into `pi` is best-effort wake-up based.
+- Completion delivery into `pi` is one-time best-effort wake-up based; duplicate poller scans are deduped in job state.
 - If you miss the wake-up, use `/oracle-read [job-id]` to inspect the saved response preview.
 - `/oracle-status [job-id]` still shows saved job metadata and lists recent job ids when you omit the id.
 - Agent callers can use `oracle_read({ jobId })`.
@@ -173,8 +208,8 @@ Project config should only override safe, non-privileged settings.
 
 - macOS
 - Node.js 22 or newer
-- Google Chrome installed
-- ChatGPT already signed into a local Chrome profile
+- Google Chrome or another Chromium-family browser installed
+- ChatGPT already signed into the configured local browser profile
 - `pi` 0.65.0 or newer
 - `agent-browser` available on the machine
 - `tar` and `zstd` available
@@ -183,7 +218,8 @@ Project config should only override safe, non-privileged settings.
 
 ### `/oracle-auth` fails or says login is required
 
-- Make sure ChatGPT works in the same local Chrome profile you configured.
+- Make sure ChatGPT works in the same local browser profile you configured.
+- For custom Chromium cookie sources, confirm `auth.chromeCookiePath` points at that profile's `Cookies` DB and `auth.chromiumKeychain.services` names the browser's safe-storage Keychain service.
 - Re-run `/oracle-auth`.
 - If ChatGPT is half-logged-in or challenge flow state looks weird, finish the login/challenge in the headed auth browser and retry.
 
@@ -214,9 +250,10 @@ Project config should only override safe, non-privileged settings.
 
 - Install the missing local dependency and rerun the command.
 
-### Auto-detection picked the wrong Chrome profile
+### Auto-detection picked the wrong browser profile
 
 - Set `auth.chromeProfile` in `~/.pi/agent/extensions/oracle.json`.
+- For custom Chromium cookie sources, set `auth.chromeCookiePath` to the exact profile `Cookies` DB and pair it with `auth.chromiumKeychain`.
 - Re-run `/oracle-auth`.
 
 ### You want more details about a failed run
@@ -233,7 +270,7 @@ Project config should only override safe, non-privileged settings.
 ## Privacy / local data
 
 This extension is local-first, but it does read and persist local data:
-- `/oracle-auth` reads ChatGPT cookies from a local Chrome profile
+- `/oracle-auth` reads ChatGPT cookies from the configured local browser profile
 - job archives are uploaded to ChatGPT.com
 - responses and artifacts are written under the configured oracle jobs dir
 

package/docs/ORACLE_DESIGN.md

@@ -127,9 +127,10 @@ Auth bootstrap flow:
 
 1. load oracle config
 2. acquire the global auth-maintenance lock
-3. read ChatGPT cookies directly from the user’s real Chrome cookie store in read-only mode
+3. read ChatGPT cookies directly from the configured local browser cookie store in read-only mode
    - configurable source profile / cookie DB path
-   - no launch or mutation of the real Chrome profile
+   - optional configured Chromium Keychain source for browsers outside the default importer
+   - no launch or mutation of the real browser profile
 4. validate that `browser.authSeedProfileDir` is an absolute safe path and not inside the real Chrome user-data tree
 5. create a staged seed-profile path next to the target seed profile
 6. launch the isolated auth browser headed with:
@@ -246,15 +247,20 @@ Browser/auth settings are global-only because they control local privileged brow
     "chatUrl": "https://chatgpt.com/",
     "authUrl": "https://chatgpt.com/auth/login",
     "runMode": "headless",
-    "executablePath": "<optional absolute path to Chrome executable>",
+    "executablePath": "<optional absolute path to Chrome/Chromium executable>",
     "userAgent": "<optional real-Chrome UA override>",
     "args": ["--disable-blink-features=AutomationControlled"]
   },
   "auth": {
     "pollMs": 1000,
     "bootstrapTimeoutMs": 600000,
-    "chromeProfile": "<optional Chrome profile name>",
-    "chromeCookiePath": "<optional absolute path to Chrome Cookies DB>"
+    "chromeProfile": "<optional Chrome/Chromium profile name>",
+    "chromeCookiePath": "<optional absolute path to Chromium Cookies DB>",
+    "chromiumKeychain": {
+      "account": "<macOS Keychain account for non-built-in Chromium browsers>",
+      "services": ["<safe-storage service name>"],
+      "label": "<optional human-readable label>"
+    }
   },
   "worker": {
     "pollMs": 5000,
@@ -273,6 +279,23 @@ Browser/auth settings are global-only because they control local privileged brow
 }
 ```
 
+`auth.chromiumKeychain` is an opt-in alternate cookie source for Chromium-family browsers that are not handled by the default `@steipete/sweet-cookie` Chrome-compatible importer. It must be configured with `auth.chromeCookiePath`; partial config is rejected so `/oracle-auth` cannot silently fall back to a different browser profile.
+
+When both `auth.chromeCookiePath` and `auth.chromiumKeychain` are present, auth bootstrap:
+
+1. reads the configured macOS Keychain safe-storage password using `account` and the ordered `services` list
+2. snapshots the Chromium `Cookies` DB plus `Cookies-wal` / `Cookies-shm` sidecars, tolerating sidecars that disappear while the browser is closing
+3. decrypts Chromium AES-CBC cookie values, including Chromium v24+ host-hash-prefixed values
+4. dedupes duplicate cookie rows by keeping the first row after newest-expiry ordering
+5. filters importable ChatGPT auth cookies and seeds the isolated oracle auth profile
+
+Operational requirements for this path:
+
+- ChatGPT must already be logged in in the configured browser profile.
+- The target browser should be fully quit before `/oracle-auth` so the cookie DB snapshot is stable.
+- The configured Keychain item must be accessible to the current macOS user; allow Keychain access if prompted.
+- `browser.executablePath` should point at the same Chromium-family browser so the headed auth/bootstrap browser uses the intended app.
+
 ## Cleanup maintenance model
 
 Long-run hygiene is intentionally conservative:
@@ -484,12 +507,12 @@ The extension still uses the same general `pi`-native background completion patt
 - detached worker writes `${PI_ORACLE_JOBS_DIR:-/tmp}/oracle-*` state
 - poller scans jobs on an interval
 - completed job durability lives in oracle job state plus saved response/artifact files, not in synthetic session-history assistant messages
-- when a matching job reaches `complete`, `failed`, or `cancelled`, the poller issues bounded best-effort wake-up reminders to whichever matching session is currently live
+- when a matching job reaches `complete`, `failed`, or `cancelled`, the poller issues one best-effort wake-up to whichever matching session is currently live, then records `notifiedAt` so later scans do not duplicate the completion message
 - those wake-ups direct the receiver to `/oracle-read [job-id]` as the primary completion-consumption path, while still surfacing saved response/artifact paths as secondary context; `/oracle-status` remains useful for metadata and job-id discovery, and agent callers can still use `oracle_read` when they need tool output in-turn
-- manual `oracle_read`, `/oracle-read`, or `/oracle-status` inspection settles further reminder retries once the terminal job has been opened and persists provenance about which path/session settled the wake-up
-- manual inspection before the first wake-up attempt is recorded separately as observation metadata and does not suppress the first reminder send
+- wake-up content explicitly tells agents not to treat completion as an automatic `oracle_auth`, `oracle_submit`, or `oracle_cancel` retry instruction
+- manual `oracle_read`, `/oracle-read`, or `/oracle-status` inspection after a wake-up persists provenance about which path/session settled the wake-up
 - if no wake-up lands, the job remains available via `/oracle-read`, `/oracle-status`, `oracle_read`, and the saved `${PI_ORACLE_JOBS_DIR:-/tmp}/oracle-<job-id>/` response/artifact files
-- because completion delivery is best-effort, pruning uses explicit terminal-job age policy instead of pretending a durable session notification happened
+- because completion delivery is best-effort, pruning uses explicit terminal-job age policy plus `notifiedAt`/wakeup state instead of pretending a durable session notification was appended
 - recently sent wake-ups keep response/artifact files retained briefly so follow-up turns do not point at deleted paths if cleanup or pruning races with delivery
 
 ## What was removed by this pivot
@@ -565,7 +588,7 @@ Live-validated after the concurrency redesign:
 - the poller no longer needs the worker to stay alive just to observe completion for artifact-producing runs
 - expired/missing auth now fails as a clean auth-related error instead of generic UI/config drift
 - `/oracle-auth` repairs the seed profile and a post-repair probe succeeds again
-- live auth recovery also exposed and corrected a real source-profile misconfiguration during validation; the configured Chrome profile must actually contain the active ChatGPT session cookies
+- live auth recovery also exposed and corrected a real source-profile misconfiguration during validation; the configured browser profile must actually contain the active ChatGPT session cookies
 
 ## Known remaining work
 

package/extensions/oracle/lib/config.ts

@@ -209,6 +209,11 @@ export interface OracleConfig {
     bootstrapTimeoutMs: number;
     chromeProfile: string;
     chromeCookiePath?: string;
+    chromiumKeychain?: {
+      account: string;
+      services: string[];
+      label?: string;
+    };
   };
   worker: {
     pollMs: number;
@@ -286,11 +291,12 @@ export function getOracleConfigLoadDetails(cwd: string): OracleConfigLoadDetails
 }
 
 export function formatOracleAuthConfigRemediation(details: OracleConfigLoadDetails): string {
+  const authFields = "auth.chromeProfile / auth.chromeCookiePath / auth.chromiumKeychain";
   if (!details.projectConfigExists) {
-    return `Set auth.chromeProfile / auth.chromeCookiePath in ${details.effectiveAuthConfigPath}.`;
+    return `Set ${authFields} in ${details.effectiveAuthConfigPath}.`;
   }
   return (
-    `Set auth.chromeProfile / auth.chromeCookiePath in ${details.effectiveAuthConfigPath}. ` +
+    `Set ${authFields} in ${details.effectiveAuthConfigPath}. ` +
     `Project overrides are also read from ${details.projectConfigPath}, but auth.* is loaded from ${details.effectiveAuthConfigPath}.`
   );
 }
@@ -330,6 +336,7 @@ export const DEFAULT_CONFIG: OracleConfig = {
     bootstrapTimeoutMs: 10 * 60 * 1000,
     chromeProfile: detectedChromeProfileName,
     chromeCookiePath: undefined,
+    chromiumKeychain: undefined,
   },
   worker: {
     pollMs: 5000,
@@ -439,6 +446,20 @@ function expectStringArray(value: unknown, path: string): string[] {
   return value;
 }
 
+function expectOptionalChromiumKeychain(value: unknown, path: string): OracleConfig["auth"]["chromiumKeychain"] {
+  if (value === undefined) return undefined;
+  const keychain = expectObject(value, path);
+  const services = expectStringArray(keychain.services, `${path}.services`);
+  if (services.length === 0) {
+    throw new Error(`Invalid oracle config: ${path}.services must include at least one service name`);
+  }
+  return {
+    account: expectString(keychain.account, `${path}.account`),
+    services,
+    label: expectOptionalString(keychain.label, `${path}.label`),
+  };
+}
+
 function expectInteger(value: unknown, path: string, minimum: number, maximum?: number): number {
   if (typeof value !== "number" || !Number.isInteger(value) || value < minimum || (maximum !== undefined && value > maximum)) {
     const range = maximum === undefined ? `>= ${minimum}` : `between ${minimum} and ${maximum}`;
@@ -523,6 +544,12 @@ function validateOracleConfig(value: unknown): OracleConfig {
     throw new Error("Invalid oracle config: browser.runtimeProfilesDir must be separate from browser.authSeedProfileDir");
   }
 
+  const chromeCookiePath = expectOptionalAbsoluteNormalizedPath(auth.chromeCookiePath, "auth.chromeCookiePath");
+  const chromiumKeychain = expectOptionalChromiumKeychain(auth.chromiumKeychain, "auth.chromiumKeychain");
+  if (chromiumKeychain !== undefined && chromeCookiePath === undefined) {
+    throw new Error("Invalid oracle config: auth.chromiumKeychain requires auth.chromeCookiePath");
+  }
+
   return {
     defaults: {
       preset,
@@ -544,7 +571,8 @@ function validateOracleConfig(value: unknown): OracleConfig {
       pollMs: expectInteger(auth.pollMs, "auth.pollMs", 100),
       bootstrapTimeoutMs: expectInteger(auth.bootstrapTimeoutMs, "auth.bootstrapTimeoutMs", 1000),
       chromeProfile: expectString(auth.chromeProfile, "auth.chromeProfile"),
-      chromeCookiePath: expectOptionalAbsoluteNormalizedPath(auth.chromeCookiePath, "auth.chromeCookiePath"),
+      chromeCookiePath,
+      chromiumKeychain,
     },
     worker: {
       pollMs: expectInteger(worker.pollMs, "worker.pollMs", 100),

package/extensions/oracle/lib/poller.ts

@@ -15,6 +15,7 @@ import {
   hasPersistedOriginSession,
   isActiveOracleJob,
   listOracleJobDirs,
+  markJobNotified,
   noteWakeupRequested,
   readJob,
   recordNotificationTarget,
@@ -245,7 +246,11 @@ async function scan(
   }
   if (await releaseWakeupLeaseIfInactive(wakeupTargetLeaseKey, lifecycle)) return;
 
-  await promoteQueuedJobs({ workerPath, source: "poller" });
+  try {
+    await promoteQueuedJobs({ workerPath, source: "poller", lockTimeoutMs: POLLER_LOCK_TIMEOUT_MS });
+  } catch (error) {
+    if (!isLockTimeoutError(error, "admission", "global")) throw error;
+  }
   if (await releaseWakeupLeaseIfInactive(wakeupTargetLeaseKey, lifecycle)) return;
 
   const terminalJobs = listOracleJobDirs()
@@ -324,7 +329,6 @@ async function scan(
         await releaseNotificationClaim(jobId, notificationClaimant).catch(() => undefined);
         return;
       }
-      requestWakeupTurn(pi, deliverable);
       const notedWakeup = await noteWakeupRequested(jobId);
       if (!notedWakeup) {
         await releaseNotificationClaim(jobId, notificationClaimant).catch(() => undefined);
@@ -334,6 +338,13 @@ async function scan(
         await releaseNotificationClaim(jobId, notificationClaimant).catch(() => undefined);
         return;
       }
+      await hooks.beforeMarkJobNotified?.(deliverable);
+      await markJobNotified(jobId, notificationClaimant, {
+        notificationSessionKey: pollerKey,
+        notificationSessionFile: currentSessionFile,
+      });
+      if (await releaseWakeupLeaseIfInactive(wakeupTargetLeaseKey, lifecycle)) return;
+      requestWakeupTurn(pi, deliverable);
       if (snapshot.hasUI) {
         snapshot.ui.notify(`Oracle job ${claimed.id} is ${claimed.status}.`, "info");
       }

package/extensions/oracle/lib/queue.ts

@@ -25,6 +25,7 @@ export interface OracleQueuePosition {
 export interface PromoteQueuedJobsOptions {
   workerPath: string;
   source: string;
+  lockTimeoutMs?: number;
   spawnWorkerFn?: typeof spawnWorker;
   loadConfigFn?: typeof loadOracleConfig;
 }
@@ -141,7 +142,7 @@ export async function promoteQueuedJobsWithinAdmissionLock(options: PromoteQueue
 export async function promoteQueuedJobs(options: PromoteQueuedJobsOptions): Promise<{ promotedJobIds: string[] }> {
   return withLock("admission", "global", { processPid: process.pid, source: options.source }, async () => {
     return promoteQueuedJobsWithinAdmissionLock(options);
-  });
+  }, { timeoutMs: options.lockTimeoutMs });
 }
 
 export async function createQueuedJob(

package/extensions/oracle/lib/tools.ts

@@ -63,7 +63,7 @@ const ORACLE_SUBMIT_PARAMS = Type.Object({
   files: Type.Array(Type.String({
     description: "Project-relative file or directory path to include in the archive.",
     minLength: 1,
-    pattern: ".*\\S.*",
+    pattern: "^.*\\S.*$",
   }), {
     description: "Exact project-relative files/directories to include in the oracle archive.",
     minItems: 1,
@@ -71,7 +71,8 @@ const ORACLE_SUBMIT_PARAMS = Type.Object({
   preset: Type.Optional(
     Type.String({
       description:
-        "ChatGPT model preset. Omit to use the configured default preset. Canonical ids are preferred; matching human-readable preset labels and common hyphen/space variants are normalized automatically.",
+        `ChatGPT model preset. Omit to use the configured default preset. Canonical ids: ${ORACLE_SUBMIT_PRESET_IDS.join(", ")}. ` +
+        "Matching human-readable preset labels and common hyphen/space variants are normalized automatically.",
     }),
   ),
   followUpJobId: Type.Optional(Type.String({ description: "Earlier oracle job id whose chat thread should be continued." })),
@@ -1054,7 +1055,7 @@ export function registerOracleTools(pi: ExtensionAPI, workerPath: string, authWo
   pi.registerTool({
     name: "oracle_auth",
     label: "Oracle Auth",
-    description: "Refresh the shared oracle auth seed profile by importing ChatGPT cookies from your configured real Chrome profile.",
+    description: "Refresh the shared oracle auth seed profile by importing ChatGPT cookies from your configured local browser profile.",
     promptSnippet: "Refresh oracle auth before retrying a login-required oracle run.",
     promptGuidelines: [
       "Call oracle_auth when an oracle run failed because ChatGPT login is required, the worker said to rerun /oracle-auth, or stale auth appears to be blocking submission execution.",
@@ -1101,7 +1102,9 @@ export function registerOracleTools(pi: ExtensionAPI, workerPath: string, authWo
       "For any other submit-time error, stop and report the error instead of retrying automatically.",
       "If oracle_submit returns a queued job instead of an immediately dispatched one, treat that as success and stop exactly the same way.",
       "After a successful or queued oracle_submit, stop; do not continue the task while the oracle job is running. If oracle_submit failed with retryable archive_too_large, narrow the archive and retry first.",
-      "Use `preset` as the only model-selection parameter on oracle_submit. Canonical ids are preferred, and matching human-readable preset labels are normalized automatically. Omit preset to use the configured default.",
+      "Use `preset` as the only model-selection parameter on oracle_submit. " +
+      `Canonical ids: ${ORACLE_SUBMIT_PRESET_IDS.join(", ")}. ` +
+      "matching human-readable preset labels are normalized automatically. Omit preset to use the configured default.",
     ],
     parameters: ORACLE_SUBMIT_PARAMS,
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {

package/extensions/oracle/shared/job-lifecycle-helpers.mjs

@@ -287,9 +287,6 @@ export function markOracleJobNotified(job, options = {}) {
     notificationEntryId: options.notificationEntryId ?? job.notificationEntryId,
     notificationSessionKey: options.notificationSessionKey ?? job.notificationSessionKey,
     notificationSessionFile: options.notificationSessionFile ?? job.notificationSessionFile,
-    wakeupAttemptCount: 0,
-    wakeupLastRequestedAt: undefined,
-    wakeupSettledAt: undefined,
     notifyClaimedAt: undefined,
     notifyClaimedBy: undefined,
   });

package/extensions/oracle/shared/job-observability-helpers.d.mts

@@ -4,6 +4,7 @@ export interface OracleJobSummaryLike {
   id: string;
   status: string;
   phase: string;
+  phaseAt?: string;
   createdAt: string;
   queuedAt?: string;
   submittedAt?: string;
@@ -38,6 +39,7 @@ export interface OracleJobSummaryOptions {
   includeWorkerLogPath?: boolean;
   nowMs?: number;
   heartbeatStaleMs?: number;
+  suggestedPollAfterSeconds?: number;
 }
 
 export interface OracleSubmitResponseOptions {

package/extensions/oracle/shared/job-observability-helpers.mjs

@@ -48,6 +48,7 @@ function formatAutoPrunedArchiveMessage(autoPrunedPrefixes) {
 
 const ACTIVE_SUMMARY_STATUSES = new Set(["preparing", "submitted", "waiting"]);
 const DEFAULT_ORACLE_HEARTBEAT_STALE_MS = 3 * 60 * 1000;
+const DEFAULT_ACTIVE_JOB_POLL_HINT_SECONDS = 15;
 
 /**
  * @param {string | undefined} value
@@ -99,6 +100,31 @@ function formatHeartbeatFreshness(job, options = {}) {
   return `heartbeat: ${freshness} (${formatElapsed(elapsedMs)} ${submittedMs !== undefined ? "since submit" : "since create"})`;
 }
 
+/**
+ * @param {OracleJobSummaryLike} job
+ * @param {OracleJobSummaryOptions} [options]
+ * @returns {string[]}
+ */
+function formatActiveProgressLines(job, options = {}) {
+  if (!ACTIVE_SUMMARY_STATUSES.has(job.status)) return [];
+  const nowMs = Number.isFinite(options.nowMs) ? options.nowMs : Date.now();
+  const submittedMs = parseTimestamp(job.submittedAt);
+  const createdMs = parseTimestamp(job.createdAt);
+  const phaseMs = parseTimestamp(job.phaseAt);
+  const baselineMs = submittedMs ?? createdMs;
+  const elapsedLine = baselineMs === undefined
+    ? undefined
+    : `elapsed: ${formatElapsed(nowMs - baselineMs)} ${submittedMs !== undefined ? "since submit" : "since create"}`;
+  const phaseElapsedLine = phaseMs === undefined
+    ? undefined
+    : `phase-elapsed: ${formatElapsed(nowMs - phaseMs)} in ${job.phase}`;
+  const pollHintSeconds = Number.isFinite(options.suggestedPollAfterSeconds)
+    ? Math.max(1, Math.round(options.suggestedPollAfterSeconds))
+    : DEFAULT_ACTIVE_JOB_POLL_HINT_SECONDS;
+  const pollHint = `poll-hint: wait about ${pollHintSeconds}s before checking again, or stop and wait for the one-time completion wake-up`;
+  return [elapsedLine, phaseElapsedLine, pollHint].filter(Boolean);
+}
+
 /**
  * @param {{ id: string; status: string }} job
  * @returns {string}
@@ -142,6 +168,7 @@ export function formatOracleJobSummary(job, options = {}) {
     `project: ${job.projectId}`,
     `session: ${job.sessionId}`,
     formatHeartbeatFreshness(job, options),
+    ...formatActiveProgressLines(job, options),
     job.completedAt ? `completed: ${job.completedAt}` : undefined,
     job.followUpToJobId ? `follow-up-to: ${job.followUpToJobId}` : undefined,
     job.chatUrl ? `chat: ${job.chatUrl}` : undefined,
@@ -175,7 +202,8 @@ export function buildOracleWakeupNotificationContent(job, options = {}) {
   const artifactsPath = options.artifactsPath ?? `artifacts unavailable for ${job.id}`;
   return [
     `Oracle job ${job.id} is ${job.status}.`,
-    `Use /oracle-read ${job.id} to inspect the saved response preview. /oracle-status ${job.id} still shows saved job metadata. Agent callers can use oracle_read({ jobId: "${job.id}" }) if they need tool output in the current turn.`,
+    "This is a one-time completion wake-up, not a retry instruction. Do not call oracle_auth, oracle_submit, or oracle_cancel automatically from this wake-up.",
+    `Use /oracle-read ${job.id} to inspect the saved response preview. /oracle-status ${job.id} still shows saved job metadata. Agent callers can use oracle_read({ jobId: "${job.id}" }) once if they need tool output in the current turn.`,
     responseLine,
     `Artifacts: ${artifactsPath}`,
     formatOracleLifecycleEvent(getLatestOracleJobLifecycleEvent(job)) ? `Last event: ${formatOracleLifecycleEvent(getLatestOracleJobLifecycleEvent(job))}` : undefined,
@@ -199,7 +227,7 @@ export function formatOracleSubmitResponse(job, options) {
     `Response will be written to: ${job.responsePath}`,
     formatOracleLifecycleEvent(getLatestOracleJobLifecycleEvent(job)) ? `Last event: ${formatOracleLifecycleEvent(getLatestOracleJobLifecycleEvent(job))}` : undefined,
     options.queued ? "The job will start automatically when capacity is available." : undefined,
-    "Stop now and wait for the oracle completion wake-up.",
+    "Do not poll now; wait for the one-time oracle completion wake-up.",
   ]
     .filter(Boolean)
     .join("\n");

package/extensions/oracle/worker/auth-bootstrap.mjs

@@ -1,8 +1,8 @@
-// Purpose: Bootstrap isolated oracle browser auth by importing real Chrome cookies and validating ChatGPT session readiness.
+// Purpose: Bootstrap isolated oracle browser auth by importing real Chromium-family cookies and validating ChatGPT session readiness.
 // Responsibilities: Copy/import cookies, classify auth pages, drive lightweight account-selection flows, and persist diagnostics for auth failures.
 // Scope: Auth bootstrap worker only; long-running oracle job execution stays in run-job.mjs and shared lifecycle/state helpers stay elsewhere.
 // Usage: Spawned by /oracle-auth to prepare the shared auth seed profile used by future oracle jobs.
-// Invariants/Assumptions: Runs against a local macOS Chrome profile, preserves private diagnostics, and must fail clearly when auth state cannot be verified.
+// Invariants/Assumptions: Runs against a local macOS Chromium-family profile, preserves private diagnostics, and must fail clearly when auth state cannot be verified.
 import { withLock } from "./state-locks.mjs";
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
@@ -11,6 +11,7 @@ import { homedir, tmpdir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 import { getCookies } from "@steipete/sweet-cookie";
 import { ensureAccountCookie, filterImportableAuthCookies } from "./auth-cookie-policy.mjs";
+import { getCookiesFromConfiguredChromiumSource } from "./chromium-cookie-source.mjs";
 import { buildAllowedChatGptOrigins } from "./chatgpt-ui-helpers.mjs";
 import { buildAccountChooserCandidateLabels, classifyChatAuthPage, normalizeLoginProbeResult } from "./auth-flow-helpers.mjs";
 
@@ -91,11 +92,11 @@ function authConfigRemediation() {
   if (typeof configLoad?.remediation === "string" && configLoad.remediation) return configLoad.remediation;
   if (typeof configLoad?.projectConfigPath === "string" && configLoad.projectConfigPath && configLoad.projectConfigExists) {
     return (
-      `Set auth.chromeProfile / auth.chromeCookiePath in ${effectiveAuthConfigPath()}. ` +
+      `Set auth.chromeProfile / auth.chromeCookiePath / auth.chromiumKeychain in ${effectiveAuthConfigPath()}. ` +
       `Project overrides are also read from ${configLoad.projectConfigPath}, but auth.* is loaded from ${effectiveAuthConfigPath()}.`
     );
   }
-  return `Set auth.chromeProfile / auth.chromeCookiePath in ${effectiveAuthConfigPath()}.`;
+  return `Set auth.chromeProfile / auth.chromeCookiePath / auth.chromiumKeychain in ${effectiveAuthConfigPath()}.`;
 }
 
 function authConfigSummary() {
@@ -463,14 +464,24 @@ function cookieSource() {
 }
 
 function cookieSourceLabel() {
+  if (config.auth.chromeCookiePath && config.auth.chromiumKeychain) return `Chromium cookie DB ${config.auth.chromeCookiePath}`;
   return config.auth.chromeCookiePath
     ? `Chrome cookie DB ${config.auth.chromeCookiePath}`
     : `Chrome profile ${config.auth.chromeProfile}`;
 }
 
-async function readSourceCookies() {
-  await log(`Reading ChatGPT cookies from ${cookieSourceLabel()}`);
-  const { cookies, warnings } = await getCookies({
+async function readRawSourceCookies() {
+  if (config.auth.chromeCookiePath && config.auth.chromiumKeychain) {
+    return await getCookiesFromConfiguredChromiumSource({
+      dbPath: config.auth.chromeCookiePath,
+      keychain: config.auth.chromiumKeychain,
+      origins: cookieOrigins(),
+      profile: config.auth.chromeProfile,
+      timeoutMs: 5_000,
+    });
+  }
+
+  return await getCookies({
     url: config.browser.chatUrl,
     origins: cookieOrigins(),
     browsers: ["chrome"],
@@ -478,9 +489,14 @@ async function readSourceCookies() {
     chromeProfile: cookieSource(),
     timeoutMs: 5_000,
   });
+}
+
+async function readSourceCookies() {
+  await log(`Reading ChatGPT cookies from ${cookieSourceLabel()}`);
+  const { cookies, warnings } = await readRawSourceCookies();
 
   if (warnings.length) {
-    await log(`sweet-cookie warnings: ${warnings.join(" | ")}`);
+    await log(`Cookie source warnings: ${warnings.join(" | ")}`);
   }
 
   const filtered = filterImportableAuthCookies(cookies, config.browser.chatUrl);
@@ -501,7 +517,7 @@ async function readSourceCookies() {
 
   if (!hasSessionToken) {
     throw new Error(
-      `No ChatGPT session-token cookies were found in ${cookieSourceLabel()}. Make sure ChatGPT is logged into that Chrome profile. ${authConfigRemediation()}`,
+      `No ChatGPT session-token cookies were found in ${cookieSourceLabel()}. Make sure ChatGPT is logged into that browser profile. ${authConfigRemediation()}`,
     );
   }
 
@@ -828,7 +844,7 @@ async function run() {
 
 run().catch((error) => {
   process.stderr.write(
-    `${error instanceof Error ? error.message : String(error)}\nSee ${LOG_PATH} and diagnostics in ${DIAGNOSTICS_DIR || "(oracle-auth diagnostics dir unavailable)"}\n${authConfigSummary()}\nIf needed, ensure the configured real Chrome profile is already logged into ChatGPT and grant macOS Keychain access when prompted.`,
+    `${error instanceof Error ? error.message : String(error)}\nSee ${LOG_PATH} and diagnostics in ${DIAGNOSTICS_DIR || "(oracle-auth diagnostics dir unavailable)"}\n${authConfigSummary()}\nIf needed, ensure the configured browser profile is already logged into ChatGPT and grant macOS Keychain access when prompted.`,
   );
   process.exit(1);
 });

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

@@ -114,7 +114,8 @@ export function classifyChatAuthPage(args) {
       state: "login_required",
       message:
         `Synced cookies from ${args.cookieSourceLabel}, but ChatGPT still rejected the session ` +
-        `(status=${args.probe?.status ?? 0}). Check auth.chromeProfile/auth.chromeCookiePath and inspect ${args.logPath}.`,
+        `(status=${args.probe?.status ?? 0}); the cookie DB may be stale, from the wrong browser profile, or for an account that is logged out. ` +
+        `Check auth.chromeProfile/auth.chromeCookiePath/auth.chromiumKeychain and inspect ${args.logPath}.`,
     };
   }
 
@@ -131,7 +132,8 @@ export function classifyChatAuthPage(args) {
       state: "login_required",
       message:
         `Synced cookies from ${args.cookieSourceLabel}, but ChatGPT still rejected the session ` +
-        `(status=${args.probe?.status ?? 0}). Check auth.chromeProfile/auth.chromeCookiePath and inspect ${args.logPath}.`,
+        `(status=${args.probe?.status ?? 0}); the cookie DB may be stale, from the wrong browser profile, or for an account that is logged out. ` +
+        `Check auth.chromeProfile/auth.chromeCookiePath/auth.chromiumKeychain and inspect ${args.logPath}.`,
     };
   }
 

package/extensions/oracle/worker/chromium-cookie-source.d.mts

@@ -0,0 +1,21 @@
+import type { ImportedAuthCookie } from "./auth-cookie-policy.mjs";
+
+export interface ChromiumKeychainConfig {
+  account: string;
+  services: string[];
+  label?: string;
+  service?: string;
+}
+
+export interface ConfiguredChromiumSourceOptions {
+  dbPath: string;
+  keychain: ChromiumKeychainConfig;
+  origins: string[];
+  profile: string;
+  timeoutMs?: number;
+  includeExpired?: boolean;
+}
+
+export function getCookiesFromConfiguredChromiumSource(
+  options: ConfiguredChromiumSourceOptions,
+): Promise<{ cookies: ImportedAuthCookie[]; warnings: string[] }>;

package/extensions/oracle/worker/chromium-cookie-source.mjs

@@ -0,0 +1,291 @@
+// Purpose: Read ChatGPT cookies from arbitrary macOS Chromium-family cookie stores when sweet-cookie's built-in browser list is too narrow.
+// Responsibilities: Snapshot a Chromium Cookies SQLite DB, decrypt AES-CBC cookie values with a configured Keychain item, and return sweet-cookie-shaped cookie objects.
+// Scope: macOS Chromium cookie extraction only; auth policy filtering and browser seeding stay in auth-bootstrap.mjs.
+// Usage: auth-bootstrap.mjs uses this when auth.chromiumKeychain is configured alongside auth.chromeCookiePath.
+// Invariants/Assumptions: The configured cookie path points at a Chromium Cookies DB and the configured Keychain item is the browser's safe-storage secret.
+import { spawn } from "node:child_process";
+import { createDecipheriv, pbkdf2Sync } from "node:crypto";
+import { copyFileSync, existsSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+
+const CHROMIUM_EPOCH_OFFSET_SECONDS = 11_644_473_600n;
+const COOKIE_VALUE_DECODER = new TextDecoder("utf-8", { fatal: true });
+const MACOS_CHROMIUM_KEY_ITERATIONS = 1003;
+
+function spawnCapture(command, args, options = {}) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    const timeoutMs = options.timeoutMs ?? 5_000;
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+    }, timeoutMs);
+    timer.unref?.();
+
+    child.stdout.on("data", (data) => { stdout += String(data); });
+    child.stderr.on("data", (data) => { stderr += String(data); });
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      resolve({ ok: false, stdout, stderr, error: error.message });
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve({
+        ok: code === 0 && !timedOut,
+        stdout,
+        stderr,
+        error: timedOut ? `Timed out after ${timeoutMs}ms` : stderr.trim(),
+      });
+    });
+  });
+}
+
+async function readKeychainPassword(keychain, timeoutMs) {
+  const services = Array.isArray(keychain.services) && keychain.services.length > 0 ? keychain.services : [keychain.service];
+  for (const service of services.filter(Boolean)) {
+    const result = await spawnCapture("security", ["find-generic-password", "-w", "-a", keychain.account, "-s", service], { timeoutMs });
+    if (result.ok) {
+      const password = result.stdout.trim();
+      if (password) return { ok: true, password, service };
+      return { ok: false, error: `macOS Keychain returned an empty ${keychain.label || service} password.` };
+    }
+  }
+  return { ok: false, error: `Failed to read macOS Keychain (${keychain.label || keychain.account}): no configured service returned a password.` };
+}
+
+function snapshotCookieDb(dbPath) {
+  const tempDir = mkdtempSync(join(tmpdir(), "pi-oracle-chromium-cookies-"));
+  const tempDbPath = join(tempDir, "Cookies");
+  try {
+    copyFileSync(dbPath, tempDbPath);
+    copySidecar(dbPath, `${tempDbPath}-wal`, "-wal");
+    copySidecar(dbPath, `${tempDbPath}-shm`, "-shm");
+    return { tempDir, tempDbPath };
+  } catch (error) {
+    rmSync(tempDir, { recursive: true, force: true });
+    throw error;
+  }
+}
+
+function copySidecar(sourceDbPath, targetPath, suffix) {
+  const sidecarPath = `${sourceDbPath}${suffix}`;
+  try {
+    copyFileSync(sidecarPath, targetPath);
+  } catch (error) {
+    if (isMissingFileError(error)) return;
+    throw error;
+  }
+}
+
+function isMissingFileError(error) {
+  return Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT");
+}
+
+function readMetaVersion(db) {
+  try {
+    const row = db.prepare("SELECT value FROM meta WHERE key = 'version'").get();
+    const parsed = Number.parseInt(String(row?.value ?? "0"), 10);
+    return Number.isFinite(parsed) ? parsed : 0;
+  } catch {
+    return 0;
+  }
+}
+
+function parentCookieDomains(host) {
+  const labels = host.split(".").filter(Boolean);
+  const domains = new Set([host, `.${host}`]);
+  for (let index = 1; index < labels.length - 1; index += 1) {
+    const parent = labels.slice(index).join(".");
+    domains.add(parent);
+    domains.add(`.${parent}`);
+  }
+  return [...domains];
+}
+
+function sqlStringLiteral(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+
+function buildHostWhereClause(origins) {
+  const domains = new Set();
+  for (const origin of origins) {
+    try {
+      for (const domain of parentCookieDomains(new URL(origin).hostname)) domains.add(domain);
+    } catch {
+      // Ignore malformed origins; validated ChatGPT config supplies the real set.
+    }
+  }
+  if (domains.size === 0) return "0";
+  return `host_key IN (${[...domains].map(sqlStringLiteral).join(", ")})`;
+}
+
+function hostMatchesAny(originHosts, hostKey) {
+  const cookieDomain = hostKey.startsWith(".") ? hostKey.slice(1) : hostKey;
+  return originHosts.some((host) => host === cookieDomain || host.endsWith(`.${cookieDomain}`));
+}
+
+function chromiumExpirationToUnixSeconds(value) {
+  if (value === undefined || value === null || String(value) === "0") return undefined;
+  try {
+    const raw = BigInt(String(value));
+    const seconds = raw / 1_000_000n - CHROMIUM_EPOCH_OFFSET_SECONDS;
+    if (seconds <= 0n) return undefined;
+    return Number(seconds);
+  } catch {
+    return undefined;
+  }
+}
+
+function normalizeSameSite(value) {
+  const normalized = String(value ?? "").toLowerCase();
+  if (normalized === "2" || normalized === "strict") return "Strict";
+  if (normalized === "1" || normalized === "lax") return "Lax";
+  if (normalized === "0" || normalized === "none" || normalized === "no_restriction") return "None";
+  return undefined;
+}
+
+function deriveMacosChromiumKey(password) {
+  return pbkdf2Sync(password, "saltysalt", MACOS_CHROMIUM_KEY_ITERATIONS, 16, "sha1");
+}
+
+function decryptCookieValue(encryptedValue, key, options) {
+  const buffer = Buffer.from(encryptedValue);
+  if (buffer.length < 3) return null;
+  const prefix = buffer.subarray(0, 3).toString("utf8");
+  if (!/^v\d\d$/.test(prefix)) return decodeCookieBytes(buffer, false);
+
+  try {
+    const iv = Buffer.alloc(16, 0x20);
+    const decipher = createDecipheriv("aes-128-cbc", key, iv);
+    decipher.setAutoPadding(false);
+    const padded = Buffer.concat([decipher.update(buffer.subarray(3)), decipher.final()]);
+    const unpadded = removePkcs7Padding(padded);
+    return decodeCookieBytes(unpadded, options.stripHashPrefix);
+  } catch {
+    return null;
+  }
+}
+
+function removePkcs7Padding(value) {
+  if (!value.length) return value;
+  const padding = value[value.length - 1];
+  if (!padding || padding > 16) return value;
+  return value.subarray(0, value.length - padding);
+}
+
+function decodeCookieBytes(value, stripHashPrefix) {
+  const bytes = stripHashPrefix && value.length >= 32 ? value.subarray(32) : value;
+  try {
+    return stripLeadingControlChars(COOKIE_VALUE_DECODER.decode(bytes));
+  } catch {
+    return null;
+  }
+}
+
+function stripLeadingControlChars(value) {
+  let index = 0;
+  while (index < value.length && value.charCodeAt(index) < 0x20) index += 1;
+  return value.slice(index);
+}
+
+function collectCookies(rows, options, key, warnings) {
+  const cookies = [];
+  const now = Math.floor(Date.now() / 1000);
+  const hosts = options.origins.map((origin) => new URL(origin).hostname);
+  let warnedEncryptedType = false;
+
+  for (const row of rows) {
+    const name = typeof row.name === "string" ? row.name : "";
+    const hostKey = typeof row.host_key === "string" ? row.host_key : "";
+    if (!name || !hostKey || !hostMatchesAny(hosts, hostKey)) continue;
+
+    let value = typeof row.value === "string" && row.value.length > 0 ? row.value : null;
+    if (value === null) {
+      if (!(row.encrypted_value instanceof Uint8Array)) {
+        if (!warnedEncryptedType && row.encrypted_value !== undefined) {
+          warnings.push("Chromium cookie encrypted_value is in an unsupported type.");
+          warnedEncryptedType = true;
+        }
+        continue;
+      }
+      value = decryptCookieValue(row.encrypted_value, key, { stripHashPrefix: options.stripHashPrefix });
+    }
+    if (value === null) continue;
+
+    const expires = chromiumExpirationToUnixSeconds(row.expires_utc);
+    if (!options.includeExpired && expires !== undefined && expires < now) continue;
+
+    const cookie = {
+      name,
+      value,
+      domain: hostKey.startsWith(".") ? hostKey.slice(1) : hostKey,
+      path: typeof row.path === "string" && row.path ? row.path : "/",
+      secure: row.is_secure === 1 || row.is_secure === "1" || row.is_secure === true,
+      httpOnly: row.is_httponly === 1 || row.is_httponly === "1" || row.is_httponly === true,
+      source: { browser: "chromium", profile: options.profile },
+    };
+    if (expires !== undefined) cookie.expires = expires;
+    const sameSite = normalizeSameSite(row.samesite);
+    if (sameSite !== undefined) cookie.sameSite = sameSite;
+    cookies.push(cookie);
+  }
+
+  return dedupeCookies(cookies);
+}
+
+function dedupeCookies(cookies) {
+  const seen = new Map();
+  for (const cookie of cookies) {
+    const key = `${cookie.domain}\t${cookie.path}\t${cookie.name}`;
+    if (!seen.has(key)) seen.set(key, cookie);
+  }
+  return [...seen.values()];
+}
+
+export async function getCookiesFromConfiguredChromiumSource(options) {
+  const warnings = [];
+  if (!options.dbPath || !existsSync(options.dbPath)) {
+    return { cookies: [], warnings: [`Chromium cookies database not found: ${options.dbPath || "(missing path)"}`] };
+  }
+
+  const passwordResult = await readKeychainPassword(options.keychain, options.timeoutMs ?? 5_000);
+  if (!passwordResult.ok) return { cookies: [], warnings: [passwordResult.error] };
+
+  let snapshot;
+  try {
+    snapshot = snapshotCookieDb(options.dbPath);
+  } catch (error) {
+    return { cookies: [], warnings: [`Failed to copy Chromium cookie DB: ${error instanceof Error ? error.message : String(error)}`] };
+  }
+
+  try {
+    const db = new DatabaseSync(snapshot.tempDbPath, { readOnly: true });
+    try {
+      const metaVersion = readMetaVersion(db);
+      const where = buildHostWhereClause(options.origins);
+      const sql =
+        `SELECT name, value, host_key, path, CAST(expires_utc AS TEXT) AS expires_utc, samesite, encrypted_value, ` +
+        `is_secure AS is_secure, is_httponly AS is_httponly FROM cookies WHERE (${where}) ORDER BY cookies.expires_utc DESC;`;
+      const rows = db.prepare(sql).all();
+      const key = deriveMacosChromiumKey(passwordResult.password);
+      const cookies = collectCookies(rows, {
+        origins: options.origins,
+        profile: options.profile,
+        includeExpired: options.includeExpired === true,
+        stripHashPrefix: metaVersion >= 24,
+      }, key, warnings);
+      return { cookies, warnings };
+    } finally {
+      db.close();
+    }
+  } catch (error) {
+    return { cookies: [], warnings: [`Failed to read Chromium cookies (requires a modern Chromium cookie DB): ${error instanceof Error ? error.message : String(error)}`] };
+  } finally {
+    rmSync(snapshot.tempDir, { recursive: true, force: true });
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-oracle",
-  "version": "0.6.13",
+  "version": "0.6.15",
   "description": "ChatGPT web-oracle extension for pi with isolated browser auth, async jobs, and project-context archives.",
   "private": false,
   "license": "MIT",
@@ -42,7 +42,7 @@
     ]
   },
   "scripts": {
-    "check:oracle-extension": "node --check extensions/oracle/shared/process-helpers.mjs && node --check extensions/oracle/shared/state-coordination-helpers.mjs && node --check extensions/oracle/shared/job-coordination-helpers.mjs && node --check extensions/oracle/shared/job-lifecycle-helpers.mjs && node --check extensions/oracle/shared/job-observability-helpers.mjs && node --check extensions/oracle/worker/run-job.mjs && node --check extensions/oracle/worker/state-locks.mjs && node --check extensions/oracle/worker/artifact-heuristics.mjs && node --check extensions/oracle/worker/chatgpt-ui-helpers.mjs && node --check extensions/oracle/worker/chatgpt-flow-helpers.mjs && node --check extensions/oracle/worker/auth-flow-helpers.mjs && node --check extensions/oracle/worker/auth-cookie-policy.mjs && node --check extensions/oracle/worker/auth-bootstrap.mjs && esbuild extensions/oracle/index.ts --bundle --platform=node --format=esm --external:@mariozechner/pi-coding-agent --external:@mariozechner/pi-ai --external:typebox --outfile=/tmp/pi-oracle-extension-check.js",
+    "check:oracle-extension": "node --check extensions/oracle/shared/process-helpers.mjs && node --check extensions/oracle/shared/state-coordination-helpers.mjs && node --check extensions/oracle/shared/job-coordination-helpers.mjs && node --check extensions/oracle/shared/job-lifecycle-helpers.mjs && node --check extensions/oracle/shared/job-observability-helpers.mjs && node --check extensions/oracle/worker/run-job.mjs && node --check extensions/oracle/worker/state-locks.mjs && node --check extensions/oracle/worker/artifact-heuristics.mjs && node --check extensions/oracle/worker/chatgpt-ui-helpers.mjs && node --check extensions/oracle/worker/chatgpt-flow-helpers.mjs && node --check extensions/oracle/worker/auth-flow-helpers.mjs && node --check extensions/oracle/worker/auth-cookie-policy.mjs && node --check extensions/oracle/worker/chromium-cookie-source.mjs && node --check extensions/oracle/worker/auth-bootstrap.mjs && esbuild extensions/oracle/index.ts --bundle --platform=node --format=esm --external:@mariozechner/pi-coding-agent --external:@mariozechner/pi-ai --external:typebox --outfile=/tmp/pi-oracle-extension-check.js",
     "typecheck": "tsc --noEmit -p tsconfig.json",
     "typecheck:worker-helpers": "tsc --noEmit -p tsconfig.worker-helpers.json",
     "sanity:oracle": "node scripts/oracle-sanity-runner.mjs",