pi-oracle 0.1.0 → 0.1.2

package/README.md

@@ -32,6 +32,12 @@ An oracle job:
 5. persists the response and any artifacts under `/tmp/oracle-<job-id>/`
 6. wakes the originating `pi` session on completion
 
+## Example
+
+```text
+/oracle Invoke the Oracle to have it generate a thorough code review of the current pending changes. Include all modified files, and adjacent files, in the archive. Use the Pro Model with Extended effort.
+```
+
 ## Why this exists
 
 The goal is to get strong ChatGPT web-model answers without:

package/extensions/oracle/lib/commands.ts

@@ -6,7 +6,7 @@ import { loadOracleConfig } from "./config.js";
 import { buildOracleDispatchPrompt } from "./instructions.js";
 import { cancelOracleJob, isActiveOracleJob, listJobsForCwd, readJob, reconcileStaleOracleJobs } from "./jobs.js";
 import { refreshOracleStatus } from "./poller.js";
-import { withGlobalReconcileLock } from "./locks.js";
+import { isLockTimeoutError, withGlobalReconcileLock } from "./locks.js";
 import { getProjectId } from "./runtime.js";
 
 function summarizeJob(jobId: string): string {
@@ -45,9 +45,13 @@ function readScopedJob(jobId: string, cwd: string) {
 
 async function runAuthBootstrap(authWorkerPath: string, cwd: string): Promise<string> {
   const config = loadOracleConfig(cwd);
-  await withGlobalReconcileLock({ processPid: process.pid, source: "oracle_auth", cwd }, async () => {
-    await reconcileStaleOracleJobs();
-  });
+  try {
+    await withGlobalReconcileLock({ processPid: process.pid, source: "oracle_auth", cwd }, async () => {
+      await reconcileStaleOracleJobs();
+    });
+  } 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)], {

package/extensions/oracle/lib/instructions.ts

@@ -16,6 +16,8 @@ export function buildOracleDispatchPrompt(request: string): string {
     "- Always include an archive. Do not submit without context files.",
     "- Keep the archive narrowly scoped and relevant.",
     "- Prefer the configured default model/effort unless the task clearly needs something else.",
+    "- Only use autoSwitchToThinking with the instant model family.",
+    "- If oracle_submit fails, stop and report the error. Do not retry automatically.",
     "- After oracle_submit returns, end your turn. Do not keep working while the oracle runs.",
     "",
     "User request:",

package/extensions/oracle/lib/locks.ts

@@ -53,6 +53,36 @@ async function writeMetadata(path: string, metadata: unknown): Promise<void> {
   await writeFile(join(path, "metadata.json"), `${JSON.stringify(metadata, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
 }
 
+function readLockProcessPid(path: string): number | undefined {
+  const metadataPath = join(path, "metadata.json");
+  if (!existsSync(metadataPath)) return undefined;
+  try {
+    const metadata = JSON.parse(readFileSync(metadataPath, "utf8")) as { processPid?: unknown };
+    return typeof metadata.processPid === "number" && Number.isInteger(metadata.processPid) && metadata.processPid > 0
+      ? metadata.processPid
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function isProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ESRCH") return false;
+    return true;
+  }
+}
+
+async function maybeReclaimStaleLock(path: string): Promise<boolean> {
+  const processPid = readLockProcessPid(path);
+  if (!processPid || isProcessAlive(processPid)) return false;
+  await rm(path, { recursive: true, force: true }).catch(() => undefined);
+  return true;
+}
+
 export async function acquireLock(
   kind: string,
   key: string,
@@ -70,6 +100,7 @@ export async function acquireLock(
       return { path };
     } catch (error) {
       if (!(error && typeof error === "object" && "code" in error && error.code === "EEXIST")) throw error;
+      if (await maybeReclaimStaleLock(path)) continue;
     }
     await sleep(POLL_MS);
   }

package/extensions/oracle/lib/tools.ts

@@ -5,7 +5,7 @@ import { join } from "node:path";
 import { StringEnum } from "@mariozechner/pi-ai";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
-import { withGlobalReconcileLock, withLock } from "./locks.js";
+import { isLockTimeoutError, withGlobalReconcileLock, withLock } from "./locks.js";
 import { loadOracleConfig, EFFORTS, MODEL_FAMILIES, type OracleEffort, type OracleModelFamily } from "./config.js";
 import {
   cancelOracleJob,
@@ -37,9 +37,11 @@ const ORACLE_SUBMIT_PARAMS = Type.Object({
     description: "Exact project-relative files/directories to include in the oracle archive.",
     minItems: 1,
   }),
-  modelFamily: Type.Optional(StringEnum(MODEL_FAMILIES)),
-  effort: Type.Optional(StringEnum(EFFORTS)),
-  autoSwitchToThinking: Type.Optional(Type.Boolean()),
+  modelFamily: Type.Optional(StringEnum(MODEL_FAMILIES, { description: "ChatGPT model family: instant, thinking, or pro." })),
+  effort: Type.Optional(StringEnum(EFFORTS, { description: "Reasoning effort. Use only values supported by the chosen model family." })),
+  autoSwitchToThinking: Type.Optional(
+    Type.Boolean({ description: "Only valid when modelFamily is instant. Omit for thinking and pro." }),
+  ),
   followUpJobId: Type.Optional(Type.String({ description: "Earlier oracle job id whose chat thread should be continued." })),
 });
 
@@ -209,6 +211,8 @@ export function registerOracleTools(pi: ExtensionAPI, workerPath: string): void
       "Gather context before calling oracle_submit.",
       "Always include a narrowly scoped archive of exact relevant files/directories.",
       "Stop after dispatching oracle_submit; do not continue the task while the oracle job is running.",
+      "If oracle_submit fails, stop and report the error instead of retrying automatically.",
+      "Only use autoSwitchToThinking with modelFamily=instant.",
     ],
     parameters: ORACLE_SUBMIT_PARAMS,
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
@@ -224,9 +228,13 @@ export function registerOracleTools(pi: ExtensionAPI, workerPath: string): void
       const followUp = resolveFollowUp(params.followUpJobId, ctx.cwd);
 
       validateSubmissionOptions(params, modelFamily, effort, autoSwitchToThinking);
-      await withGlobalReconcileLock({ processPid: process.pid, source: "oracle_submit", cwd: ctx.cwd }, async () => {
-        await reconcileStaleOracleJobs();
-      });
+      try {
+        await withGlobalReconcileLock({ processPid: process.pid, source: "oracle_submit", cwd: ctx.cwd }, async () => {
+          await reconcileStaleOracleJobs();
+        });
+      } catch (error) {
+        if (!isLockTimeoutError(error, "reconcile", "global")) throw error;
+      }
 
       const jobId = randomUUID();
       const tempArchivePath = join(tmpdir(), `oracle-archive-${jobId}.tar.zst`);

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

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
-import { appendFile, chmod, lstat, mkdir, rename, rm, writeFile } from "node:fs/promises";
+import { appendFile, chmod, lstat, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { getCookies } from "@steipete/sweet-cookie";
@@ -49,6 +49,36 @@ function leaseKey(kind, key) {
   return `${kind}-${createHash("sha256").update(key).digest("hex").slice(0, 24)}`;
 }
 
+async function readLockProcessPid(path) {
+  const metadataPath = join(path, "metadata.json");
+  if (!existsSync(metadataPath)) return undefined;
+  try {
+    const metadata = JSON.parse(await readFile(metadataPath, "utf8"));
+    return typeof metadata?.processPid === "number" && Number.isInteger(metadata.processPid) && metadata.processPid > 0
+      ? metadata.processPid
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ESRCH") return false;
+    return true;
+  }
+}
+
+async function maybeReclaimStaleLock(path) {
+  const processPid = await readLockProcessPid(path);
+  if (!processPid || isProcessAlive(processPid)) return false;
+  await rm(path, { recursive: true, force: true }).catch(() => undefined);
+  return true;
+}
+
 async function acquireLock(kind, key, metadata, timeoutMs = 30_000) {
   const path = join(LOCKS_DIR, leaseKey(kind, key));
   const deadline = Date.now() + timeoutMs;
@@ -62,6 +92,7 @@ async function acquireLock(kind, key, metadata, timeoutMs = 30_000) {
       return path;
     } catch (error) {
       if (!(error && typeof error === "object" && "code" in error && error.code === "EEXIST")) throw error;
+      if (await maybeReclaimStaleLock(path)) continue;
     }
     await sleep(200);
   }

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

@@ -53,6 +53,36 @@ function leaseKey(kind, key) {
   return `${kind}-${createHash("sha256").update(key).digest("hex").slice(0, 24)}`;
 }
 
+async function readLockProcessPid(path) {
+  const metadataPath = join(path, "metadata.json");
+  if (!existsSync(metadataPath)) return undefined;
+  try {
+    const metadata = JSON.parse(await readFile(metadataPath, "utf8"));
+    return typeof metadata?.processPid === "number" && Number.isInteger(metadata.processPid) && metadata.processPid > 0
+      ? metadata.processPid
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ESRCH") return false;
+    return true;
+  }
+}
+
+async function maybeReclaimStaleLock(path) {
+  const processPid = await readLockProcessPid(path);
+  if (!processPid || isProcessAlive(processPid)) return false;
+  await rm(path, { recursive: true, force: true }).catch(() => undefined);
+  return true;
+}
+
 async function acquireLock(kind, key, metadata, timeoutMs = 30_000) {
   const path = join(LOCKS_DIR, leaseKey(kind, key));
   const deadline = Date.now() + timeoutMs;
@@ -66,6 +96,7 @@ async function acquireLock(kind, key, metadata, timeoutMs = 30_000) {
       return path;
     } catch (error) {
       if (!(error && typeof error === "object" && "code" in error && error.code === "EEXIST")) throw error;
+      if (await maybeReclaimStaleLock(path)) continue;
     }
     await sleep(200);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-oracle",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "ChatGPT web-oracle extension for pi with isolated browser auth, async jobs, and project-context archives.",
   "private": false,
   "license": "MIT",