@llblab/pi-kit 0.5.2 → 0.7.0

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to `@llblab/pi-kit` are documented here.
 
+## 0.7.0 - 2026-09-10
+
+- `Current Distribution`: Advances Actors to `0.53.0`, State Flow to `0.6.0`, Telegram to `0.45.0`, and Skills to `1.15.0`. The kit now includes durable Workspace-bound Telegram Threads, expanded run orchestration, current opt-in state handoffs, and the latest portable workflows while preserving the package set, resource inventory, and explicit load order.
+
+## 0.6.0 - 2026-09-06
+
+- `Current Distribution`: Advances Telegram to `0.44.0`, Grow Loop to `0.7.5`, and Skills to `1.14.1`. The kit now includes reliable default-on Telegram draft previews and prompt anchors, unambiguous `grow-loop` runtime status, and ABCd contiguous-list validation while preserving the existing package set, resource inventory, and load order.
+
 ## 0.5.2 - 2026-09-06
 
 - `Telegram Ordering Hotfix`: Advances the exact Telegram pin to `0.43.2`, bringing bounded threadless command lifetime, causal final/artifact/compaction publication order, stale-delivery fencing, and suppression of voice replay after uncertain acknowledgement. Other pins and the resource inventory remain unchanged; operator-coordinated live smoke follows release.

package/README.md

@@ -10,13 +10,13 @@ Package links lead to the owning repositories for usage, documentation, issues,
 
 | Package | Version | Purpose |
 | --- | ---: | --- |
-| [`@llblab/pi-actors`](https://github.com/llblab/pi-actors) | `0.52.1` | Inspectable local Runs, reusable Recipes, persistent tools, and delegation Skills |
+| [`@llblab/pi-actors`](https://github.com/llblab/pi-actors) | `0.53.0` | Inspectable local Runs, reusable Recipes, persistent tools, and delegation Skills |
 | [`@llblab/pi-clean-room`](https://github.com/llblab/pi-clean-room) | `0.1.1` | Isolated nested Pi TUI with explicitly selected extensions |
 | [`@llblab/pi-codex-usage`](https://github.com/llblab/pi-codex-usage) | `0.9.4` | Compact Codex/Spark subscription-limit status |
-| [`@llblab/pi-grow-loop`](https://github.com/llblab/pi-grow-loop) | `0.7.4` | Visible continuation scheduling and bounded worker Skills |
-| [`@llblab/pi-state-flow`](https://github.com/llblab/pi-state-flow) | `0.3.0` | Opt-in validated state handoffs between agent runs |
-| [`@llblab/pi-telegram`](https://github.com/llblab/pi-telegram) | `0.43.2` | Telegram companion, queues, files, voice, controls, and Generative Apps guidance |
-| [`@llblab/skills`](https://github.com/llblab/skills) | `1.14.0` | Portable workflows for engineering, review, design, context maintenance, and other focused tasks |
+| [`@llblab/pi-grow-loop`](https://github.com/llblab/pi-grow-loop) | `0.7.5` | Visible continuation scheduling and bounded worker Skills |
+| [`@llblab/pi-state-flow`](https://github.com/llblab/pi-state-flow) | `0.6.0` | Opt-in validated state handoffs between agent runs |
+| [`@llblab/pi-telegram`](https://github.com/llblab/pi-telegram) | `0.45.0` | Telegram companion, queues, files, voice, controls, and Generative Apps guidance |
+| [`@llblab/skills`](https://github.com/llblab/skills) | `1.15.0` | Portable workflows for engineering, review, design, context maintenance, and other focused tasks |
 
 Versions are exact by design. An upstream release does not change an installed kit until this repository explicitly advances the dependency and publishes a new kit version. Runtime defects and package-specific feature requests belong in the linked repository; package selection and kit installation issues belong here.
 

package/node_modules/@llblab/pi-actors/AGENTS.md

@@ -136,7 +136,7 @@ Tool result/error text contributes exactly one leading line break. Keep model-fa
 
 File watchers accelerate reconciliation; a bounded interval recovers missed terminal and retained-attention events. Canonical attention observation uses stable retained ids and bounds seen memory to the current suffix across compaction; only allowlisted legacy outbox fallback uses line offsets. Ordinary `notify` and `followup` hints prime at startup without replay and require durable state or artifacts for recovery. Explicit `steer` instead re-enters through the owner journal until exact presentation records its newer generation-fenced Trace marker.
 
-Ordinary root terminals remain authoritative in Run state until the owner-scoped completion scheduler snapshots an immutable batch at a settled or idle boundary. Batch delivery is generation-fenced and bounded at 256 durable members, 64 model-facing rows, 16 KiB of context, and a 1 MiB journal. `sendMessage()` acceptance advances only to queued; only the exact batch id and content appearing in model-bound `context` advances to presented and authorizes exact-generation handled markers. Restart recovery walks the bounded active Pi session parent chain: exact queued evidence waits without resend, proven absence returns the envelope to pending, and incomplete or conflicting evidence remains queued with diagnostics. Retry duplicates collapse before presentation, malformed envelopes fail closed, and automatic review waits behind an active completion batch.
+Ordinary terminals retain inherited delivery lineage from each nested Actor process to the top-level coordinator. Only that root coordinator may schedule completion follow-ups; descendant sessions stay quiet, descendants wait for their containing top-level Run to terminate, and the complete ready forest is flattened into one immutable settled/idle batch with parent-child rows and bounded semantic outputs. The same batch renders as one visible operator card and one model prompt. Batch delivery is generation-fenced and bounded at 256 durable members, 64 model-facing rows, 16 KiB of context, and a 1 MiB journal. Successful `sendMessage()` acceptance durably finalizes the completion batch and authorizes exact-generation handled markers, so a missed context callback cannot block later completion epochs. Send failure retains the pending batch for retry; queued recovery remains only for the narrow crash boundary between transport acceptance and finalization. Restart recovery walks the bounded active Pi session parent chain: exact queued evidence waits without resend, proven absence returns the envelope to pending, and incomplete or conflicting evidence remains queued with diagnostics. Retry duplicates collapse before presentation, malformed envelopes fail closed, and automatic review waits behind an active completion batch.
 
 When deferred Run results gate the next step, wait for their completion batch. Inspect early only for operator request, meaningful attention, or diagnosis of an overdue Run.
 

package/node_modules/@llblab/pi-actors/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 > Each release keeps at most 8 outcome records of at most 512 characters.
 
+## 0.53.0: Tree-Compressed Completion Delivery
+
+- `Quiet Draft Reloads`: Keeps automatic Recipe reload active for draft-directory changes while showing “Recipe tools refreshed” only for active non-draft Recipe changes or registry-root replacement, so ordinary spawn draft capture no longer produces misleading tool-refresh noise.
+- `Tree-Compressed Completion Delivery`: Propagates exact root-owner and parent-generation lineage through nested Actor processes. Descendants stay quiet and wait for the complete top-level tree; the root batches ready trees and concurrent roots into one visible gray card plus one parent-child model prompt with bounded outputs. Completion forests render in stable root/descendant preorder. Successful Pi acceptance finalizes completion members immediately, preventing missed callbacks or long branches from blocking later epochs; settled/context delivery accepts fresh Pi context wrappers only for the exact active session owner, while urgent steer retains exact presentation acknowledgment.
+- `Command Timeout Trees`: Terminates the full command-template descendant tree on timeout, preventing inherited output streams from leaving an Actor stuck after its command deadline while preserving outer Run process-group cancellation.
+
 ## 0.52.1: Unified Playback Control Hotfix
 
 - `Unified Playback CLI`: Consolidates standalone playback and external control into `playback.mjs`; standalone commands remain runtime-independent, while Actor-owned commands retain exact terminal Control evidence. The maintained Music Player Generative App uses the same explicit control entrypoint. Post-stop status remains readable despite leftover Run metadata; inactive controls fail before journal admission. External callers of the removed `playback-client.mjs` use `playback.mjs control` instead.

package/node_modules/@llblab/pi-actors/README.md

@@ -153,7 +153,7 @@ Trace fields are exact: `id`, `ts`, `kind`, and optional `summary`, `data`, `lev
 
 Generic command lifecycle is Trace-only: runner-owned `command.done` records preserve completion and execution evidence but never request or project attention, including malformed legacy records carrying `steer`. There is no Recipe-level command-completion delivery switch. Semantic attention is explicit: `notify` shows visible status without a model turn, `followup` supplies ordinary checkpoint context, and `steer` requests urgent delivery at Pi's next safe assistant/tool boundary. `notify` and `followup` remain retained wake hints that may compact away, so persist recovery state or an artifact first. `steer` is admitted to the bounded owner delivery journal before `deliverAs: "steer"`, acknowledged only in exact model-bound context, and never suppresses the eventual root-terminal batch. Store large evidence in artifacts or bounded execution captures.
 
-Ordinary finite Runs project root terminal results through one owner-fenced completion scheduler. Completions that accumulate while Pi is active or inside the idle debounce window enter one immutable bounded batch and cause one automatic agent turn after Pi settles; terminal generations are acknowledged only when that exact batch reaches model-bound context. Sequence, parallel, repeat, and imported branches remain internal and never create branch-level turns, while separately launched Runs retain exact independent generations. Silent Runs and synchronous stop acknowledgments remain non-projecting.
+Ordinary finite Runs project terminal results through one root-coordinator completion scheduler. Nested actors inherit durable parent-generation lineage: their own Pi sessions never emit completion turns, their results wait until the containing top-level Run terminates, and the ready trees join other top-level completions accumulated during the same active/idle epoch. One immutable bounded forest causes one automatic agent turn after the root Pi settles. The operator sees one gray completion card, while the agent receives the same parent-child tree with bounded actor outputs as one prompt; terminal generations are acknowledged after Pi durably accepts the exact batch, preventing one missed context callback from blocking later completion epochs. Sequence, parallel, repeat, and imported branches remain internal, while separately launched Runs retain exact independent generations. Silent Runs and synchronous stop acknowledgments remain non-projecting.
 
 ## Control
 

package/node_modules/@llblab/pi-actors/dist/lib/async-runs.d.ts

@@ -4,6 +4,7 @@
  */
 import type { CommandTemplateFailureScope, CommandTemplateValue } from "./command-templates.ts";
 import { type CurrentPolicyProvenance } from "./model-context.ts";
+import * as RunDeliveryLineage from "./run-delivery-lineage.ts";
 import * as RecipesReferences from "./recipes-references.ts";
 import { type RunArtifactDeclaration } from "./runs-artifacts.ts";
 import { type RunProcessIdentity } from "./runs-process.ts";
@@ -92,6 +93,8 @@ export interface AsyncRunMeta {
     artifacts?: Record<string, RunArtifactDeclaration>;
     control?: string[];
     control_endpoint?: AsyncRunControlEndpoint;
+    delivery_owner_id?: string;
+    delivery_parent?: RunDeliveryLineage.RunDeliveryParent;
     model_policy?: CurrentPolicyProvenance;
     notification_policy?: "normal" | "silent";
     process_identity?: RunProcessIdentity;

package/node_modules/@llblab/pi-actors/dist/lib/async-runs.js

@@ -11,6 +11,7 @@ import { isDeepStrictEqual } from "node:util";
 import { writeJsonAtomic } from "./file-state.js";
 import { CURRENT_MODEL_VALUE_KEY, CURRENT_THINKING_VALUE_KEY, describeCurrentPolicyProvenance, } from "./model-context.js";
 import * as Paths from "./paths.js";
+import * as RunDeliveryLineage from "./run-delivery-lineage.js";
 import * as RecipesReferences from "./recipes-references.js";
 import * as RecipesUsage from "./recipes-usage.js";
 import * as Schema from "./schema.js";
@@ -369,6 +370,8 @@ export function startRun(params, cwd, options = {}) {
         };
         const transportContext = normalizeRunTransportContext(startParams.transport_context);
         const artifacts = resolveArtifactPaths(startParams.artifacts, outputValues);
+        const runInstanceId = randomUUID();
+        const deliveryLineage = RunDeliveryLineage.inheritedRunDeliveryLineage(startParams.ownerId);
         const meta = {
             argv: [process.execPath, ...argv],
             createdAt: new Date().toISOString(),
@@ -386,7 +389,7 @@ export function startRun(params, cwd, options = {}) {
             ...(recipe ? { recipe } : {}),
             ...(recipeFile ? { recipe_file: recipeFile } : {}),
             run,
-            run_instance_id: randomUUID(),
+            run_instance_id: runInstanceId,
             state_dir: stateDir,
             state_schema: RuntimeIdentity.RUN_STATE_SCHEMA,
             status: "running",
@@ -399,6 +402,7 @@ export function startRun(params, cwd, options = {}) {
             ...(startParams.control_endpoint
                 ? { control_endpoint: startParams.control_endpoint }
                 : {}),
+            ...(deliveryLineage ?? {}),
             ...(startParams.notification_policy === "silent"
                 ? { notification_policy: "silent" }
                 : {}),
@@ -429,6 +433,15 @@ export function startRun(params, cwd, options = {}) {
         const child = spawn(process.execPath, argv, {
             cwd,
             detached: true,
+            ...(deliveryLineage
+                ? {
+                    env: RunDeliveryLineage.runDeliveryChildEnv(deliveryLineage, {
+                        run,
+                        run_instance_id: runInstanceId,
+                        state_dir: stateDir,
+                    }),
+                }
+                : {}),
             stdio: ["ignore", outFd, errFd],
         });
         closeSync(outFd);

package/node_modules/@llblab/pi-actors/dist/lib/command-templates.js

@@ -3,7 +3,7 @@
  * Zones: shell-free command parsing, placeholder expansion, local process execution, composition semantics
  * Owns portable command-template parsing, expansion, risk checks, retries, timeouts, and direct execution.
  */
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { accessSync, appendFileSync, constants, mkdirSync, mkdtempSync, statSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { basename, delimiter, extname, isAbsolute, join, resolve as resolvePath } from "node:path";
@@ -714,14 +714,56 @@ function execCommandTemplateOnce(command, args, options = {}) {
         let settled = false;
         let timeoutId;
         let killTimeoutId;
+        const signalProcessTree = (signal) => {
+            if (proc.pid === undefined)
+                return;
+            if (process.platform === "win32") {
+                spawnSync("taskkill", [
+                    "/PID",
+                    String(proc.pid),
+                    "/T",
+                    ...(signal === "SIGKILL" ? ["/F"] : []),
+                ]);
+                return;
+            }
+            const snapshot = spawnSync("ps", ["-eo", "pid=,ppid="], { encoding: "utf8" });
+            const children = new Map();
+            for (const line of snapshot.stdout?.split(/\r?\n/u) ?? []) {
+                const [pidText, parentText] = line.trim().split(/\s+/u);
+                const pid = Number(pidText);
+                const parent = Number(parentText);
+                if (!Number.isSafeInteger(pid) || !Number.isSafeInteger(parent))
+                    continue;
+                const siblings = children.get(parent) ?? [];
+                siblings.push(pid);
+                children.set(parent, siblings);
+            }
+            const descendants = [];
+            const collect = (parent) => {
+                for (const child of children.get(parent) ?? []) {
+                    collect(child);
+                    descendants.push(child);
+                }
+            };
+            collect(proc.pid);
+            for (const pid of [...descendants, proc.pid]) {
+                try {
+                    process.kill(pid, signal);
+                }
+                catch (error) {
+                    if (error.code !== "ESRCH")
+                        throw error;
+                }
+            }
+        };
         const killProcess = () => {
             if (killed)
                 return;
             killed = true;
-            proc.kill("SIGTERM");
+            signalProcessTree("SIGTERM");
             killTimeoutId = setTimeout(() => {
                 if (!settled)
-                    proc.kill("SIGKILL");
+                    signalProcessTree("SIGKILL");
             }, options.killGrace ?? 5000);
         };
         const settle = (code) => {

package/node_modules/@llblab/pi-actors/dist/lib/extension-runtime.js

@@ -113,7 +113,7 @@ export function createActorExtensionRuntime(pi) {
         },
         getRunOwnerId,
         onAgentSettled(ctx) {
-            if (activeRunContext !== ctx)
+            if (!activeRunOwnerId || getRunOwnerId(ctx) !== activeRunOwnerId)
                 return;
             if (!runUiRuntime.flushCompletionBatch(ctx))
                 automaticReview.schedule();

package/node_modules/@llblab/pi-actors/dist/lib/observability.d.ts

@@ -13,6 +13,12 @@ export interface RunObservation {
     activeSubagents?: number;
     completed?: number;
     descendantSubagents?: number;
+    deliveryOwnerId?: string;
+    deliveryParent?: {
+        run: string;
+        run_instance_id: string;
+        state_dir: string;
+    };
     failures?: number;
     ownerId?: string;
     artifacts?: Record<string, string>;
@@ -69,6 +75,8 @@ export declare function readRunUiSnapshot(state: RunUiObservationState, ownerId:
     includeAttention?: boolean;
     stateRoot?: string;
 }): RunUiSnapshot;
+/** Observe every Run generation routed to one root coordinator. */
+export declare function readRunDeliverySnapshot(state: RunUiObservationState, deliveryOwnerId: string, stateRoot?: string): RunUiSnapshot;
 export declare function pruneRunUiObservationState(state: RunUiObservationState, snapshot: Pick<RunUiSnapshot, "summary" | "transitions">): void;
 export declare function deliverRunAttentionNotifications(events: RunAttentionEvent[], sink: RunUiNotificationSink): void;
 export interface RunRetirementCandidate {
@@ -124,6 +132,11 @@ export interface RunRetirementExecutorOptions {
     sendStop: (candidate: RunRetirementCandidate) => Promise<unknown>;
 }
 export interface RunTransition {
+    deliveryParent?: {
+        run: string;
+        run_instance_id: string;
+        state_dir: string;
+    };
     from: RunObservedStatus;
     run: string;
     runInstanceId?: string;
@@ -162,7 +175,7 @@ export interface RunAttentionEvent {
     ts: string;
 }
 export type RunTransitionNotificationType = "info" | "warning" | "error";
-export declare function summarizeRuns(stateRoot?: string, ownerId?: string): RunSummary;
+export declare function summarizeRuns(stateRoot?: string, ownerId?: string, deliveryOwnerId?: string): RunSummary;
 export declare function countRunningSubagentsByRun(stateRoot?: string, ownerId?: string): Map<string, number>;
 export declare function countRunningSubagents(stateRoot?: string, ownerId?: string): number;
 export declare function renderSubagentStatus(count: number, frame?: number): string | undefined;
@@ -180,6 +193,6 @@ export declare function shouldSendRunAttentionFollowUp(event: RunAttentionEvent)
 export declare function formatRunAttentionMessage(event: RunAttentionEvent): string;
 export declare function getRunTransitionNotificationType(transition: RunTransition): RunTransitionNotificationType;
 export declare function shouldNotifyRunTransition(transition: RunTransition): boolean;
-/** Build exact immutable generation members for owner-journal admission. */
-export declare function collectRunCompletionBatchMembers(transitions: RunTransition[]): RunCompletionBatchMember[];
+/** Build exact immutable members only after each containing root Run is terminal. */
+export declare function collectRunCompletionBatchMembers(transitions: RunTransition[], deliveryRuns?: RunObservation[]): RunCompletionBatchMember[];
 export declare function formatRunTransitionMessage(transition: RunTransition): string;

package/node_modules/@llblab/pi-actors/dist/lib/observability.js

@@ -32,6 +32,16 @@ export function readRunUiSnapshot(state, ownerId, options = {}) {
         transitions: detectRunTransitions(state.observed, summary),
     };
 }
+/** Observe every Run generation routed to one root coordinator. */
+export function readRunDeliverySnapshot(state, deliveryOwnerId, stateRoot) {
+    const summary = summarizeRuns(stateRoot, undefined, deliveryOwnerId);
+    return {
+        attentionEvents: [],
+        status: undefined,
+        summary,
+        transitions: detectRunTransitions(state.observed, summary),
+    };
+}
 export function pruneRunUiObservationState(state, snapshot) {
     pruneRunObservationState(state.observed, state.legacyEventLines, snapshot.summary, snapshot.transitions.map((transition) => transition.stateDir ?? transition.run), state.attentionEventIds);
 }
@@ -348,6 +358,19 @@ function observeRun(stateDir) {
             failures: Array.isArray(progress.failures)
                 ? progress.failures.length
                 : undefined,
+            ...(typeof status.delivery_owner_id === "string"
+                ? { deliveryOwnerId: status.delivery_owner_id }
+                : {}),
+            ...(status.delivery_parent &&
+                typeof status.delivery_parent === "object" &&
+                !Array.isArray(status.delivery_parent) &&
+                typeof status.delivery_parent.run === "string" &&
+                typeof status.delivery_parent.run_instance_id === "string" &&
+                typeof status.delivery_parent.state_dir === "string"
+                ? {
+                    deliveryParent: status.delivery_parent,
+                }
+                : {}),
             ...(typeof status.ownerId === "string"
                 ? { ownerId: status.ownerId }
                 : {}),
@@ -391,7 +414,7 @@ function observeRun(stateDir) {
         return undefined;
     }
 }
-export function summarizeRuns(stateRoot = Paths.getRunStateRoot(), ownerId) {
+export function summarizeRuns(stateRoot = Paths.getRunStateRoot(), ownerId, deliveryOwnerId) {
     if (!existsSync(stateRoot)) {
         return {
             cancelled: 0,
@@ -409,7 +432,10 @@ export function summarizeRuns(stateRoot = Paths.getRunStateRoot(), ownerId) {
         scanRunStateDirs(stateRoot))
         .map((stateDir) => observeRun(stateDir))
         .filter((run) => Boolean(run))
-        .filter((run) => ownerId === undefined || run.ownerId === ownerId)
+        .filter((run) => deliveryOwnerId !== undefined
+        ? run.deliveryOwnerId === deliveryOwnerId ||
+            (run.deliveryOwnerId === undefined && run.ownerId === deliveryOwnerId)
+        : ownerId === undefined || run.ownerId === ownerId)
         .sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""));
     const processSubagentsByRun = countRunningSubagentsByRun(stateRoot, ownerId);
     const runsWithDescendants = runs.map((run) => {
@@ -683,6 +709,7 @@ export function detectRunTransitions(previous, summary) {
             transitions.push({
                 from: old ?? "running",
                 run: run.run,
+                ...(run.deliveryParent ? { deliveryParent: run.deliveryParent } : {}),
                 ...(run.stateDir ? { stateDir: run.stateDir } : {}),
                 ...(run.artifacts ? { artifacts: run.artifacts } : {}),
                 ...(run.launchCorrelation ? { launchCorrelation: run.launchCorrelation } : {}),
@@ -921,15 +948,56 @@ export function shouldNotifyRunTransition(transition) {
         transition.to === "killed" ||
         transition.to === "exited");
 }
-/** Build exact immutable generation members for owner-journal admission. */
-export function collectRunCompletionBatchMembers(transitions) {
-    return transitions.flatMap((transition) => {
+function deliveryGenerationIdentity(input) {
+    return input.stateDir && input.runInstanceId
+        ? `${input.stateDir}\0${input.runInstanceId}`
+        : undefined;
+}
+function deliveryTreePosition(input, runsByIdentity) {
+    const ownIdentity = deliveryGenerationIdentity(input);
+    if (!ownIdentity)
+        return undefined;
+    let parent = input.deliveryParent;
+    let depth = 0;
+    let rootIdentity = ownIdentity;
+    const visited = new Set([ownIdentity]);
+    while (parent) {
+        const identity = `${parent.state_dir}\0${parent.run_instance_id}`;
+        if (visited.has(identity))
+            return undefined;
+        visited.add(identity);
+        const ancestor = runsByIdentity.get(identity);
+        if (!ancestor || ancestor.notificationPolicy === "silent")
+            return undefined;
+        depth += 1;
+        rootIdentity = identity;
+        parent = ancestor.deliveryParent;
+    }
+    return { depth, rootIdentity };
+}
+/** Build exact immutable members only after each containing root Run is terminal. */
+export function collectRunCompletionBatchMembers(transitions, deliveryRuns = []) {
+    const runsByIdentity = new Map(deliveryRuns.flatMap((run) => {
+        const identity = deliveryGenerationIdentity(run);
+        return identity ? [[identity, run]] : [];
+    }));
+    const incompleteRoots = new Set(deliveryRuns.flatMap((run) => {
+        if (TERMINAL.has(run.status))
+            return [];
+        const position = deliveryTreePosition(run, runsByIdentity);
+        return position ? [position.rootIdentity] : [];
+    }));
+    const admitted = transitions.flatMap((transition) => {
         if (!shouldNotifyRunTransition(transition) ||
             !transition.stateDir ||
             !transition.runInstanceId ||
             !transition.terminalAt ||
             Number.isNaN(Date.parse(transition.terminalAt)))
             return [];
+        const position = deliveryTreePosition(transition, runsByIdentity);
+        if (!position || incompleteRoots.has(position.rootIdentity))
+            return [];
+        const { depth } = position;
         const artifactEntries = Object.entries(transition.artifacts ?? {})
             .filter((entry) => typeof entry[1] === "string" && Boolean(entry[1]))
             .slice(0, 4);
@@ -939,6 +1007,20 @@ export function collectRunCompletionBatchMembers(transitions) {
                 ...(artifactEntries.length > 0
                     ? { artifacts: Object.fromEntries(artifactEntries) }
                     : {}),
+                ...(transition.semanticResult?.body?.trim()
+                    ? {
+                        output: transition.semanticResult.body.trim().length > 4_000
+                            ? `${transition.semanticResult.body.trim().slice(0, 3_999)}…`
+                            : transition.semanticResult.body.trim(),
+                    }
+                    : {}),
+                ...(transition.deliveryParent
+                    ? {
+                        parent_run: transition.deliveryParent.run,
+                        parent_run_instance_id: transition.deliveryParent.run_instance_id,
+                        parent_state_dir: transition.deliveryParent.state_dir,
+                    }
+                    : {}),
                 run: transition.run,
                 run_instance_id: transition.runInstanceId,
                 state_dir: transition.stateDir,
@@ -947,11 +1029,14 @@ export function collectRunCompletionBatchMembers(transitions) {
                     ? `${rawSummary.slice(0, 999)}…`
                     : rawSummary,
                 terminal_at: transition.terminalAt,
+                tree_depth: depth,
             }];
-    }).sort((left, right) => left.terminal_at.localeCompare(right.terminal_at) ||
+    });
+    return admitted.sort((left, right) => left.tree_depth - right.tree_depth ||
+        left.terminal_at.localeCompare(right.terminal_at) ||
         left.run.localeCompare(right.run) ||
         left.run_instance_id.localeCompare(right.run_instance_id) ||
-        left.state_dir.localeCompare(right.state_dir));
+        left.state_dir.localeCompare(right.state_dir)).map(({ tree_depth: _depth, ...member }) => member);
 }
 const TERMINAL_FOLLOW_UP_ARTIFACT_LIMIT = 4;
 const TERMINAL_FOLLOW_UP_IDENTIFIER_CHARS = 120;

package/node_modules/@llblab/pi-actors/dist/lib/pi.d.ts

@@ -46,5 +46,4 @@ export declare function inspectRunSteerSessionEvidence(ctx: ExtensionContext, in
     eventId: string;
     steerId: string;
 }): SessionEvidence.ActiveSessionEntryEvidence;
-export declare function inspectRunCompletionBatchSessionEvidence(ctx: ExtensionContext, batchId: string, content: string): SessionEvidence.ActiveSessionEntryEvidence;
 export declare function registerToolDefinitions(pi: ExtensionAPI, definitions: Iterable<unknown>): void;

package/node_modules/@llblab/pi-actors/dist/lib/pi.js

@@ -22,7 +22,7 @@ export function sendRunCompletionBatch(pi, batchId, content) {
     pi.sendMessage({
         customType: RUN_COMPLETION_BATCH_CUSTOM_TYPE,
         content,
-        display: false,
+        display: true,
         details: {
             pi_actors_delivery: {
                 batch_id: batchId,
@@ -59,18 +59,21 @@ function completionBatchMessage(message) {
         typeof record.content !== "string")
         return undefined;
     const details = record.details;
-    if (!details || typeof details !== "object" || Array.isArray(details))
-        return undefined;
-    const delivery = details.pi_actors_delivery;
-    if (!delivery || typeof delivery !== "object" || Array.isArray(delivery))
-        return undefined;
-    const envelope = delivery;
-    if (envelope.kind !== "completion_batch" ||
-        typeof envelope.batch_id !== "string" ||
-        !envelope.batch_id ||
-        envelope.batch_id.length > 128)
+    const delivery = details && typeof details === "object" && !Array.isArray(details)
+        ? details.pi_actors_delivery
+        : undefined;
+    const envelope = delivery && typeof delivery === "object" && !Array.isArray(delivery)
+        ? delivery
+        : undefined;
+    const detailedId = envelope?.kind === "completion_batch" &&
+        typeof envelope.batch_id === "string"
+        ? envelope.batch_id
+        : undefined;
+    const contentId = /^Batch: `([^`]{1,128})`$/mu.exec(record.content)?.[1];
+    const batchId = detailedId ?? contentId;
+    if (!batchId || batchId.length > 128)
         return undefined;
-    return { batchId: envelope.batch_id, content: record.content };
+    return { batchId, content: record.content };
 }
 /** Collapse exact retry duplicates and remove conflicting delivery envelopes. */
 export function dedupeRunCompletionBatchContext(messages) {
@@ -183,18 +186,6 @@ export function inspectRunSteerSessionEvidence(ctx, input) {
         },
     });
 }
-export function inspectRunCompletionBatchSessionEvidence(ctx, batchId, content) {
-    return SessionEvidence.inspectBoundedActiveSessionEntries({
-        getEntry: (id) => ctx.sessionManager.getEntry(id),
-        leaf: ctx.sessionManager.getLeafEntry(),
-        match: (entry) => {
-            const batch = completionBatchMessage(entry);
-            if (!batch || batch.batchId !== batchId)
-                return undefined;
-            return batch.content === content ? "present" : "conflict";
-        },
-    });
-}
 export function registerToolDefinitions(pi, definitions) {
     for (const definition of definitions)
         pi.registerTool(definition);

package/node_modules/@llblab/pi-actors/dist/lib/run-delivery-lineage.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Run delivery lineage.
+ * Zones: inherited coordinator root, parent Run generation, delivery-tree filtering
+ * Owns durable completion ancestry; excludes delivery persistence and Pi scheduling.
+ */
+export interface RunDeliveryParent {
+    run: string;
+    run_instance_id: string;
+    state_dir: string;
+}
+export interface RunDeliveryLineage {
+    delivery_owner_id: string;
+    delivery_parent?: RunDeliveryParent;
+}
+export declare function inheritedRunDeliveryLineage(ownerId: string | undefined, env?: NodeJS.ProcessEnv): RunDeliveryLineage | undefined;
+export declare function runDeliveryChildEnv(lineage: RunDeliveryLineage, parent: RunDeliveryParent, env?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export declare function getProcessDeliveryOwnerId(env?: NodeJS.ProcessEnv): string | undefined;

package/node_modules/@llblab/pi-actors/dist/lib/run-delivery-lineage.js

@@ -0,0 +1,44 @@
+/**
+ * Run delivery lineage.
+ * Zones: inherited coordinator root, parent Run generation, delivery-tree filtering
+ * Owns durable completion ancestry; excludes delivery persistence and Pi scheduling.
+ */
+const DELIVERY_OWNER_ENV = "PI_ACTORS_DELIVERY_OWNER_ID";
+const PARENT_RUN_ENV = "PI_ACTORS_DELIVERY_PARENT_RUN";
+const PARENT_INSTANCE_ENV = "PI_ACTORS_DELIVERY_PARENT_INSTANCE";
+const PARENT_STATE_DIR_ENV = "PI_ACTORS_DELIVERY_PARENT_STATE_DIR";
+function nonEmpty(value) {
+    const text = value?.trim();
+    return text || undefined;
+}
+export function inheritedRunDeliveryLineage(ownerId, env = process.env) {
+    const localOwner = nonEmpty(ownerId);
+    if (!localOwner)
+        return undefined;
+    const deliveryOwner = nonEmpty(env[DELIVERY_OWNER_ENV]) ?? localOwner;
+    const run = nonEmpty(env[PARENT_RUN_ENV]);
+    const runInstanceId = nonEmpty(env[PARENT_INSTANCE_ENV]);
+    const stateDir = nonEmpty(env[PARENT_STATE_DIR_ENV]);
+    const completeParent = run && runInstanceId && stateDir
+        ? { run, run_instance_id: runInstanceId, state_dir: stateDir }
+        : undefined;
+    if ((run || runInstanceId || stateDir) && !completeParent) {
+        throw new Error("Inherited Run delivery parent lineage is incomplete");
+    }
+    return {
+        delivery_owner_id: deliveryOwner,
+        ...(completeParent ? { delivery_parent: completeParent } : {}),
+    };
+}
+export function runDeliveryChildEnv(lineage, parent, env = process.env) {
+    return {
+        ...env,
+        [DELIVERY_OWNER_ENV]: lineage.delivery_owner_id,
+        [PARENT_RUN_ENV]: parent.run,
+        [PARENT_INSTANCE_ENV]: parent.run_instance_id,
+        [PARENT_STATE_DIR_ENV]: parent.state_dir,
+    };
+}
+export function getProcessDeliveryOwnerId(env = process.env) {
+    return nonEmpty(env[DELIVERY_OWNER_ENV]);
+}

package/node_modules/@llblab/pi-actors/dist/lib/run-delivery.d.ts

@@ -7,6 +7,10 @@ export type RunCompletionDeliveryStatus = "done" | "failed" | "killed" | "exited
 export type RunDeliveryPhase = "pending" | "queued" | "presented";
 export interface RunCompletionBatchMember {
     artifacts?: Record<string, string>;
+    parent_run?: string;
+    parent_run_instance_id?: string;
+    parent_state_dir?: string;
+    output?: string;
     run: string;
     run_instance_id: string;
     state_dir: string;