pi-oracle 0.7.9 → 0.7.10

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## Unreleased
 
+## 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

@@ -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`
 

package/docs/ORACLE_DESIGN.md

@@ -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:
@@ -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/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.10",
   "description": "ChatGPT and Grok web-oracle extension for pi with isolated browser auth, async jobs, and project-context archives.",
   "private": false,
   "license": "MIT",

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.