@llblab/pi-actors 0.45.0 → 0.45.1

package/AGENTS.md

@@ -44,6 +44,7 @@ Pi host
 
 ## Key Domains
 
+- `extension-runtime.ts`: low-level Pi session lifecycle, tool adaptation, and runtime service composition behind the thin `index.ts` event-registration root.
 - `command-templates.ts`: portable synchronous execution graph.
 - `recipes-references.ts`, `recipes-discovery.ts`, `recipe-control.ts`: Recipe resolution, imports, shadowing, and Control declarations.
 - `async-runs.ts`: lifecycle facade.
@@ -135,6 +136,7 @@ When a deferred Run result gates the next step, wait for its terminal follow-up.
 ## Documentation and Release Discipline
 
 - Keep published text portable: use `~`, `<repo>`, or relative paths.
+- Keep executable JavaScript and TypeScript blocks compact: no blank lines inside function bodies or control-flow blocks. Structural object, type, interface, class, and module bodies are exempt.
 - Update `skills/actors/SKILL.md` when durable operating mechanics change.
 - Keep `skills/swarm/SKILL.md` focused on multi-agent methodology rather than kernel internals.
 - Recipe `description` is optional because discovery supplies stable fallback tool copy; packaged Recipe QA must report zero diagnostics and zero release-blocking warnings without component boilerplate.

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 > Each release keeps at most 8 outcome records of at most 512 characters.
 
+## 0.45.1: Entrypoint and Release Policy
+
+- `Architecture`: Keeps `index.ts` as a thin Pi event-registration and composition root while moving session lifecycle, runtime service composition, Skill discovery, and tool adaptation into the acyclic `extension-runtime.ts` domain.
+- `Release Policy`: Raises the fixed shipped-source ceiling to 32,000 lines and rejects blank lines inside executable JavaScript/TypeScript blocks across the complete source and test tree while exempting structural declarations.
+- `Package Metadata`: Moves the package image to the new raw-content endpoint to restore cross-origin loading.
+
 ## 0.45.0: Skill Recipe Standard Library
 
 - `Recipe Values`: Makes inline argument defaults optional, applies caller > values > defaults > inline precedence across tools, Runs, imports, and delegation, and validates final typed/enum values plus duplicate, unknown-default, and conflicting-type declarations.

package/README.md

@@ -1,5 +1,7 @@
 # pi-actors
 
+![pi-actors banner](https://raw.githubusercontent.com/llblab/pi-actors/main/banner.jpg)
+
 Local Run kernel and persistent tool registry for [Pi](https://github.com/badlogic/pi-mono).
 
 ```text

package/dist/index.d.ts

@@ -1,8 +1,7 @@
 /**
  * pi-actors — actor runtime and persistent local tool registry for pi.
  * Zones: composition root, pi agent, actor runtime
- *
- * Wraps command templates as callable pi tools, stores durable user tools as recipe files, and exposes actor orchestration across reloads and sessions.
+ * Owns extension composition and Pi event registration, not domain behavior.
  */
 import * as Pi from "./lib/pi.ts";
 export default function toolRegistryExtension(pi: Pi.ExtensionAPI): void;

package/dist/index.js

@@ -1,117 +1,17 @@
 /**
  * pi-actors — actor runtime and persistent local tool registry for pi.
  * Zones: composition root, pi agent, actor runtime
- *
- * Wraps command templates as callable pi tools, stores durable user tools as recipe files, and exposes actor orchestration across reloads and sessions.
+ * Owns extension composition and Pi event registration, not domain behavior.
  */
-import * as AutomaticReviewRuntime from "./lib/automatic-review-runtime.js";
-import * as CommandTemplates from "./lib/command-templates.js";
+import * as ExtensionRuntime from "./lib/extension-runtime.js";
 import * as InspectorCommand from "./lib/inspector-command.js";
-import * as Paths from "./lib/paths.js";
-import * as Pi from "./lib/pi.js";
-import * as Prompts from "./lib/prompts.js";
-import * as RecipesReferences from "./lib/recipes-references.js";
-import * as RunUiRuntime from "./lib/run-ui-runtime.js";
-import * as Runtime from "./lib/runtime.js";
-import * as Temp from "./lib/temp.js";
-import * as Tools from "./lib/tools.js";
-import * as ToolsResponse from "./lib/tools-response.js";
 export default function toolRegistryExtension(pi) {
-    let activeRunContext;
-    const getRunOwnerId = Pi.getSessionId;
-    const automaticReview = AutomaticReviewRuntime.createAutomaticReviewRuntime({
-        getActiveContext: () => activeRunContext,
-        getRunOwnerId,
-        getThinkingLevel: () => pi.getThinkingLevel(),
-    });
-    const runUiRuntime = RunUiRuntime.createRunUiRuntime({
-        getActiveContext: () => activeRunContext,
-        getRunOwnerId,
-        onRunEvent: automaticReview.schedule,
-        pi,
-    });
-    const actorToolDefinitions = new Map();
-    const withCurrentThinkingContext = (definition) => {
-        if (typeof definition.execute !== "function")
-            return definition;
-        const execute = definition.execute;
-        return {
-            ...definition,
-            execute: async (...args) => {
-                const nextArgs = [...args];
-                const ctx = nextArgs[4];
-                if (ctx && typeof ctx === "object") {
-                    nextArgs[4] = {
-                        ...ctx,
-                        getThinkingLevel: () => pi.getThinkingLevel(),
-                    };
-                }
-                try {
-                    return ToolsResponse.spaceToolResult(await execute(...nextArgs));
-                }
-                catch (error) {
-                    throw ToolsResponse.spaceToolError(error);
-                }
-            },
-        };
-    };
-    const runtime = Runtime.createAutoToolsRuntime({
-        configPath: Paths.EXTENSION_RUNTIME_PATHS.configPath,
-        exec: CommandTemplates.execCommandTemplate,
-        getActiveTools: () => pi.getActiveTools(),
-        registerTool: (definition) => {
-            const wrapped = withCurrentThinkingContext(definition);
-            actorToolDefinitions.set(wrapped.name, wrapped);
-            pi.registerTool(wrapped);
-        },
-        reservedToolNames: Tools.RESERVED_TOOL_NAMES,
-        setActiveTools: (toolNames) => pi.setActiveTools(toolNames),
-    });
-    const recipeReload = Runtime.createRecipeToolReloadWatcher(runtime);
-    pi.on("resources_discover", async () => {
-        const skillPaths = Paths.getExistingExtensionSkillPaths(import.meta.url);
-        if (skillPaths.length === 0)
-            return;
-        return { skillPaths };
-    });
-    pi.on("session_start", async (_event, ctx) => {
-        // Clear the pre-overlay widget after hot reloads from older pi-actors builds.
-        ctx.ui.setWidget("zz-pi-actors-comms", undefined);
-        activeRunContext = ctx;
-        runUiRuntime.close();
-        automaticReview.close();
-        recipeReload.close();
-        await Temp.prepareExtensionTempDir(Paths.EXTENSION_RUNTIME_PATHS.tempDir);
-        if (activeRunContext !== ctx)
-            return;
-        automaticReview.start(ctx);
-        runtime.loadTools(ctx);
-        runUiRuntime.start(ctx);
-        recipeReload.watch(ctx);
-    });
-    pi.on("agent_end", async (_event, ctx) => {
-        if (activeRunContext === ctx)
-            automaticReview.schedule();
-    });
-    pi.on("session_shutdown", async (event, ctx) => {
-        activeRunContext = undefined;
-        automaticReview.close();
-        recipeReload.close();
-        runUiRuntime.shutdown(event.reason, ctx);
-    });
-    InspectorCommand.registerActorInspectorCommand(pi, getRunOwnerId);
-    pi.on("before_agent_start", async (event) => {
-        RecipesReferences.setActiveSkillRecipeSources(event.systemPromptOptions.skills ?? []);
-        return {
-            systemPrompt: `${event.systemPrompt}\n\n${Prompts.ONBOARDING_SYSTEM_PROMPT}`,
-        };
-    });
-    Pi.registerToolDefinitions(pi, Tools.createCoreActorToolDefinitions({
-        configPath: Paths.EXTENSION_RUNTIME_PATHS.configPath,
-        getActiveTools: () => pi.getActiveTools(),
-        getRuntimeTool: (name) => Tools.resolveActiveRuntimeTool(name, runtime.getTools(), (activeName) => actorToolDefinitions.get(activeName)),
-        handleRuntimeControl: automaticReview.handleControl,
-        registryRuntime: runtime,
-        setActiveTools: (toolNames) => pi.setActiveTools(toolNames),
-    }).map(withCurrentThinkingContext));
+    const runtime = ExtensionRuntime.createActorExtensionRuntime(pi);
+    pi.on("resources_discover", async () => runtime.discoverResources(import.meta.url));
+    pi.on("session_start", async (_event, ctx) => runtime.onSessionStart(ctx));
+    pi.on("agent_end", async (_event, ctx) => runtime.onAgentEnd(ctx));
+    pi.on("session_shutdown", async (event, ctx) => runtime.onSessionShutdown(event.reason, ctx));
+    pi.on("before_agent_start", async (event) => runtime.beforeAgentStart(event.systemPrompt, event.systemPromptOptions.skills ?? []));
+    InspectorCommand.registerActorInspectorCommand(pi, runtime.getRunOwnerId);
+    runtime.registerCoreTools();
 }

package/dist/lib/extension-runtime.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Pi actor extension runtime coordinator.
+ * Zones: extension session lifecycle, host tool adaptation, runtime service composition
+ * Owns low-level Pi lifecycle effects and tool wrapping without owning event registration.
+ */
+import * as Pi from "./pi.ts";
+import * as RecipesReferences from "./recipes-references.ts";
+export interface ActorExtensionRuntime {
+    beforeAgentStart(systemPrompt: string, skills: RecipesReferences.ActiveSkillRecipeSource[]): {
+        systemPrompt: string;
+    };
+    discoverResources(metaUrl: string): {
+        skillPaths: string[];
+    } | undefined;
+    getRunOwnerId(ctx: Pi.ExtensionContext): string;
+    onAgentEnd(ctx: Pi.ExtensionContext): void;
+    onSessionShutdown(reason: string, ctx: Pi.ExtensionContext): void;
+    onSessionStart(ctx: Pi.ExtensionContext): Promise<void>;
+    registerCoreTools(): void;
+}
+export declare function createActorExtensionRuntime(pi: Pi.ExtensionAPI): ActorExtensionRuntime;

package/dist/lib/extension-runtime.js

@@ -0,0 +1,116 @@
+/**
+ * Pi actor extension runtime coordinator.
+ * Zones: extension session lifecycle, host tool adaptation, runtime service composition
+ * Owns low-level Pi lifecycle effects and tool wrapping without owning event registration.
+ */
+import * as AutomaticReviewRuntime from "./automatic-review-runtime.js";
+import * as CommandTemplates from "./command-templates.js";
+import * as Paths from "./paths.js";
+import * as Pi from "./pi.js";
+import * as Prompts from "./prompts.js";
+import * as RecipesReferences from "./recipes-references.js";
+import * as RunUiRuntime from "./run-ui-runtime.js";
+import * as Runtime from "./runtime.js";
+import * as Temp from "./temp.js";
+import * as Tools from "./tools.js";
+import * as ToolsResponse from "./tools-response.js";
+export function createActorExtensionRuntime(pi) {
+    let activeRunContext;
+    const getRunOwnerId = Pi.getSessionId;
+    const automaticReview = AutomaticReviewRuntime.createAutomaticReviewRuntime({
+        getActiveContext: () => activeRunContext,
+        getRunOwnerId,
+        getThinkingLevel: () => pi.getThinkingLevel(),
+    });
+    const runUiRuntime = RunUiRuntime.createRunUiRuntime({
+        getActiveContext: () => activeRunContext,
+        getRunOwnerId,
+        onRunEvent: automaticReview.schedule,
+        pi,
+    });
+    const actorToolDefinitions = new Map();
+    const withCurrentThinkingContext = (definition) => {
+        if (typeof definition.execute !== "function")
+            return definition;
+        const execute = definition.execute;
+        return {
+            ...definition,
+            execute: async (...args) => {
+                const nextArgs = [...args];
+                const ctx = nextArgs[4];
+                if (ctx && typeof ctx === "object") {
+                    nextArgs[4] = {
+                        ...ctx,
+                        getThinkingLevel: () => pi.getThinkingLevel(),
+                    };
+                }
+                try {
+                    return ToolsResponse.spaceToolResult(await execute(...nextArgs));
+                }
+                catch (error) {
+                    throw ToolsResponse.spaceToolError(error);
+                }
+            },
+        };
+    };
+    const runtime = Runtime.createAutoToolsRuntime({
+        configPath: Paths.EXTENSION_RUNTIME_PATHS.configPath,
+        exec: CommandTemplates.execCommandTemplate,
+        getActiveTools: () => pi.getActiveTools(),
+        registerTool: (definition) => {
+            const wrapped = withCurrentThinkingContext(definition);
+            actorToolDefinitions.set(wrapped.name, wrapped);
+            pi.registerTool(wrapped);
+        },
+        reservedToolNames: Tools.RESERVED_TOOL_NAMES,
+        setActiveTools: (toolNames) => pi.setActiveTools(toolNames),
+    });
+    const recipeReload = Runtime.createRecipeToolReloadWatcher(runtime);
+    return {
+        beforeAgentStart(systemPrompt, skills) {
+            RecipesReferences.setActiveSkillRecipeSources(skills);
+            return {
+                systemPrompt: `${systemPrompt}\n\n${Prompts.ONBOARDING_SYSTEM_PROMPT}`,
+            };
+        },
+        discoverResources(metaUrl) {
+            const skillPaths = Paths.getExistingExtensionSkillPaths(metaUrl);
+            return skillPaths.length > 0 ? { skillPaths } : undefined;
+        },
+        getRunOwnerId,
+        onAgentEnd(ctx) {
+            if (activeRunContext === ctx)
+                automaticReview.schedule();
+        },
+        onSessionShutdown(reason, ctx) {
+            activeRunContext = undefined;
+            automaticReview.close();
+            recipeReload.close();
+            runUiRuntime.shutdown(reason, ctx);
+        },
+        async onSessionStart(ctx) {
+            ctx.ui.setWidget("zz-pi-actors-comms", undefined);
+            activeRunContext = ctx;
+            runUiRuntime.close();
+            automaticReview.close();
+            recipeReload.close();
+            await Temp.prepareExtensionTempDir(Paths.EXTENSION_RUNTIME_PATHS.tempDir);
+            if (activeRunContext !== ctx)
+                return;
+            automaticReview.start(ctx);
+            runtime.loadTools(ctx);
+            runUiRuntime.start(ctx);
+            recipeReload.watch(ctx);
+        },
+        registerCoreTools() {
+            Pi.registerToolDefinitions(pi, Tools.createCoreActorToolDefinitions({
+                configPath: Paths.EXTENSION_RUNTIME_PATHS.configPath,
+                getActiveTools: () => pi.getActiveTools(),
+                getRuntimeTool: (name) => Tools.resolveActiveRuntimeTool(name, runtime.getTools(), (activeName) => actorToolDefinitions.get(activeName)),
+                handleRuntimeControl: automaticReview.handleControl,
+                registryRuntime: runtime,
+                setActiveTools: (toolNames) => pi.setActiveTools(toolNames),
+            }).map(withCurrentThinkingContext));
+        },
+    };
+}

package/dist/scripts/async-runner.mjs

@@ -74,7 +74,6 @@ function summarizeCommandDetail(commandDetail) {
 
 export async function runAsyncRunner(stateDir = process.argv[2]) {
   if (!stateDir) throw new Error("missing state dir");
-
   const runPath = join(stateDir, "run.json");
   const progressPath = join(stateDir, "progress.json");
   const resultPath = join(stateDir, "result.json");
@@ -83,11 +82,9 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
   const stderrPath = join(stateDir, "stderr.log");
   const executionPath = join(stateDir, "execution.json");
   const meta = JSON.parse(readFileSync(runPath, "utf8"));
-
   function event(kind, data = {}) {
     appendRunTraceEvent(stateDir, { kind, data });
   }
-
   function observation(kind, summary, data = {}, delivery = "log", level = "info") {
     appendRunTraceEvent(stateDir, {
       kind,
@@ -97,7 +94,6 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
       ...(level === "error" ? { level: "error" } : {}),
     });
   }
-
   function progress(phase, extra = {}) {
     writeJsonAtomic(progressPath, {
       ...(meta.model_policy ? { model_policy: meta.model_policy } : {}),
@@ -106,7 +102,6 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
       ...extra,
     });
   }
-
   let activeSubagents = 0;
   let completedSubagents = 0;
   let promptCounter = 0;
@@ -115,7 +110,6 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
   const evidenceRecords = [];
   const stageOccurrences = new Map();
   let reportEvidence;
-
   function writeExecutionManifest(status) {
     writeJsonAtomic(executionPath, {
       version: 1,
@@ -129,7 +123,6 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
       updated_at: new Date().toISOString(),
     });
   }
-
   function commandSessionFiles(sessionDir) {
     if (!sessionDir) return [];
     try {
@@ -141,7 +134,6 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
       return [];
     }
   }
-
   function commandEvidenceStartRecord({
     commandDetail,
     commandId,
@@ -181,7 +173,6 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
           : "not_required",
     };
   }
-
   function commandEvidenceRecord({
     captureDir,
     commandDetail,
@@ -273,7 +264,6 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
             : "rejected",
     };
   }
-
   function auditReviewReport(text) {
     const required = evidenceRecords
       .filter((record) =>
@@ -294,11 +284,9 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
       complete_allowed: missing.length === 0,
     };
   }
-
   function getCommandDoneDelivery(result) {
     return result.code !== 0 || activeSubagents > 0 ? "followup" : "log";
   }
-
   function progressRunning() {
     progress("running", {
       activeSubagents,
@@ -306,14 +294,12 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
       failures: subagentFailures,
     });
   }
-
   function promptFilePath() {
     promptCounter += 1;
     const dir = join(stateDir, "prompts");
     mkdirSync(dir, { recursive: true });
     return join(dir, `command-${String(promptCounter).padStart(3, "0")}.md`);
   }
-
   function readPromptText(promptFile) {
     if (!promptFile) return undefined;
     try {
@@ -322,7 +308,6 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
       return undefined;
     }
   }
-
   async function observedExec(command, args, options) {
     captureCounter += 1;
     const commandId = `command-${String(captureCounter).padStart(3, "0")}`;
@@ -485,7 +470,6 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
     progressRunning();
     return result;
   }
-
   try {
     event("run.runner.start", { pid: process.pid });
     progressRunning();

package/dist/scripts/executable-block-style.d.mts

@@ -0,0 +1 @@
+export function executableBlockBlankLines(source: string): number[];

package/dist/scripts/executable-block-style.mjs

@@ -0,0 +1,73 @@
+/** Detect blank lines inside executable JavaScript and TypeScript blocks. */
+
+export function executableBlockBlankLines(source) {
+  const lines = source.split(/\r?\n/u);
+  const blanks = [];
+  const stack = [];
+  let blockComment = false;
+  let currentExecutableDepth = 0;
+  let previousCode = "";
+  let quote;
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+    const line = lines[lineIndex];
+    if (
+      /^\s*$/u.test(line) &&
+      currentExecutableDepth > 0 &&
+      quote !== "`"
+    )
+      blanks.push(lineIndex + 1);
+    let code = "";
+    let regularExpression = false;
+    for (let index = 0; index < line.length; index += 1) {
+      const char = line[index];
+      const next = line[index + 1];
+      if (blockComment) {
+        if (char === "*" && next === "/") {
+          blockComment = false;
+          index += 1;
+        }
+        continue;
+      }
+      if (quote) {
+        if (char === "\\") index += 1;
+        else if (char === quote) quote = undefined;
+        continue;
+      }
+      if (regularExpression) {
+        if (char === "\\") index += 1;
+        else if (char === "/") regularExpression = false;
+        continue;
+      }
+      if (char === "/" && next === "*") {
+        blockComment = true;
+        index += 1;
+        continue;
+      }
+      if (char === "/" && next === "/") break;
+      if (
+        char === "/" &&
+        /^(?:|.*(?:[=(,:;!&|?{}]|\b(?:return|case|throw)))\s*$/u.test(code)
+      ) {
+        regularExpression = true;
+        continue;
+      }
+      if (char === '"' || char === "'" || char === "`") {
+        quote = char;
+        continue;
+      }
+      if (char === "{") {
+        const prefix = code.trimEnd() || previousCode;
+        const executable =
+          /\)\s*$|=>\s*$|\b(?:else|try|finally|do)\s*$/u.test(prefix);
+        stack.push(executable);
+        if (executable) currentExecutableDepth += 1;
+      } else if (char === "}") {
+        if (stack.pop()) currentExecutableDepth -= 1;
+      }
+      code += char;
+    }
+    if (quote !== "`") quote = undefined;
+    if (code.trim()) previousCode = code.trim();
+  }
+  return blanks;
+}

package/dist/scripts/locker.mjs

@@ -65,7 +65,6 @@ async function runLocker(argv = process.argv.slice(2)) {
   const controlPath = join(stateDir, "control.fifo");
   let runInstanceId;
   mkdirSync(stateDir, { recursive: true });
-
   function readJson(path, fallback) {
     if (!existsSync(path)) return fallback;
     try {
@@ -74,11 +73,9 @@ async function runLocker(argv = process.argv.slice(2)) {
       return fallback;
     }
   }
-
   function writeJson(path, value) {
     writeJsonAtomic(path, value);
   }
-
   function getControlEndpoint() {
     if (process.platform !== "win32") return { path: controlPath, type: "fifo" };
     const hash = createHash("sha256")
@@ -87,7 +84,6 @@ async function runLocker(argv = process.argv.slice(2)) {
       .slice(0, 20);
     return { path: `\\\\.\\pipe\\pi-actors-locker-${hash}`, type: "named-pipe" };
   }
-
   function writeControlEndpoint(endpoint) {
     if (!runInstanceId) throw new Error("Run generation unavailable for Control endpoint");
     writeJson(join(stateDir, "control-endpoint.json"), {
@@ -96,7 +92,6 @@ async function runLocker(argv = process.argv.slice(2)) {
       run_instance_id: runInstanceId,
     });
   }
-
   function journal(event, data = {}) {
     const release = acquireFileMutationLock(journalPath);
     try {
@@ -111,11 +106,9 @@ async function runLocker(argv = process.argv.slice(2)) {
       writeTextAtomic(journalPath, content);
     } finally { release(); }
   }
-
   function encodeJournal(records) {
     return records.length ? `${records.map((record) => JSON.stringify(record)).join("\n")}\n` : "";
   }
-
   function emitTrace(kind, summary, data = {}, level = "info") {
     appendRunTraceEvent(stateDir, {
       attention: "followup",
@@ -125,11 +118,9 @@ async function runLocker(argv = process.argv.slice(2)) {
       summary,
     });
   }
-
   function now() {
     return Date.now();
   }
-
   function cleanExpiredLocks(locks) {
     const current = now();
     const kept = {};
@@ -139,7 +130,6 @@ async function runLocker(argv = process.argv.slice(2)) {
     }
     return kept;
   }
-
   function normalizeControl(line) {
     const trimmed = line.trim();
     if (!trimmed) return undefined;
@@ -160,8 +150,6 @@ async function runLocker(argv = process.argv.slice(2)) {
       );
     }
   }
-
-
   function tailJournal(count) {
     if (!existsSync(journalPath)) return [];
     return readFileSync(journalPath, "utf8")
@@ -177,7 +165,6 @@ async function runLocker(argv = process.argv.slice(2)) {
         }
       });
   }
-
   function printSnapshot() {
     const locks = cleanExpiredLocks(readJson(locksPath, {}));
     writeJson(locksPath, locks);
@@ -195,7 +182,6 @@ async function runLocker(argv = process.argv.slice(2)) {
       ),
     );
   }
-
   function nextTask(queue, locks) {
     const items = Array.isArray(queue.items) ? queue.items : [];
     const index = items.findIndex((item) => {
@@ -205,7 +191,6 @@ async function runLocker(argv = process.argv.slice(2)) {
     if (index < 0) return undefined;
     return items.splice(index, 1)[0];
   }
-
   function handle(control) {
     const action = control.action;
     const body =
@@ -333,18 +318,15 @@ async function runLocker(argv = process.argv.slice(2)) {
     journal("lock.unknown", { action, input: body });
     emitTrace("lock.unknown", `Unknown Control ${action}`, { action, input: body }, "warning");
   }
-
   if (mode === "snapshot") {
     printSnapshot();
     process.exit(0);
   }
-
   const startupRun = readJson(join(stateDir, "run.json"), undefined);
   if (!startupRun || typeof startupRun.run_instance_id !== "string") {
     throw new Error("Run generation unavailable for Control service");
   }
   runInstanceId = startupRun.run_instance_id;
-
   function handleLine(line) {
     const control = normalizeControl(line);
     if (!control) return false;
@@ -376,7 +358,6 @@ async function runLocker(argv = process.argv.slice(2)) {
       return false;
     }
   }
-
   async function serveFifo(endpoint) {
     if (!existsSync(endpoint.path)) {
       const result = spawnSync("mkfifo", [endpoint.path]);
@@ -403,7 +384,6 @@ async function runLocker(argv = process.argv.slice(2)) {
       fs.closeSync(fd);
     }
   }
-
   async function serveNamedPipe(endpoint) {
     let resolveStopped;
     const stopped = new Promise((resolve) => {
@@ -428,7 +408,6 @@ async function runLocker(argv = process.argv.slice(2)) {
     });
     await stopped;
   }
-
   const endpoint = getControlEndpoint();
   writeJson(queuePath, readJson(queuePath, { items: [] }));
   writeJson(locksPath, cleanExpiredLocks(readJson(locksPath, {})));

package/dist/scripts/recipe-utils.mjs

@@ -369,7 +369,6 @@ if (!command) {
   usage();
   process.exit(1);
 }
-
 if (command === "run-summary")
   runSummary(args[0] ?? "~/.pi/agent/tmp/pi-actors/runs");
 else if (command === "run-ops-snapshot")