pi-oracle 0.1.12 → 0.2.1

package/docs/ORACLE_RECOVERY_DRILL.md

@@ -0,0 +1,127 @@
+# Oracle Recovery Drill
+
+This document codifies the safe validation drill for expired / missing auth in the isolated oracle seed profile.
+
+The goal is to prove:
+1. a broken seed profile fails cleanly
+2. the failure is classified as auth/login-required, not as generic UI drift
+3. `/oracle-auth` repairs the seed profile
+4. the next normal oracle job succeeds again
+
+## Safety guarantees
+
+This drill must **not** touch the user’s real Chrome profile.
+It only mutates the isolated oracle seed profile configured by `browser.authSeedProfileDir`.
+
+That directory must remain separate from the real Chrome user-data tree.
+
+## Preconditions
+
+- No active oracle jobs
+- `pi` reloaded with the current extension code
+- `/oracle-auth` happy path already known to work in the current environment
+
+## Backup
+
+Create a backup of the current seed profile first:
+
+```bash
+SEED="<oracle-auth-seed-profile-dir>"
+BACKUP="/tmp/oracle-auth-seed-backup-$(date +%Y%m%dT%H%M%S)"
+cp -cR "$SEED" "$BACKUP"
+echo "$BACKUP"
+```
+
+## Expired/missing-auth simulation
+
+Replace the seed profile with an empty isolated directory:
+
+```bash
+SEED="<oracle-auth-seed-profile-dir>"
+rm -rf "$SEED"
+mkdir -p "$SEED"
+chmod 700 "$SEED"
+```
+
+This simulates a seed profile with no usable ChatGPT session.
+
+## Validation steps
+
+### 1. Reload `pi`
+
+Reload so the extension sees the current seed directory state.
+
+### 2. Run a tiny oracle job
+
+Use a tiny prompt with a tiny archive.
+Expected result:
+- job fails quickly
+- failure is clearly auth/login related
+- failure is **not** misclassified as:
+  - model configuration failure
+  - artifact failure
+  - generic timeout
+  - vague UI drift
+
+### 3. Repair with `/oracle-auth`
+
+Run:
+
+```text
+/oracle-auth
+```
+
+Expected result:
+- ChatGPT cookies are re-synced into the seed profile
+- no real Chrome profile is mutated
+- command reports success
+
+### 4. Reload `pi` again
+
+Reload after auth repair.
+
+### 5. Run the same tiny oracle job again
+
+Expected result:
+- job succeeds normally
+- response persists under `/tmp/oracle-<job-id>/response.md`
+- wake-up triggers correctly
+
+## Pass criteria
+
+The drill passes only if all of the following are true:
+
+- Broken seed profile fails as an auth/login-required problem
+- `/oracle-auth` repairs the seed profile cleanly
+- The next normal oracle run succeeds
+- No active worker/session/profile cleanup regressions appear
+- No interaction with the real Chrome profile is required beyond cookie sync during `/oracle-auth`
+
+## Evidence to capture
+
+For the failed run:
+- `/tmp/oracle-<job-id>/job.json`
+- `/tmp/oracle-<job-id>/logs/worker.log`
+- any failure diagnostics under that job dir
+
+For the repair:
+- `/tmp/oracle-auth.log`
+- `/tmp/oracle-auth.url.txt`
+- `/tmp/oracle-auth.snapshot.txt`
+- `/tmp/oracle-auth.body.txt`
+
+For the successful rerun:
+- `/tmp/oracle-<job-id>/job.json`
+- `/tmp/oracle-<job-id>/response.md`
+- `/tmp/oracle-<job-id>/logs/worker.log`
+
+## Maintainer note
+
+This is a maintainer/operator validation document, not end-user setup documentation.
+It intentionally includes destructive steps against the isolated oracle seed profile only.
+
+## If the drill fails
+
+If the broken-seed run fails with anything other than a clean auth classification, fix that before treating recovery as production-ready.
+
+If `/oracle-auth` does not restore a working seed, treat auth recovery as still blocking.

package/extensions/oracle/index.ts

@@ -3,9 +3,11 @@ import { dirname, join } from "node:path";
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { loadOracleConfig } from "./lib/config.js";
 import { registerOracleCommands } from "./lib/commands.js";
-import { pruneTerminalOracleJobs, reconcileStaleOracleJobs } from "./lib/jobs.js";
+import { getSessionFile, pruneTerminalOracleJobs, reconcileStaleOracleJobs } from "./lib/jobs.js";
 import { isLockTimeoutError, withGlobalReconcileLock } from "./lib/locks.js";
 import { refreshOracleStatus, startPoller, stopPoller } from "./lib/poller.js";
+import { promoteQueuedJobs } from "./lib/queue.js";
+import { hasPersistedSessionFile } from "./lib/runtime.js";
 import { registerOracleTools } from "./lib/tools.js";
 
 export default function oracleExtension(pi: ExtensionAPI) {
@@ -13,7 +15,7 @@ export default function oracleExtension(pi: ExtensionAPI) {
   const workerPath = join(extensionDir, "worker", "run-job.mjs");
   const authWorkerPath = join(extensionDir, "worker", "auth-bootstrap.mjs");
 
-  registerOracleCommands(pi, authWorkerPath);
+  registerOracleCommands(pi, authWorkerPath, workerPath);
   registerOracleTools(pi, workerPath);
 
   async function runStartupMaintenance(ctx: ExtensionContext): Promise<void> {
@@ -25,20 +27,29 @@ export default function oracleExtension(pi: ExtensionAPI) {
     } catch (error) {
       if (!isLockTimeoutError(error, "reconcile", "global")) throw error;
     }
+
+    await promoteQueuedJobs({ workerPath, source: "oracle_session_start" });
   }
 
   function startPollerForContext(ctx: ExtensionContext) {
     try {
+      const sessionFile = getSessionFile(ctx);
+      if (!hasPersistedSessionFile(sessionFile)) {
+        stopPoller(ctx);
+        ctx.ui.setStatus("oracle", ctx.ui.theme.fg("accent", "oracle: unavailable"));
+        return;
+      }
+
       const config = loadOracleConfig(ctx.cwd);
       void runStartupMaintenance(ctx).catch((error) => {
         console.error("Oracle startup maintenance failed:", error);
       });
-      startPoller(pi, ctx, config.poller.intervalMs);
+      startPoller(pi, ctx, config.poller.intervalMs, workerPath);
       refreshOracleStatus(ctx);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       stopPoller(ctx);
-      ctx.ui.setStatus("oracle", ctx.ui.theme.fg("danger", "oracle: config error"));
+      ctx.ui.setStatus("oracle", ctx.ui.theme.fg("error", "oracle: config error"));
       ctx.ui.notify(message, "warning");
     }
   }

package/extensions/oracle/lib/commands.ts

@@ -3,13 +3,17 @@ import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-cod
 import { loadOracleConfig } from "./config.js";
 import {
   cancelOracleJob,
-  isActiveOracleJob,
+  isOpenOracleJob,
+  isTerminalOracleJob,
   listJobsForCwd,
+  markWakeupSettled,
   pruneTerminalOracleJobs,
   readJob,
   reconcileStaleOracleJobs,
   removeTerminalOracleJob,
+  shouldAdvanceQueueAfterCancellation,
 } from "./jobs.js";
+import { getQueuePosition, promoteQueuedJobs } from "./queue.js";
 import { refreshOracleStatus } from "./poller.js";
 import { isLockTimeoutError, withGlobalReconcileLock } from "./locks.js";
 import { getProjectId } from "./runtime.js";
@@ -18,11 +22,15 @@ function summarizeJob(jobId: string): string {
   const job = readJob(jobId);
   if (!job) return `Oracle job ${jobId} not found.`;
 
+  const queuePosition = job.status === "queued" ? getQueuePosition(job.id) : undefined;
   return [
     `job: ${job.id}`,
     `status: ${job.status}`,
     `phase: ${job.phase}`,
     `created: ${job.createdAt}`,
+    job.queuedAt ? `queued: ${job.queuedAt}` : undefined,
+    job.submittedAt ? `submitted: ${job.submittedAt}` : undefined,
+    queuePosition ? `queue-position: ${queuePosition.position} of ${queuePosition.depth} global` : undefined,
     `project: ${job.projectId}`,
     `session: ${job.sessionId}`,
     job.completedAt ? `completed: ${job.completedAt}` : undefined,
@@ -84,7 +92,7 @@ async function runAuthBootstrap(authWorkerPath: string, cwd: string): Promise<st
   });
 }
 
-export function registerOracleCommands(pi: ExtensionAPI, authWorkerPath: string): void {
+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) => {
@@ -107,16 +115,24 @@ export function registerOracleCommands(pi: ExtensionAPI, authWorkerPath: string)
         ctx.ui.notify("No oracle jobs found for this project", "info");
         return;
       }
-      if (explicitJobId && !readScopedJob(jobId, ctx.cwd)) {
+      const job = readScopedJob(jobId, ctx.cwd);
+      if (!job) {
         ctx.ui.notify(`Oracle job ${jobId} was not found in this project`, "warning");
         return;
       }
-      ctx.ui.notify(summarizeJob(jobId), "info");
+      if (isTerminalOracleJob(job)) {
+        await markWakeupSettled(job.id, {
+          source: "oracle_status",
+          sessionFile: ctx.sessionManager.getSessionFile?.(),
+          cwd: ctx.cwd,
+        });
+      }
+      ctx.ui.notify(summarizeJob(job.id), "info");
     },
   });
 
   pi.registerCommand("oracle-cancel", {
-    description: "Cancel an active oracle job",
+    description: "Cancel a queued or active oracle job",
     handler: async (args, ctx) => {
       const explicitJobId = args.trim();
       const jobId = explicitJobId || getLatestJobId(ctx.cwd);
@@ -130,14 +146,20 @@ export function registerOracleCommands(pi: ExtensionAPI, authWorkerPath: string)
         ctx.ui.notify(`Oracle job ${jobId} not found in this project`, "warning");
         return;
       }
-      if (!isActiveOracleJob(job)) {
-        ctx.ui.notify(`Oracle job ${jobId} is not active (${job.status})`, "info");
+      if (!isOpenOracleJob(job)) {
+        ctx.ui.notify(`Oracle job ${jobId} is not cancellable (${job.status})`, "info");
         return;
       }
 
       const cancelled = await cancelOracleJob(jobId);
+      if (shouldAdvanceQueueAfterCancellation(cancelled)) {
+        await promoteQueuedJobs({ workerPath, source: "oracle_cancel_command" });
+      }
       refreshOracleStatus(ctx);
-      ctx.ui.notify(`Cancelled oracle job ${cancelled.id}`, "info");
+      const message = cancelled.status === "cancelled" || cancelled.status === "failed"
+        ? `Cancelled oracle job ${cancelled.id}`
+        : `Oracle job ${cancelled.id} was already ${cancelled.status}`;
+      ctx.ui.notify(message, "info");
     },
   });
 
@@ -156,20 +178,22 @@ export function registerOracleCommands(pi: ExtensionAPI, authWorkerPath: string)
         return;
       }
 
-      const activeJobs = jobs.filter((job): job is NonNullable<typeof job> => Boolean(job && isActiveOracleJob(job)));
-      if (activeJobs.length > 0) {
+      const nonTerminalJobs = jobs.filter((job): job is NonNullable<typeof job> => Boolean(job && !isTerminalOracleJob(job)));
+      if (nonTerminalJobs.length > 0) {
         ctx.ui.notify(
-          `Refusing to remove active oracle job${activeJobs.length === 1 ? "" : "s"}: ${activeJobs.map((job) => job.id).join(", ")}`,
+          `Refusing to remove non-terminal oracle job${nonTerminalJobs.length === 1 ? "" : "s"}: ${nonTerminalJobs.map((job) => job.id).join(", ")}`,
           "warning",
         );
         return;
       }
 
       const cleanupWarnings: string[] = [];
+      let removedCount = 0;
       const removeJobs = async () => {
         for (const job of jobs) {
           if (!job) continue;
           const result = await removeTerminalOracleJob(job);
+          if (result.removed) removedCount += 1;
           cleanupWarnings.push(...result.cleanupReport.warnings.map((warning) => `${job.id}: ${warning}`));
         }
       };
@@ -186,7 +210,10 @@ export function registerOracleCommands(pi: ExtensionAPI, authWorkerPath: string)
 
       refreshOracleStatus(ctx);
       const warningSuffix = cleanupWarnings.length > 0 ? ` Cleanup warnings:\n${cleanupWarnings.join("\n")}` : "";
-      ctx.ui.notify(`Removed ${jobs.length} oracle job director${jobs.length === 1 ? "y" : "ies"}.${warningSuffix}`, cleanupWarnings.length > 0 ? "warning" : "info");
+      const removalSummary = removedCount === jobs.length
+        ? `Removed ${removedCount} oracle job director${removedCount === 1 ? "y" : "ies"}.`
+        : `Removed ${removedCount} of ${jobs.length} oracle job director${jobs.length === 1 ? "y" : "ies"}; retained ${jobs.length - removedCount} with cleanup warnings.`;
+      ctx.ui.notify(`${removalSummary}${warningSuffix}`, cleanupWarnings.length > 0 ? "warning" : "info");
     },
   });
 }

package/extensions/oracle/lib/config.ts

@@ -106,7 +106,7 @@ export const DEFAULT_CONFIG: OracleConfig = {
     sessionPrefix: "oracle",
     authSeedProfileDir: join(agentExtensionsDir, "oracle-auth-seed-profile"),
     runtimeProfilesDir: join(agentExtensionsDir, "oracle-runtime-profiles"),
-    maxConcurrentJobs: 8,
+    maxConcurrentJobs: 2,
     cloneStrategy: "apfs-clone",
     chatUrl: "https://chatgpt.com/",
     authUrl: "https://chatgpt.com/auth/login",
@@ -299,7 +299,7 @@ function validateOracleConfig(value: unknown): OracleConfig {
   const modelFamily = expectEnum(defaults.modelFamily, "defaults.modelFamily", MODEL_FAMILIES);
   const effort = expectEnum(defaults.effort, "defaults.effort", EFFORTS);
   const autoSwitchToThinking = expectBoolean(defaults.autoSwitchToThinking, "defaults.autoSwitchToThinking");
-  if (modelFamily === "pro" && !PRO_EFFORTS.includes(effort)) {
+  if (modelFamily === "pro" && effort !== "standard" && effort !== "extended") {
     throw new Error(`Invalid oracle config: defaults.effort must be one of ${PRO_EFFORTS.join(", ")} for pro`);
   }
   if (modelFamily !== "instant" && autoSwitchToThinking) {