pi-oracle 0.7.9 → 0.7.11

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## Unreleased
 
+## 0.7.11 - 2026-06-15
+
+### Changed
+- updated the local pi development and validation baseline to `@earendil-works/*` `0.79.4`
+- refreshed oracle docs and sanity-check baselines for pi `0.79.4`
+
+### Validation
+- ran the full `npm run verify:oracle` release gate under pi `0.79.4`
+
+## 0.7.10 - 2026-06-13
+
+### Added
+- added explicit existing ChatGPT browser-thread targeting for `/oracle`, `oracle_preflight`, and `oracle_submit` through optional `chatGptConversationId`, accepting raw ChatGPT conversation ids or full `https://chatgpt.com/c/...` / `https://chat.openai.com/c/...` URLs while preserving fresh-thread defaults when omitted
+
+### Validation
+- verified existing-thread preflight and submit flows in isolated `pi` sessions, including persisted `chatUrl` / `conversationId` job metadata with a fake worker
+- ran the full `npm run verify:oracle` release gate
+
 ## 0.7.9 - 2026-06-11
 
 ### Fixed

package/README.md

@@ -2,7 +2,7 @@
 
 `pi-oracle` lets a `pi` agent send hard, long-running work to ChatGPT.com or Grok through the web app, with repo archives, background execution, saved results, and a best-effort wake-up back into `pi` when the answer is ready.
 
-> Status: experimental public beta. Validated on macOS, Linux, and Windows native with Chromium-family browsers and pi `0.79.1`. Pi `0.79.1+` is the suggested tested floor for project-trust-aware package/runtime validation, but pi-bundled runtime packages remain optional wildcard peers so npm peer ranges do not block users from trying newer pi releases. Normal oracle jobs run in an isolated browser profile, not your active browser window.
+> Status: experimental public beta. Validated on macOS, Linux, and Windows native with Chromium-family browsers and pi `0.79.4`. Pi `0.79.4+` is the suggested tested floor for project-trust-aware package/runtime validation, but pi-bundled runtime packages remain optional wildcard peers so npm peer ranges do not block users from trying newer pi releases. Normal oracle jobs run in an isolated browser profile, not your active browser window.
 
 ## What a successful run looks like
 
@@ -77,7 +77,7 @@ You need:
 
 - macOS, Linux, or Windows native
 - Node.js 22 or newer
-- Suggested tested floor: `pi` 0.79.1 or newer; older pi versions are not blocked by package metadata but are outside the current validation baseline
+- Suggested tested floor: `pi` 0.79.4 or newer; older pi versions are not blocked by package metadata but are outside the current validation baseline
 - Google Chrome/Chromium or another Chromium-family browser
 - ChatGPT or Grok already signed in to the configured local browser profile for the provider you plan to use
 - `agent-browser`, `tar`, and `zstd` available on the machine
@@ -134,6 +134,10 @@ If the wake-up does not arrive, run:
 /oracle-followup <job-id> Tighten the migration plan around rollback risk, and include the most relevant surrounding files/docs as long as the archive stays comfortably within the 250 MiB limit.
 ```
 
+```text
+/oracle Continue existing ChatGPT conversation 6a28ab5c-e4d4-83e8-b8be-dd39f38a26d6. Review the current auth code and include enough surrounding context to propose concrete fixes.
+```
+
 ## How it works
 
 ```mermaid
@@ -153,13 +157,14 @@ Key design choices:
 - **Tools own execution.** `oracle_submit` builds the archive, admits or queues the job, starts the worker, and returns immediately.
 - **Auth uses a seed profile.** `/oracle-auth` imports cookies into an isolated seed profile; each job clones that seed into its own temporary runtime profile.
 - **Follow-ups preserve provider thread state.** `/oracle-followup <job-id> ...` resolves the prior job's saved provider URL and submits the next prompt with `followUpJobId`.
+- **Existing ChatGPT browser threads are opt-in.** Normal `/oracle` jobs still start a fresh provider thread. When the user explicitly provides a ChatGPT conversation id or `https://chatgpt.com/c/...` URL, the agent passes `chatGptConversationId` so `oracle_submit` opens that existing thread in the isolated runtime.
 - **Wake-up is best effort, storage is durable.** A missed wake-up does not lose the result.
 
 ## Commands and tools
 
 User-facing commands:
 
-- `/oracle <request>` — prepare context and dispatch a ChatGPT or Grok web oracle job
+- `/oracle <request>` — prepare context and dispatch a ChatGPT or Grok web oracle job. If the request explicitly includes an existing ChatGPT conversation id/URL, the agent can continue that browser-created thread; otherwise `/oracle` starts a fresh thread as before.
 - `/oracle-followup <job-id> <request>` — continue an earlier oracle job in the same provider thread
 - `/oracle-auth [chatgpt|grok]` — sync provider cookies into the isolated oracle auth seed profile
 - `/oracle-read [job-id]` — inspect job status and saved response preview
@@ -171,7 +176,7 @@ Agent-facing tools:
 
 - `oracle_preflight`
 - `oracle_auth`
-- `oracle_submit`
+- `oracle_submit` (`chatGptConversationId` is optional and only for explicitly continuing an existing ChatGPT browser conversation id/URL; omit it for the default fresh thread)
 - `oracle_read`
 - `oracle_cancel`
 
@@ -179,7 +184,7 @@ Agent-facing tools:
 
 Most users can start with defaults. Set an agent-level config only when you need a non-default provider, mode, preset, or browser profile.
 
-Pi 0.79.1 gates project-local inputs behind project trust. `pi-oracle` preserves its historical risk-on extension behavior for existing users: project-local `.pi/extensions/oracle.json` safe overrides still load by default for compatibility. They are ignored when you explicitly opt out of project-local inputs with `--no-approve` or save a “do not trust” decision for the project. Privileged browser/auth settings still come only from the agent-level config.
+Pi 0.79.4 gates project-local inputs behind project trust. `pi-oracle` preserves its historical risk-on extension behavior for existing users: project-local `.pi/extensions/oracle.json` safe overrides still load by default for compatibility. They are ignored when you explicitly opt out of project-local inputs with `--no-approve` or save a “do not trust” decision for the project. Privileged browser/auth settings still come only from the agent-level config.
 
 `~/.pi/agent/extensions/oracle.json`
 
@@ -394,7 +399,7 @@ For macOS, Ubuntu, and Windows native package/build plus packed runtime validati
 npm run release:check
 ```
 
-The real runtime suite defaults to deterministic installed-tool execution so platform proof stays bounded. Provider/model defaults remain `zai/glm-5.1` 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.
+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.
 
 For manual end-to-end local-extension smoke testing, use [`docs/ORACLE_ISOLATED_PI_VALIDATION.md`](docs/ORACLE_ISOLATED_PI_VALIDATION.md). That workflow launches isolated `pi` coding-agent sessions against this checkout and uses `instant` or `thinking_light`, as required by the project validation policy.
 

package/docs/ORACLE_DESIGN.md

@@ -7,7 +7,7 @@ Companion doc:
 - `docs/ORACLE_RECOVERY_DRILL.md` — safe expired-auth recovery validation drill
 
 Compatibility target:
-- `pi` 0.79.1+ is the suggested tested floor for current project-trust-aware package/runtime validation
+- `pi` 0.79.4+ is the suggested tested floor for current project-trust-aware package/runtime validation
 - package metadata keeps pi runtime packages as optional wildcard peers, so this suggested floor is not enforced as a hard npm install requirement
 - current extension lifecycle only; no backward-compatibility shims for removed `session_switch` / `session_fork` events
 
@@ -157,7 +157,10 @@ The authenticated seed profile remains the source of truth for future oracle run
 Agent-facing submissions resolve a provider first. ChatGPT submissions use **`preset`**; the canonical registry is `ORACLE_SUBMIT_PRESETS` in `extensions/oracle/lib/config.ts`. Grok submissions use **`mode: "heavy"`** today and reject ChatGPT-only presets. For ChatGPT, **`preset` is the only model-selection parameter** on `oracle_submit`; there are no `modelFamily`, `effort`, or `autoSwitchToThinking` fields. Submit-time inputs accept canonical preset ids plus matching human-readable labels/common hyphen-space variants, and the tool normalizes them back to the canonical id before persisting job state. Prompt-template guidance biases toward omitting provider/model fields and using configured defaults unless the task or user explicitly asks for one. It also biases toward context-rich archives up to the provider ceiling, narrowing only when the user explicitly asks for a tight archive, privacy/sensitivity requires it, or size pressure forces it. When local archive creation still exceeds that ceiling after default exclusions and whole-repo auto-pruning, prompt guidance now treats the failure as a retryable archive-selection miss rather than a terminal dead end: agents should cut scope automatically, retry once or twice, and only surface the cut decisions if the archive still cannot fit.
 
 1. resolve the provider and preset/mode (submit-time or config default) into an execution snapshot
-2. resolve optional `followUpJobId` into a prior `chatUrl` and `conversationId`
+2. resolve optional thread targeting:
+   - `followUpJobId` into a prior oracle job `chatUrl` and `conversationId`, or
+   - `chatGptConversationId` into a user/browser-created ChatGPT `https://chatgpt.com/c/<id>` URL
+   Omit both for the default fresh-thread behavior.
 3. build the archive first into a temporary path
 4. allocate a unique runtime:
    - `runtimeId`
@@ -166,7 +169,7 @@ Agent-facing submissions resolve a provider first. ChatGPT submissions use **`pr
 5. under the global admission lock, first promote any older queued jobs that can now run
 6. if runtime capacity is still available:
    - acquire the runtime lease
-   - acquire the conversation lease for follow-up jobs
+   - acquire the conversation lease for same-thread jobs, including follow-ups and explicit existing ChatGPT conversation ids
    - create `${PI_ORACLE_JOBS_DIR:-/tmp}/oracle-<job-id>/...` job state as `submitted`
 7. otherwise create `${PI_ORACLE_JOBS_DIR:-/tmp}/oracle-<job-id>/...` job state as `queued`
 8. move the prepared archive into the job directory with a unique filename
@@ -184,7 +187,8 @@ Per job:
    - the job’s `runtimeProfileDir`
    - headless by default
 3. open either:
-   - the saved `chatUrl` for follow-up jobs, or
+   - the saved `chatUrl` for follow-up jobs,
+   - the normalized `chatGptConversationId` URL for explicit existing ChatGPT browser threads, or
    - the configured provider URL
 4. classify page state before touching the UI
 5. fail fast on:
@@ -230,7 +234,7 @@ Merged config locations:
 - global: `~/.pi/agent/extensions/oracle.json`
 - project: `.pi/extensions/oracle.json`
 
-Project config remains restricted to safe overrides only. On Pi 0.79.1+, pi itself gates project-local inputs behind project trust, but `pi-oracle` keeps its historical risk-on extension behavior for this package-specific safe override file: `.pi/extensions/oracle.json` loads by default for compatibility, and is ignored when Pi reports the project is untrusted, including `--no-approve` or saved “do not trust” decisions. This preserves the existing extension experience while still honoring explicit opt-out/distrust decisions. Browser/auth settings remain global-only because they control local privileged browser state.
+Project config remains restricted to safe overrides only. On Pi 0.79.4+, pi itself gates project-local inputs behind project trust, but `pi-oracle` keeps its historical risk-on extension behavior for this package-specific safe override file: `.pi/extensions/oracle.json` loads by default for compatibility, and is ignored when Pi reports the project is untrusted, including `--no-approve` or saved “do not trust” decisions. This preserves the existing extension experience while still honoring explicit opt-out/distrust decisions. Browser/auth settings remain global-only because they control local privileged browser state.
 
 ### Current config shape
 
@@ -495,11 +499,13 @@ Same-thread continuity is persisted as data, not runtime browser state.
 
 Approach:
 
-- expose `/oracle-followup <job-id> <request>` as the user-facing way to continue the same provider thread later
+- expose `/oracle-followup <job-id> <request>` as the user-facing way to continue an oracle-created provider thread later
+- allow `/oracle`/`oracle_submit` to opt into a browser-created ChatGPT thread only when the user explicitly supplies `chatGptConversationId` as a raw id or `https://chatgpt.com/c/...` URL
 - store `chatUrl` only after the conversation URL stabilizes
 - derive and persist `conversationId` from that URL when possible
 - for a follow-up job, resolve `followUpJobId` to the prior `chatUrl`
-- acquire a conversation lease before launching the follow-up
+- for an explicit existing ChatGPT thread, normalize `chatGptConversationId` to `https://chatgpt.com/c/<id>` without requiring prior oracle job state
+- acquire a conversation lease before launching the same-thread job
 - launch a fresh isolated browser using a fresh runtime clone of the auth seed
 - open that URL
 - continue there if authentication and page-state checks pass

package/docs/ORACLE_ISOLATED_PI_VALIDATION.md

@@ -27,7 +27,7 @@ The extension is loaded from the local checkout with:
 pi --approve --no-extensions -e "$REPO/extensions/oracle/index.ts"
 ```
 
-That ensures the session is exercising the in-repo code, not a globally installed package. `--approve` is intentional for this isolated workflow on Pi 0.79.1+: the test fixture is this trusted checkout, and non-interactive/scripted validation must not block on the project-trust prompt.
+That ensures the session is exercising the in-repo code, not a globally installed package. `--approve` is intentional for this isolated workflow on Pi 0.79.4+: the test fixture is this trusted checkout, and non-interactive/scripted validation must not block on the project-trust prompt.
 
 The local extension now intercepts TUI `/oracle` and `/oracle-followup` before prompt-template expansion, re-injects the compact slash request as the visible user message for prompt-history/up-arrow recall, and reads the in-repo prompt files as hidden dispatch instructions, so do not pass `--prompt-template` for normal local-extension validation. In print/json/rpc modes, the extension contributes the prompt templates itself.
 

package/docs/platform-smoke.md

@@ -36,7 +36,7 @@ Target setup:
 Real runtime suite auth:
 
 - Default deterministic installed-tool smoke does not require provider API keys.
-- Provider/model defaults remain `zai/glm-5.1` for optional model-agent debugging.
+- Provider/model defaults remain `zai/glm-5.2` for optional model-agent debugging.
 - Set `PI_ORACLE_REAL_TEST_MODEL_AGENT=1` to run the slower model-agent path; then the provider auth env is required (`ZAI_API_KEY` by default, reported only as present/redacted).
 - Override with `PI_ORACLE_REAL_TEST_PROVIDER` and `PI_ORACLE_REAL_TEST_MODEL`; auth variable names live in `platform-smoke.config.mjs`.
 
@@ -90,7 +90,7 @@ On each required target, `platform-build`:
 5. runs `npm pack`;
 6. creates a fresh target-local pi project;
 7. runs `npm install --no-save <packed tarball>`;
-8. runs `pi install -l ./node_modules/pi-oracle --approve` so Pi 0.79.1 project-trust gating intentionally trusts the temporary fixture;
+8. runs `pi install -l ./node_modules/pi-oracle --approve` so Pi 0.79.4 project-trust gating intentionally trusts the temporary fixture;
 9. runs `pi list --approve`;
 10. asserts the installed package came from `node_modules/pi-oracle` and did not use `pi -e` / source-extension shortcuts.
 

package/extensions/oracle/lib/config.ts

@@ -6,7 +6,7 @@
 import { execFileSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { getAgentDir, hasProjectTrustInputs, ProjectTrustStore } from "@earendil-works/pi-coding-agent";
+import { getAgentDir, hasTrustRequiringProjectResources, ProjectTrustStore } from "@earendil-works/pi-coding-agent";
 import { isAbsolute, join, normalize } from "node:path";
 import {
   assertNotKnownBrowserUserDataPath,
@@ -351,7 +351,7 @@ function isProjectConfigTrusted(cwd: string, agentDir: string, projectConfigExis
   const trustCwd = options?.projectConfigTrustCwd ?? cwd;
   const cliOverride = getProjectTrustCliOverride();
   if (cliOverride !== undefined) return cliOverride;
-  if (!projectConfigExists && !hasProjectTrustInputs(trustCwd)) return true;
+  if (!projectConfigExists && !hasTrustRequiringProjectResources(trustCwd)) return true;
   try {
     const trustStore = new ProjectTrustStore(agentDir);
     const trustDecision = trustStore.get(trustCwd);

package/extensions/oracle/lib/tools.ts

@@ -25,6 +25,7 @@ import {
   resolveOracleConfigForProvider,
   resolveOracleGrokMode,
   resolveOracleSubmitPreset,
+  type OracleConfig,
   type OracleProvider,
 } from "./config.js";
 import {
@@ -94,11 +95,21 @@ const ORACLE_SUBMIT_PARAMS = Type.Object({
     }),
   ),
   followUpJobId: Type.Optional(Type.String({ description: "Earlier oracle job id whose chat thread should be continued." })),
+  chatGptConversationId: Type.Optional(Type.String({
+    description: "Existing ChatGPT conversation id, or full https://chatgpt.com/c/... URL, to continue. Omit for default behavior: starting a fresh oracle thread. Do not combine with followUpJobId.",
+    minLength: 1,
+    pattern: "^.*\\S.*$",
+  })),
 });
 
 const ORACLE_PREFLIGHT_PARAMS = Type.Object({
   provider: Type.Optional(Type.String({ description: `Provider readiness to check. Omit to use the configured default provider. Supported providers: ${ORACLE_PROVIDERS.join(", ")}.` })),
   followUpJobId: Type.Optional(Type.String({ description: "Earlier oracle job id whose provider/thread readiness should be checked." })),
+  chatGptConversationId: Type.Optional(Type.String({
+    description: "Existing ChatGPT conversation id, or full https://chatgpt.com/c/... URL, whose provider/thread readiness should be checked. Do not combine with followUpJobId.",
+    minLength: 1,
+    pattern: "^.*\\S.*$",
+  })),
 });
 
 const ORACLE_AUTH_PARAMS = Type.Object({
@@ -750,12 +761,59 @@ export function getQueueAdmissionFailure(args: {
   return undefined;
 }
 
-function resolveFollowUp(previousJobId: string | undefined, cwd: string): {
+type OracleConversationTarget = {
   followUpToJobId?: string;
   chatUrl?: string;
   conversationId?: string;
   provider?: "chatgpt" | "grok";
-} {
+  label?: string;
+};
+
+const CHATGPT_CONVERSATION_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9-]{7,}$/;
+const CHATGPT_CONVERSATION_URL_HOSTS = new Set(["chatgpt.com", "chat.openai.com"]);
+
+function chatGptConversationOrigin(config: Pick<OracleConfig, "browser">): string {
+  try {
+    const parsed = new URL(config.browser.chatUrl);
+    if (CHATGPT_CONVERSATION_URL_HOSTS.has(parsed.hostname.toLowerCase())) return parsed.origin;
+  } catch {
+    // Fall through to the canonical ChatGPT origin.
+  }
+  return "https://chatgpt.com";
+}
+
+export function resolveChatGptConversationReference(
+  rawReference: string | undefined,
+  config: Pick<OracleConfig, "browser">,
+): { chatUrl: string; conversationId: string } | undefined {
+  if (rawReference === undefined) return undefined;
+  const reference = rawReference.trim();
+  if (!reference) throw new Error("ChatGPT conversation id must be a non-empty string");
+
+  try {
+    const parsed = new URL(reference);
+    const host = parsed.hostname.toLowerCase();
+    const conversationId = parseConversationId(parsed.toString());
+    if (parsed.protocol !== "https:" || !CHATGPT_CONVERSATION_URL_HOSTS.has(host) || !conversationId) {
+      throw new Error();
+    }
+    return {
+      chatUrl: `${parsed.origin}/c/${conversationId}`,
+      conversationId,
+    };
+  } catch {
+    if (!CHATGPT_CONVERSATION_ID_PATTERN.test(reference)) {
+      throw new Error(`Invalid ChatGPT conversation id or URL: ${rawReference}`);
+    }
+    const origin = chatGptConversationOrigin(config);
+    return {
+      chatUrl: `${origin}/c/${reference}`,
+      conversationId: reference,
+    };
+  }
+}
+
+function resolveFollowUp(previousJobId: string | undefined, cwd: string): OracleConversationTarget {
   if (!previousJobId) return {};
   const previous = readJob(previousJobId);
   if (!previous) {
@@ -770,14 +828,37 @@ function resolveFollowUp(previousJobId: string | undefined, cwd: string): {
   if (!previous.chatUrl) {
     throw new Error(`Follow-up oracle job ${previousJobId} has no persisted chat URL`);
   }
+  const conversationId = previous.conversationId || parseConversationId(previous.chatUrl);
   return {
     followUpToJobId: previous.id,
     chatUrl: previous.chatUrl,
-    conversationId: previous.conversationId || parseConversationId(previous.chatUrl),
+    conversationId,
     provider: previous.selection?.provider === "grok" ? "grok" : "chatgpt",
+    label: `follow-up job ${previous.id}`,
   };
 }
 
+function resolveConversationTarget(args: {
+  followUpJobId?: string;
+  chatGptConversationId?: string;
+  cwd: string;
+  config: OracleConfig;
+}): OracleConversationTarget {
+  if (args.followUpJobId !== undefined && args.chatGptConversationId !== undefined) {
+    throw new Error("Pass either followUpJobId or chatGptConversationId, not both");
+  }
+  if (args.chatGptConversationId !== undefined) {
+    const target = resolveChatGptConversationReference(args.chatGptConversationId, args.config);
+    if (!target) return {};
+    return {
+      ...target,
+      provider: "chatgpt",
+      label: `ChatGPT conversation ${target.conversationId}`,
+    };
+  }
+  return resolveFollowUp(args.followUpJobId, args.cwd);
+}
+
 type OracleToolName = "oracle_auth" | "oracle_submit" | "oracle_read" | "oracle_cancel";
 type OracleToolErrorSource = OracleToolName | "oracle_preflight";
 type OracleQueueSnapshot = { queued: boolean; position?: number; depth?: number };
@@ -1036,6 +1117,23 @@ function buildOracleToolErrorDetails(toolName: OracleToolErrorSource, error: unk
     };
   }
 
+  if ((toolName === "oracle_submit" || toolName === "oracle_preflight") && message === "Pass either followUpJobId or chatGptConversationId, not both") {
+    return {
+      code: "oracle_thread_target_conflict",
+      message,
+      suggestedNextStep: "Retry with exactly one same-thread target: followUpJobId for an oracle-created thread, or chatGptConversationId for an existing ChatGPT browser thread.",
+    };
+  }
+
+  if ((toolName === "oracle_submit" || toolName === "oracle_preflight") && (message === "ChatGPT conversation id must be a non-empty string" || message.startsWith("Invalid ChatGPT conversation id or URL: "))) {
+    return {
+      code: "invalid_chatgpt_conversation_id",
+      message,
+      rejectedValue: typeof params.chatGptConversationId === "string" ? params.chatGptConversationId : undefined,
+      suggestedNextStep: "Retry with a ChatGPT conversation id like 6a28ab5c-e4d4-83e8-b8be-dd39f38a26d6 or a full https://chatgpt.com/c/... URL, or omit chatGptConversationId to start a fresh thread.",
+    };
+  }
+
   if (toolName === "oracle_submit" && message.startsWith("Follow-up oracle job not found: ")) {
     return {
       code: "follow_up_job_not_found",
@@ -1164,7 +1262,7 @@ function isProjectTrusted(ctx: ExtensionContext): boolean {
   return (ctx as { isProjectTrusted?: () => boolean }).isProjectTrusted?.() ?? true;
 }
 
-async function runOraclePreflight(ctx: ExtensionContext, params: { provider?: unknown; followUpJobId?: unknown } = {}): Promise<OraclePreflightDetails> {
+async function runOraclePreflight(ctx: ExtensionContext, params: { provider?: unknown; followUpJobId?: unknown; chatGptConversationId?: unknown } = {}): Promise<OraclePreflightDetails> {
   const sessionFile = getSessionFile(ctx);
   if (!hasPersistedSessionFile(sessionFile)) {
     return {
@@ -1184,14 +1282,18 @@ async function runOraclePreflight(ctx: ExtensionContext, params: { provider?: un
   let provider: OracleProvider | undefined;
   try {
     const followUpJobId = params.followUpJobId;
+    const chatGptConversationId = params.chatGptConversationId;
     if (followUpJobId !== undefined && typeof followUpJobId !== "string") {
       throw new Error("oracle_preflight followUpJobId must be a string");
     }
+    if (chatGptConversationId !== undefined && typeof chatGptConversationId !== "string") {
+      throw new Error("oracle_preflight chatGptConversationId must be a string");
+    }
     const baseConfig = loadOracleConfig(ctx.cwd, { projectConfigTrusted: isProjectTrusted(ctx) });
-    const followUp = resolveFollowUp(followUpJobId, ctx.cwd);
-    provider = normalizeOracleProvider(params.provider, followUp.provider ?? baseConfig.defaults.provider, "oracle_preflight");
-    if (followUp.provider && provider !== followUp.provider) {
-      throw new Error(`Follow-up job ${followUpJobId} uses provider ${followUp.provider}; cannot check it with ${provider}.`);
+    const target = resolveConversationTarget({ followUpJobId, chatGptConversationId, cwd: ctx.cwd, config: baseConfig });
+    provider = normalizeOracleProvider(params.provider, target.provider ?? baseConfig.defaults.provider, "oracle_preflight");
+    if (target.provider && provider !== target.provider) {
+      throw new Error(`${target.label ?? "Oracle conversation"} requires provider ${target.provider}; cannot check it with ${provider}.`);
     }
     config = resolveOracleConfigForProvider(baseConfig, provider);
   } catch (error) {
@@ -1201,14 +1303,14 @@ async function runOraclePreflight(ctx: ExtensionContext, params: { provider?: un
       session: { persisted: true, sessionFile },
       config: { ready: false },
       auth: { ready: false },
-      error: buildOracleToolErrorDetails("oracle_preflight", error, {}),
+      error: buildOracleToolErrorDetails("oracle_preflight", error, asRecord(params) ?? {}),
     };
   }
 
   try {
     await assertOracleSubmitPrerequisites(config);
   } catch (error) {
-    const errorDetails = buildOracleToolErrorDetails("oracle_preflight", error, {});
+    const errorDetails = buildOracleToolErrorDetails("oracle_preflight", error, asRecord(params) ?? {});
     return {
       ready: false,
       provider,
@@ -1251,7 +1353,7 @@ export function registerOracleTools(pi: ExtensionAPI, workerPath: string, authWo
     description: "Check whether oracle is ready in this session before spending time gathering context or preparing a submission.",
     promptSnippet: "Check oracle readiness before expensive /oracle preparation.",
     promptGuidelines: [
-      "Call oracle_preflight before doing expensive /oracle preparation. Pass provider='grok' when the user explicitly asks for Grok, or followUpJobId for same-thread follow-ups. If ready is false, stop immediately and report the suggested next step instead of reading files or crafting archive inputs.",
+      "Call oracle_preflight before doing expensive /oracle preparation. Pass provider='grok' when the user explicitly asks for Grok, followUpJobId for same-thread follow-ups from oracle-created jobs, or chatGptConversationId when the user explicitly provides an existing ChatGPT browser conversation id/URL. If ready is false, stop immediately and report the suggested next step instead of reading files or crafting archive inputs.",
     ],
     parameters: ORACLE_PREFLIGHT_PARAMS,
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
@@ -1299,10 +1401,12 @@ export function registerOracleTools(pi: ExtensionAPI, workerPath: string, authWo
     label: "Oracle Submit",
     description:
       "Dispatch a background ChatGPT or Grok web oracle job after gathering context. Always pass a prompt and exact project-relative archive inputs. " +
-      "Optional provider: set `provider` to `grok` when the user asks for Grok; Grok currently supports only Heavy. Optional ChatGPT model: set parameter `preset`, or omit it for configured defaults; canonical preset ids are listed in the README and ORACLE_SUBMIT_PRESETS registry, and matching labels are normalized at submit time.",
+      "Optional provider: set `provider` to `grok` when the user asks for Grok; Grok currently supports only Heavy. Optional ChatGPT model: set parameter `preset`, or omit it for configured defaults; canonical preset ids are listed in the README and ORACLE_SUBMIT_PRESETS registry, and matching labels are normalized at submit time. " +
+      "Optional thread target: pass `chatGptConversationId` only when the user explicitly provides an existing ChatGPT browser conversation id/URL to continue; omit it for the default fresh oracle thread.",
     promptSnippet: "Dispatch a background ChatGPT or Grok web oracle job after gathering repo context.",
     promptGuidelines: [
       "Gather context before calling oracle_submit.",
+      "If the user explicitly provides an existing ChatGPT browser conversation id or https://chatgpt.com/c/... URL, pass it as chatGptConversationId and force provider='chatgpt'; otherwise omit chatGptConversationId so oracle_submit starts a fresh thread by default.",
       "If the immediately preceding oracle run failed because ChatGPT or Grok login is required or the worker explicitly said to rerun /oracle-auth, call oracle_auth once before retrying the submission; pass provider='grok' for Grok retries. Do not loop auth refreshes.",
       "Prefer context-rich archives up to the provider ceiling because more relevant surrounding context is usually better than less: 250 MB for ChatGPT and 200 MiB for Grok.",
       "By default, archive the whole repo by passing '.' for broad or unclear requests; default archive exclusions apply automatically, including common bulky outputs and obvious credentials/private data like .env files, key material, credential dotfiles, local database files, and nested secrets directories anywhere in the repo.",
@@ -1328,10 +1432,15 @@ export function registerOracleTools(pi: ExtensionAPI, workerPath: string, authWo
         const originSessionFile = requirePersistedSessionFile(getSessionFile(ctx), "submit oracle jobs");
         const projectId = getProjectId(projectCwd);
         const sessionId = getSessionId(originSessionFile, projectId);
-        const followUp = resolveFollowUp(params.followUpJobId, projectCwd);
-        const provider = normalizeOracleProvider(params.provider, followUp.provider ?? baseConfig.defaults.provider, "oracle_submit");
-        if (followUp.provider && provider !== followUp.provider) {
-          throw new Error(`Follow-up job ${params.followUpJobId} uses provider ${followUp.provider}; cannot continue it with ${provider}.`);
+        const target = resolveConversationTarget({
+          followUpJobId: params.followUpJobId,
+          chatGptConversationId: params.chatGptConversationId,
+          cwd: projectCwd,
+          config: baseConfig,
+        });
+        const provider = normalizeOracleProvider(params.provider, target.provider ?? baseConfig.defaults.provider, "oracle_submit");
+        if (target.provider && provider !== target.provider) {
+          throw new Error(`${target.label ?? "Oracle conversation"} requires provider ${target.provider}; cannot continue it with ${provider}.`);
         }
         if (provider === "grok" && typeof params.preset === "string") {
           throw new Error("oracle_submit preset is only valid for ChatGPT. For Grok, use provider='grok' and mode='heavy'.");
@@ -1340,7 +1449,7 @@ export function registerOracleTools(pi: ExtensionAPI, workerPath: string, authWo
           ? resolveOracleGrokMode(normalizeGrokMode(params.mode, baseConfig.defaults.grokMode))
           : resolveOracleSubmitPreset(typeof params.preset === "string" ? coerceOracleSubmitPresetId(params.preset) : baseConfig.defaults.preset);
         const config = resolveOracleConfigForProvider(baseConfig, provider);
-        const targetChatUrl = followUp.chatUrl;
+        const targetChatUrl = target.chatUrl;
         // Validate caller-specified archive paths before surfacing unrelated local setup failures such as a missing auth seed profile.
         resolveArchiveInputs(projectCwd, params.files);
         await assertOracleSubmitPrerequisites(config);
@@ -1405,7 +1514,7 @@ export function registerOracleTools(pi: ExtensionAPI, workerPath: string, authWo
                   prompt: params.prompt,
                   files: params.files,
                   selection,
-                  followUpToJobId: followUp.followUpToJobId,
+                  followUpToJobId: target.followUpToJobId,
                   chatUrl: targetChatUrl,
                   requestSource: "tool",
                 },
@@ -1425,18 +1534,18 @@ export function registerOracleTools(pi: ExtensionAPI, workerPath: string, authWo
             }
 
             runtimeLeaseAcquired = true;
-            if (followUp.conversationId) {
+            if (target.conversationId) {
               const conversationAttempt = await tryAcquireConversationLease({
                 jobId,
-                conversationId: followUp.conversationId,
+                conversationId: target.conversationId,
                 projectId,
                 sessionId,
                 createdAt: admittedAt,
               });
               if (!conversationAttempt.acquired) {
                 throw new Error(
-                  `Oracle conversation ${followUp.conversationId} is already in use by job ${conversationAttempt.blocker?.jobId ?? "unknown"}. ` +
-                    "Concurrent follow-ups to the same ChatGPT thread are not allowed.",
+                  `Oracle conversation ${target.conversationId} is already in use by job ${conversationAttempt.blocker?.jobId ?? "unknown"}. ` +
+                    "Concurrent jobs targeting the same ChatGPT thread are not allowed.",
                 );
               }
               conversationLeaseAcquired = true;
@@ -1448,7 +1557,7 @@ export function registerOracleTools(pi: ExtensionAPI, workerPath: string, authWo
                 prompt: params.prompt,
                 files: params.files,
                 selection,
-                followUpToJobId: followUp.followUpToJobId,
+                followUpToJobId: target.followUpToJobId,
                 chatUrl: targetChatUrl,
                 requestSource: "tool",
               },
@@ -1563,7 +1672,7 @@ export function registerOracleTools(pi: ExtensionAPI, workerPath: string, authWo
             runtimeId: runtimeLeaseAcquired ? runtime.runtimeId : undefined,
             runtimeProfileDir: runtimeLeaseAcquired ? runtime.runtimeProfileDir : undefined,
             runtimeSessionName: workerSpawned ? runtime.runtimeSessionName : undefined,
-            conversationId: conversationLeaseAcquired ? followUp.conversationId : undefined,
+            conversationId: conversationLeaseAcquired ? target.conversationId : undefined,
           }).catch(() => ({ attempted: [], warnings: [] }));
           if (job && cleanupReport.warnings.length > 0) {
             await appendCleanupWarnings(job.id, cleanupReport.warnings).catch(() => undefined);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-oracle",
-  "version": "0.7.9",
+  "version": "0.7.11",
   "description": "ChatGPT and Grok web-oracle extension for pi with isolated browser auth, async jobs, and project-context archives.",
   "private": false,
   "license": "MIT",
@@ -80,8 +80,8 @@
     "protobufjs": "7.6.1"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "0.79.1",
-    "@earendil-works/pi-coding-agent": "0.79.1",
+    "@earendil-works/pi-ai": "0.79.4",
+    "@earendil-works/pi-coding-agent": "0.79.4",
     "@types/node": "^22.19.19",
     "esbuild": "^0.28.0",
     "tsx": "^4.22.3",

package/platform-smoke.config.mjs

@@ -40,7 +40,7 @@ export default {
   nodeValidationMajor: 24,
   realSmoke: {
     defaultProvider: "zai",
-    defaultModel: "glm-5.1",
+    defaultModel: "glm-5.2",
     authEnvByProvider: {
       zai: ["ZAI_API_KEY"],
       openai: ["OPENAI_API_KEY"],

package/prompts/oracle.md

@@ -13,7 +13,7 @@ Hard requirements:
 - After a successful or queued `oracle_submit`, your final answer must be only a terse dispatch summary with the job id and response path. Do not ask questions, offer to watch/poll/read, list next steps, or continue working.
 
 Required workflow:
-1. Call `oracle_preflight` immediately. If the user says to use Grok, pass `provider: "grok"` to `oracle_preflight`. If the user says to use ChatGPT, pass `provider: "chatgpt"`. If the user says to use ChatGPT Instant, pass `provider: "chatgpt"` and later call `oracle_submit` with `preset: "instant"`.
+1. Call `oracle_preflight` immediately. If the user says to use Grok, pass `provider: "grok"` to `oracle_preflight`. If the user says to use ChatGPT, pass `provider: "chatgpt"`. If the user says to use ChatGPT Instant, pass `provider: "chatgpt"` and later call `oracle_submit` with `preset: "instant"`. If the user explicitly provides an existing ChatGPT conversation id or `https://chatgpt.com/c/...` URL, pass it as `chatGptConversationId` to `oracle_preflight` and force `provider: "chatgpt"`. Omit `chatGptConversationId` unless the user explicitly asks to continue an existing browser-created ChatGPT thread.
 2. If `oracle_preflight` reports `ready: false`, stop before any expensive prep. Do not read files, search the codebase, prepare archive inputs, or call `oracle_auth` automatically. Report the blocking issue plus the suggested next step.
 3. Understand the request and decide whether it is explicitly narrow or genuinely broad.
 4. Gather enough repo context to choose archive inputs and write a strong oracle prompt. Bias toward context-rich submissions when they fit within the provider archive ceiling: 250 MB for ChatGPT, 200 MiB for Grok.
@@ -21,12 +21,13 @@ Required workflow:
 6. If the request is broad, architectural, release-oriented, or otherwise repo-wide, gather broader context and usually archive `.`.
 7. Choose archive inputs for the oracle job.
 8. Craft a concise but complete oracle prompt for the selected web provider.
-9. Call `oracle_submit` with the prompt and exact archive inputs. Do not ask for confirmation before this submit step unless `oracle_preflight` or `oracle_submit` returns a blocker that requires user action.
+9. Call `oracle_submit` with the prompt and exact archive inputs. Include `chatGptConversationId` only when the user explicitly provided an existing ChatGPT conversation id/URL to continue; otherwise omit it so the default remains a fresh oracle thread. Do not ask for confirmation before this submit step unless `oracle_preflight` or `oracle_submit` returns a blocker that requires user action.
 10. Stop immediately after dispatching the oracle job. “Stop” means no follow-up questions, no offers to poll/watch/read, and no extra next-step list.
 
 Oracle provider/model (`oracle_submit`):
 - If the user says to use Grok (for example “Use the oracle to Grok about ...”), pass **`provider: "grok"`**. Grok currently supports only **`mode: "heavy"`**; omit `mode` unless the user explicitly says Heavy.
 - If the user says ChatGPT, pass **`provider: "chatgpt"`**. Never route a ChatGPT request to Grok.
+- If the user provides an existing ChatGPT conversation id such as `6a28ab5c-e4d4-83e8-b8be-dd39f38a26d6` or a `https://chatgpt.com/c/...` URL, pass it as **`chatGptConversationId`** to both `oracle_preflight` and `oracle_submit`, and pass **`provider: "chatgpt"`**. This is only for explicit existing browser-created ChatGPT threads; omit it for normal `/oracle` jobs.
 - Otherwise omit **`provider`** to use the configured default provider, or pass **`provider: "chatgpt"`** only when needed for clarity.
 - To choose a specific ChatGPT model, pass **`preset`** with one of the allowed ids from the canonical preset registry.
 - Matching human-readable preset labels and common hyphen/space variants are also accepted and normalized automatically, but prefer canonical ids when readily available.

package/scripts/oracle-real-smoke.mjs

@@ -14,7 +14,7 @@ const require = createRequire(import.meta.url);
 const tsxCli = require.resolve("tsx/cli");
 
 const DEFAULT_PROVIDER = "zai";
-const DEFAULT_MODEL = "glm-5.1";
+const DEFAULT_MODEL = "glm-5.2";
 const DEFAULT_TIMEOUT_MS = 180_000;
 const PACKAGE_NAME = "pi-oracle";
 

package/scripts/platform-smoke/targets.mjs

@@ -54,7 +54,7 @@ function realSmokeProvider(config = {}) {
 }
 
 function realSmokeModel(config = {}) {
-  return process.env.PI_ORACLE_REAL_TEST_MODEL || config.realSmoke?.defaultModel || "glm-5.1";
+  return process.env.PI_ORACLE_REAL_TEST_MODEL || config.realSmoke?.defaultModel || "glm-5.2";
 }
 
 function truthy(value) {

package/scripts/platform-smoke.mjs

@@ -57,7 +57,7 @@ Environment:
   PLATFORM_SMOKE_WINDOWS_WORK_ROOT Windows work root
   PI_ORACLE_SMOKE_*              Project-specific aliases for the PLATFORM_SMOKE_* knobs above
   PI_ORACLE_REAL_TEST_PROVIDER   Real smoke provider (default: zai)
-  PI_ORACLE_REAL_TEST_MODEL      Real smoke model (default: glm-5.1)
+  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
 `);
 }