@llblab/pi-actors 0.41.1 → 0.42.1

package/lib/runs-status.ts

@@ -1,20 +1,26 @@
 /**
  * Async run status and log readers.
- * Owns status derivation from run state files plus bounded log/event tails.
+ * Owns: status derivation from run state files plus bounded log/event tails.
  */
 
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 
-import type { AsyncRunStatus } from "./async-runs.ts";
 import {
-  isWithinRunnerIdentityGrace,
   verifyRunProcessIdentity,
   type RunProcessIdentity,
 } from "./runs-process.ts";
 import { readJsonlFileResilient } from "./state-readers.ts";
 
-export type RunJsonReader = (path: string) => Record<string, unknown> | undefined;
+export type AsyncRunStatus =
+  | "running"
+  | "done"
+  | "failed"
+  | "exited"
+  | "cancelled"
+  | "killed";
+
+type RunJsonReader = (path: string) => Record<string, unknown> | undefined;
 
 function getInterruptedRunStatus(
   stateDir: string,
@@ -35,7 +41,7 @@ export function buildRunStatus(
   meta: Record<string, unknown>,
   readJson: RunJsonReader,
   _runnerPath: string,
-  runnerIdentityGraceMs: number,
+  _runnerIdentityGraceMs: number,
 ): Record<string, unknown> {
   const result = readJson(join(stateDir, "result.json"));
   const pid = Number(meta.pid || 0);
@@ -45,9 +51,7 @@ export function buildRunStatus(
   );
   const aliveOwnedRunner = Boolean(
     pid &&
-      (processIdentity.valid ||
-        (processIdentity.status === "unsupported_proof" &&
-          isWithinRunnerIdentityGrace(meta, runnerIdentityGraceMs))),
+      (processIdentity.valid || processIdentity.status === "unsupported_proof"),
   );
   const status: AsyncRunStatus = result
     ? Number(result.code ?? 0) === 0
@@ -57,6 +61,9 @@ export function buildRunStatus(
       ? "running"
       : (getInterruptedRunStatus(stateDir) ?? "exited");
   const terminalHandled = readJson(join(stateDir, "terminal-handled.json"));
+  const terminalDeliveryFailure = readJson(
+    join(stateDir, "terminal-delivery-failure.json"),
+  );
   return {
     ...meta,
     eventsFile: join(stateDir, "events.jsonl"),
@@ -66,6 +73,8 @@ export function buildRunStatus(
     process_identity_status: processIdentity.status,
     progress: readJson(join(stateDir, "progress.json")) || null,
     result: result || null,
+    ...(terminalDeliveryFailure
+      ? { terminal_delivery_failure: terminalDeliveryFailure } : {}),
     ...(terminalHandled ? { terminal_handled: terminalHandled } : {}),
     state_dir: String(meta.state_dir ?? stateDir),
     stderrLog: join(stateDir, "stderr.log"),

package/lib/runtime.ts

@@ -182,18 +182,29 @@ export function createAutoToolsRuntime(
   };
 }
 
+export interface RecipeToolReloadWatcherDeps {
+  exists?: (path: string) => boolean;
+  recipeRoot?: string;
+  watchPath?: typeof watch;
+}
+
 export function createRecipeToolReloadWatcher(
   runtime: Pick<ToolRegistryRuntime, "loadTools">,
+  deps: RecipeToolReloadWatcherDeps = {},
 ): RecipeToolReloadWatcher {
+  const pathExists = deps.exists ?? existsSync;
+  const watchPath = deps.watchPath ?? watch;
   let reloadTimeout: NodeJS.Timeout | undefined;
   let rootWatcher: FSWatcher | undefined;
   let parentWatcher: FSWatcher | undefined;
   let failureNotified = false;
   const close = (): void => {
-    rootWatcher?.close();
+    const closingRoot = rootWatcher;
     rootWatcher = undefined;
-    parentWatcher?.close();
+    closingRoot?.close();
+    const closingParent = parentWatcher;
     parentWatcher = undefined;
+    closingParent?.close();
     if (reloadTimeout) clearTimeout(reloadTimeout);
     reloadTimeout = undefined;
   };
@@ -217,28 +228,31 @@ export function createRecipeToolReloadWatcher(
   const watchParent = (ctx: RuntimeContext, recipeRoot: string): void => {
     if (parentWatcher || rootWatcher) return;
     const parent = dirname(recipeRoot);
-    if (!existsSync(parent)) {
+    if (!pathExists(parent)) {
       notifyFailure(ctx);
       return;
     }
     try {
-      parentWatcher = watch(parent, (_event, changedFile) => {
+      const watcher = watchPath(parent, (_event, changedFile) => {
+        if (parentWatcher !== watcher) return;
         if (
           changedFile &&
           String(changedFile) !== basename(recipeRoot) &&
-          !existsSync(recipeRoot)
+          !pathExists(recipeRoot)
         ) {
           return;
         }
-        if (!existsSync(recipeRoot)) return;
-        parentWatcher?.close();
+        if (!pathExists(recipeRoot)) return;
         parentWatcher = undefined;
+        watcher.close();
         watchRoot(ctx, recipeRoot);
         scheduleReload(ctx);
       });
-      parentWatcher.on("error", () => {
-        parentWatcher?.close();
+      parentWatcher = watcher;
+      watcher.on("error", () => {
+        if (parentWatcher !== watcher) return;
         parentWatcher = undefined;
+        watcher.close();
         notifyFailure(ctx);
       });
     } catch {
@@ -247,25 +261,28 @@ export function createRecipeToolReloadWatcher(
   };
   const watchRoot = (ctx: RuntimeContext, recipeRoot: string): void => {
     if (rootWatcher) return;
-    if (!existsSync(recipeRoot)) {
+    if (!pathExists(recipeRoot)) {
       watchParent(ctx, recipeRoot);
       return;
     }
     try {
-      rootWatcher = watch(recipeRoot, () => {
-        if (!existsSync(recipeRoot)) {
-          rootWatcher?.close();
+      const watcher = watchPath(recipeRoot, () => {
+        if (rootWatcher !== watcher) return;
+        if (!pathExists(recipeRoot)) {
           rootWatcher = undefined;
+          watcher.close();
           scheduleReload(ctx);
           watchParent(ctx, recipeRoot);
           return;
         }
         scheduleReload(ctx);
       });
-      rootWatcher.on("error", () => {
-        rootWatcher?.close();
+      rootWatcher = watcher;
+      watcher.on("error", () => {
+        if (rootWatcher !== watcher) return;
         rootWatcher = undefined;
-        if (existsSync(recipeRoot)) notifyFailure(ctx);
+        watcher.close();
+        if (pathExists(recipeRoot)) notifyFailure(ctx);
         else watchParent(ctx, recipeRoot);
       });
     } catch {
@@ -276,7 +293,7 @@ export function createRecipeToolReloadWatcher(
     close,
     watch(ctx: RuntimeContext): void {
       if (rootWatcher || parentWatcher) return;
-      watchRoot(ctx, Paths.getRecipeRoot());
+      watchRoot(ctx, deps.recipeRoot ?? Paths.getRecipeRoot());
     },
   };
 }