pi-oracle 0.6.3 → 0.6.5

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## Unreleased
 
+## 0.6.5 - 2026-04-15
+
+### Changed
+- pinned `packageManager` metadata to `npm@11.12.1` and refreshed the release lockfile against the current stable pi toolchain so `verify:oracle` resolves reproducibly across machines
+- kept the published oracle runtime surface unchanged while moving local development dependencies to the current stable pi/TypeScript/Node typing baseline
+
+## 0.6.4 - 2026-04-14
+
+### Changed
+- bumped the local development and release toolchain to the latest published pi packages and current TypeScript/esbuild/Node type definitions so release verification now runs against the same pi generation shipping on this machine
+
+### Fixed
+- `oracle_submit` archive creation now handles downstream `zstd` pipe failures as normal tool errors instead of crashing the host `pi` process with an unhandled `write EPIPE` on newer Node runtimes
+- sanity coverage now exercises the broken-pipe archive path so early downstream compressor exits regress to a clean rejection instead of a process-level crash
+
 ## 0.6.3 - 2026-04-13
 
 ### Fixed

package/extensions/oracle/lib/commands.ts

@@ -6,7 +6,7 @@
 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 { formatOracleCancelOutcome, formatOracleJobSummary } from "../shared/job-observability-helpers.mjs";
 import { runOracleAuthBootstrap } from "./auth.js";
 import {
   cancelOracleJob,
@@ -14,6 +14,7 @@ import {
   isOpenOracleJob,
   isTerminalOracleJob,
   listJobsForCwd,
+  ORACLE_STALE_HEARTBEAT_MS,
   markWakeupSettled,
   readJob,
   reconcileStaleOracleJobs,
@@ -44,6 +45,7 @@ async function summarizeJob(jobId: string, options?: { responsePreview?: boolean
     artifactsPath: `${getJobDir(job.id)}/artifacts`,
     responseAvailable,
     responsePreview,
+    heartbeatStaleMs: ORACLE_STALE_HEARTBEAT_MS,
   });
 }
 
@@ -153,10 +155,7 @@ export function registerOracleCommands(pi: ExtensionAPI, authWorkerPath: string,
         await promoteQueuedJobs({ workerPath, source: "oracle_cancel_command" });
       }
       refreshOracleStatus(ctx);
-      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");
+      ctx.ui.notify(formatOracleCancelOutcome(cancelled), "info");
     },
   });
 

package/extensions/oracle/lib/jobs.ts

@@ -83,6 +83,19 @@ export function hasPersistedOriginSession(
   return typeof job.originSessionFile === "string" && job.originSessionFile.length > 0 && job.sessionId === job.originSessionFile;
 }
 
+function hasActiveCancelIntent(job: Pick<OracleJob, "status" | "cancelRequestedAt">): boolean {
+  return !isTerminalOracleJob(job) && typeof job.cancelRequestedAt === "string" && job.cancelRequestedAt.length > 0;
+}
+
+function markCancelRequested(job: OracleJob, reason: string, at: string): OracleJob {
+  if (hasActiveCancelIntent(job)) return job;
+  return {
+    ...job,
+    cancelRequestedAt: at,
+    cancelReason: reason,
+  };
+}
+
 export function isWorkerProcessAlive(pid: number | undefined, startedAt?: string): boolean {
   return isTrackedProcessAlive(pid, startedAt);
 }
@@ -113,6 +126,8 @@ export interface OracleJob {
   submittedAt?: string;
   completedAt?: string;
   heartbeatAt?: string;
+  cancelRequestedAt?: string;
+  cancelReason?: string;
   cwd: string;
   projectId: string;
   sessionId: string;
@@ -595,6 +610,7 @@ export async function reconcileStaleOracleJobs(): Promise<OracleJob[]> {
       const currentStaleReason = getStaleOracleJobReason(current, now);
       if (!currentStaleReason) return;
 
+      const cancelRequested = hasActiveCancelIntent(current);
       terminated = await terminateWorkerPid(current.workerPid, current.workerStartedAt);
       transitioned = true;
       const suffix = current.workerPid
@@ -602,19 +618,31 @@ export async function reconcileStaleOracleJobs(): Promise<OracleJob[]> {
           ? ` Terminated stale worker PID ${current.workerPid}.`
           : ` Failed to terminate stale worker PID ${current.workerPid}.`
         : "";
-      repairedJob = transitionOracleJobPhase(current, "failed", {
-        at: recoveredAt,
-        source: "oracle:reconcile",
-        message: `Recovered stale job: ${currentStaleReason}.${suffix}`.trim(),
-        clearNotificationClaim: true,
-        patch: {
-          heartbeatAt: recoveredAt,
-          cleanupPending: terminated,
-          error: current.error
-            ? `${current.error}\nRecovered stale job: ${currentStaleReason}.${suffix}`.trim()
-            : `Recovered stale job: ${currentStaleReason}.${suffix}`.trim(),
-        },
-      });
+      repairedJob = cancelRequested && terminated
+        ? transitionOracleJobPhase(current, "cancelled", {
+          at: recoveredAt,
+          source: "oracle:reconcile",
+          message: `Recovered requested cancellation: ${currentStaleReason}.${suffix}`.trim(),
+          clearNotificationClaim: true,
+          patch: {
+            heartbeatAt: recoveredAt,
+            cleanupPending: true,
+            error: current.cancelReason ?? current.error ?? "Cancelled by user",
+          },
+        })
+        : transitionOracleJobPhase(current, "failed", {
+          at: recoveredAt,
+          source: "oracle:reconcile",
+          message: `Recovered stale job: ${currentStaleReason}.${suffix}`.trim(),
+          clearNotificationClaim: true,
+          patch: {
+            heartbeatAt: recoveredAt,
+            cleanupPending: terminated,
+            error: current.error
+              ? `${current.error}\nRecovered stale job: ${currentStaleReason}.${suffix}`.trim()
+              : `Recovered stale job: ${currentStaleReason}.${suffix}`.trim(),
+          },
+        });
       await writeJobUnlocked(repairedJob);
     });
 
@@ -803,30 +831,48 @@ export async function cancelOracleJob(id: string, reason = "Cancelled by user"):
       }));
     }
 
-    const terminated = await terminateWorkerPid(current.workerPid, current.workerStartedAt);
+    let cancelTarget: Pick<OracleJob, "workerPid" | "workerStartedAt"> | undefined;
+    await withJobLock(id, { processPid: process.pid, action: "markCancelRequested", jobId: id }, async () => {
+      const latest = readJob(id);
+      if (!latest || isTerminalOracleJob(latest) || latest.status === "queued") return;
+      cancelTarget = { workerPid: latest.workerPid, workerStartedAt: latest.workerStartedAt };
+      const next = markCancelRequested(latest, reason, now);
+      if (next !== latest) {
+        await writeJobUnlocked(next);
+      }
+    });
+
+    const terminated = await terminateWorkerPid(cancelTarget?.workerPid, cancelTarget?.workerStartedAt);
     let transitioned = false;
-    const cancelled = await updateJob(id, (job) => {
-      if (isTerminalOracleJob(job)) return job;
+    let cancelled: OracleJob | undefined;
+    await withJobLock(id, { processPid: process.pid, action: "finalizeCancelOracleJob", jobId: id }, async () => {
+      const latest = readJob(id);
+      if (!latest) throw new Error(`Oracle job not found: ${id}`);
+      if (isTerminalOracleJob(latest)) {
+        cancelled = latest;
+        return;
+      }
       transitioned = true;
-      return transitionOracleJobPhase(job, terminated ? "cancelled" : "failed", {
+      cancelled = transitionOracleJobPhase(latest, terminated ? "cancelled" : "failed", {
         at: now,
         source: "oracle:cancel",
         message: terminated
-          ? `Job cancelled: ${reason}`
-          : `Job cancellation failed because worker PID ${job.workerPid ?? "unknown"} did not exit.`,
+          ? `Job cancelled: ${latest.cancelReason ?? reason}`
+          : `Job cancellation failed because worker PID ${latest.workerPid ?? "unknown"} did not exit.`,
         clearNotificationClaim: true,
         patch: {
           heartbeatAt: now,
           cleanupPending: terminated,
-          error: terminated ? reason : `${reason}; worker PID ${job.workerPid ?? "unknown"} did not exit`,
+          error: terminated ? latest.cancelReason ?? reason : `${latest.cancelReason ?? reason}; worker PID ${latest.workerPid ?? "unknown"} did not exit`,
         },
       });
+      await writeJobUnlocked(cancelled);
     });
-    if (!transitioned) return cancelled;
+    if (!cancelled || !transitioned) return cancelled ?? readJob(id)!;
 
     if (!terminated) {
       const cleanupWarnings = [
-        `Oracle runtime cleanup is blocked because worker PID ${current.workerPid ?? "unknown"} could not be terminated safely.`,
+        `Oracle runtime cleanup is blocked because worker PID ${cancelled.workerPid ?? cancelTarget?.workerPid ?? "unknown"} could not be terminated safely.`,
       ];
       return updateJob(id, (job) => applyOracleJobCleanupWarnings(job, cleanupWarnings, {
         at: now,

package/extensions/oracle/lib/tools.ts

@@ -10,7 +10,7 @@ import { basename, join, posix } from "node:path";
 import { runOracleAuthBootstrap } from "./auth.js";
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
-import { formatOracleJobSummary, formatOracleSubmitResponse } from "../shared/job-observability-helpers.mjs";
+import { formatOracleCancelOutcome, formatOracleJobSummary, formatOracleSubmitResponse } from "../shared/job-observability-helpers.mjs";
 import { getLatestOracleJobLifecycleEvent, getLatestOracleTerminalLifecycleEvent, transitionOracleJobPhase } from "../shared/job-lifecycle-helpers.mjs";
 import { isLockTimeoutError, withGlobalReconcileLock, withLock } from "./locks.js";
 import {
@@ -31,6 +31,7 @@ import {
   isTerminalOracleJob,
   listOracleJobDirs,
   markWakeupSettled,
+  ORACLE_STALE_HEARTBEAT_MS,
   readJob,
   pruneTerminalOracleJobs,
   reconcileStaleOracleJobs,
@@ -89,6 +90,7 @@ const MAX_QUEUED_JOBS_PER_ACTIVE_RUNTIME = 1;
 const MAX_QUEUED_ARCHIVE_BYTES_PER_ACTIVE_RUNTIME = MAX_ARCHIVE_BYTES;
 const ARCHIVE_COMMAND_TIMEOUT_MS = 120_000;
 const ARCHIVE_COMMAND_KILL_GRACE_MS = 2_000;
+const ARCHIVE_PIPE_FAILURE_ERROR_CODES = new Set(["EPIPE", "ERR_STREAM_DESTROYED"]);
 
 const DEFAULT_ARCHIVE_EXCLUDED_DIR_NAMES_ANYWHERE = new Set([
   ".git",
@@ -159,6 +161,12 @@ function appendArchiveEntries(target: string[], source: Iterable<string>): void
   for (const entry of source) target.push(entry);
 }
 
+function getErrorCode(error: unknown): string | undefined {
+  return error && typeof error === "object" && "code" in error && typeof error.code === "string"
+    ? error.code
+    : undefined;
+}
+
 function mergeArchiveEntryGroups(groups: Iterable<Iterable<string>>): string[] {
   const merged: string[] = [];
   for (const group of groups) appendArchiveEntries(merged, group);
@@ -415,6 +423,18 @@ async function writeArchiveFile(
       else rejectPromise(new Error(stderr || `archive command failed (tar=${tarCode}, zstd=${zstdCode})`));
     };
 
+    const handlePipeError = (error: unknown) => {
+      const normalized = error instanceof Error ? error : new Error(String(error));
+      if (ARCHIVE_PIPE_FAILURE_ERROR_CODES.has(getErrorCode(normalized) ?? "")) {
+        stderr = `${stderr}${stderr ? "\n" : ""}${normalized.message}`;
+        tar.stdout.unpipe(zstd.stdin);
+        terminateChildren();
+        finish();
+        return;
+      }
+      finish(normalized);
+    };
+
     const commandTimeoutMs = options?.commandTimeoutMs ?? ARCHIVE_COMMAND_TIMEOUT_MS;
     if (commandTimeoutMs > 0) {
       timeout = setTimeout(() => {
@@ -433,6 +453,8 @@ async function writeArchiveFile(
     });
     tar.on("error", (error) => finish(error instanceof Error ? error : new Error(String(error))));
     zstd.on("error", (error) => finish(error instanceof Error ? error : new Error(String(error))));
+    tar.stdout.on("error", handlePipeError);
+    zstd.stdin.on("error", handlePipeError);
     tar.on("close", (code) => {
       tarCode = code;
       finish();
@@ -1378,6 +1400,7 @@ export function registerOracleTools(pi: ExtensionAPI, workerPath: string, authWo
                 artifactsPath: `${getJobDir(current.id)}/artifacts`,
                 responsePreview,
                 responseAvailable,
+                heartbeatStaleMs: ORACLE_STALE_HEARTBEAT_MS,
               }),
             },
           ],
@@ -1419,7 +1442,7 @@ export function registerOracleTools(pi: ExtensionAPI, workerPath: string, authWo
         }
         if (ctx.hasUI) refreshOracleStatus(ctx);
         return {
-          content: [{ type: "text", text: cancelled.status === "cancelled" || cancelled.status === "failed" ? `Cancelled oracle job ${cancelled.id}.` : `Oracle job ${cancelled.id} was already ${cancelled.status}.` }],
+          content: [{ type: "text", text: formatOracleCancelOutcome(cancelled) }],
           details: { job: redactJobDetails(cancelled, { queue: buildOracleQueueSnapshot(cancelled, cancelled.status === "queued" ? getQueuePosition(cancelled.id) : undefined) }) },
         };
       } catch (error) {

package/extensions/oracle/shared/job-lifecycle-helpers.d.mts

@@ -34,6 +34,8 @@ export interface OracleLifecycleTrackedJobLike {
   submittedAt?: string;
   completedAt?: string;
   heartbeatAt?: string;
+  cancelRequestedAt?: string;
+  cancelReason?: string;
   lifecycleEvents?: OracleJobLifecycleEvent[];
   cleanupPending?: boolean;
   cleanupWarnings?: string[];

package/extensions/oracle/shared/job-lifecycle-helpers.mjs

@@ -167,7 +167,11 @@ export function transitionOracleJobPhase(job, phase, options = {}) {
       ? { submittedAt: patch.submittedAt ?? job.submittedAt ?? at }
       : {}),
     ...(TERMINAL_ORACLE_JOB_STATUSES.includes(status)
-      ? { completedAt: patch.completedAt ?? job.completedAt ?? at }
+      ? {
+        completedAt: patch.completedAt ?? job.completedAt ?? at,
+        cancelRequestedAt: undefined,
+        cancelReason: undefined,
+      }
       : { completedAt: patch.completedAt ?? job.completedAt }),
     ...(options.clearNotificationClaim
       ? { notifyClaimedAt: undefined, notifyClaimedBy: undefined }

package/extensions/oracle/shared/job-observability-helpers.d.mts

@@ -8,6 +8,7 @@ export interface OracleJobSummaryLike {
   queuedAt?: string;
   submittedAt?: string;
   completedAt?: string;
+  heartbeatAt?: string;
   projectId: string;
   sessionId: string;
   followUpToJobId?: string;
@@ -35,6 +36,8 @@ export interface OracleJobSummaryOptions {
   responseAvailable?: boolean;
   includeLatestEvent?: boolean;
   includeWorkerLogPath?: boolean;
+  nowMs?: number;
+  heartbeatStaleMs?: number;
 }
 
 export interface OracleSubmitResponseOptions {
@@ -51,6 +54,7 @@ export interface OracleStatusCounts {
 
 export declare function formatBytes(bytes: number): string;
 export declare function formatOracleLifecycleEvent(event: OracleJobLifecycleEvent | undefined): string | undefined;
+export declare function formatOracleCancelOutcome(job: { id: string; status: string }): string;
 export declare function formatOracleJobSummary(job: OracleJobSummaryLike, options?: OracleJobSummaryOptions): string;
 export declare function buildOracleWakeupNotificationContent(
   job: OracleJobSummaryLike,

package/extensions/oracle/shared/job-observability-helpers.mjs

@@ -46,6 +46,69 @@ function formatAutoPrunedArchiveMessage(autoPrunedPrefixes) {
   return `Archive auto-pruned generic generated-output-name dirs to fit size limit: ${autoPrunedPrefixes.map((entry) => `${entry.relativePath}/ (${formatBytes(entry.bytes)})`).join(", ")}`;
 }
 
+const ACTIVE_SUMMARY_STATUSES = new Set(["preparing", "submitted", "waiting"]);
+const DEFAULT_ORACLE_HEARTBEAT_STALE_MS = 3 * 60 * 1000;
+
+/**
+ * @param {string | undefined} value
+ * @returns {number | undefined}
+ */
+function parseTimestamp(value) {
+  if (!value) return undefined;
+  const ms = Date.parse(value);
+  return Number.isNaN(ms) ? undefined : ms;
+}
+
+/**
+ * @param {number} elapsedMs
+ * @returns {string}
+ */
+function formatElapsed(elapsedMs) {
+  const totalSeconds = Math.max(0, Math.round(elapsedMs / 1000));
+  if (totalSeconds < 60) return `${totalSeconds}s`;
+  const totalMinutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  if (totalMinutes < 60) return seconds === 0 ? `${totalMinutes}m` : `${totalMinutes}m ${String(seconds).padStart(2, "0")}s`;
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  return minutes === 0 ? `${hours}h` : `${hours}h ${String(minutes).padStart(2, "0")}m`;
+}
+
+/**
+ * @param {OracleJobSummaryLike} job
+ * @param {OracleJobSummaryOptions} [options]
+ * @returns {string | undefined}
+ */
+function formatHeartbeatFreshness(job, options = {}) {
+  if (!ACTIVE_SUMMARY_STATUSES.has(job.status)) return undefined;
+  const nowMs = Number.isFinite(options.nowMs) ? options.nowMs : Date.now();
+  const staleMs = Number.isFinite(options.heartbeatStaleMs) ? options.heartbeatStaleMs : DEFAULT_ORACLE_HEARTBEAT_STALE_MS;
+  const heartbeatMs = parseTimestamp(job.heartbeatAt);
+  if (heartbeatMs !== undefined) {
+    const elapsedMs = Math.max(0, nowMs - heartbeatMs);
+    return `heartbeat: ${elapsedMs > staleMs ? "likely stale" : "fresh"} (${formatElapsed(elapsedMs)} ago)`;
+  }
+
+  const submittedMs = parseTimestamp(job.submittedAt);
+  const createdMs = parseTimestamp(job.createdAt);
+  const baselineMs = submittedMs ?? createdMs;
+  if (baselineMs === undefined) return "heartbeat: unavailable";
+
+  const elapsedMs = Math.max(0, nowMs - baselineMs);
+  const freshness = elapsedMs > staleMs ? "waiting for first worker update; likely stale" : "waiting for first worker update";
+  return `heartbeat: ${freshness} (${formatElapsed(elapsedMs)} ${submittedMs !== undefined ? "since submit" : "since create"})`;
+}
+
+/**
+ * @param {{ id: string; status: string }} job
+ * @returns {string}
+ */
+export function formatOracleCancelOutcome(job) {
+  if (job.status === "cancelled") return `Cancelled oracle job ${job.id}.`;
+  if (job.status === "failed") return `Oracle job ${job.id} failed during cancellation.`;
+  return `Oracle job ${job.id} finished as ${job.status} before cancellation completed.`;
+}
+
 /**
  * @param {OracleJobSummaryLike} job
  * @param {OracleJobSummaryOptions} [options]
@@ -78,6 +141,7 @@ export function formatOracleJobSummary(job, options = {}) {
     options.queuePosition ? `queue-position: ${options.queuePosition.position} of ${options.queuePosition.depth} global` : undefined,
     `project: ${job.projectId}`,
     `session: ${job.sessionId}`,
+    formatHeartbeatFreshness(job, options),
     job.completedAt ? `completed: ${job.completedAt}` : undefined,
     job.followUpToJobId ? `follow-up-to: ${job.followUpToJobId}` : undefined,
     job.chatUrl ? `chat: ${job.chatUrl}` : undefined,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-oracle",
-  "version": "0.6.3",
+  "version": "0.6.5",
   "description": "ChatGPT web-oracle extension for pi with isolated browser auth, async jobs, and project-context archives.",
   "private": false,
   "license": "MIT",
@@ -62,18 +62,19 @@
     "basic-ftp": "^5.2.2"
   },
   "devDependencies": {
-    "@mariozechner/pi-ai": "^0.65.2",
-    "@mariozechner/pi-coding-agent": "^0.65.2",
+    "@mariozechner/pi-ai": "^0.67.2",
+    "@mariozechner/pi-coding-agent": "^0.67.2",
     "@sinclair/typebox": "^0.34.49",
-    "@types/node": "^24.6.0",
-    "esbuild": "^0.27.0",
-    "tsx": "^4.20.6",
-    "typescript": "^5.9.3"
+    "@types/node": "^25.6.0",
+    "esbuild": "^0.28.0",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.2"
   },
   "engines": {
     "node": ">=22"
   },
   "os": [
     "darwin"
-  ]
+  ],
+  "packageManager": "npm@11.12.1"
 }