@llblab/pi-actors 0.41.1 → 0.42.1

package/dist/lib/runtime.js

@@ -124,16 +124,20 @@ export function createAutoToolsRuntime(deps) {
         registerRuntimeTool,
     };
 }
-export function createRecipeToolReloadWatcher(runtime) {
+export function createRecipeToolReloadWatcher(runtime, deps = {}) {
+    const pathExists = deps.exists ?? existsSync;
+    const watchPath = deps.watchPath ?? watch;
     let reloadTimeout;
     let rootWatcher;
     let parentWatcher;
     let failureNotified = false;
     const close = () => {
-        rootWatcher?.close();
+        const closingRoot = rootWatcher;
         rootWatcher = undefined;
-        parentWatcher?.close();
+        closingRoot?.close();
+        const closingParent = parentWatcher;
         parentWatcher = undefined;
+        closingParent?.close();
         if (reloadTimeout)
             clearTimeout(reloadTimeout);
         reloadTimeout = undefined;
@@ -158,27 +162,32 @@ export function createRecipeToolReloadWatcher(runtime) {
         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))
+                if (!pathExists(recipeRoot))
                     return;
-                parentWatcher?.close();
                 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);
             });
         }
@@ -189,25 +198,30 @@ export function createRecipeToolReloadWatcher(runtime) {
     const watchRoot = (ctx, recipeRoot) => {
         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))
+                watcher.close();
+                if (pathExists(recipeRoot))
                     notifyFailure(ctx);
                 else
                     watchParent(ctx, recipeRoot);
@@ -222,7 +236,7 @@ export function createRecipeToolReloadWatcher(runtime) {
         watch(ctx) {
             if (rootWatcher || parentWatcher)
                 return;
-            watchRoot(ctx, Paths.getRecipeRoot());
+            watchRoot(ctx, deps.recipeRoot ?? Paths.getRecipeRoot());
         },
     };
 }

package/dist/lib/tool-review-lineage-transaction.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Journaled tool-review lineage finalization.
+ * Zones: lineage projection persistence, ledger/index CAS, crash roll-forward
+ * Owns idempotent ledger mutation after portfolio filesystem commit; admission-state activation and quarantine cleanup remain separate.
+ */
+export interface ToolReviewLineageTransactionResult {
+    journalPath: string;
+    phase: "committed";
+}
+export interface ToolReviewLineageTransactionOptions {
+    checkpoint?(checkpoint: "ledger_written" | "prepared"): void;
+    now?(): Date;
+    recipeRoot: string;
+}
+export declare function finalizeToolReviewLineage(approvedPath: string, options: ToolReviewLineageTransactionOptions): ToolReviewLineageTransactionResult;
+export interface ToolReviewRevisionRollbackResult {
+    journalPath: string;
+    lineageName: string;
+    restoredRevision: number;
+    targetPath: string;
+}
+export interface ToolReviewRevisionRollbackOptions {
+    checkpoint?(checkpoint: "ledger_written" | "prepared" | "recipe_written"): void;
+    now?(): Date;
+    recipeRoot: string;
+}
+export declare function rollbackToolRecipeRevision(lineageName: string, revision: number, options: ToolReviewRevisionRollbackOptions): ToolReviewRevisionRollbackResult;