@llblab/pi-actors 0.42.0 → 0.42.2

package/AGENTS.md

@@ -108,7 +108,7 @@ Pi host
 - Preserve node controls: `when`, positive `timeout`, `delay`, bounded `retry`, `failure`, and `recover` cleanup.
 - Persist every async command's complete byte-exact stdout/stderr under command- and retry-specific run-state paths while keeping returned tails bounded and pipeline stdin complete.
 - Keep async run state under `~/.pi/agent/tmp/pi-actors/runs` with injected `{run_id}` and `{state_dir}` values.
-- Preserve event-driven observability with bounded reconciliation: file watchers accelerate durable retrying terminal follow-up notifications, while a conservative terminal-only interval recovers missed watcher activity, rearms degraded watchers, and never replays outbox traffic. Queue coordinator context through Pi follow-up delivery rather than steering so current work finishes before async results arrive and host follow-up batching policy can combine concurrent completions. Terminal delivery is at-least-once across the unavoidable send/handled-marker crash window; watch-triggered and periodic delivery share one live-runtime in-flight guard.
+- Preserve event-driven observability with bounded reconciliation: file watchers accelerate durable retrying terminal follow-up notifications, while a conservative terminal-only interval recovers missed watcher activity, rearms degraded watchers, and never replays outbox traffic. Queue compact terminal coordinator notices through Pi follow-up delivery rather than steering so current work finishes before async results arrive and host follow-up batching policy can combine concurrent completions; LLM content contains only run id, status, one base path, and relative artifact names, while semantic output/error/correlation stays in non-LLM details and run state. Terminal delivery is at-least-once across the unavoidable send/handled-marker crash window; watch-triggered and periodic delivery share one live-runtime in-flight guard.
 - 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 on operator request, meaningful actor event, or diagnosis of an overdue/stuck run.
 - Do not restore busy-polling examples, duplicate terminal notifications, or duplicate notifications for handled `cancel`, `kill`, or control-stop actions.
 
@@ -142,7 +142,7 @@ Pi host
 - Keep tail truncation, full-output temp files, failure formatting, and centralized limits intact.
 - Published docs must not include machine-local absolute paths.
 - Any view scanning run directories must apply coordinator/session ownership filters before exposing summaries or previews.
-- Actor Inspector remains evidence-first; its `Kill` action is available only for a focused owned running run, requires in-overlay confirmation, revalidates exact ownership/status at action time, routes through canonical `control.kill`, and renders bounded success/failure feedback without direct process signaling.
+- Actor Inspector remains evidence-first; its `Kill` action is available only for a focused owned running run, requires in-overlay confirmation, revalidates exact ownership/status at action time, routes through canonical `control.kill`, and renders bounded success/failure feedback without direct process signaling. Keep active key hints in the bottom border as one blue-key/border-accent-description rail joined by border-accent `─`, never as a dedicated body row or bullet-separated footer.
 - Direct branch messages are active inbox queues; guard branch-local append/status rewrites with the branch inbox lock and keep claim/handled/failed transitions tested.
 - Run-state launch and destructive retention require the runtime ownership marker bound to the canonical directory and run id; reject non-run directories, missing/mismatched markers, and symlink aliases rather than trusting `run.json`.
 - Runner lifecycle and destructive process controls require the persisted cross-platform process identity proof (start time, command, and cwd where available), revalidated at authorization and immediately before signaling; dead, mismatched, or unsupported proofs stay distinct and fail closed rather than degrading to pid liveness. On Unix, only process-group `ESRCH` followed by another matching identity proof permits exact-pid fallback. Keep the residual post-read OS PID/PGID reuse window explicit because Node lacks one portable identity-stable group handle.

package/BACKLOG.md

@@ -1,7 +1,3 @@
 # Project Backlog
 
-## Open Work
-
-### Windows filesystem fencing verification
-
-- [ ] Add Windows CI and native NTFS regressions for consolidation root identity, directory junction/reparse-point substitution, lifecycle locks, and recovery without requiring privileged symbolic-link creation. Keep bigint device/inode capture, document filesystems that report weak or zero file identity, and evaluate a native handle-relative mutation layer only if real Windows evidence justifies expanding beyond Node’s portable process-crash and trusted-state-tree contract.
+No open items.

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## Unreleased
 
+## 0.42.2: Inspector Key Rail and Terminal Follow-up Context
+
+- `[Inspector Key Rail]` Moved every Inspector hotkey hint onto the bottom border, replacing the dedicated two-row footer with a border-connected rail. Blue key labels remain, while descriptions and `─` connectors use the border accent instead of bullet separators; the main viewport cap rises from 16 to 24 rows. Impact: the Inspector gains two content rows without losing keyboard discoverability, and the kill confirmation dialog now shares the same visual grammar.
+- `[Terminal Follow-up Context]` Kept terminal delivery on Pi's `followUp` queue but reduced LLM content to run id, status, one base path, and relative artifact names. Bounded semantic stdout/error payloads, correlation, and adapter transport metadata remain available only in non-LLM details and run state; the launcher writes initial progress before spawning its runner, and runners write terminal progress and review evidence before the `result.json` completion marker. Impact: completed background actors no longer inject raw output or unsolicited workflow prompts into coordinator context, and result readers never see an incomplete terminal state.
+
+## 0.42.1: Terminal Delivery and Cross-platform Validation
+
+- `[Terminal Delivery]` Added one bounded semantic terminal result with durable launch/tool-call correlation and bounded adapter-provided transport context. Explicit advertised semantic envelopes win; successful accepted reviews that advertise `review.completed` deterministically synthesize it when absent, while failed runs include their terminal error. Watcher and reconciliation delivery share the existing live in-flight dedupe guard, failed sends persist bounded retry evidence without writing the handled marker, and status exposes the latest failure. Impact: coordinators and Telegram-style chat/thread adapters can retain the exact launch/result relationship across detached completion instead of receiving only run-file metadata.
+- `[Inspector Kill Dialog]` Replaced the inline kill prompt with a dedicated responsive confirmation overlay showing the exact run and current status, explicit destructive copy, Cancel-first focus, arrow/Tab selection, Enter activation, and direct Y/N/Escape behavior. Exact owner, generation, and running status still revalidate through canonical control after confirmation, and bounded feedback returns to the Inspector. Impact: destructive actor termination now has an unmistakable, keyboard-predictable safety boundary.
+- `[Cross-platform CI]` Added identical release-validation matrix jobs for Ubuntu, macOS, and Windows with fail-fast disabled, bounded timeouts, pinned Node setup, npm caching, and `npm ci`; dependency audit now runs once in a separate Ubuntu job. Added invariants that keep audit outside platform-neutral validation. Impact: the package has one baseline release path across all supported host filesystems and shells.
+- `[macOS Run Ownership]` Recognized the exact platform-owned `/var` to `/private/var` temporary-root alias without weakening nested-parent or leaf-symlink rejection. Impact: run-state ownership remains fail-closed for caller-controlled aliases while macOS temporary directories pass canonical ownership checks.
+- `[Portable Build and Cleanup]` Invoked local JavaScript entrypoints through Node instead of relying on shell-specific executable resolution, recognized both path separators when resolving run state, converted file URLs with the platform API, made path assertions native, serialized release suites that exercise shared watchers, and cancelled live fixtures before removing their state. Impact: Windows paths and builds remain shell-free while macOS and Windows cleanup no longer races active worker writes.
+- `[Windows Filesystem Fencing]` Added native-only NTFS regressions for bigint consolidation-root identity, unprivileged directory-junction alias locking, lifecycle locking, draft-root reparse substitution, and trusted-root recovery replacement. Documented weak/zero device-inode filesystems and retained the portable realpath/root-identity/CAS contract without preemptively introducing a native handle-relative mutation layer. Impact: the Windows runner now owns concrete evidence for the deeper filesystem boundary rather than inheriting Unix symlink assumptions.
+- `[Cross-platform Validation Evidence]` Completed the release-validation matrix on Ubuntu, macOS, and Windows in GitHub Actions run `30322093465`, including native NTFS bigint root identity, directory-junction mutation/lifecycle locking, draft-root junction substitution, and trusted-root replacement recovery regressions. The failures found while establishing the matrix were portable path, command, process-tree, temporary-root alias, line-ending, and fixture-lifecycle gaps; no residual trusted-state-tree substitution window was reproduced, so a native handle-relative mutation layer is not warranted. Impact: the release boundary now has direct platform evidence for the portable process-crash and trusted-state-tree contract.
+
 ## 0.42.0: Automatic Recipe Evolution and Recipe-first Inspector
 
 - `Recipe-first Inspector`: The Inspector now opens on a bounded, redacted `Recipe` document for the selected owned run, showing authored identity, resolved launch template and values, composition, policy, mailbox, and artifacts without following mutable external recipe paths. `Messages` and `Turns` remain adjacent tabs; Turns use one scrollable detail level without duplicated recipe context, and documents/timelines/details support arrows plus PageUp/PageDown. Nested values render as compact indented text with label-first, separator-aware wrapping and consistent lowercase hints. Recipe documents retain ↑-at-top/← navigation to tabs, and ← now also returns a scrolled Messages or Turns list directly to its tabs without resetting the selected row. Turns retain one cached evidence snapshot while list/detail navigation remains active, eliminating repeated full session-file parsing on every arrow key while preserving periodic refresh when focus returns to higher-level controls.

package/README.md

@@ -293,7 +293,7 @@ Packaged recipes are building blocks. Use `spawn file=<recipe>` for maintained p
 | A useful output that should survive context compression | Artifacts |
 | A repeated local workflow | Recipe/tool memory |
 
-When a directly spawned inline/ad hoc actor or a recipe outside the user recipe root completes successfully, `pi-actors` may include a promotion suggestion in its terminal follow-up notification. The agent should ask first and never auto-save.
+Terminal completion queues a minimal follow-up with run id, status, one base path, and relative artifact names only. Bounded semantic output, launch/tool-call correlation, and optional transport context remain in non-LLM follow-up details and run state, so adapters retain the exact launch/result relationship without injecting actor output into coordinator context. Inspect the run before deciding whether a successful pattern deserves recipe persistence; never auto-save without the operator's confirmation.
 
 ## Platform support
 

package/dist/lib/async-runs.d.ts

@@ -18,6 +18,7 @@ export interface AsyncRunControlEndpoint {
     path: string;
     type: "fifo" | "mailbox" | "named-pipe";
 }
+export declare function normalizeRunTransportContext(value: unknown): Record<string, string | number | boolean> | undefined;
 export interface AsyncRunStartParams {
     async?: boolean;
     control?: AsyncRunControlEndpoint;
@@ -26,6 +27,10 @@ export interface AsyncRunStartParams {
     lifecycleHooks?: {
         onLockContention?(): void;
     };
+    launch_correlation?: {
+        correlation_id?: string;
+        tool_call_id?: string;
+    };
     name?: string;
     ownerId?: string;
     run_id?: string;
@@ -50,6 +55,7 @@ export interface AsyncRunStartParams {
     retry?: number | string;
     failure?: CommandTemplateFailureScope;
     recover?: CommandTemplateValue;
+    transport_context?: Record<string, unknown>;
     repeat?: number;
     values?: Record<string, unknown>;
     policy_values?: Record<string, unknown>;
@@ -62,6 +68,10 @@ export interface AsyncRunMeta {
     createdAt: string;
     cwd: string;
     launch_source?: AsyncRunLaunchSource;
+    launch_correlation?: {
+        correlation_id?: string;
+        tool_call_id?: string;
+    };
     ownerId?: string;
     pid: number;
     recipe?: string;
@@ -81,6 +91,7 @@ export interface AsyncRunMeta {
     process_identity?: RunProcessIdentity;
     recipe_context_records?: RecipesReferences.TemplateRecipeContextRecord[];
     retire_when?: "children_terminal";
+    transport_context?: Record<string, unknown>;
 }
 export { safeRunId } from "./runs-identity.ts";
 export { resolveArtifactManifest } from "./runs-artifacts.ts";
@@ -136,6 +147,7 @@ export interface RunControlExpectation {
     runInstanceId?: string;
 }
 export declare function markRunTerminalNotificationHandled(stateDir: string, status: string): void;
+export declare function recordRunTerminalDeliveryFailure(stateDir: string, status: string, error: unknown): void;
 export declare function cancelRun(runOrDir: string, expected?: RunControlExpectation): Record<string, unknown>;
 export declare function archiveRun(runOrDir: string): Record<string, unknown>;
 export declare function pruneRun(runOrDir: string, options?: {

package/dist/lib/async-runs.js

@@ -5,7 +5,7 @@
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { closeSync, existsSync, mkdirSync, openSync, readdirSync, statSync, writeFileSync, } from "node:fs";
-import { basename, dirname, extname, join, relative, resolve } from "node:path";
+import { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { writeJsonAtomic } from "./file-state.js";
 import { CURRENT_MODEL_VALUE_KEY, CURRENT_THINKING_VALUE_KEY, describeCurrentPolicyProvenance, } from "./model-context.js";
@@ -27,6 +27,27 @@ import { deliverRunMessage, } from "./runs-messages.js";
 import { buildRunStatus, tailFile, tailLines, } from "./runs-status.js";
 import { readJsonFileResilient } from "./state-readers.js";
 const RUNNER_IDENTITY_GRACE_MS = 5000;
+export function normalizeRunTransportContext(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const normalized = {};
+    for (const [key, item] of Object.entries(value).slice(0, 16)) {
+        const safeKey = key.trim().slice(0, 64);
+        if (!safeKey)
+            continue;
+        if (typeof item === "string") {
+            normalized[safeKey] = item.trim().slice(0, 256);
+            continue;
+        }
+        if (typeof item === "number" && Number.isFinite(item)) {
+            normalized[safeKey] = item;
+            continue;
+        }
+        if (typeof item === "boolean")
+            normalized[safeKey] = item;
+    }
+    return Object.keys(normalized).length ? normalized : undefined;
+}
 const DEFAULT_STATE_ROOT = Paths.getRunStateRoot();
 const DEFAULT_RECIPE_ROOT = Paths.getRecipeRoot();
 function packageRoot() {
@@ -91,7 +112,8 @@ function resolveRecipeFile(file) {
 function isMutableUsageRecipeFile(file) {
     const userRoot = resolve(DEFAULT_RECIPE_ROOT);
     const resolved = resolve(file);
-    return resolved.startsWith(`${userRoot}/`);
+    const relation = relative(userRoot, resolved);
+    return relation !== "" && !relation.startsWith("..") && !isAbsolute(relation);
 }
 function readRecipeFile(file) {
     const path = resolveRecipeFile(file);
@@ -260,6 +282,7 @@ export function startRun(params, cwd) {
             ...(startParams.defaults || {}),
             ...values,
         };
+        const transportContext = normalizeRunTransportContext(startParams.transport_context);
         const artifacts = resolveArtifactPaths(startParams.artifacts, outputValues);
         const meta = {
             argv: [process.execPath, ...argv],
@@ -268,6 +291,8 @@ export function startRun(params, cwd) {
             ...(startParams.launch_source
                 ? { launch_source: startParams.launch_source }
                 : {}),
+            ...(startParams.launch_correlation
+                ? { launch_correlation: startParams.launch_correlation } : {}),
             ...(startParams.ownerId ? { ownerId: startParams.ownerId } : {}),
             pid: 0,
             ...(recipe ? { recipe } : {}),
@@ -292,8 +317,17 @@ export function startRun(params, cwd) {
             ...(startParams.retire_when === "children_terminal"
                 ? { retire_when: "children_terminal" }
                 : {}),
+            ...(transportContext
+                ? { transport_context: transportContext } : {}),
         };
         writeJsonAtomic(join(stateDir, "run.json"), meta);
+        writeJsonAtomic(join(stateDir, "progress.json"), {
+            completed: 0,
+            failures: [],
+            model_policy: modelPolicy,
+            phase: "starting",
+            updatedAt: new Date().toISOString(),
+        });
         const child = spawn(process.execPath, argv, {
             cwd,
             detached: true,
@@ -306,13 +340,6 @@ export function startRun(params, cwd) {
         if (processIdentity)
             meta.process_identity = processIdentity;
         writeJsonAtomic(join(stateDir, "run.json"), meta);
-        writeJsonAtomic(join(stateDir, "progress.json"), {
-            completed: 0,
-            failures: [],
-            model_policy: modelPolicy,
-            phase: "starting",
-            updatedAt: new Date().toISOString(),
-        });
         writeFileSync(join(stateDir, "events.jsonl"), `${JSON.stringify({ event: "run.start", run, run_instance_id: meta.run_instance_id, pid: meta.pid, ts: new Date().toISOString() })}\n`, { flag: "a" });
         child.unref();
         return meta;
@@ -323,7 +350,7 @@ export function startRun(params, cwd) {
 }
 export { parseRunOutboxEventLine } from "./runs-outbox.js";
 function resolveRunStateDir(runOrDir) {
-    return resolve(runOrDir.includes("/")
+    return resolve(/[\\/]/u.test(runOrDir)
         ? runOrDir
         : join(DEFAULT_STATE_ROOT, safeRunId(runOrDir)));
 }
@@ -515,11 +542,11 @@ function finalizeInterruptedReviewEvidence(stateDir, phase, signal) {
                 return {
                     attempt: index + 1,
                     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,
                     },
                 };
@@ -606,6 +633,20 @@ export function markRunTerminalNotificationHandled(stateDir, status) {
         status,
     });
 }
+export function recordRunTerminalDeliveryFailure(stateDir, status, error) {
+    const path = join(stateDir, "terminal-delivery-failure.json");
+    const previous = readJson(path);
+    const message = (error instanceof Error ? error.message : String(error))
+        .replaceAll(/\s+/g, " ")
+        .trim()
+        .slice(0, 500);
+    writeJsonAtomic(path, {
+        attempts: Math.max(0, Number(previous?.attempts ?? 0)) + 1,
+        error: message || "unknown delivery failure",
+        status,
+        ts: new Date().toISOString(),
+    });
+}
 export function cancelRun(runOrDir, expected = {}) {
     const result = stopRun(runOrDir, "SIGTERM", "run.cancel", expected);
     return Object.hasOwn(result, "stopped")

package/dist/lib/command-templates.js

@@ -344,7 +344,7 @@ export function splitCommandTemplate(input) {
     let active = false;
     for (const char of input) {
         if (escaped) {
-            current += char;
+            current += /[\s'"\\]/u.test(char) ? char : `\\${char}`;
             escaped = false;
             active = true;
             continue;

package/dist/lib/inspector-overlay.d.ts

@@ -40,6 +40,7 @@ export declare class ActorInspectorOverlay {
     private detailTurn?;
     private feedback?;
     private killConfirmation?;
+    private killDialogChoice;
     private readonly readKeys;
     private focus;
     private filterControlIndex;
@@ -62,8 +63,9 @@ export declare class ActorInspectorOverlay {
     private selectRun;
     private cycleRun;
     private requestKill;
+    private cancelKill;
     private confirmKill;
-    private renderKillConfirmation;
+    private renderKillDialog;
     private listItemCount;
     private selectorAnchor;
     private renderKeyHints;
@@ -102,11 +104,13 @@ export declare class ActorInspectorOverlay {
     private openDetail;
     private backDetail;
     private closeDetail;
+    private footerBorder;
     private border;
     private stripeBackground;
     private stripedRow;
     private row;
     private takeVisiblePrefix;
     private dropVisiblePrefix;
+    private center;
     private fit;
 }

package/dist/lib/inspector-overlay.js

@@ -33,6 +33,7 @@ export class ActorInspectorOverlay {
     detailTurn;
     feedback;
     killConfirmation;
+    killDialogChoice = "cancel";
     readKeys = new Set();
     focus = "tabs";
     filterControlIndex = 0;
@@ -67,13 +68,25 @@ export class ActorInspectorOverlay {
             return;
         }
         if (this.killConfirmation) {
-            if (matchesKey(data, "escape") || data.toLowerCase() === "n") {
-                this.feedback = { ok: false, message: "Kill cancelled." };
-                this.killConfirmation = undefined;
+            const key = data.toLowerCase();
+            if (matchesKey(data, "escape") || key === "n") {
+                this.cancelKill();
             }
-            else if (matchesKey(data, "return") || data.toLowerCase() === "y") {
+            else if (matchesKey(data, "left") ||
+                matchesKey(data, "right") ||
+                matchesKey(data, "tab")) {
+                this.killDialogChoice =
+                    this.killDialogChoice === "cancel" ? "kill" : "cancel";
+            }
+            else if (key === "y") {
                 this.confirmKill();
             }
+            else if (matchesKey(data, "return")) {
+                if (this.killDialogChoice === "kill")
+                    this.confirmKill();
+                else
+                    this.cancelKill();
+            }
             this.tui.requestRender();
             return;
         }
@@ -200,6 +213,8 @@ export class ActorInspectorOverlay {
         this.ensureSelectedRun(this.runs());
         const safeWidth = Math.max(24, width);
         const innerWidth = Math.max(1, safeWidth - 2);
+        if (this.killConfirmation)
+            return this.renderKillDialog(safeWidth, innerWidth);
         const lines = [];
         lines.push(this.border("╭", " Actor Inspector ", "╮", innerWidth));
         lines.push(this.row(this.renderRunControl(), innerWidth));
@@ -224,18 +239,16 @@ export class ActorInspectorOverlay {
         if (selectorTop) {
             const leadingBorder = "─".repeat(selectorAnchor);
             const remainingBorder = "─".repeat(Math.max(0, innerWidth - visibleWidth(selectorTop) - selectorAnchor));
-            lines.push(`${this.theme.fg("border", `├${leadingBorder}`)}${selectorTop}${this.theme.fg("border", `${remainingBorder}┤`)}`);
+            lines.push(`${this.theme.fg("borderAccent", `├${leadingBorder}`)}${selectorTop}${this.theme.fg("borderAccent", `${remainingBorder}┤`)}`);
         }
         else
             lines.push(this.border("├", "", "┤", innerWidth));
         this.contentStripeIndices = [];
-        const baseContent = this.killConfirmation
-            ? this.renderKillConfirmation()
-            : this.detailOpen
-                ? this.renderDetail(innerWidth)
-                : this.selectedRun
-                    ? this.renderTimeline(innerWidth)
-                    : this.renderRunSelector(innerWidth);
+        const baseContent = this.detailOpen
+            ? this.renderDetail(innerWidth)
+            : this.selectedRun
+                ? this.renderTimeline(innerWidth)
+                : this.renderRunSelector(innerWidth);
         const content = this.feedback && !this.killConfirmation
             ? [
                 this.theme.fg(this.feedback.ok
@@ -267,9 +280,7 @@ export class ActorInspectorOverlay {
             const preservedBase = this.stripeBackground(this.fit(this.dropVisiblePrefix(base, popupWidth + popupAnchor), baseWidth), stripeIndex);
             lines.push(this.row(`${leadingBase}${visiblePopup}${preservedBase}`, innerWidth, true));
         }
-        lines.push(this.border("├", "", "┤", innerWidth));
-        lines.push(this.row(this.renderKeyHints(), innerWidth));
-        lines.push(this.border("╰", "", "╯", innerWidth));
+        lines.push(this.footerBorder(this.renderKeyHints(), innerWidth));
         return lines;
     }
     invalidate() { }
@@ -285,7 +296,7 @@ export class ActorInspectorOverlay {
     }
     contentViewportRows() {
         const overlayRows = Math.floor(this.tui.terminal.rows * 0.94);
-        return Math.max(4, Math.min(16, overlayRows - 7));
+        return Math.max(4, Math.min(24, overlayRows - 5));
     }
     selectRun(run, index) {
         this.selectedRun = run;
@@ -337,11 +348,19 @@ export class ActorInspectorOverlay {
         this.killConfirmation = {
             run: run.run,
             runInstanceId: run.runInstanceId,
+            status: run.status,
         };
+        this.killDialogChoice = "cancel";
+    }
+    cancelKill() {
+        this.feedback = { ok: false, message: "Kill cancelled." };
+        this.killConfirmation = undefined;
+        this.killDialogChoice = "cancel";
     }
     confirmKill() {
         const confirmation = this.killConfirmation;
         this.killConfirmation = undefined;
+        this.killDialogChoice = "cancel";
         if (!confirmation || !this.killRun) {
             this.feedback = { ok: false, message: "Kill unavailable in this Inspector." };
             return;
@@ -357,11 +376,41 @@ export class ActorInspectorOverlay {
             };
         }
     }
-    renderKillConfirmation() {
-        return [
-            this.theme.fg("error", ` Kill running actor run:${this.killConfirmation?.run}?`),
-            this.theme.fg("muted", " This sends canonical control.kill and cannot be undone."),
+    renderKillDialog(_width, innerWidth) {
+        const confirmation = this.killConfirmation;
+        const totalRows = this.contentViewportRows() + 5;
+        const cancel = this.killDialogChoice === "cancel"
+            ? this.theme.bg("selectedBg", this.theme.fg("accent", "  Cancel  "))
+            : this.theme.fg("muted", "  Cancel  ");
+        const kill = this.killDialogChoice === "kill"
+            ? this.theme.bg("selectedBg", this.theme.fg("error", "  Kill actor  "))
+            : this.theme.fg("error", "  Kill actor  ");
+        const body = [
+            "",
+            this.theme.fg("error", "Kill this running actor?"),
+            "",
+            `${this.theme.fg("muted", "Run:")} ${this.theme.fg("accent", `run:${confirmation.run}`)}`,
+            `${this.theme.fg("muted", "Current status:")} ${this.theme.fg("warning", confirmation.status)}`,
+            "",
+            this.theme.fg("text", "This sends canonical control.kill."),
+            this.theme.fg("error", "The action is destructive and cannot be undone."),
+            "",
+            `${cancel}    ${kill}`,
+            "",
         ];
+        const lines = [this.border("╭", " Confirm Actor Kill ", "╮", innerWidth)];
+        const availableRows = Math.max(1, totalRows - 2);
+        const topPadding = Math.max(0, Math.floor((availableRows - body.length) / 2));
+        const dialogRows = [
+            ...Array.from({ length: topPadding }, () => ""),
+            ...body,
+        ].slice(0, availableRows);
+        while (dialogRows.length < availableRows)
+            dialogRows.push("");
+        for (const line of dialogRows)
+            lines.push(this.row(this.center(line, innerWidth), innerWidth));
+        lines.push(this.footerBorder(this.renderKeyHints(), innerWidth));
+        return lines;
     }
     listItemCount() {
         if (this.tab === "recipe")
@@ -384,27 +433,34 @@ export class ActorInspectorOverlay {
         return Math.max(0, tabs.indexOf(label) - 2);
     }
     renderKeyHints() {
-        const hint = (keys, description) => `${this.theme.fg("accent", keys)}${this.theme.fg("dim", ` ${description}`)}`;
+        const hint = (keys, description) => `${this.theme.fg("accent", keys)}${this.theme.fg("borderAccent", ` ${description}`)}`;
+        const divider = this.theme.fg("borderAccent", " ─ ");
+        const hints = (...items) => items.map(([keys, description]) => hint(keys, description)).join(divider);
         if (this.killConfirmation)
-            return ` ${hint("y/enter", "confirm kill")}  ${hint("n/esc", "cancel")}`;
+            return hints(["←→/tab", "choose"], ["enter/y", "confirm"], ["esc/n", "cancel"]);
         if (this.focus === "select")
             return this.menuLevel === "value"
-                ? ` ${hint("↑↓", "option")}  ${hint("enter", "apply")}  ${hint("←/esc", "back")}`
-                : ` ${hint("↑↓", "option")}  ${hint("→/enter", "open")}  ${hint("←/esc", "back")}`;
+                ? hints(["↑↓", "option"], ["enter", "apply"], ["←/esc", "back"])
+                : hints(["↑↓", "option"], ["→/enter", "open"], ["←/esc", "back"]);
         if (this.focus === "recipe")
-            return ` ${hint("↑↓/pgup/pgdn", "scroll")}  ${hint("↑ at top", "tabs")}  ${hint("←/esc", "tabs")}`;
+            return hints(["↑↓/pgup/pgdn", "scroll"], ["↑ at top", "tabs"], ["←/esc", "tabs"]);
         if (this.focus === "detail")
-            return ` ${hint("↑↓/pgup/pgdn", "scroll")}  ${hint("←/esc", "back")}`;
+            return hints(["↑↓/pgup/pgdn", "scroll"], ["←/esc", "back"]);
         if (this.focus === "list")
-            return ` ${hint("↑↓/pgup/pgdn", "row")}  ${hint("→/enter", "open")}  ${hint("←", "tabs")}  ${hint("esc", "close")}`;
+            return hints(["↑↓/pgup/pgdn", "row"], ["→/enter", "open"], ["←", "tabs"], ["esc", "close"]);
         if (this.focus === "runs") {
+            const items = [
+                ["←→", "run"],
+                ["↓", "tabs"],
+                ["enter", "list"],
+            ];
             const run = this.runs().find((item) => item.run === this.selectedRun);
-            const killHint = this.killRun && run?.status === "running" && run.runInstanceId
-                ? `  ${hint("k", "kill")}`
-                : "";
-            return ` ${hint("←→", "run")}  ${hint("↓", "tabs")}  ${hint("enter", "list")}${killHint}  ${hint("esc", "close")}`;
+            if (this.killRun && run?.status === "running" && run.runInstanceId)
+                items.push(["k", "kill"]);
+            items.push(["esc", "close"]);
+            return hints(...items);
         }
-        return ` ${hint("←→", "navigate")}  ${hint("↑↓", "change row")}  ${hint("enter", "select")}  ${hint("esc", "close")}`;
+        return hints(["←→", "navigate"], ["↑↓", "change row"], ["enter", "select"], ["esc", "close"]);
     }
     renderRunControl() {
         const runs = this.runs();
@@ -962,7 +1018,7 @@ export class ActorInspectorOverlay {
         const hiddenAbove = start > 0;
         const hiddenBelow = start + visibleOptions.length < options.length;
         const contentWidth = Math.max(4, ...options.map((option) => visibleWidth(option) + 4));
-        const border = (left, right, marker = "") => this.theme.fg("border", `${omitLeftBorder ? "" : left}${marker}${"─".repeat(Math.max(0, contentWidth - visibleWidth(marker)))}${omitRightBorder ? "" : right}`);
+        const border = (left, right, marker = "") => this.theme.fg("borderAccent", `${omitLeftBorder ? "" : left}${marker}${"─".repeat(Math.max(0, contentWidth - visibleWidth(marker)))}${omitRightBorder ? "" : right}`);
         return [
             border("╭", "╮", hiddenAbove ? "↑" : ""),
             ...visibleOptions.map((option, localIndex) => {
@@ -975,7 +1031,7 @@ export class ActorInspectorOverlay {
                 const styled = focused || index === parentIndex
                     ? this.theme.bg("selectedBg", colored)
                     : colored;
-                return `${omitLeftBorder ? "" : this.theme.fg("border", "│")}${styled}${omitRightBorder ? "" : this.theme.fg("border", "│")}`;
+                return `${omitLeftBorder ? "" : this.theme.fg("borderAccent", "│")}${styled}${omitRightBorder ? "" : this.theme.fg("borderAccent", "│")}`;
             }),
             border("╰", "╯", hiddenBelow ? "↓" : ""),
         ];
@@ -1017,10 +1073,17 @@ export class ActorInspectorOverlay {
         this.detailScroll = 0;
         this.focus = "list";
     }
+    footerBorder(hints, width) {
+        const prefix = " ";
+        const suffix = " ─";
+        const content = truncateToWidth(hints, Math.max(0, width - visibleWidth(prefix) - visibleWidth(suffix)), "");
+        const fill = "─".repeat(Math.max(0, width - visibleWidth(prefix) - visibleWidth(suffix) - visibleWidth(content)));
+        return `${this.theme.fg("borderAccent", `╰${prefix}`)}${content}${this.theme.fg("borderAccent", `${suffix}${fill}╯`)}`;
+    }
     border(left, title, right, width) {
         const titleText = truncateToWidth(title, width, "");
         const fill = "─".repeat(Math.max(0, width - visibleWidth(titleText)));
-        return this.theme.fg("border", `${left}${titleText}${fill}${right}`);
+        return this.theme.fg("borderAccent", `${left}${titleText}${fill}${right}`);
     }
     stripeBackground(content, index) {
         if (index % 2 === 0)
@@ -1035,7 +1098,7 @@ export class ActorInspectorOverlay {
     }
     row(content, width, fitted = false) {
         const body = fitted ? content : this.fit(content, width);
-        return `${this.theme.fg("border", "│")}${body}${this.theme.fg("border", "│")}`;
+        return `${this.theme.fg("borderAccent", "│")}${body}${this.theme.fg("borderAccent", "│")}`;
     }
     takeVisiblePrefix(content, width) {
         const plain = stripVTControlCharacters(content);
@@ -1062,6 +1125,11 @@ export class ActorInspectorOverlay {
         }
         return plain.slice(index);
     }
+    center(content, width) {
+        const contentWidth = visibleWidth(content);
+        const leading = Math.max(0, Math.floor((width - contentWidth) / 2));
+        return `${" ".repeat(leading)}${content}`;
+    }
     fit(content, width) {
         // A Component render entry must remain exactly one terminal row. Persisted
         // prompts, messages, and tool results may contain line breaks or tabs;

package/dist/lib/inspector.js

@@ -126,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,6 +15,7 @@ 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";
@@ -22,6 +23,7 @@ export interface RunObservation {
     terminalHandled?: boolean;
     retireWhen?: string;
     run: string;
+    semanticResult?: RunTerminalSemanticResult;
     tool?: string;
     stateDir?: string;
     status: RunObservedStatus;
@@ -131,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;
@@ -169,5 +181,4 @@ export declare function formatRunOutboxMessage(event: RunOutboxEvent): string;
 export declare function getRunTransitionNotificationType(transition: RunTransition): RunTransitionNotificationType;
 export declare function shouldNotifyRunTransition(transition: RunTransition): boolean;
 export declare function shouldSendRunTransitionFollowUp(transition: RunTransition): boolean;
-export declare function shouldSuggestRecipePersistence(transition: RunTransition): boolean;
 export declare function formatRunTransitionMessage(transition: RunTransition): string;