@llblab/pi-actors 0.42.0 → 0.42.2

package/lib/prompts.ts

@@ -29,7 +29,7 @@ export const ONBOARDING_SYSTEM_PROMPT = `pi-actors quick model:
 - Recipe imports are local variables; imported recipes are definitions, not nested async runs; parent async:true creates one run.
 - Actor-mode trigger: if work may outlive this turn, need steering/follow-up/artifacts, run as a service, fan out, or be resumed/inspected later, use spawn -> message -> inspect instead of ad hoc shell backgrounding.
 - Use spawn/message/inspect for actor-level start/send/observe; short foreground checks can stay ordinary tools/templates; avoid runtime/FIFO/outbox vocabulary in public guidance.
-- Run state lives under ~/.pi/agent/tmp/pi-actors/runs. Inspect intentionally and avoid busy-polling. Terminal and coordinator-bound notifications queue as Pi follow-ups so concurrently completed actors can reach the coordinator after current work instead of steering between tool calls. When a deferred actor result gates the next step, wait for its terminal follow-up; do not schedule continuation loops, repeatedly inspect, or mutate its reviewed scope while it runs. Inspect early only for an operator request, a meaningful actor event, or diagnosis of an overdue/stuck run.
+- Run state lives under ~/.pi/agent/tmp/pi-actors/runs. Inspect intentionally and avoid busy-polling. Terminal and coordinator-bound notifications queue as Pi follow-ups so concurrently completed actors can reach the coordinator after current work instead of steering between tool calls. Terminal follow-up content stays minimal: run, status, one base path, and relative artifact names only; semantic output stays in non-LLM details and run state. When a deferred actor result gates the next step, wait for its terminal follow-up; do not schedule continuation loops, repeatedly inspect, or mutate its reviewed scope while it runs. Inspect early only for an operator request, a meaningful actor event, or diagnosis of an overdue/stuck run.
 - Maintain ~/.pi/agent/recipes like MEMORY.md for capabilities: keep useful tools, curate stale ones, and fix/remove/disable invalid recipes flagged by registry warnings; packaged/ad hoc recipes are lower-priority components; offer to save successful recurring patterns only after confirmation.
 - Prefer maintained packaged recipes/pipelines with spawn file=<recipe> before ad hoc scripts/wrappers; review swarms inherit current model/thinking, preflight before fanout, and expose quorum/concurrency/TTL knobs unless explicit args are passed.
 - For any non-trivial actor use or pi-actors change, read the bundled actors skill first. Before launching multiple actors/subagents for parallel implementation, independent artifact generation, delegated audit, or review, also read the bundled swarm skill; the coordinator owns decomposition, disjoint scopes, launch correctness, integration, and final validation. For deeper guidance, inspect installed extension sources/docs/recipes because README/docs are not automatically in context.`;

package/lib/runs-control.ts

@@ -42,6 +42,7 @@ export function getRunProcessSignalPlan(
 export interface RunProcessSignalDeps {
   killProcess?: typeof process.kill;
   runtimePlatform?: NodeJS.Platform;
+  spawnProcess?: typeof spawnSync;
   verifyIdentity?: (
     pid: number,
     expected: RunProcessIdentity,
@@ -70,8 +71,26 @@ export function signalOwnedRunProcess(
   }
   const plan = getRunProcessSignalPlan(pid, signal, runtimePlatform);
   if (plan.command && plan.args) {
-    const result = spawnSync(plan.command, plan.args, { encoding: "utf8" });
+    const spawnProcess = deps.spawnProcess ?? spawnSync;
+    let result = spawnProcess(plan.command, plan.args, { encoding: "utf8" });
+    if (
+      runtimePlatform === "win32" &&
+      result.status !== 0 &&
+      !plan.args.includes("/F")
+    ) {
+      result = spawnProcess(plan.command, [...plan.args, "/F"], {
+        encoding: "utf8",
+      });
+    }
     if (result.status !== 0) {
+      if (expectedIdentity) {
+        const finalProof = (deps.verifyIdentity ?? verifyRunProcessIdentity)(
+          pid,
+          expectedIdentity,
+          runtimePlatform,
+        );
+        if (finalProof.status === "dead_pid") return plan;
+      }
       throw new Error(
         result.stderr?.trim() ||
           result.stdout?.trim() ||

package/lib/runs-ownership.ts

@@ -12,7 +12,8 @@ import {
   realpathSync,
 } from "node:fs";
 import { randomUUID } from "node:crypto";
-import { join, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { isAbsolute, join, relative, resolve } from "node:path";
 
 import { writeJsonAtomic } from "./file-state.ts";
 
@@ -35,13 +36,31 @@ function comparablePath(path: string): string {
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 
+function isSystemTempRootAlias(resolved: string, canonical: string): boolean {
+  const tempRoot = resolve(tmpdir());
+  const relativeStateDir = relative(tempRoot, resolved);
+  if (
+    relativeStateDir === ".." ||
+    relativeStateDir.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) ||
+    isAbsolute(relativeStateDir)
+  ) {
+    return false;
+  }
+  const canonicalTempRoot = realpathSync.native(tempRoot);
+  const expectedCanonical = resolve(canonicalTempRoot, relativeStateDir);
+  return comparablePath(canonical) === comparablePath(expectedCanonical);
+}
+
 function assertCanonicalDirectory(stateDir: string): string {
   const resolved = resolve(stateDir);
   if (lstatSync(resolved).isSymbolicLink()) {
     throw new Error(`Run state directory cannot be a symlink: ${resolved}`);
   }
-  const canonical = realpathSync(resolved);
-  if (comparablePath(canonical) !== comparablePath(resolved)) {
+  const canonical = realpathSync.native(resolved);
+  if (
+    comparablePath(canonical) !== comparablePath(resolved) &&
+    !isSystemTempRootAlias(resolved, canonical)
+  ) {
     throw new Error(`Run state directory has an ambiguous symlink alias: ${resolved}`);
   }
   return resolved;

package/lib/runs-process.ts

@@ -6,7 +6,7 @@
 import { spawnSync } from "node:child_process";
 import { existsSync, readFileSync, readlinkSync, realpathSync } from "node:fs";
 import { platform } from "node:os";
-import { resolve } from "node:path";
+import { posix, win32 } from "node:path";
 
 export interface RunProcessIdentity {
   command: string;
@@ -125,8 +125,9 @@ export function captureRunProcessIdentity(
   if (!identity.command.includes(runnerPath) || !identity.command.includes(stateDir)) {
     return undefined;
   }
-  const resolvedCwd = resolve(cwd);
-  const canonicalCwd = existsSync(resolvedCwd)
+  const pathApi = runtimePlatform === "win32" ? win32 : posix;
+  const resolvedCwd = pathApi.resolve(cwd);
+  const canonicalCwd = runtimePlatform === platform() && existsSync(resolvedCwd)
     ? realpathSync.native(resolvedCwd)
     : resolvedCwd;
   const expectedCwd =

package/lib/runs-start.ts

@@ -93,6 +93,7 @@ export function prepareStateDirForStart(
     "result.json",
     "stderr.log",
     "stdout.log",
+    "terminal-delivery-failure.json",
     "terminal-handled.json",
   ]) {
     rmSync(join(stateDir, file), { force: true });

package/lib/runs-status.ts

@@ -61,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"),
@@ -70,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/tools-inspect.ts

@@ -7,6 +7,7 @@
 import { execFileSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 
 import * as AsyncRuns from "./async-runs.ts";
 import * as Limits from "./limits.ts";
@@ -269,7 +270,7 @@ function getPiActorsRuntimeStatus(): Record<string, unknown> {
   } catch {
     git_commit = undefined;
   }
-  const entrypoint = new URL(import.meta.url).pathname;
+  const entrypoint = fileURLToPath(import.meta.url);
   return {
     automatic_recipe_review: Paths.isAutomaticRecipeReviewEnabled(),
     entrypoint,

package/lib/tools-local.ts

@@ -143,6 +143,14 @@ export function createRuntimeToolDefinition(
     paramSchema.run_id = Schema.stringSchema(
       "Optional run id override for this async template recipe invocation.",
     );
+  if (isAsyncRecipe) {
+    paramSchema.correlation_id = Schema.stringSchema(
+      "Optional workflow correlation id preserved in terminal follow-up delivery.",
+    );
+    paramSchema.transport_context = Schema.looseObjectSchema(
+      "Optional originating transport route preserved for detached terminal follow-up.",
+    );
+  }
   return {
     name: cfg.name,
     label: cfg.name,
@@ -155,7 +163,7 @@ export function createRuntimeToolDefinition(
         )
       : Prompts.formatRegisteredToolPromptSnippet(cfg.template),
     async execute(
-      _toolCallId: string,
+      toolCallId: string,
       params: unknown,
       signal: AbortSignal | undefined,
       _onUpdate: unknown,
@@ -172,7 +180,7 @@ export function createRuntimeToolDefinition(
         }
         if (isAsyncRecipe) {
           const input = params as Record<string, unknown>;
-          const { run_id, ...values } = input;
+          const { correlation_id, run_id, transport_context, ...values } = input;
           const base = cfg.recipe ? cfg.recipe : { file: String(cfg.template) };
           const runId =
             typeof run_id === "string" && run_id.trim()
@@ -182,6 +190,17 @@ export function createRuntimeToolDefinition(
             {
               ...base,
               launch_source: "tool",
+              launch_correlation: {
+                ...(typeof correlation_id === "string"
+                  ? { correlation_id } : {}),
+                tool_call_id: toolCallId,
+              },
+              ...(transport_context &&
+              typeof transport_context === "object" &&
+              !Array.isArray(transport_context)
+                ? {
+                    transport_context: transport_context as Record<string, unknown>,
+                  } : {}),
               ownerId: getRunOwnerId(ctx),
               run_id: runId,
               tool: cfg.name,

package/lib/tools-spawn.ts

@@ -144,6 +144,9 @@ export function createSpawnToolDefinition<
         as: Schema.stringSchema(
           "Optional actor address for the spawned run, e.g. run:<id>.",
         ),
+        correlation_id: Schema.stringSchema(
+          "Optional workflow correlation id preserved in terminal follow-up delivery.",
+        ),
         file: Schema.stringSchema(
           "Optional template recipe JSON file. Bare names resolve under ~/.pi/agent/recipes.",
         ),
@@ -162,6 +165,9 @@ export function createSpawnToolDefinition<
         values: Schema.looseObjectSchema(
           "Runtime placeholder values passed to the actor.",
         ),
+        transport_context: Schema.looseObjectSchema(
+          "Optional originating transport route preserved for detached terminal follow-up, e.g. Telegram chat_id and thread_id.",
+        ),
         verbose: Schema.booleanSchema(
           "Return full JSON instead of compact text.",
         ),
@@ -169,7 +175,7 @@ export function createSpawnToolDefinition<
       [],
     ),
     async execute(
-      _toolCallId: string,
+      toolCallId: string,
       params: unknown,
       _signal: AbortSignal | undefined,
       _onUpdate: unknown,
@@ -196,7 +202,14 @@ export function createSpawnToolDefinition<
           {
             file: recipe,
             launch_source: "spawn",
+            launch_correlation: {
+              ...(typeof input.correlation_id === "string"
+                ? { correlation_id: input.correlation_id } : {}),
+              tool_call_id: toolCallId,
+            },
             ownerId: getRunOwnerId(ctx),
+            ...(input.transport_context
+              ? { transport_context: asRecord(input.transport_context) } : {}),
             run_id: runId,
             ...(input.template !== undefined
               ? {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-actors",
-  "version": "0.42.0",
+  "version": "0.42.2",
   "private": false,
   "description": "Local Actor Kernel for Pi",
   "keywords": [
@@ -27,11 +27,12 @@
   "scripts": {
     "check": "node --experimental-strip-types -e \"await import('./index.ts'); console.log('pi-actors: extension import ok')\"",
     "conformance": "node scripts/conformance.mjs",
-    "test": "node --experimental-strip-types --test tests/*.test.ts",
+    "test": "node --experimental-strip-types --test --test-concurrency=1 tests/*.test.ts",
     "pack:dry": "npm pack --dry-run",
     "recipes:qa": "node scripts/validate-recipe.mjs recipes --all --qa --summary",
     "release:validate": "npm run validate && node scripts/release-gates.mjs",
-    "validate": "npx tsc --noEmit && npm run recipes:qa && npm run build && npm run check && npm test && npm run conformance && npm audit --audit-level=high && npm run pack:dry",
+    "validate": "npx tsc --noEmit && npm run recipes:qa && npm run build && npm run check && npm test && npm run conformance && npm run pack:dry",
+    "audit:dependencies": "npm audit --audit-level=high --omit=peer",
     "build": "node scripts/build-dist.mjs",
     "prepack": "npm run build"
   },

package/scripts/async-runner.mjs

@@ -135,7 +135,7 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
     try {
       return readdirSync(sessionDir, { withFileTypes: true })
         .filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl"))
-        .map((entry) => relative(stateDir, join(sessionDir, entry.name)))
+        .map((entry) => relative(stateDir, join(sessionDir, entry.name)).replaceAll("\\", "/"))
         .sort();
     } catch {
       return [];
@@ -167,12 +167,12 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
       ...(recipeContext ? { recipe_context: recipeContext } : {}),
       command: commandDetail,
       ...(materialized.promptFile
-        ? { prompt_file: relative(stateDir, materialized.promptFile) }
+        ? { prompt_file: relative(stateDir, materialized.promptFile).replaceAll("\\", "/") }
         : {}),
       ...(materialized.promptBytes
         ? { prompt_bytes: materialized.promptBytes }
         : {}),
-      ...(sessionDir ? { session_dir: relative(stateDir, sessionDir) } : {}),
+      ...(sessionDir ? { session_dir: relative(stateDir, sessionDir).replaceAll("\\", "/") } : {}),
       attempts: [],
       semantic_acceptance:
         options?.evidenceContext?.acceptOutput === "review_evidence" ||
@@ -209,11 +209,11 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
       attempts.push({
         attempt,
         stdout: {
-          path: relative(stateDir, stdoutFile),
+          path: relative(stateDir, stdoutFile).replaceAll("\\", "/"),
           bytes: existsSync(stdoutFile) ? statSync(stdoutFile).size : 0,
         },
         stderr: {
-          path: relative(stateDir, stderrFile),
+          path: relative(stateDir, stderrFile).replaceAll("\\", "/"),
           bytes: existsSync(stderrFile) ? statSync(stderrFile).size : 0,
         },
       });
@@ -248,12 +248,12 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
       ...(recipeContext ? { recipe_context: recipeContext } : {}),
       command: commandDetail,
       ...(materialized.promptFile
-        ? { prompt_file: relative(stateDir, materialized.promptFile) }
+        ? { prompt_file: relative(stateDir, materialized.promptFile).replaceAll("\\", "/") }
         : {}),
       ...(materialized.promptBytes
         ? { prompt_bytes: materialized.promptBytes }
         : {}),
-      ...(sessionDir ? { session_dir: relative(stateDir, sessionDir) } : {}),
+      ...(sessionDir ? { session_dir: relative(stateDir, sessionDir).replaceAll("\\", "/") } : {}),
       ...(commandSessionFiles(sessionDir).length > 0
         ? { session_files: commandSessionFiles(sessionDir) }
         : {}),
@@ -386,7 +386,7 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
       command: commandDetail,
       ...(materialized.promptFile ? { prompt_file: materialized.promptFile } : {}),
       ...(materialized.promptBytes ? { prompt_bytes: materialized.promptBytes } : {}),
-      ...(session.sessionDir ? { session_dir: relative(stateDir, session.sessionDir) } : {}),
+      ...(session.sessionDir ? { session_dir: relative(stateDir, session.sessionDir).replaceAll("\\", "/") } : {}),
     });
     progressRunning();
     const captureDir = join(stateDir, "captures", commandId);
@@ -457,7 +457,7 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
       ...captureDetails(result),
       ...(materialized.promptFile ? { prompt_file: materialized.promptFile } : {}),
       ...(materialized.promptBytes ? { prompt_bytes: materialized.promptBytes } : {}),
-      ...(session.sessionDir ? { session_dir: relative(stateDir, session.sessionDir) } : {}),
+      ...(session.sessionDir ? { session_dir: relative(stateDir, session.sessionDir).replaceAll("\\", "/") } : {}),
       ...(commandSessionFiles(session.sessionDir).length > 0
         ? { session_files: commandSessionFiles(session.sessionDir) }
         : {}),
@@ -517,6 +517,11 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
       };
       throw error;
     }
+    writeEvidenceManifest("done");
+    progress("done", {
+      completed: 1,
+      failures: result.details.nonCriticalFailures || [],
+    });
     writeJsonAtomic(resultPath, {
       code: result.details.code,
       command: result.details.command,
@@ -525,26 +530,11 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
       truncated: result.details.truncated,
       completedAt: new Date().toISOString(),
     });
-    writeEvidenceManifest("done");
-    progress("done", {
-      completed: 1,
-      failures: result.details.nonCriticalFailures || [],
-    });
     event("run.done", { code: result.details.code });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     const details = error && typeof error === "object" ? error.details : undefined;
     appendFileSync(stderrPath, `${message}\n`);
-    writeJsonAtomic(resultPath, {
-      code: typeof details?.code === "number" ? details.code : 1,
-      error: message,
-      killed: Boolean(details?.killed),
-      ...(Array.isArray(details?.branches) ? { branches: details.branches } : {}),
-      ...(details?.failureReason ? { failure_reason: details.failureReason } : {}),
-      ...(meta.model_policy ? { model_policy: meta.model_policy } : {}),
-      ...(details?.softQuorum ? { soft_quorum: details.softQuorum } : {}),
-      completedAt: new Date().toISOString(),
-    });
     writeEvidenceManifest("failed");
     progress("failed", {
       completed: 0,
@@ -555,6 +545,16 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
           : [{ message }],
       ...(details?.failureReason ? { failureReason: details.failureReason } : {}),
     });
+    writeJsonAtomic(resultPath, {
+      code: typeof details?.code === "number" ? details.code : 1,
+      error: message,
+      killed: Boolean(details?.killed),
+      ...(Array.isArray(details?.branches) ? { branches: details.branches } : {}),
+      ...(details?.failureReason ? { failure_reason: details.failureReason } : {}),
+      ...(meta.model_policy ? { model_policy: meta.model_policy } : {}),
+      ...(details?.softQuorum ? { soft_quorum: details.softQuorum } : {}),
+      completedAt: new Date().toISOString(),
+    });
     event("run.failed", {
       error: message,
       ...(details?.failureReason ? { failure_reason: details.failureReason } : {}),

package/scripts/build-dist.mjs

@@ -20,13 +20,18 @@ import { join } from "node:path";
 
 function run(command, args) {
   const result = spawnSync(command, args, { stdio: "inherit" });
+  if (result.error) throw result.error;
   if (result.status !== 0) process.exit(result.status ?? 1);
 }
 
 rmSync("dist", { recursive: true, force: true });
 mkdirSync("dist", { recursive: true });
 
-run("tsc", ["-p", "tsconfig.build.json"]);
+run(process.execPath, [
+  join("node_modules", "typescript", "bin", "tsc"),
+  "-p",
+  "tsconfig.build.json",
+]);
 
 mkdirSync(join("dist", "pi-actors"), { recursive: true });
 writeFileSync(

package/scripts/conformance.mjs

@@ -28,7 +28,12 @@ function packageRoot() {
 
 const result = spawnSync(
   process.execPath,
-  ["--experimental-strip-types", "--test", ...conformanceSuites],
+  [
+    "--experimental-strip-types",
+    "--test",
+    "--test-concurrency=1",
+    ...conformanceSuites,
+  ],
   { cwd: packageRoot(), encoding: "utf8", stdio: "pipe" },
 );
 

package/scripts/recipe-utils.mjs

@@ -16,7 +16,7 @@ import {
   statSync,
   writeFileSync,
 } from "node:fs";
-import { dirname, extname, join, relative, resolve } from "node:path";
+import { basename, dirname, extname, join, relative, resolve, sep } from "node:path";
 
 function usage() {
   console.error(`Usage:
@@ -101,7 +101,7 @@ function collectRunSummary(rootValue) {
   const root = resolve(
     rootValue.replace(/^~(?=\/|$)/, process.env.HOME ?? "~"),
   );
-  const files = walkFiles(root, 2).filter((file) => file.endsWith("/run.json"));
+  const files = walkFiles(root, 2).filter((file) => basename(file) === "run.json");
   const rows = [];
   for (const file of files) {
     const run = readJson(file);
@@ -118,7 +118,7 @@ function collectRunSummary(rootValue) {
     const progress = readJson(join(runDir, "progress.json"));
     const result = readJson(join(runDir, "result.json"));
     rows.push({
-      run: run.run_id ?? run.run ?? relative(root, file).split("/")[0],
+      run: run.run_id ?? run.run ?? relative(root, file).split(sep)[0],
       status: getRunStatus(run, progress, result),
       recipe: run.recipe ?? run.recipe_file ?? "",
       updated:

package/skills/actors/SKILL.md

@@ -2,7 +2,7 @@
 name: actors
 description: Required practical guide for non-trivial pi-actors use, including parallel actor launches, subagent fanout, and autonomous coordinator workflows. Read before using or changing spawn, message, inspect, actor runs, tools, recipes, command templates, async lifecycle, mailboxes, artifacts, and local orchestration mechanics.
 metadata:
-  version: 0.42.0
+  version: 0.42.2
 ---
 
 # Actors (pi-actors)
@@ -69,7 +69,7 @@ Rules:
 - Command-template strings execute directly without a shell. Operators such as `&&`, `||`, pipes, redirects, and `cd` remain literal argv unless an explicit trusted shell is the executable. Prefer absolute paths or template arrays for sequencing; put non-trivial shell behavior in a reviewed script.
 - Use `file`/`recipe` for saved recipes; bare names resolve under `~/.pi/agent/recipes`.
 - Use inline `template` for one-off experiments; promote useful repeats to recipes.
-- When a successful actor follow-up suggests persistence, decide whether the pattern deserves durable tool memory; call `register_tool` yourself only when the evidence is strong, and ask before writing the user recipe root.
+- Terminal follow-up context contains only run id, status, one base path, and relative artifact names. Inspect the run for contents; semantic output and correlation remain in non-LLM details and state. Decide whether a successful pattern deserves durable tool memory only after inspection, and ask before writing the user recipe root.
 - Use stable `as` names when you will inspect or message the actor later.
 - Public run state is runtime-owned; do not pass custom `state_dir` paths. This keeps `run:<id>` addressability and retention on one boundary.
 - `async: true` on the recipe is the detached run switch.
@@ -126,7 +126,7 @@ Views:
 - `artifacts`: declared artifact paths/status plus the same bounded owned review-evidence manifest when present.
 - `recipes` target: registry summary for active, shadowed, invalid, disabled, and diagnostic recipe entries.
 
-Let terminal notifications arrive. They queue through Pi's follow-up delivery mode, so a busy coordinator finishes its current work before receiving concurrently completed actor results; the host's `followUpMode` controls whether queued results arrive together or one at a time. File watching accelerates delivery, while a bounded ten-second terminal-only reconciliation pass recovers missed or failed watcher activity without replaying outbox traffic; watcher degradation and rearm remain visible diagnostics. When a deferred actor result gates the next step, wait for that terminal follow-up instead of scheduling continuation loops, repeatedly inspecting, or mutating the actor's reviewed scope. Idle coordinators still start a normal turn through `triggerTurn: true`. Inspect early only for an operator request, a meaningful actor event, or diagnosis of an overdue or stuck run.
+Let terminal notifications arrive. They queue through Pi's follow-up delivery mode, so a busy coordinator finishes its current work before receiving concurrently completed actor results; the host's `followUpMode` controls whether queued results arrive together or one at a time. Their LLM context content stays limited to run id, status, one base path, and relative artifact names; inspect state for raw output while correlation and semantic details remain outside LLM context. File watching accelerates delivery, while a bounded ten-second terminal-only reconciliation pass recovers missed or failed watcher activity without replaying outbox traffic; watcher degradation and rearm remain visible diagnostics. When a deferred actor result gates the next step, wait for that terminal follow-up instead of scheduling continuation loops, repeatedly inspecting, or mutating the actor's reviewed scope. Idle coordinators still start a normal turn through `triggerTurn: true`. Inspect early only for an operator request, a meaningful actor event, or diagnosis of an overdue or stuck run.
 
 ## Runtime Communication Rules
 

package/skills/swarm/SKILL.md

@@ -2,7 +2,7 @@
 name: swarm
 description: Subagent and actor orchestration with scoped locks, fanout, and quorum consensus. Use before launching multiple parallel actors or subagents for independent implementation, artifact generation, review, delegated audit, coordinated execution, or any workflow that needs autonomous coordinator decomposition and integration.
 metadata:
-  version: 0.42.0
+  version: 0.42.2
 ---
 
 # Swarm