pi-oracle 0.5.0 → 0.6.1

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## Unreleased
+
+## 0.6.1 - 2026-04-13
+
+### Fixed
+- whole-repo archive expansion now merges very large entry groups iteratively instead of using spread/flat patterns that can overflow the JavaScript call stack during `oracle_submit`
+- oracle sanity coverage now guards the large-entry merge path so broad archive submissions regress to a real archive/env error instead of `Maximum call stack size exceeded`
+
+## 0.6.0 - 2026-04-13
+
+### Added
+- `oracle_auth`, an agent-facing tool that mirrors `/oracle-auth` so oracle runs can refresh the shared ChatGPT auth seed profile before a single retry when stale auth blocks execution
+
+### Changed
+- `/oracle` and `/oracle-followup` now follow a stricter preflight-first flow, bias toward context-rich archive selection up to the 250 MB ceiling, and explicitly allow one `oracle_auth` refresh before retrying stale-auth/login-required failures
+- package metadata now follows the current pi package dependency guidance by publishing `@mariozechner/pi-coding-agent` and `@sinclair/typebox` as peer dependencies while keeping local typechecking/dev resolution intact
+
+### Fixed
+- `/oracle` no-session and missing-seed flows now stop before unnecessary repo exploration, and prompt-template guidance keeps relevant surrounding archive context instead of over-optimizing for minimal slices when extra context still fits
+- oracle model selection now recognizes ChatGPT family controls exposed as radios/menu items plus durable closed-chip states like `Extended thinking` and `Extended Pro`, so remembered new-chat defaults no longer derail preset configuration or ready-state detection
+- authenticated ready-state detection now accepts extended closed-chip model controls during auth/bootstrap verification, preventing false login/setup failures when ChatGPT remembers a non-default preset
+
 ## 0.5.0 - 2026-04-12
 
 ### Added

package/README.md

@@ -52,7 +52,7 @@ pi install https://github.com/fitchmultz/pi-oracle
 
 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.
 
-For explicitly narrow requests, `/oracle` should gather only minimal context and prefer a minimal archive instead of broad repo exploration. It should also omit `preset` and use the configured default model unless the task clearly needs a different one.
+For explicitly narrow requests, `/oracle` should still prefer a context-rich relevant archive up to the 250 MB ceiling, including nearby tests, docs, config, and adjacent modules when that can improve answer quality. Reserve tightly minimal archives for an explicit user request for a tight archive, privacy-sensitive material, or size-constrained cases. It should also omit `preset` and use the configured default model unless the task clearly needs a different one.
 
 If you miss the wake-up, the result is still saved durably in the oracle job directory and can be read later.
 
@@ -67,14 +67,20 @@ If you miss the wake-up, the result is still saved durably in the oracle job dir
 ```
 
 ```text
-/oracle Explain the README guidance for /oracle-clean retention grace. Only archive README.md unless another file is clearly necessary.
+/oracle Explain the README guidance for /oracle-clean retention grace. Archive README.md plus any nearby docs or implementation files that help answer accurately.
 ```
 
+```text
+/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 limit.
+```
+
+After a job finishes, use `/oracle-followup <job-id> <request>` to continue the same ChatGPT thread without hand-writing the low-level `followUpJobId` tool parameter.
+
 ## High-level flow
 
 ```mermaid
 flowchart LR
-    A["/oracle request"] --> B["Agent preflights, then gathers only the needed repo context"]
+    A["/oracle request"] --> B["Agent preflights, then gathers a context-rich relevant repo slice"]
     B --> C["oracle_submit builds archive"]
     C --> D["Detached worker starts isolated ChatGPT runtime"]
     D --> E["Archive + prompt sent to ChatGPT.com"]
@@ -88,13 +94,16 @@ 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-status [job-id]` — inspect job status
-- `/oracle-cancel [job-id]` — cancel queued or active job
+- `/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
 - `/oracle-clean <job-id|all>` — remove temp files for terminal jobs; recently woken terminal jobs may stay retained briefly and return a retry-after hint
 
 Agent-facing tools:
 - `oracle_preflight`
+- `oracle_auth`
 - `oracle_submit`
 - `oracle_read`
 - `oracle_cancel`
@@ -152,7 +161,10 @@ 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.
-- If you miss the wake-up, use `oracle_read(jobId)` or `/oracle-status`.
+- 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 })`.
+- If a prior oracle run failed because ChatGPT login was required or the worker explicitly said to rerun `/oracle-auth`, agent callers can run `oracle_auth({})` once and then retry the submission once.
 - `/oracle-clean` can still refuse a terminal job briefly after a wake-up send so saved response/artifact paths survive the follow-up turn; when that guard applies, it returns the next eligible cleanup time.
 
 ## Requirements
@@ -185,7 +197,9 @@ Project config should only override safe, non-privileged settings.
 
 ### A job finished but no wake-up arrived
 
-- Use `/oracle-status [job-id]` or `oracle_read(jobId)`.
+- Use `/oracle-read [job-id]` to inspect the saved response preview.
+- Use `/oracle-status [job-id]` when you want status metadata or need help finding a job id.
+- Agent callers can use `oracle_read({ jobId })` if they need tool output in the current turn.
 - Results are still saved on disk even if the reminder turn does not land.
 
 ### `/oracle-clean` refuses a terminal job right after completion

package/docs/ORACLE_DESIGN.md

@@ -65,15 +65,21 @@ The extension now follows the current `pi` session lifecycle model:
   - implemented as a prompt template, not an extension command
   - asks the agent to gather context and dispatch an oracle job
   - intentionally uses native pi prompt/template queueing so submissions survive streaming and compaction
+- `/oracle-followup <job-id> <request>`
+  - implemented as a prompt template, not an extension command
+  - asks the agent to continue an earlier oracle job in the same ChatGPT thread via `followUpJobId`
+  - keeps same-thread continuation available to normal users without requiring raw tool-call syntax
 
 ### Commands
 
 - `/oracle-auth`
   - syncs ChatGPT cookies from the user’s real Chrome into the isolated oracle profile and verifies them there
+- `/oracle-read [job-id]`
+  - shows job status plus the saved response preview
 - `/oracle-status [job-id]`
-  - shows job status
-- `/oracle-cancel [job-id]`
-  - cancels a queued or active job
+  - shows job status and lists recent job ids when the caller omits an explicit id
+- `/oracle-cancel <job-id>`
+  - cancels a queued or active job by id; does not guess a default target
 - `/oracle-clean <job-id|all>`
   - removes temp files for terminal jobs only
 
@@ -82,6 +88,8 @@ The extension now follows the current `pi` session lifecycle model:
 - `oracle_preflight`
   - lightweight agent-facing readiness check for persisted-session and local oracle prerequisites
   - intended to run before expensive `/oracle` context gathering
+- `oracle_auth`
+  - agent-facing auth refresh tool that mirrors `/oracle-auth` for stale-auth recovery before a retry
 - `oracle_submit`
   - low-level agent-facing dispatch tool
   - creates archive and launches a detached worker
@@ -103,12 +111,13 @@ Instead it instructs the agent to:
 1. call `oracle_preflight` immediately
 2. stop right away if preflight reports the session or local oracle setup is not ready
 3. understand whether the request is explicitly narrow or genuinely broad
-4. gather only the smallest repo context needed to submit well
-5. if the request is narrow, prefer a minimal targeted archive and dispatch as soon as enough context is in hand
-6. if the request is broad/repo-wide, gather broader context and usually archive `.`
-7. craft the oracle prompt
-8. call `oracle_submit`
-9. stop and wait for the completion wake-up (best-effort; durable oracle response/artifact state is already persisted outside session history)
+4. if the immediately preceding oracle run failed because ChatGPT login is required or the worker explicitly said to rerun `/oracle-auth`, call `oracle_auth` once before retrying
+5. gather enough repo context to submit well and bias toward context-rich archives when they fit within the 250 MB ceiling
+6. if the request is narrow, start from the directly relevant area but still include nearby tests, docs, config, and adjacent modules when they may improve answer quality
+7. if the request is broad/repo-wide, gather broader context and usually archive `.`
+8. craft the oracle prompt
+9. call `oracle_submit`
+10. stop and wait for the completion wake-up (best-effort; durable oracle response/artifact state is already persisted outside session history)
 
 ### `/oracle-auth`
 
@@ -139,7 +148,7 @@ The authenticated seed profile remains the source of truth for future oracle run
 
 ### `oracle_submit`
 
-Agent-facing submissions use **`preset`**; the canonical registry is `ORACLE_SUBMIT_PRESETS` in `extensions/oracle/lib/config.ts`. **`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 `preset` and using the configured default unless the task clearly needs a different model or the user explicitly asked for one.
+Agent-facing submissions use **`preset`**; the canonical registry is `ORACLE_SUBMIT_PRESETS` in `extensions/oracle/lib/config.ts`. **`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 `preset` and using the configured default unless the task clearly needs a different model or the user explicitly asked for one. It also biases toward context-rich archives up to the 250 MB ceiling, narrowing only when the user explicitly asks for a tight archive, privacy/sensitivity requires it, or size pressure forces it.
 
 1. resolve the preset (submit-time or config default) into an execution snapshot
 2. resolve optional `followUpJobId` into a prior `chatUrl` and `conversationId`
@@ -454,6 +463,7 @@ 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 ChatGPT thread later
 - 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`
@@ -473,10 +483,10 @@ The extension still uses the same general `pi`-native background completion patt
 - 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
-- those wake-ups direct the receiver to `oracle_read(jobId)` as the canonical completion-consumption path, while still surfacing saved response/artifact paths as secondary context
-- manual `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
+- 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
-- if no wake-up lands, the job remains available via `/oracle-status`, `oracle_read`, and the saved `${PI_ORACLE_JOBS_DIR:-/tmp}/oracle-<job-id>/` response/artifact files
+- 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
 - 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
 
@@ -518,8 +528,8 @@ Implemented in code for the pivot and concurrency redesign:
 
 Retained from the earlier MVP:
 
-- `/oracle`, `/oracle-status`, `/oracle-cancel`, `/oracle-clean`
-- `oracle_submit`, `oracle_read`, `oracle_cancel`
+- `/oracle`, `/oracle-followup`, `/oracle-read`, `/oracle-status`, `/oracle-cancel`, `/oracle-clean`
+- `oracle_auth`, `oracle_submit`, `oracle_read`, `oracle_cancel`
 - detached background worker model
 - `${PI_ORACLE_JOBS_DIR:-/tmp}/oracle-<job-id>/...` state layout
 - shell-safe archive creation using `tar` piped to `zstd`

package/extensions/oracle/index.ts

@@ -21,7 +21,7 @@ export default function oracleExtension(pi: ExtensionAPI) {
   const authWorkerPath = join(extensionDir, "worker", "auth-bootstrap.mjs");
 
   registerOracleCommands(pi, authWorkerPath, workerPath);
-  registerOracleTools(pi, workerPath);
+  registerOracleTools(pi, workerPath, authWorkerPath);
 
   async function runStartupMaintenance(ctx: ExtensionContext): Promise<void> {
     try {

package/extensions/oracle/lib/auth.ts

@@ -0,0 +1,50 @@
+// Purpose: Share oracle auth-bootstrap orchestration between slash commands and agent-facing tools.
+// Responsibilities: Load effective auth guidance, run reconcile maintenance, spawn the auth bootstrap worker, and return user-facing results.
+// Scope: Extension-side auth bootstrap orchestration only; browser cookie import and profile validation stay in worker/auth-bootstrap.mjs.
+// Usage: Imported by oracle commands and tools whenever the shared oracle auth seed profile must be refreshed.
+// Invariants/Assumptions: Auth bootstrap runs under the global reconcile lock when available, uses the effective oracle config for the current workspace root, and returns the worker's stdout/stderr message verbatim on success or failure.
+import { spawn } from "node:child_process";
+import { formatOracleAuthConfigRemediation, formatOracleAuthConfigSummary, getOracleConfigLoadDetails, loadOracleConfig } from "./config.js";
+import { pruneTerminalOracleJobs, reconcileStaleOracleJobs } from "./jobs.js";
+import { isLockTimeoutError, withGlobalReconcileLock } from "./locks.js";
+
+export async function runOracleAuthBootstrap(authWorkerPath: string, cwd: string): Promise<string> {
+  const config = loadOracleConfig(cwd);
+  const configLoad = getOracleConfigLoadDetails(cwd);
+  const authConfigGuidance = {
+    ...configLoad,
+    remediation: formatOracleAuthConfigRemediation(configLoad),
+    summary: formatOracleAuthConfigSummary(configLoad),
+  };
+
+  try {
+    await withGlobalReconcileLock({ processPid: process.pid, source: "oracle_auth", cwd }, async () => {
+      await reconcileStaleOracleJobs();
+      await pruneTerminalOracleJobs();
+    });
+  } catch (error) {
+    if (!isLockTimeoutError(error, "reconcile", "global")) throw error;
+  }
+
+  return await new Promise<string>((resolve, reject) => {
+    const child = spawn(process.execPath, [authWorkerPath, JSON.stringify({ config, configLoad: authConfigGuidance })], {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (data) => {
+      stdout += String(data);
+    });
+    child.stderr.on("data", (data) => {
+      stderr += String(data);
+    });
+    child.on("error", (error) => reject(error));
+    child.on("close", (code) => {
+      const message = stdout.trim() || stderr.trim() || "Oracle auth bootstrap finished with no output.";
+      if (code === 0) resolve(message);
+      else reject(new Error(message));
+    });
+  });
+}

package/extensions/oracle/lib/commands.ts

@@ -3,11 +3,11 @@
 // Scope: Command-facing orchestration only; durable lifecycle mutations live in jobs/runtime/tools modules and browser execution stays in worker scripts.
 // Usage: Imported by the oracle extension entrypoint to register /oracle-* commands with pi.
 // Invariants/Assumptions: Commands operate on persisted project-scoped jobs and rely on shared observability formatting for detached-state clarity.
-import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
 import { formatOracleJobSummary } from "../shared/job-observability-helpers.mjs";
-import { formatOracleAuthConfigRemediation, formatOracleAuthConfigSummary, getOracleConfigLoadDetails, loadOracleConfig } from "./config.js";
+import { runOracleAuthBootstrap } from "./auth.js";
 import {
   cancelOracleJob,
   getJobDir,
@@ -15,7 +15,6 @@ import {
   isTerminalOracleJob,
   listJobsForCwd,
   markWakeupSettled,
-  pruneTerminalOracleJobs,
   readJob,
   reconcileStaleOracleJobs,
   removeTerminalOracleJob,
@@ -26,15 +25,25 @@ import { refreshOracleStatus } from "./poller.js";
 import { isLockTimeoutError, withGlobalReconcileLock } from "./locks.js";
 import { getProjectId } from "./runtime.js";
 
-function summarizeJob(jobId: string): string {
+async function summarizeJob(jobId: string, options?: { responsePreview?: boolean }): Promise<string> {
   const job = readJob(jobId);
   if (!job) return `Oracle job ${jobId} not found.`;
 
   const responseAvailable = Boolean(job.responsePath && existsSync(job.responsePath));
+  let responsePreview: string | undefined;
+  if (options?.responsePreview && responseAvailable && job.responsePath) {
+    try {
+      responsePreview = (await readFile(job.responsePath, "utf8")).slice(0, 4000);
+    } catch {
+      responsePreview = undefined;
+    }
+  }
+
   return formatOracleJobSummary(job, {
     queuePosition: job.status === "queued" ? getQueuePosition(job.id) : undefined,
     artifactsPath: `${getJobDir(job.id)}/artifacts`,
     responseAvailable,
+    responsePreview,
   });
 }
 
@@ -42,59 +51,25 @@ function getLatestJobId(cwd: string): string | undefined {
   return listJobsForCwd(cwd)[0]?.id;
 }
 
+function listRecentJobIds(cwd: string, limit = 5): string | undefined {
+  const jobs = listJobsForCwd(cwd).slice(0, limit);
+  if (jobs.length === 0) return undefined;
+  return jobs.map((job) => `${job.id} (${job.status})`).join(", ");
+}
+
 function readScopedJob(jobId: string, cwd: string) {
   const job = readJob(jobId);
   if (!job || job.projectId !== getProjectId(cwd)) return undefined;
   return job;
 }
 
-async function runAuthBootstrap(authWorkerPath: string, cwd: string): Promise<string> {
-  const config = loadOracleConfig(cwd);
-  const configLoad = getOracleConfigLoadDetails(cwd);
-  const authConfigGuidance = {
-    ...configLoad,
-    remediation: formatOracleAuthConfigRemediation(configLoad),
-    summary: formatOracleAuthConfigSummary(configLoad),
-  };
-  try {
-    await withGlobalReconcileLock({ processPid: process.pid, source: "oracle_auth", cwd }, async () => {
-      await reconcileStaleOracleJobs();
-      await pruneTerminalOracleJobs();
-    });
-  } catch (error) {
-    if (!isLockTimeoutError(error, "reconcile", "global")) throw error;
-  }
-
-  return await new Promise<string>((resolve, reject) => {
-    const child = spawn(process.execPath, [authWorkerPath, JSON.stringify({ config, configLoad: authConfigGuidance })], {
-      cwd,
-      stdio: ["ignore", "pipe", "pipe"],
-    });
-
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (data) => {
-      stdout += String(data);
-    });
-    child.stderr.on("data", (data) => {
-      stderr += String(data);
-    });
-    child.on("error", (error) => reject(error));
-    child.on("close", (code) => {
-      const message = stdout.trim() || stderr.trim() || "Oracle auth bootstrap finished with no output.";
-      if (code === 0) resolve(message);
-      else reject(new Error(message));
-    });
-  });
-}
-
 export function registerOracleCommands(pi: ExtensionAPI, authWorkerPath: string, workerPath: string): void {
   pi.registerCommand("oracle-auth", {
     description: "Sync ChatGPT cookies from real Chrome into the oracle auth seed profile",
     handler: async (_args, ctx) => {
       ctx.ui.notify("Syncing ChatGPT cookies from real Chrome into the oracle auth seed profile…", "info");
       try {
-        const result = await runAuthBootstrap(authWorkerPath, ctx.cwd);
+        const result = await runOracleAuthBootstrap(authWorkerPath, ctx.cwd);
         ctx.ui.notify(result, "info");
       } catch (error) {
         ctx.ui.notify(error instanceof Error ? error.message : String(error), "warning");
@@ -103,7 +78,7 @@ export function registerOracleCommands(pi: ExtensionAPI, authWorkerPath: string,
   });
 
   pi.registerCommand("oracle-status", {
-    description: "Show oracle job status",
+    description: "Show oracle job status and recent job ids",
     handler: async (args, ctx) => {
       const explicitJobId = args.trim();
       const jobId = explicitJobId || getLatestJobId(ctx.cwd);
@@ -123,12 +98,14 @@ export function registerOracleCommands(pi: ExtensionAPI, authWorkerPath: string,
           cwd: ctx.cwd,
         });
       }
-      ctx.ui.notify(summarizeJob(job.id), "info");
+      const summary = await summarizeJob(job.id);
+      const recentJobs = !explicitJobId ? listRecentJobIds(ctx.cwd) : undefined;
+      ctx.ui.notify([summary, recentJobs ? `Recent jobs: ${recentJobs}` : undefined].filter(Boolean).join("\n"), "info");
     },
   });
 
-  pi.registerCommand("oracle-cancel", {
-    description: "Cancel a queued or active oracle job",
+  pi.registerCommand("oracle-read", {
+    description: "Show oracle job status plus saved response preview",
     handler: async (args, ctx) => {
       const explicitJobId = args.trim();
       const jobId = explicitJobId || getLatestJobId(ctx.cwd);
@@ -136,8 +113,32 @@ export function registerOracleCommands(pi: ExtensionAPI, authWorkerPath: string,
         ctx.ui.notify("No oracle jobs found for this project", "info");
         return;
       }
+      const job = readScopedJob(jobId, ctx.cwd);
+      if (!job) {
+        ctx.ui.notify(`Oracle job ${jobId} was not found in this project`, "warning");
+        return;
+      }
+      if (isTerminalOracleJob(job)) {
+        await markWakeupSettled(job.id, {
+          source: "oracle_read_command",
+          sessionFile: ctx.sessionManager.getSessionFile?.(),
+          cwd: ctx.cwd,
+        });
+      }
+      ctx.ui.notify(await summarizeJob(job.id, { responsePreview: true }), "info");
+    },
+  });
 
-      const job = explicitJobId ? readScopedJob(jobId, ctx.cwd) : readJob(jobId);
+  pi.registerCommand("oracle-cancel", {
+    description: "Cancel a queued or active oracle job by id",
+    handler: async (args, ctx) => {
+      const jobId = args.trim();
+      if (!jobId) {
+        ctx.ui.notify("Usage: /oracle-cancel <job-id>\nUse /oracle-status to find the job id you want to cancel.", "warning");
+        return;
+      }
+
+      const job = readScopedJob(jobId, ctx.cwd);
       if (!job) {
         ctx.ui.notify(`Oracle job ${jobId} not found in this project`, "warning");
         return;

package/extensions/oracle/lib/config.ts

@@ -8,6 +8,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { getAgentDir } from "@mariozechner/pi-coding-agent";
 import { isAbsolute, join, normalize } from "node:path";
+import { getProjectId } from "./runtime.js";
 
 export const MODEL_FAMILIES = ["instant", "thinking", "pro"] as const;
 export type OracleModelFamily = (typeof MODEL_FAMILIES)[number];
@@ -270,8 +271,9 @@ export interface OracleConfigLoadDetails {
 
 export function getOracleConfigLoadDetails(cwd: string): OracleConfigLoadDetails {
   const agentDir = getAgentDir();
+  const projectRoot = getProjectId(cwd);
   const agentConfigPath = join(agentDir, "extensions", "oracle.json");
-  const projectConfigPath = join(cwd, ".pi", "extensions", "oracle.json");
+  const projectConfigPath = join(projectRoot, ".pi", "extensions", "oracle.json");
   return {
     agentDir,
     agentConfigPath,

package/extensions/oracle/lib/jobs.ts

@@ -34,7 +34,7 @@ import { cleanupRuntimeArtifacts, getProjectId, getSessionId, parseConversationI
 export type OracleJobStatus = SharedOracleJobStatus;
 export type OracleJobPhase = SharedOracleJobPhase;
 
-export type OracleWakeupSettlementSource = "oracle_read" | "oracle_status";
+export type OracleWakeupSettlementSource = "oracle_read" | "oracle_status" | "oracle_read_command";
 
 export { ACTIVE_ORACLE_JOB_STATUSES, OPEN_ORACLE_JOB_STATUSES, TERMINAL_ORACLE_JOB_STATUSES };
 export const ORACLE_MISSING_WORKER_GRACE_MS = 30_000;
@@ -728,8 +728,10 @@ export async function releaseNotificationClaim(jobId: string, claimedBy: string)
 export async function noteWakeupRequested(jobId: string, at = new Date().toISOString()): Promise<OracleJob | undefined> {
   try {
     return await updateJob(jobId, (job) => noteOracleJobWakeupRequested(job, { at, source: "oracle:poller" }));
-  } catch {
-    return readJob(jobId);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.startsWith("Oracle job not found:")) return undefined;
+    throw error;
   }
 }
 
@@ -927,7 +929,16 @@ export function resolveArchiveInputs(cwd: string, files: string[]): { absolute:
 
   const realCwd = realpathSync(cwd);
   return files.map((file) => {
+    if (!file.trim()) {
+      throw new Error("Archive input must be a non-empty project-relative path");
+    }
+    if (file.trim() === "." && file !== ".") {
+      throw new Error("Archive input must use '.' exactly for a whole-repo archive");
+    }
     const absolute = resolve(cwd, file);
+    if (absolute === cwd && file !== ".") {
+      throw new Error("Archive input must use '.' exactly for a whole-repo archive");
+    }
     const relative = absolute.startsWith(`${cwd}/`) ? absolute.slice(cwd.length + 1) : absolute === cwd ? "." : "";
     if (!relative) {
       throw new Error(`Archive input must be inside the project cwd: ${file}`);

package/extensions/oracle/lib/poller.ts

@@ -245,8 +245,14 @@ async function scan(pi: ExtensionAPI, ctx: ExtensionContext, workerPath: string,
         continue;
       }
 
-      requestWakeupTurn(pi, deliverable);
-      await noteWakeupRequested(jobId).catch(() => undefined);
+      const notedWakeup = await noteWakeupRequested(jobId);
+      const deliverableAfterNote = notedWakeup ?? readJob(jobId);
+      if (!deliverableAfterNote || shouldPruneTerminalJob(deliverableAfterNote, Date.now())) {
+        await releaseNotificationClaim(jobId, notificationClaimant).catch(() => undefined);
+        continue;
+      }
+
+      requestWakeupTurn(pi, deliverableAfterNote);
       if (ctx.hasUI) {
         ctx.ui.notify(`Oracle job ${claimed.id} is ${claimed.status}.`, "info");
       }