pi-oracle 0.1.3 → 0.1.5

package/README.md

@@ -30,6 +30,7 @@ An oracle job:
 3. uploads the archive and sends the prompt
 4. waits in the background
 5. persists the response and any artifacts under `/tmp/oracle-<job-id>/`
+   - old terminal jobs are later pruned according to cleanup retention settings
 6. wakes the originating `pi` session on completion
 
 ## Example
@@ -105,9 +106,17 @@ Common settings:
 - `browser.runtimeProfilesDir`
 - `auth.chromeProfile`
 - `auth.chromeCookiePath`
+- `cleanup.completeJobRetentionMs`
+- `cleanup.failedJobRetentionMs`
 
 Project config should only override safe, non-privileged settings.
 
+Cleanup behavior:
+- terminal job directories under `/tmp/oracle-<job-id>/` are retained for inspection, then pruned conservatively
+- completed/cancelled jobs are pruned after `cleanup.completeJobRetentionMs` once they have been notified
+- failed jobs are pruned after `cleanup.failedJobRetentionMs`
+- `/oracle-clean` performs runtime cleanup before removing the job directory and reports cleanup warnings if any residual cleanup step fails
+
 Detailed design and maintainer docs:
 - `docs/ORACLE_DESIGN.md`
 - `docs/ORACLE_RECOVERY_DRILL.md`

package/extensions/oracle/index.ts

@@ -3,6 +3,8 @@ 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 { isLockTimeoutError, withGlobalReconcileLock } from "./lib/locks.js";
 import { refreshOracleStatus, startPoller, stopPoller, stopPollerForSession } from "./lib/poller.js";
 import { registerOracleTools } from "./lib/tools.js";
 
@@ -14,10 +16,24 @@ export default function oracleExtension(pi: ExtensionAPI) {
   registerOracleCommands(pi, authWorkerPath);
   registerOracleTools(pi, workerPath);
 
+  async function runStartupMaintenance(ctx: ExtensionContext): Promise<void> {
+    try {
+      await withGlobalReconcileLock({ processPid: process.pid, source: "oracle_session_start", cwd: ctx.cwd }, async () => {
+        await reconcileStaleOracleJobs();
+        await pruneTerminalOracleJobs();
+      }, { timeoutMs: 250 });
+    } catch (error) {
+      if (!isLockTimeoutError(error, "reconcile", "global")) throw error;
+    }
+  }
+
   function startPollerForContext(previousSessionFile: string | undefined, ctx: ExtensionContext) {
     stopPollerForSession(previousSessionFile, ctx.cwd);
     try {
       const config = loadOracleConfig(ctx.cwd);
+      void runStartupMaintenance(ctx).catch((error) => {
+        console.error("Oracle startup maintenance failed:", error);
+      });
       startPoller(pi, ctx, config.poller.intervalMs);
       refreshOracleStatus(ctx);
     } catch (error) {

package/extensions/oracle/lib/commands.ts

@@ -1,10 +1,16 @@
 import { spawn } from "node:child_process";
-import { rm } from "node:fs/promises";
-import { join } from "node:path";
 import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
 import { loadOracleConfig } from "./config.js";
 import { buildOracleDispatchPrompt } from "./instructions.js";
-import { cancelOracleJob, isActiveOracleJob, listJobsForCwd, readJob, reconcileStaleOracleJobs } from "./jobs.js";
+import {
+  cancelOracleJob,
+  isActiveOracleJob,
+  listJobsForCwd,
+  pruneTerminalOracleJobs,
+  readJob,
+  reconcileStaleOracleJobs,
+  removeTerminalOracleJob,
+} from "./jobs.js";
 import { refreshOracleStatus } from "./poller.js";
 import { isLockTimeoutError, withGlobalReconcileLock } from "./locks.js";
 import { getProjectId } from "./runtime.js";
@@ -27,6 +33,8 @@ function summarizeJob(jobId: string): string {
     job.responsePath ? `response: ${job.responsePath}` : undefined,
     job.responseFormat ? `response-format: ${job.responseFormat}` : undefined,
     typeof job.artifactFailureCount === "number" ? `artifact-failures: ${job.artifactFailureCount}` : undefined,
+    job.lastCleanupAt ? `last-cleanup: ${job.lastCleanupAt}` : undefined,
+    job.cleanupWarnings?.length ? `cleanup-warnings: ${job.cleanupWarnings.join(" | ")}` : undefined,
     job.error ? `error: ${job.error}` : undefined,
   ]
     .filter(Boolean)
@@ -48,6 +56,7 @@ async function runAuthBootstrap(authWorkerPath: string, cwd: string): Promise<st
   try {
     await withGlobalReconcileLock({ processPid: process.pid, source: "oracle_auth", cwd }, async () => {
       await reconcileStaleOracleJobs();
+      await pruneTerminalOracleJobs();
     });
   } catch (error) {
     if (!isLockTimeoutError(error, "reconcile", "global")) throw error;
@@ -176,13 +185,28 @@ export function registerOracleCommands(pi: ExtensionAPI, authWorkerPath: string)
         return;
       }
 
-      for (const job of jobs) {
-        if (!job) continue;
-        await rm(join("/tmp", `oracle-${job.id}`), { recursive: true, force: true });
+      const cleanupWarnings: string[] = [];
+      const removeJobs = async () => {
+        for (const job of jobs) {
+          if (!job) continue;
+          const result = await removeTerminalOracleJob(job);
+          cleanupWarnings.push(...result.cleanupReport.warnings.map((warning) => `${job.id}: ${warning}`));
+        }
+      };
+
+      try {
+        await withGlobalReconcileLock({ processPid: process.pid, source: "oracle_clean", cwd: ctx.cwd }, async () => {
+          await reconcileStaleOracleJobs();
+          await removeJobs();
+        });
+      } catch (error) {
+        if (!isLockTimeoutError(error, "reconcile", "global")) throw error;
+        await removeJobs();
       }
 
       refreshOracleStatus(ctx);
-      ctx.ui.notify(`Removed ${jobs.length} oracle job director${jobs.length === 1 ? "y" : "ies"}`, "info");
+      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");
     },
   });
 }

package/extensions/oracle/lib/config.ts

@@ -18,7 +18,7 @@ export type OracleCloneStrategy = (typeof CLONE_STRATEGIES)[number];
 
 const PRO_EFFORTS = ["standard", "extended"] as const satisfies readonly OracleEffort[];
 const ALLOWED_CHATGPT_ORIGINS = new Set(["https://chatgpt.com", "https://chat.openai.com"]);
-const PROJECT_OVERRIDE_KEYS = new Set(["defaults", "worker", "poller", "artifacts"]);
+const PROJECT_OVERRIDE_KEYS = new Set(["defaults", "worker", "poller", "artifacts", "cleanup"]);
 const DEFAULT_MAC_CHROME_EXECUTABLE = "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome";
 const DEFAULT_MAC_CHROME_USER_DATA_DIR = join(homedir(), "Library", "Application Support", "Google", "Chrome");
 
@@ -57,6 +57,10 @@ export interface OracleConfig {
   artifacts: {
     capture: boolean;
   };
+  cleanup: {
+    completeJobRetentionMs: number;
+    failedJobRetentionMs: number;
+  };
 }
 
 function detectDefaultChromeExecutablePath(): string | undefined {
@@ -127,6 +131,10 @@ export const DEFAULT_CONFIG: OracleConfig = {
   artifacts: {
     capture: true,
   },
+  cleanup: {
+    completeJobRetentionMs: 14 * 24 * 60 * 60 * 1000,
+    failedJobRetentionMs: 30 * 24 * 60 * 60 * 1000,
+  },
 };
 
 function isObject(value: unknown): value is Record<string, unknown> {
@@ -303,6 +311,7 @@ function validateOracleConfig(value: unknown): OracleConfig {
   const worker = expectObject(root.worker, "worker");
   const poller = expectObject(root.poller, "poller");
   const artifacts = expectObject(root.artifacts, "artifacts");
+  const cleanup = expectObject(root.cleanup, "cleanup");
 
   const authSeedProfileDir = expectSafeProfileDir(browser.authSeedProfileDir, "browser.authSeedProfileDir");
   const runtimeProfilesDir = expectSafeProfileDir(browser.runtimeProfilesDir, "browser.runtimeProfilesDir");
@@ -345,6 +354,10 @@ function validateOracleConfig(value: unknown): OracleConfig {
     artifacts: {
       capture: expectBoolean(artifacts.capture, "artifacts.capture"),
     },
+    cleanup: {
+      completeJobRetentionMs: expectInteger(cleanup.completeJobRetentionMs, "cleanup.completeJobRetentionMs", 0),
+      failedJobRetentionMs: expectInteger(cleanup.failedJobRetentionMs, "cleanup.failedJobRetentionMs", 0),
+    },
   };
 }
 

package/extensions/oracle/lib/jobs.ts

@@ -1,12 +1,12 @@
 import { createHash, randomUUID } from "node:crypto";
 import { spawn, execFileSync } from "node:child_process";
 import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
 import type { OracleConfig, OracleEffort, OracleModelFamily } from "./config.js";
 import { withJobLock } from "./locks.js";
-import { cleanupRuntimeArtifacts, getProjectId, getSessionId, parseConversationId } from "./runtime.js";
+import { cleanupRuntimeArtifacts, getProjectId, getSessionId, parseConversationId, type OracleCleanupReport } from "./runtime.js";
 
 export type OracleJobStatus = "preparing" | "submitted" | "waiting" | "complete" | "failed" | "cancelled";
 export type OracleJobPhase =
@@ -28,6 +28,8 @@ export const ACTIVE_ORACLE_JOB_STATUSES: OracleJobStatus[] = ["preparing", "subm
 export const ORACLE_MISSING_WORKER_GRACE_MS = 30_000;
 export const ORACLE_STALE_HEARTBEAT_MS = 3 * 60 * 1000;
 export const ORACLE_NOTIFICATION_CLAIM_TTL_MS = 60_000;
+const ORACLE_COMPLETE_JOB_RETENTION_MS = 14 * 24 * 60 * 60 * 1000;
+const ORACLE_FAILED_JOB_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
 
 export function isActiveOracleJob(job: Pick<OracleJob, "status">): boolean {
   return ACTIVE_ORACLE_JOB_STATUSES.includes(job.status);
@@ -119,6 +121,8 @@ export interface OracleJob {
   runtimeProfileDir: string;
   seedGeneration?: string;
   config: OracleConfig;
+  cleanupWarnings?: string[];
+  lastCleanupAt?: string;
 }
 
 export interface OracleSubmitInput {
@@ -301,13 +305,63 @@ export function getStaleOracleJobReason(job: OracleJob, now = Date.now()): strin
   return undefined;
 }
 
-async function cleanupJobResources(job: OracleJob): Promise<void> {
-  await cleanupRuntimeArtifacts({
+export async function cleanupJobResources(
+  job: Pick<OracleJob, "runtimeId" | "runtimeProfileDir" | "runtimeSessionName" | "conversationId">,
+): Promise<OracleCleanupReport> {
+  return cleanupRuntimeArtifacts({
     runtimeId: job.runtimeId,
     runtimeProfileDir: job.runtimeProfileDir,
     runtimeSessionName: job.runtimeSessionName,
     conversationId: job.conversationId,
-  }).catch(() => undefined);
+  });
+}
+
+function getCleanupRetentionMs(job: OracleJob): { complete: number; failed: number } {
+  return {
+    complete: job.config.cleanup?.completeJobRetentionMs ?? ORACLE_COMPLETE_JOB_RETENTION_MS,
+    failed: job.config.cleanup?.failedJobRetentionMs ?? ORACLE_FAILED_JOB_RETENTION_MS,
+  };
+}
+
+function shouldPruneTerminalJob(job: OracleJob, now = Date.now()): boolean {
+  if (!isTerminalOracleJobStatus(job.status)) return false;
+  const completedMs = parseTimestamp(job.completedAt) ?? parseTimestamp(job.createdAt);
+  if (completedMs === undefined) return false;
+  const ageMs = now - completedMs;
+
+  const retention = getCleanupRetentionMs(job);
+
+  if ((job.status === "complete" || job.status === "cancelled") && job.notifiedAt) {
+    return ageMs >= retention.complete;
+  }
+
+  if (job.status === "failed") {
+    return ageMs >= retention.failed;
+  }
+
+  return false;
+}
+
+export async function removeTerminalOracleJob(job: OracleJob): Promise<{ removed: boolean; cleanupReport: OracleCleanupReport }> {
+  if (isActiveOracleJob(job)) return { removed: false, cleanupReport: { attempted: [], warnings: [] } };
+  const cleanupReport = await cleanupJobResources(job);
+  await rm(getJobDir(job.id), { recursive: true, force: true });
+  return { removed: true, cleanupReport };
+}
+
+export async function pruneTerminalOracleJobs(now = Date.now()): Promise<string[]> {
+  const removedJobIds: string[] = [];
+
+  for (const jobDir of listOracleJobDirs()) {
+    const job = readJob(jobDir);
+    if (!job || !shouldPruneTerminalJob(job, now)) continue;
+    const removed = await removeTerminalOracleJob(job);
+    if (removed.removed) {
+      removedJobIds.push(job.id);
+    }
+  }
+
+  return removedJobIds;
 }
 
 export async function reconcileStaleOracleJobs(): Promise<OracleJob[]> {
@@ -340,7 +394,15 @@ export async function reconcileStaleOracleJobs(): Promise<OracleJob[]> {
           : `Recovered stale job: ${staleReason}.${suffix}`.trim(),
       }, new Date(now).toISOString()),
     }));
-    await cleanupJobResources(repairedJob);
+    const cleanupReport = await cleanupJobResources(repairedJob);
+    if (cleanupReport.warnings.length > 0) {
+      await updateJob(repairedJob.id, (current) => ({
+        ...current,
+        cleanupWarnings: [...(current.cleanupWarnings || []), ...cleanupReport.warnings],
+        lastCleanupAt: new Date(now).toISOString(),
+        error: [current.error, ...cleanupReport.warnings].filter(Boolean).join("\n"),
+      }));
+    }
     repaired.push(repairedJob);
   }
 
@@ -425,8 +487,15 @@ export async function cancelOracleJob(id: string, reason = "Cancelled by user"):
       error: terminated ? reason : `${reason}; worker PID ${job.workerPid ?? "unknown"} did not exit`,
     }, now),
   }));
-  await cleanupJobResources(cancelled);
-  return cancelled;
+  const cleanupReport = await cleanupJobResources(cancelled);
+  if (cleanupReport.warnings.length === 0) return cancelled;
+
+  return updateJob(id, (job) => ({
+    ...job,
+    cleanupWarnings: [...(job.cleanupWarnings || []), ...cleanupReport.warnings],
+    lastCleanupAt: now,
+    error: [job.error, ...cleanupReport.warnings].filter(Boolean).join("\n"),
+  }));
 }
 
 export async function createJob(

package/extensions/oracle/lib/locks.ts

@@ -83,6 +83,20 @@ async function maybeReclaimStaleLock(path: string): Promise<boolean> {
   return true;
 }
 
+export async function sweepStaleLocks(): Promise<string[]> {
+  const dir = getLocksDir();
+  const removed: string[] = [];
+
+  for (const name of readdirSync(dir)) {
+    const path = join(dir, name);
+    if (await maybeReclaimStaleLock(path)) {
+      removed.push(path);
+    }
+  }
+
+  return removed;
+}
+
 export async function acquireLock(
   kind: string,
   key: string,
@@ -143,6 +157,7 @@ export async function withGlobalReconcileLock<T>(
   fn: () => Promise<T>,
   options?: { timeoutMs?: number },
 ): Promise<T> {
+  await sweepStaleLocks();
   return withLock("reconcile", "global", metadata, fn, { timeoutMs: options?.timeoutMs ?? 30_000 });
 }
 

package/extensions/oracle/lib/runtime.ts

@@ -172,24 +172,78 @@ export async function cloneSeedProfileToRuntime(config: OracleConfig, runtimePro
   return getSeedGeneration(config);
 }
 
+const AGENT_BROWSER_CLOSE_TIMEOUT_MS = 10_000;
+
+export interface OracleCleanupReport {
+  attempted: Array<"browser" | "runtimeProfileDir" | "conversationLease" | "runtimeLease">;
+  warnings: string[];
+}
+
+async function closeRuntimeBrowserSession(runtimeSessionName: string): Promise<string | undefined> {
+  return new Promise<string | undefined>((resolve) => {
+    const child = spawn("agent-browser", ["--session", runtimeSessionName, "close"], { stdio: "ignore" });
+    let settled = false;
+    let timeout: NodeJS.Timeout | undefined;
+    let timedOut = false;
+
+    const finish = (warning?: string) => {
+      if (settled) return;
+      settled = true;
+      if (timeout) clearTimeout(timeout);
+      resolve(warning);
+    };
+
+    timeout = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      setTimeout(() => {
+        child.kill("SIGKILL");
+        finish(`Timed out closing agent-browser session ${runtimeSessionName} after ${AGENT_BROWSER_CLOSE_TIMEOUT_MS}ms`);
+      }, 2_000).unref?.();
+    }, AGENT_BROWSER_CLOSE_TIMEOUT_MS);
+    timeout.unref?.();
+
+    child.on("error", (error) => finish(`Failed to close agent-browser session ${runtimeSessionName}: ${error.message}`));
+    child.on("close", (code) => {
+      if (timedOut || code === 0) finish();
+      else finish(`agent-browser close exited with code ${code} for session ${runtimeSessionName}`);
+    });
+  });
+}
+
 export async function cleanupRuntimeArtifacts(runtime: {
   runtimeId?: string;
   runtimeProfileDir?: string;
   runtimeSessionName?: string;
   conversationId?: string;
-}): Promise<void> {
+}): Promise<OracleCleanupReport> {
+  const report: OracleCleanupReport = { attempted: [], warnings: [] };
+
   if (runtime.runtimeSessionName) {
-    await new Promise<void>((resolve) => {
-      const child = spawn("agent-browser", ["--session", runtime.runtimeSessionName, "close"], { stdio: "ignore" });
-      child.on("error", () => resolve());
-      child.on("close", () => resolve());
-    });
+    report.attempted.push("browser");
+    const warning = await closeRuntimeBrowserSession(runtime.runtimeSessionName).catch((error: Error) => error.message);
+    if (warning) report.warnings.push(warning);
   }
   if (runtime.runtimeProfileDir) {
-    await rm(runtime.runtimeProfileDir, { recursive: true, force: true }).catch(() => undefined);
+    report.attempted.push("runtimeProfileDir");
+    await rm(runtime.runtimeProfileDir, { recursive: true, force: true }).catch((error: Error) => {
+      report.warnings.push(`Failed to remove runtime profile ${runtime.runtimeProfileDir}: ${error.message}`);
+    });
+  }
+  if (runtime.conversationId) {
+    report.attempted.push("conversationLease");
+  }
+  await releaseConversationLease(runtime.conversationId).catch((error: Error) => {
+    report.warnings.push(`Failed to release conversation lease ${runtime.conversationId}: ${error.message}`);
+  });
+  if (runtime.runtimeId) {
+    report.attempted.push("runtimeLease");
   }
-  await releaseConversationLease(runtime.conversationId);
-  await releaseRuntimeLease(runtime.runtimeId);
+  await releaseRuntimeLease(runtime.runtimeId).catch((error: Error) => {
+    report.warnings.push(`Failed to release runtime lease ${runtime.runtimeId}: ${error.message}`);
+  });
+
+  return report;
 }
 
 export function stableProjectLabel(projectId: string): string {

package/extensions/oracle/lib/tools.ts

@@ -13,6 +13,7 @@ import {
   getSessionFile,
   isActiveOracleJob,
   readJob,
+  pruneTerminalOracleJobs,
   reconcileStaleOracleJobs,
   resolveArchiveInputs,
   sha256File,
@@ -196,6 +197,8 @@ function redactJobDetails(job: NonNullable<ReturnType<typeof readJob>>) {
     artifactsManifestPath: job.artifactsManifestPath,
     archiveDeletedAfterUpload: job.archiveDeletedAfterUpload,
     runtimeId: job.runtimeId,
+    cleanupWarnings: job.cleanupWarnings,
+    lastCleanupAt: job.lastCleanupAt,
     error: job.error,
   };
 }
@@ -231,6 +234,7 @@ export function registerOracleTools(pi: ExtensionAPI, workerPath: string): void
       try {
         await withGlobalReconcileLock({ processPid: process.pid, source: "oracle_submit", cwd: ctx.cwd }, async () => {
           await reconcileStaleOracleJobs();
+          await pruneTerminalOracleJobs();
         });
       } catch (error) {
         if (!isLockTimeoutError(error, "reconcile", "global")) throw error;

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

@@ -1,10 +1,11 @@
 import { createHash } from "node:crypto";
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
-import { appendFile, chmod, lstat, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { appendFile, chmod, lstat, mkdir, readdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { basename, dirname, join, resolve } from "node:path";
 import { getCookies } from "@steipete/sweet-cookie";
+import { ensureAccountCookie, filterImportableAuthCookies } from "./auth-cookie-policy.mjs";
 
 const rawConfig = process.argv[2];
 if (!rawConfig) {
@@ -34,6 +35,7 @@ const SCREENSHOT_PATH = "/tmp/oracle-auth.png";
 const REAL_CHROME_USER_DATA_DIR = resolve(homedir(), "Library", "Application Support", "Google", "Chrome");
 const ORACLE_STATE_DIR = "/tmp/pi-oracle-state";
 const LOCKS_DIR = join(ORACLE_STATE_DIR, "locks");
+const STALE_STAGING_PROFILE_MAX_AGE_MS = 24 * 60 * 60 * 1000;
 
 let runtimeProfileDir = config.browser.authSeedProfileDir;
 
@@ -179,6 +181,42 @@ async function ensureNotSymlink(path, label) {
   }
 }
 
+async function isAuthBrowserConnected() {
+  const result = await spawnCommand("agent-browser", [...targetBrowserBaseArgs(), "--json", "stream", "status"], { allowFailure: true });
+  try {
+    const parsed = JSON.parse(result.stdout || "{}");
+    return parsed?.data?.connected === true;
+  } catch {
+    return false;
+  }
+}
+
+async function sweepStaleStagingProfiles(targetDir) {
+  const parentDir = dirname(targetDir);
+  const prefix = `${basename(targetDir)}.staging-`;
+  const now = Date.now();
+
+  if (await isAuthBrowserConnected()) {
+    await log(`Skipping stale staging-profile sweep while auth browser session ${authSessionName()} is still connected`);
+    return;
+  }
+
+  const names = await readdir(parentDir).catch(() => []);
+  for (const name of names) {
+    if (!name.startsWith(prefix)) continue;
+    const candidatePath = join(parentDir, name);
+    try {
+      const stats = await stat(candidatePath);
+      if (!stats.isDirectory()) continue;
+      if (now - stats.mtimeMs < STALE_STAGING_PROFILE_MAX_AGE_MS) continue;
+      await rm(candidatePath, { recursive: true, force: true });
+      await log(`Removed stale auth staging profile ${candidatePath}`);
+    } catch (error) {
+      await log(`Failed to remove stale auth staging profile ${candidatePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+}
+
 async function createProfilePlan(profileDir) {
   const targetDir = resolve(profileDir);
   if (!targetDir.startsWith("/")) {
@@ -197,6 +235,7 @@ async function createProfilePlan(profileDir) {
   await ensureNotSymlink(dirname(targetDir), "Oracle profile parent directory");
   await ensureNotSymlink(targetDir, "Oracle profile directory");
   await ensureNotSymlink(backupDir, "Oracle backup profile directory");
+  await sweepStaleStagingProfiles(targetDir);
   return { targetDir, stagingDir, backupDir };
 }
 
@@ -367,42 +406,6 @@ function stripQuery(url) {
   }
 }
 
-function normalizeSameSite(value) {
-  if (value === "Lax" || value === "Strict" || value === "None") return value;
-  return undefined;
-}
-
-function normalizeExpiration(expires) {
-  if (!expires || Number.isNaN(expires)) return undefined;
-  const value = Number(expires);
-  if (!Number.isFinite(value) || value <= 0) return undefined;
-  // Chrome cookie readers can surface expiries in a few formats:
-  // - Unix seconds (~1.7e9 in 2026)
-  // - Unix milliseconds (~1.7e12)
-  // - WebKit microseconds since 1601 (~1.3e16)
-  if (value > 10_000_000_000_000) return Math.round(value / 1_000_000 - 11644473600);
-  if (value > 10_000_000_000) return Math.round(value / 1000);
-  return Math.round(value);
-}
-
-function normalizeCookie(cookie, fallbackHost) {
-  if (!cookie?.name) return undefined;
-  const domain = typeof cookie.domain === "string" && cookie.domain.trim() ? cookie.domain.trim() : fallbackHost;
-  if (!domain) return undefined;
-
-  const expires = normalizeExpiration(cookie.expires);
-  return {
-    name: cookie.name,
-    value: cookie.value ?? "",
-    domain,
-    path: cookie.path || "/",
-    expires,
-    httpOnly: cookie.httpOnly ?? false,
-    secure: cookie.secure ?? true,
-    sameSite: normalizeSameSite(cookie.sameSite),
-  };
-}
-
 function cookieOrigins() {
   return Array.from(new Set([stripQuery(config.browser.chatUrl), ...CHATGPT_COOKIE_ORIGINS]));
 }
@@ -432,23 +435,20 @@ async function readSourceCookies() {
     await log(`sweet-cookie warnings: ${warnings.join(" | ")}`);
   }
 
-  const fallbackHost = new URL(config.browser.chatUrl).hostname;
-  const merged = new Map();
-  for (const cookie of cookies) {
-    const normalized = normalizeCookie(cookie, fallbackHost);
-    if (!normalized) continue;
-    const key = `${normalized.domain}:${normalized.name}`;
-    if (!merged.has(key)) merged.set(key, normalized);
-  }
-
-  const normalizedCookies = Array.from(merged.values());
+  const filtered = filterImportableAuthCookies(cookies, config.browser.chatUrl);
+  let normalizedCookies = filtered.cookies;
   await log(
-    `Read ${normalizedCookies.length} merged cookies: ${normalizedCookies.map((cookie) => `${cookie.name}@${cookie.domain}`).join(", ")}`,
+    `Read ${normalizedCookies.length} filtered auth cookies: ${normalizedCookies.map((cookie) => `${cookie.name}@${cookie.domain}`).join(", ")}`,
   );
+  if (filtered.dropped.length) {
+    await log(
+      `Dropped ${filtered.dropped.length} non-importable cookies: ` +
+        filtered.dropped.map(({ cookie, reason }) => `${cookie.name}@${cookie.domain}(${reason})`).join(", "),
+    );
+  }
 
   const hasSessionToken = normalizedCookies.some((cookie) => cookie.name.startsWith("__Secure-next-auth.session-token"));
   const hasAccountCookie = normalizedCookies.some((cookie) => cookie.name === "_account");
-  const fedrampCookie = normalizedCookies.find((cookie) => cookie.name === "_account_is_fedramp");
   await log(`Cookie presence: sessionToken=${hasSessionToken} account=${hasAccountCookie}`);
 
   if (!hasSessionToken) {
@@ -458,18 +458,11 @@ async function readSourceCookies() {
   }
 
   if (!hasAccountCookie) {
-    const isFedramp = /^(1|true|yes)$/i.test(String(fedrampCookie?.value || ""));
-    const fallbackAccountValue = isFedramp ? "fedramp" : "personal";
-    normalizedCookies.push({
-      name: "_account",
-      value: fallbackAccountValue,
-      domain: new URL(config.browser.chatUrl).hostname,
-      path: "/",
-      secure: true,
-      httpOnly: false,
-      sameSite: "Lax",
-    });
-    await log(`Synthesized missing _account cookie with value=${fallbackAccountValue}`);
+    const ensured = ensureAccountCookie(normalizedCookies, config.browser.chatUrl);
+    normalizedCookies = ensured.cookies;
+    if (ensured.synthesized) {
+      await log(`Synthesized missing _account cookie with value=${ensured.value}`);
+    }
   }
 
   return normalizedCookies;
@@ -658,6 +651,15 @@ function classifyChatPage({ url, snapshot, body, probe }) {
     };
   }
 
+  if (/http error 431|request header or cookie too large/i.test(text)) {
+    return {
+      state: "login_required",
+      message:
+        `Imported auth hit HTTP 431 during ChatGPT auth resolution, which usually means the imported cookie set is too large or stale. ` +
+        `Inspect ${LOG_PATH}.`,
+    };
+  }
+
   const outagePatterns = [
     /something went wrong/i,
     /a network error occurred/i,

package/extensions/oracle/worker/auth-cookie-policy.mjs

@@ -0,0 +1,155 @@
+const AUTH_COOKIE_NAME_PATTERNS = [
+  /^__Secure-next-auth\.session-token(?:\.|$)/,
+  /^__Secure-next-auth\.callback-url$/,
+  /^_account$/,
+  /^_account_is_fedramp$/,
+  /^_puid$/,
+  /^unified_session_manifest$/,
+  /^oai-(?:client-auth-info|client-auth-session|sc|did|hlib|asli|last-model-config|chat-web-route)$/,
+  /^auth-session-minimized(?:-client-checksum)?$/,
+  /^(?:login_session|auth_provider|hydra_redirect|iss_context|rg_context)$/,
+  /^cf_clearance$/,
+];
+
+const DROPPED_COOKIE_NAME_PATTERNS = [
+  /^_ga(?:_|$)/,
+  /^_uet/,
+  /^_rdt_uuid$/,
+  /^(?:marketing|analytics)_consent$/,
+  /^__cf_bm$/,
+  /^__cflb$/,
+  /^_cfuvid$/,
+  /^_dd_s$/,
+  /^g_state$/,
+  /^country$/,
+  /^oai-nav-state$/,
+  /^oai-login-csrf/,
+  /^__Secure-next-auth\.state$/,
+  /^__Host-next-auth\.csrf-token$/,
+];
+
+const BASE_ALLOWED_COOKIE_HOSTS = new Set([
+  'chatgpt.com',
+  'chat.openai.com',
+  'openai.com',
+  'auth.openai.com',
+  'sentinel.openai.com',
+  'atlas.openai.com',
+  'ws.chatgpt.com',
+]);
+
+function normalizeSameSite(value) {
+  if (value === 'Lax' || value === 'Strict' || value === 'None') return value;
+  return undefined;
+}
+
+function normalizeExpiration(expires) {
+  if (!expires || Number.isNaN(expires)) return undefined;
+  const value = Number(expires);
+  if (!Number.isFinite(value) || value <= 0) return undefined;
+  if (value > 10_000_000_000_000) return Math.round(value / 1_000_000 - 11644473600);
+  if (value > 10_000_000_000) return Math.round(value / 1000);
+  return Math.round(value);
+}
+
+function normalizeDomain(domain, fallbackHost) {
+  const raw = typeof domain === 'string' && domain.trim() ? domain.trim() : fallbackHost;
+  if (!raw) return undefined;
+  return raw.replace(/^\.+/, '').toLowerCase();
+}
+
+function allowedCookieHosts(chatUrl) {
+  const hosts = new Set(BASE_ALLOWED_COOKIE_HOSTS);
+  try {
+    hosts.add(new URL(chatUrl).hostname.toLowerCase());
+  } catch {
+    // ignore invalid URL here; caller validation happens elsewhere
+  }
+  return hosts;
+}
+
+function isAllowedCookieDomain(domain, chatUrl) {
+  const hosts = allowedCookieHosts(chatUrl);
+  return hosts.has(domain);
+}
+
+function matchesAny(patterns, value) {
+  return patterns.some((pattern) => pattern.test(value));
+}
+
+export function normalizeImportedCookie(cookie, fallbackHost) {
+  if (!cookie?.name) return undefined;
+  const domain = normalizeDomain(cookie.domain, fallbackHost);
+  if (!domain) return undefined;
+  return {
+    name: cookie.name,
+    value: cookie.value ?? '',
+    domain,
+    path: cookie.path || '/',
+    expires: normalizeExpiration(cookie.expires),
+    httpOnly: cookie.httpOnly ?? false,
+    secure: cookie.secure ?? true,
+    sameSite: normalizeSameSite(cookie.sameSite),
+  };
+}
+
+export function classifyImportedCookie(cookie, chatUrl) {
+  if (matchesAny(DROPPED_COOKIE_NAME_PATTERNS, cookie.name)) return 'noise';
+  if (!isAllowedCookieDomain(cookie.domain, chatUrl)) return 'foreign-domain';
+  if (!matchesAny(AUTH_COOKIE_NAME_PATTERNS, cookie.name)) return 'non-auth';
+  return 'keep';
+}
+
+export function filterImportableAuthCookies(cookies, chatUrl) {
+  const fallbackHost = (() => {
+    try {
+      return new URL(chatUrl).hostname;
+    } catch {
+      return 'chatgpt.com';
+    }
+  })();
+
+  const merged = new Map();
+  const dropped = [];
+  for (const cookie of cookies) {
+    const normalized = normalizeImportedCookie(cookie, fallbackHost);
+    if (!normalized) continue;
+    const disposition = classifyImportedCookie(normalized, chatUrl);
+    if (disposition !== 'keep') {
+      dropped.push({ cookie: normalized, reason: disposition });
+      continue;
+    }
+    const key = `${normalized.domain}:${normalized.name}`;
+    if (!merged.has(key)) merged.set(key, normalized);
+  }
+
+  return { cookies: Array.from(merged.values()), dropped };
+}
+
+export function ensureAccountCookie(cookies, chatUrl) {
+  const next = [...cookies];
+  const hasAccountCookie = next.some((cookie) => cookie.name === '_account');
+  if (hasAccountCookie) return { cookies: next, synthesized: false };
+
+  const fedrampCookie = next.find((cookie) => cookie.name === '_account_is_fedramp');
+  const isFedramp = /^(1|true|yes)$/i.test(String(fedrampCookie?.value || ''));
+  const fallbackAccountValue = isFedramp ? 'fedramp' : 'personal';
+  const domain = (() => {
+    try {
+      return new URL(chatUrl).hostname;
+    } catch {
+      return 'chatgpt.com';
+    }
+  })();
+
+  next.push({
+    name: '_account',
+    value: fallbackAccountValue,
+    domain,
+    path: '/',
+    secure: true,
+    httpOnly: false,
+    sameSite: 'Lax',
+  });
+  return { cookies: next, synthesized: true, value: fallbackAccountValue };
+}

package/extensions/oracle/worker/run-job.mjs

@@ -36,6 +36,7 @@ const ARTIFACT_CANDIDATE_STABILITY_POLLS = 2;
 const ARTIFACT_DOWNLOAD_HEARTBEAT_MS = 10_000;
 const ARTIFACT_DOWNLOAD_TIMEOUT_MS = 90_000;
 const ARTIFACT_DOWNLOAD_MAX_ATTEMPTS = 2;
+const AGENT_BROWSER_CLOSE_TIMEOUT_MS = 10_000;
 
 let currentJob;
 let browserStarted = false;
@@ -272,11 +273,33 @@ async function cloneSeedProfileToRuntime(job) {
 async function cleanupRuntime(job) {
   if (!job || cleaningUpRuntime) return;
   cleaningUpRuntime = true;
+  const warnings = [];
   try {
-    await closeBrowser(job).catch(() => undefined);
-    await releaseLease("conversation", job.conversationId).catch(() => undefined);
-    await releaseLease("runtime", job.runtimeId).catch(() => undefined);
-    await rm(job.runtimeProfileDir, { recursive: true, force: true }).catch(() => undefined);
+    await closeBrowser(job).catch(async (error) => {
+      const message = `Browser close warning during cleanup: ${error instanceof Error ? error.message : String(error)}`;
+      warnings.push(message);
+      await log(message).catch(() => undefined);
+    });
+    await releaseLease("conversation", job.conversationId).catch(async (error) => {
+      const message = `Conversation lease cleanup warning: ${error instanceof Error ? error.message : String(error)}`;
+      warnings.push(message);
+      await log(message).catch(() => undefined);
+    });
+    await releaseLease("runtime", job.runtimeId).catch(async (error) => {
+      const message = `Runtime lease cleanup warning: ${error instanceof Error ? error.message : String(error)}`;
+      warnings.push(message);
+      await log(message).catch(() => undefined);
+    });
+    await rm(job.runtimeProfileDir, { recursive: true, force: true }).catch(async (error) => {
+      const message = `Runtime profile cleanup warning: ${error instanceof Error ? error.message : String(error)}`;
+      warnings.push(message);
+      await log(message).catch(() => undefined);
+    });
+    if (warnings.length === 0) {
+      await log(`Cleanup summary: runtime ${job.runtimeId} released with no warnings`).catch(() => undefined);
+    } else {
+      await log(`Cleanup summary: runtime ${job.runtimeId} released with ${warnings.length} warning(s)`).catch(() => undefined);
+    }
   } finally {
     cleaningUpRuntime = false;
   }
@@ -298,7 +321,13 @@ async function closeBrowser(job) {
   if (cleaningUpBrowser) return;
   cleaningUpBrowser = true;
   try {
-    await spawnCommand("agent-browser", [...browserBaseArgs(job), "close"], { allowFailure: true });
+    const result = await spawnCommand("agent-browser", [...browserBaseArgs(job), "close"], {
+      allowFailure: true,
+      timeoutMs: AGENT_BROWSER_CLOSE_TIMEOUT_MS,
+    });
+    if (result.code !== 0) {
+      throw new Error(result.stderr || result.stdout || `agent-browser close exited with code ${result.code}`);
+    }
   } finally {
     browserStarted = false;
     cleaningUpBrowser = false;

package/package.json

@@ -1,12 +1,19 @@
 {
   "name": "pi-oracle",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "ChatGPT web-oracle extension for pi with isolated browser auth, async jobs, and project-context archives.",
   "private": false,
   "license": "MIT",
   "author": "Mitch Fultz (https://github.com/fitchmultz)",
   "type": "module",
-  "keywords": ["pi-package", "pi", "pi-extension", "extension", "chatgpt", "oracle"],
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-extension",
+    "extension",
+    "chatgpt",
+    "oracle"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/fitchmultz/pi-oracle.git"
@@ -24,10 +31,12 @@
     "LICENSE"
   ],
   "pi": {
-    "extensions": ["./extensions/oracle/index.ts"]
+    "extensions": [
+      "./extensions/oracle/index.ts"
+    ]
   },
   "scripts": {
-    "check:oracle-extension": "node --check extensions/oracle/worker/run-job.mjs && node --check extensions/oracle/worker/auth-bootstrap.mjs && esbuild extensions/oracle/index.ts --bundle --platform=node --format=esm --external:@mariozechner/pi-coding-agent --external:@mariozechner/pi-ai --external:@sinclair/typebox --outfile=/tmp/pi-oracle-extension-check.js",
+    "check:oracle-extension": "node --check extensions/oracle/worker/run-job.mjs && node --check extensions/oracle/worker/auth-cookie-policy.mjs && node --check extensions/oracle/worker/auth-bootstrap.mjs && esbuild extensions/oracle/index.ts --bundle --platform=node --format=esm --external:@mariozechner/pi-coding-agent --external:@mariozechner/pi-ai --external:@sinclair/typebox --outfile=/tmp/pi-oracle-extension-check.js",
     "sanity:oracle": "tsx scripts/oracle-sanity.ts",
     "pack:check": "npm pack --dry-run"
   },