@llblab/pi-actors 0.41.1 → 0.42.1

package/dist/lib/inspector.js

@@ -19,10 +19,14 @@ export function readActorInspectorRuns(stateRoot, ownerId) {
             const stateDir = path.join(stateRoot, entry.name);
             if (!matchesOwner(stateDir, ownerId))
                 return [];
+            const runMeta = readJsonFileResilient(path.join(stateDir, "run.json"), {}).value;
             const progress = readJsonFileResilient(path.join(stateDir, "progress.json"), {}).value;
             const result = readJsonFileResilient(path.join(stateDir, "result.json"), {}).value;
             return [{
                     run: entry.name,
+                    ...(typeof runMeta.run_instance_id === "string"
+                        ? { runInstanceId: runMeta.run_instance_id }
+                        : {}),
                     status: String(progress.phase ?? (Object.keys(result).length ? "terminal" : "unknown")),
                     ...(typeof progress.updatedAt === "string"
                         ? { updatedAt: progress.updatedAt }
@@ -42,6 +46,50 @@ export function readActorInspectorRuns(stateRoot, ownerId) {
         return [];
     }
 }
+export function readActorInspectorRecipe(stateDir) {
+    const result = readJsonFileResilient(path.join(stateDir, "run.json"), {});
+    const meta = result.value;
+    const contexts = Array.isArray(meta.recipe_context_records)
+        ? meta.recipe_context_records
+            .filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry)))
+        : [];
+    const primary = contexts.find((entry) => entry.depth === 0) ?? contexts[0];
+    const definition = primary?.recipe && typeof primary.recipe === "object" &&
+        !Array.isArray(primary.recipe)
+        ? primary.recipe
+        : undefined;
+    const redacted = (value) => SessionEvidence.redactSessionEvidenceValue(value);
+    const redactedRecord = (value) => redacted(Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined)));
+    return {
+        composition: contexts.map((entry) => redactedRecord({
+            ...(typeof entry.alias === "string" ? { alias: entry.alias } : {}),
+            depth: entry.depth,
+            file: entry.file,
+            import_path: entry.import_path,
+            name: entry.name,
+        })),
+        ...(definition
+            ? { definition: redactedRecord(definition) }
+            : {}),
+        diagnostics: result.diagnostics.map((diagnostic) => diagnostic.message),
+        identity: redactedRecord({
+            run: meta.run,
+            recipe: meta.recipe,
+            recipe_file: meta.recipe_file,
+            launch_source: meta.launch_source,
+        }),
+        launch: redactedRecord({
+            cwd: meta.cwd,
+            template: meta.template,
+            values: meta.values,
+            model_policy: meta.model_policy,
+            mailbox: meta.mailbox,
+            artifacts: meta.artifacts,
+            notification_policy: meta.notification_policy,
+            retire_when: meta.retire_when,
+        }),
+    };
+}
 function ownedSessionPath(stateDir, sessionFile) {
     if (path.isAbsolute(sessionFile))
         return undefined;
@@ -78,7 +126,7 @@ export function readActorInspectorTurns(stateDir) {
                 withFileTypes: true,
             })
                 .filter((file) => file.isFile() && file.name.endsWith(".jsonl"))
-                .map((file) => path.join("sessions", entry.name, file.name))
+                .map((file) => path.posix.join("sessions", entry.name, file.name))
                 .filter((file) => !recordedFiles.has(file));
             return files.length > 0
                 ? [{ id: entry.name, session_files: files, stage: "subagent" }]

package/dist/lib/observability.d.ts

@@ -15,12 +15,15 @@ export interface RunObservation {
     failures?: number;
     ownerId?: string;
     artifacts?: Record<string, string>;
+    launchCorrelation?: Record<string, string>;
     launchSource?: AsyncRuns.AsyncRunLaunchSource;
     modelPolicy?: Record<string, unknown>;
+    notificationPolicy?: "normal" | "silent";
     recipeFile?: string;
     terminalHandled?: boolean;
     retireWhen?: string;
     run: string;
+    semanticResult?: RunTerminalSemanticResult;
     tool?: string;
     stateDir?: string;
     status: RunObservedStatus;
@@ -130,12 +133,22 @@ export interface RunTransition {
     run: string;
     stateDir?: string;
     artifacts?: Record<string, string>;
+    launchCorrelation?: Record<string, string>;
     launchSource?: AsyncRuns.AsyncRunLaunchSource;
     modelPolicy?: Record<string, unknown>;
     recipeFile?: string;
     terminalHandled?: boolean;
     to: RunObservedStatus;
     tool?: string;
+    semanticResult?: RunTerminalSemanticResult;
+}
+export interface RunTerminalSemanticResult {
+    body?: string;
+    correlationId?: string;
+    metadata: Record<string, unknown>;
+    summary: string;
+    synthesized: boolean;
+    type: string;
 }
 export interface RunOutboxEvent {
     body?: unknown;

package/dist/lib/observability.js

@@ -3,7 +3,7 @@
  * Zones: async runtime, ambient UI, diagnostics
  * Owns ambient summaries, terminal events, and run outbox delivery for detached command-template runs
  */
-import { existsSync, readdirSync, readFileSync, watch, } from "node:fs";
+import { closeSync, existsSync, fstatSync, openSync, readdirSync, readFileSync, readSync, watch, } from "node:fs";
 import { basename, dirname, isAbsolute, join, relative, resolve, } from "node:path";
 import * as AsyncRuns from "./async-runs.js";
 import * as Paths from "./paths.js";
@@ -54,6 +54,13 @@ export function deliverRunTransitionNotifications(transitions, sink, inFlight =
                 AsyncRuns.markRunTerminalNotificationHandled(transition.stateDir, transition.to);
             }
         }
+        catch (error) {
+            if (transition.stateDir) {
+                AsyncRuns.recordRunTerminalDeliveryFailure(transition.stateDir, transition.to, error);
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            sink.notify(`Actor terminal delivery failed for run:${transition.run}: ${message.replaceAll(/\s+/g, " ").slice(0, 240)}`, "error");
+        }
         finally {
             inFlight.delete(key);
         }
@@ -282,6 +289,121 @@ function scanRunStateDirs(stateRoot, depth = 0, seen = new Set()) {
     }
     return result;
 }
+const TERMINAL_RESULT_BYTES = 8 * 1024;
+const TERMINAL_RESULT_CHARS = 4_000;
+function readBoundedStart(path) {
+    if (!existsSync(path))
+        return "";
+    const fd = openSync(path, "r");
+    try {
+        const size = Math.min(fstatSync(fd).size, TERMINAL_RESULT_BYTES);
+        const buffer = Buffer.alloc(size);
+        const bytes = readSync(fd, buffer, 0, size, 0);
+        const text = buffer.subarray(0, bytes).toString("utf8").trim();
+        return text.length > TERMINAL_RESULT_CHARS
+            ? `${text.slice(0, TERMINAL_RESULT_CHARS - 1)}…`
+            : text;
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+function semanticBodyFromStdout(stateDir) {
+    const text = readBoundedStart(join(stateDir, "stdout.log"));
+    if (!text)
+        return undefined;
+    const withoutMarker = text.replace(/^ACTOR_REVIEW_RESULT\s*(?:\r?\n)?/, "").trim();
+    return withoutMarker || undefined;
+}
+function terminalSemanticResult(status, stateDir, observedStatus) {
+    const correlation = status.launch_correlation &&
+        typeof status.launch_correlation === "object" &&
+        !Array.isArray(status.launch_correlation)
+        ? status.launch_correlation
+        : {};
+    const correlationId = typeof correlation.correlation_id === "string"
+        ? correlation.correlation_id
+        : typeof correlation.tool_call_id === "string"
+            ? correlation.tool_call_id
+            : undefined;
+    const mailbox = status.mailbox &&
+        typeof status.mailbox === "object" &&
+        !Array.isArray(status.mailbox)
+        ? status.mailbox
+        : {};
+    const emits = Array.isArray(mailbox.emits)
+        ? mailbox.emits.filter((item) => typeof item === "string")
+        : [];
+    const outbox = readJsonlFileResilient(join(stateDir, "outbox.jsonl")).records;
+    const explicit = outbox.findLast((record) => {
+        const type = String(record.type ?? record.event ?? "");
+        return emits.includes(type) && !["command.done", "run.done", "run.failed"].includes(type);
+    });
+    if (explicit) {
+        const type = String(explicit.type ?? explicit.event);
+        return {
+            ...(explicit.body === undefined
+                ? {} : { body: formatSemanticBody(explicit.body) }),
+            ...(typeof explicit.correlation_id === "string"
+                ? { correlationId: explicit.correlation_id } : correlationId ? { correlationId } : {}),
+            metadata: {
+                ...(explicit.metadata &&
+                    typeof explicit.metadata === "object" &&
+                    !Array.isArray(explicit.metadata)
+                    ? explicit.metadata : {}),
+                ...(status.transport_context &&
+                    typeof status.transport_context === "object" &&
+                    !Array.isArray(status.transport_context)
+                    ? {
+                        transport_context: status.transport_context,
+                    } : {}),
+                run: String(status.run ?? ""),
+                status: observedStatus,
+            },
+            summary: String(explicit.summary ?? type),
+            synthesized: false,
+            type,
+        };
+    }
+    const reviewCompleted = observedStatus === "done" && emits.includes("review.completed");
+    const result = status.result &&
+        typeof status.result === "object" &&
+        !Array.isArray(status.result)
+        ? status.result
+        : {};
+    const type = reviewCompleted
+        ? "review.completed"
+        : observedStatus === "done" ? "run.done" : "run.failed";
+    const stdoutBody = observedStatus === "done"
+        ? semanticBodyFromStdout(stateDir) : undefined;
+    return {
+        ...(stdoutBody
+            ? { body: stdoutBody }
+            : typeof result.error === "string" ? { body: result.error } : {}),
+        ...(correlationId ? { correlationId } : {}),
+        metadata: {
+            ...(status.transport_context &&
+                typeof status.transport_context === "object" &&
+                !Array.isArray(status.transport_context)
+                ? {
+                    transport_context: status.transport_context,
+                } : {}),
+            run: String(status.run ?? ""), status: observedStatus,
+        },
+        summary: reviewCompleted ? "Review completed." :
+            observedStatus === "done" ? "Run completed." : `Run ${observedStatus}.`,
+        synthesized: true,
+        type,
+    };
+}
+function formatSemanticBody(body) {
+    const rendered = typeof body === "string" ? body : JSON.stringify(body);
+    const text = typeof rendered === "string" ? rendered : String(body);
+    const compact = text.trim();
+    return compact.length > TERMINAL_RESULT_CHARS
+        ? `${compact.slice(0, TERMINAL_RESULT_CHARS - 1)}…`
+        : compact;
+}
 function observeRun(stateDir) {
     try {
         const status = AsyncRuns.getRunStatus(stateDir);
@@ -289,9 +411,15 @@ function observeRun(stateDir) {
         const run = typeof status.run === "string" ? status.run : undefined;
         if (!run)
             return undefined;
+        const observedStatus = status.status;
         return {
             activeSubagents: toNumber(progress.activeSubagents),
             completed: toNumber(progress.completed),
+            ...(status.launch_correlation &&
+                typeof status.launch_correlation === "object" &&
+                !Array.isArray(status.launch_correlation)
+                ? { launchCorrelation: status.launch_correlation }
+                : {}),
             failures: Array.isArray(progress.failures)
                 ? progress.failures.length
                 : undefined,
@@ -311,6 +439,9 @@ function observeRun(stateDir) {
                 !Array.isArray(status.model_policy)
                 ? { modelPolicy: status.model_policy }
                 : {}),
+            ...(status.notification_policy === "silent"
+                ? { notificationPolicy: "silent" }
+                : {}),
             ...(typeof status.recipe_file === "string"
                 ? { recipeFile: status.recipe_file }
                 : {}),
@@ -318,9 +449,12 @@ function observeRun(stateDir) {
             ...(typeof status.retire_when === "string"
                 ? { retireWhen: status.retire_when }
                 : {}),
+            ...(TERMINAL.has(observedStatus)
+                ? { semanticResult: terminalSemanticResult(status, stateDir, observedStatus) }
+                : {}),
             run,
             stateDir,
-            status: status.status,
+            status: observedStatus,
             ...(typeof status.tool === "string" ? { tool: status.tool } : {}),
             updatedAt: getUpdatedAt(status),
         };
@@ -615,15 +749,19 @@ export function detectRunTransitions(previous, summary) {
     for (const run of summary.runs) {
         const key = runObservationKey(run);
         const old = previous.get(key);
-        if (!run.terminalHandled && TERMINAL.has(run.status)) {
+        if (run.notificationPolicy !== "silent" &&
+            !run.terminalHandled &&
+            TERMINAL.has(run.status)) {
             transitions.push({
                 from: old ?? "running",
                 run: run.run,
                 ...(run.stateDir ? { stateDir: run.stateDir } : {}),
                 ...(run.artifacts ? { artifacts: run.artifacts } : {}),
+                ...(run.launchCorrelation ? { launchCorrelation: run.launchCorrelation } : {}),
                 ...(run.launchSource ? { launchSource: run.launchSource } : {}),
                 ...(run.modelPolicy ? { modelPolicy: run.modelPolicy } : {}),
                 ...(run.recipeFile ? { recipeFile: run.recipeFile } : {}),
+                ...(run.semanticResult ? { semanticResult: run.semanticResult } : {}),
                 ...(run.terminalHandled ? { terminalHandled: true } : {}),
                 to: run.status,
                 ...(run.tool ? { tool: run.tool } : {}),
@@ -707,6 +845,11 @@ export function detectRunOutboxEvents(previousLineCounts, summary, seenEventIds
         const key = run.stateDir ?? run.run;
         const records = readOutboxRecords(run);
         const previousCount = previousLineCounts.get(key) ?? 0;
+        if (run.notificationPolicy === "silent") {
+            previousLineCounts.set(key, records.length);
+            seenEventIds.set(key, seenEventIds.get(key) ?? new Set());
+            continue;
+        }
         const start = Math.min(previousCount, records.length);
         const seen = seenEventIds.get(key) ?? new Set();
         for (let index = start; index < records.length; index += 1) {
@@ -831,7 +974,8 @@ function isUserRecipeFile(file) {
         return false;
     const recipeRoot = resolve(Paths.getRecipeRoot());
     const path = resolve(file);
-    return path === recipeRoot || path.startsWith(`${recipeRoot}/`);
+    const relation = relative(recipeRoot, path);
+    return relation === "" || (!relation.startsWith("..") && !isAbsolute(relation));
 }
 export function shouldSuggestRecipePersistence(transition) {
     if (transition.to !== "done")
@@ -877,16 +1021,26 @@ function formatTransitionNextActions(transition) {
     ].filter(Boolean);
     return `\nNext actions: ${actions.join(" | ")}`;
 }
+function formatTransitionSemanticResult(transition) {
+    const result = transition.semanticResult;
+    if (!result)
+        return "";
+    const correlation = result.correlationId
+        ? `\nCorrelation: ${result.correlationId}` : "";
+    const body = result.body ? `\nResult:\n${result.body}` : "";
+    return `\nSemantic result: ${result.type} — ${result.summary}${correlation}${body}`;
+}
 export function formatRunTransitionMessage(transition) {
     const artifacts = formatNamedArtifacts(transition.artifacts);
     const runFiles = formatRunFileList(getRunArtifacts(transition));
     const persistenceSuggestion = formatRecipePersistenceSuggestion(transition);
     const policy = formatTransitionPolicy(transition);
     const nextActions = formatTransitionNextActions(transition);
+    const semanticResult = formatTransitionSemanticResult(transition);
     if (transition.to === "done")
-        return `Run ${transition.run} completed successfully.${policy}${artifacts}${runFiles}${nextActions}${persistenceSuggestion}`;
+        return `Run ${transition.run} completed successfully.${semanticResult}${policy}${artifacts}${runFiles}${nextActions}${persistenceSuggestion}`;
     if (transition.to === "failed")
-        return `Run ${transition.run} failed.${policy}${artifacts}${runFiles}${nextActions}`;
+        return `Run ${transition.run} failed.${semanticResult}${policy}${artifacts}${runFiles}${nextActions}`;
     if (transition.to === "cancelled")
         return `Run ${transition.run} was cancelled.${policy}${nextActions}`;
     if (transition.to === "killed")

package/dist/lib/paths.d.ts

@@ -4,6 +4,7 @@
  * Owns agent directory, tools config, recipe root, and actor run state root resolution
  */
 export declare function getAgentDir(env?: Record<string, string | undefined>): string;
+export declare function isAutomaticRecipeReviewEnabled(env?: Record<string, string | undefined>): boolean;
 export interface ExtensionRuntimePaths {
     configPath: string;
     runStateRoot: string;
@@ -12,6 +13,12 @@ export interface ExtensionRuntimePaths {
 export declare function getConfigPath(agentDir?: string): string;
 export declare function getExtensionTmpDir(agentDir?: string, extensionName?: string): string;
 export declare function getRunStateRoot(agentDir?: string): string;
+export declare function getDraftSleepRoot(agentDir?: string): string;
+export declare function getDraftSleepStatePath(agentDir?: string): string;
+export declare function getDraftSleepBatchDir(batchId: string, agentDir?: string): string;
+export declare function getToolReviewRoot(agentDir?: string): string;
+export declare function getToolReviewStatePath(agentDir?: string): string;
+export declare function getToolReviewBatchDir(reviewId: string, agentDir?: string): string;
 export declare function getExtensionRuntimePaths(agentDir?: string): ExtensionRuntimePaths;
 export declare const EXTENSION_RUNTIME_PATHS: ExtensionRuntimePaths;
 export declare function getExtensionSkillsDir(extensionUrl: string): string;

package/dist/lib/paths.js

@@ -12,6 +12,10 @@ export function getAgentDir(env = process.env) {
         ? resolve(env.PI_CODING_AGENT_DIR)
         : join(homedir(), ".pi", "agent");
 }
+export function isAutomaticRecipeReviewEnabled(env = process.env) {
+    const value = env.PI_ACTORS_AUTOMATIC_REVIEW?.trim().toLowerCase();
+    return value === undefined || !["0", "false", "off"].includes(value);
+}
 export function getConfigPath(agentDir = getAgentDir()) {
     return join(agentDir, "tool-registry.json");
 }
@@ -21,6 +25,30 @@ export function getExtensionTmpDir(agentDir = getAgentDir(), extensionName = "pi
 export function getRunStateRoot(agentDir = getAgentDir()) {
     return join(getExtensionTmpDir(agentDir), "runs");
 }
+export function getDraftSleepRoot(agentDir = getAgentDir()) {
+    return join(getExtensionTmpDir(agentDir), "draft-sleep");
+}
+export function getDraftSleepStatePath(agentDir = getAgentDir()) {
+    return join(getDraftSleepRoot(agentDir), "state.json");
+}
+export function getDraftSleepBatchDir(batchId, agentDir = getAgentDir()) {
+    if (!/^[a-f0-9-]{36}$/u.test(batchId)) {
+        throw new Error("Invalid draft sleep batch id.");
+    }
+    return join(getDraftSleepRoot(agentDir), "batches", batchId);
+}
+export function getToolReviewRoot(agentDir = getAgentDir()) {
+    return join(getExtensionTmpDir(agentDir), "tool-review");
+}
+export function getToolReviewStatePath(agentDir = getAgentDir()) {
+    return join(getToolReviewRoot(agentDir), "state.json");
+}
+export function getToolReviewBatchDir(reviewId, agentDir = getAgentDir()) {
+    if (!/^[a-f0-9-]{36}$/u.test(reviewId)) {
+        throw new Error("Invalid tool review id.");
+    }
+    return join(getToolReviewRoot(agentDir), "batches", reviewId);
+}
 export function getExtensionRuntimePaths(agentDir = getAgentDir()) {
     return {
         configPath: getConfigPath(agentDir),

package/dist/lib/recipes-discovery.js

@@ -528,30 +528,38 @@ function templatePreview(value) {
 }
 export function listDraftRecipes(root) {
     return listRecipeFiles(root).map((path) => {
-        const id = RecipesReferences.getRecipeIdFromPath(path);
-        const bytes = readFileSync(path);
-        const stat = statSync(path);
-        const config = RecipesReferences.readRawRecipeConfig(path);
-        const resolved = RecipesReferences.readResolvedRecipeConfig(path);
-        const diagnostics = getRecipeConfigDiagnostics(path, resolved);
-        const sourceRun = String(config?.description ?? "").match(/spawn run ([^\s]+)/)?.[1];
-        const preview = templatePreview(config?.template);
-        const riskLabels = getRecipeRiskLabels(resolved);
-        return {
-            id,
-            path,
-            sha256: createHash("sha256").update(bytes).digest("hex"),
-            size: bytes.byteLength,
-            created_at: stat.birthtime.toISOString(),
-            modified_at: stat.mtime.toISOString(),
-            valid: Boolean(resolved),
-            diagnostics,
-            ...(riskLabels.length ? { risk_labels: riskLabels } : {}),
-            ...(config?.description ? { description: config.description } : {}),
-            ...(sourceRun ? { source_run: sourceRun } : {}),
-            ...(config?.async !== undefined ? { async: config.async } : {}),
-            ...(preview ? { template_preview: preview } : {}),
-        };
+        for (let attempt = 0; attempt < 3; attempt += 1) {
+            const id = RecipesReferences.getRecipeIdFromPath(path);
+            const bytes = readFileSync(path);
+            const fingerprint = createHash("sha256").update(bytes).digest("hex");
+            const stat = statSync(path);
+            const config = RecipesReferences.readRawRecipeConfig(path);
+            const resolved = RecipesReferences.readResolvedRecipeConfig(path);
+            const diagnostics = getRecipeConfigDiagnostics(path, resolved);
+            const after = readFileSync(path);
+            if (createHash("sha256").update(after).digest("hex") !== fingerprint) {
+                continue;
+            }
+            const sourceRun = String(config?.description ?? "").match(/spawn run ([^\s]+)/)?.[1];
+            const preview = templatePreview(config?.template);
+            const riskLabels = getRecipeRiskLabels(resolved);
+            return {
+                id,
+                path,
+                sha256: fingerprint,
+                size: bytes.byteLength,
+                created_at: stat.birthtime.toISOString(),
+                modified_at: stat.mtime.toISOString(),
+                valid: Boolean(resolved),
+                diagnostics,
+                ...(riskLabels.length ? { risk_labels: riskLabels } : {}),
+                ...(config?.description ? { description: config.description } : {}),
+                ...(sourceRun ? { source_run: sourceRun } : {}),
+                ...(config?.async !== undefined ? { async: config.async } : {}),
+                ...(preview ? { template_preview: preview } : {}),
+            };
+        }
+        throw new Error(`Draft changed repeatedly during inventory: ${path}`);
     });
 }
 export function summarizeDiscovery(result) {

package/dist/lib/recipes-usage.d.ts

@@ -1,9 +1,21 @@
 /**
- * Recipe usage metadata helpers
- * Zones: recipe telemetry, muscle-memory cleanup evidence
- * Owns lightweight launch counters for user-owned recipe files
+ * Recipe usage and name-based lineage metadata.
+ * Zones: recipe lineage, launch telemetry, revision history, migration
+ * Owns priority-compatible recipe names and lifetime/revision counters for user recipes.
  */
 export type RecipeLaunchKind = "direct" | "spawn" | "tool";
-export declare function getRecipeUsagePath(path: string): string;
-export declare function readRecipeUsage(path: string): Record<string, unknown> | undefined;
-export declare function recordRecipeLaunch(path: string, now?: Date, kind?: RecipeLaunchKind): boolean;
+export declare function getRecipeUsageIndexPath(recipeRoot: string): string;
+export declare function getRecipeUsageLedgerPath(lineageName: string, recipeRoot: string): string;
+export declare const RECIPE_REVISION_SNAPSHOT_LIMIT = 32;
+export declare function getRecipeRevisionSnapshotPath(lineageName: string, revision: number, recipeRoot: string): string;
+export declare function readRecipeUsage(path: string, recipeRoot?: string): Record<string, unknown> | undefined;
+export declare function ensureRecipeLineage(path: string, now?: Date, recipeRoot?: string): boolean;
+export declare function isCurrentRecipeRevisionReviewed(path: string, recipeRoot?: string): boolean;
+export interface RecipeLaunchRecordOptions {
+    onMutationLockContention?(): void;
+}
+export declare function recordRecipeLaunch(path: string, now?: Date, kind?: RecipeLaunchKind, recipeRoot?: string, options?: RecipeLaunchRecordOptions): boolean;
+export declare function recordRecipeReview(path: string, reviewEpoch: string, now?: Date, recipeRoot?: string): boolean;
+export declare function recordRecipeRollback(path: string, rollbackRevision: number, now?: Date, recipeRoot?: string): boolean;
+export declare function retireRecipeUsage(path: string, recipeRoot?: string): boolean;
+export declare function moveRecipeUsage(fromPath: string, toPath: string, recipeRoot?: string): boolean;