@llblab/pi-actors 0.41.1 → 0.42.0

package/dist/lib/inspector-overlay.js

@@ -5,12 +5,19 @@
  */
 import * as path from "node:path";
 import { stripVTControlCharacters } from "node:util";
-import { matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi, } from "@earendil-works/pi-tui";
+import { matchesKey, truncateToWidth, visibleWidth, } from "@earendil-works/pi-tui";
 import * as Inspector from "./inspector.js";
+const INSPECTOR_TABS = [
+    "recipe",
+    "communications",
+    "turns",
+];
 const DETAIL_SECTION_BREAK = { sectionBreak: true };
 export class ActorInspectorOverlay {
     done;
+    killRun;
     ownerId;
+    readTurns;
     stateRoot;
     theme;
     tui;
@@ -24,23 +31,32 @@ export class ActorInspectorOverlay {
     detailOpen = false;
     detailScroll = 0;
     detailTurn;
-    detailView = "evidence";
+    feedback;
+    killConfirmation;
     readKeys = new Set();
     focus = "tabs";
     filterControlIndex = 0;
     menuLevel = "filter";
     selectorIndex = 0;
+    recipeScroll = 0;
     rowIndex = 0;
     selectedRun;
     subagentIndex = 0;
-    tab = "communications";
+    tab = "recipe";
+    turnCache;
     constructor(options) {
         this.done = options.done;
+        this.killRun = options.killRun;
         this.ownerId = options.ownerId;
+        this.readTurns = options.readTurns ?? Inspector.readActorInspectorTurns;
         this.stateRoot = options.stateRoot;
         this.theme = options.theme;
         this.tui = options.tui;
-        this.refreshTimer = setInterval(() => this.tui.requestRender(), 1000);
+        this.refreshTimer = setInterval(() => {
+            if (this.focus !== "list" && this.focus !== "detail")
+                this.turnCache = undefined;
+            this.tui.requestRender();
+        }, 1000);
         this.refreshTimer.unref?.();
     }
     handleInput(data) {
@@ -50,6 +66,22 @@ export class ActorInspectorOverlay {
             this.done();
             return;
         }
+        if (this.killConfirmation) {
+            if (matchesKey(data, "escape") || data.toLowerCase() === "n") {
+                this.feedback = { ok: false, message: "Kill cancelled." };
+                this.killConfirmation = undefined;
+            }
+            else if (matchesKey(data, "return") || data.toLowerCase() === "y") {
+                this.confirmKill();
+            }
+            this.tui.requestRender();
+            return;
+        }
+        if (data.toLowerCase() === "k") {
+            this.requestKill(runs);
+            this.tui.requestRender();
+            return;
+        }
         if (matchesKey(data, "escape")) {
             if (this.focus === "select") {
                 if (this.menuLevel === "value") {
@@ -61,6 +93,8 @@ export class ActorInspectorOverlay {
             }
             else if (this.focus === "detail")
                 this.backDetail();
+            else if (this.focus === "recipe")
+                this.focus = "tabs";
             else
                 this.done();
             this.tui.requestRender();
@@ -80,19 +114,35 @@ export class ActorInspectorOverlay {
             this.tui.requestRender();
             return;
         }
+        if (this.focus === "recipe") {
+            if (matchesKey(data, "up")) {
+                if (this.recipeScroll === 0)
+                    this.focus = "tabs";
+                else
+                    this.recipeScroll -= 1;
+            }
+            else if (matchesKey(data, "down"))
+                this.recipeScroll += 1;
+            else if (matchesKey(data, "pageUp"))
+                this.recipeScroll = Math.max(0, this.recipeScroll - this.contentViewportRows());
+            else if (matchesKey(data, "pageDown"))
+                this.recipeScroll += this.contentViewportRows();
+            else if (matchesKey(data, "left"))
+                this.focus = "tabs";
+            this.tui.requestRender();
+            return;
+        }
         if (this.focus === "detail") {
             if (matchesKey(data, "up"))
                 this.detailScroll = Math.max(0, this.detailScroll - 1);
             else if (matchesKey(data, "down"))
                 this.detailScroll += 1;
+            else if (matchesKey(data, "pageUp"))
+                this.detailScroll = Math.max(0, this.detailScroll - this.contentViewportRows());
+            else if (matchesKey(data, "pageDown"))
+                this.detailScroll += this.contentViewportRows();
             else if (matchesKey(data, "left"))
                 this.backDetail();
-            else if ((matchesKey(data, "right") || matchesKey(data, "return")) &&
-                this.detailView === "evidence" &&
-                this.tab === "turns") {
-                this.detailView = "transcript";
-                this.detailScroll = 0;
-            }
             this.tui.requestRender();
             return;
         }
@@ -108,12 +158,18 @@ export class ActorInspectorOverlay {
         }
         else if (this.focus === "tabs") {
             if (matchesKey(data, "left") || matchesKey(data, "right")) {
-                this.tab = this.tab === "communications" ? "turns" : "communications";
+                const current = INSPECTOR_TABS.indexOf(this.tab);
+                const direction = matchesKey(data, "right") ? 1 : -1;
+                this.tab = INSPECTOR_TABS[(current + direction + INSPECTOR_TABS.length) % INSPECTOR_TABS.length];
                 this.filterControlIndex = 0;
+                this.recipeScroll = 0;
                 this.rowIndex = 0;
             }
             else if (matchesKey(data, "up"))
                 this.focus = "runs";
+            else if ((matchesKey(data, "down") || matchesKey(data, "return")) &&
+                this.tab === "recipe")
+                this.focus = "recipe";
             else if (matchesKey(data, "down") && this.listItemCount() > 0)
                 this.focus = "list";
             else if (matchesKey(data, "return"))
@@ -121,7 +177,13 @@ export class ActorInspectorOverlay {
         }
         else if (this.focus === "list") {
             const count = this.tab === "communications" ? this.communicationPreviews().length : this.turnItems().length;
-            if (matchesKey(data, "up")) {
+            if (matchesKey(data, "left"))
+                this.focus = "tabs";
+            else if (matchesKey(data, "pageUp"))
+                this.rowIndex = Math.max(0, this.rowIndex - this.contentViewportRows());
+            else if (matchesKey(data, "pageDown"))
+                this.rowIndex = Math.min(Math.max(0, count - 1), this.rowIndex + this.contentViewportRows());
+            else if (matchesKey(data, "up")) {
                 if (this.rowIndex === 0)
                     this.focus = "tabs";
                 else
@@ -167,11 +229,23 @@ export class ActorInspectorOverlay {
         else
             lines.push(this.border("├", "", "┤", innerWidth));
         this.contentStripeIndices = [];
-        const content = this.detailOpen
-            ? this.renderDetail(innerWidth)
-            : this.selectedRun
-                ? this.renderTimeline(innerWidth)
-                : this.renderRunSelector(innerWidth);
+        const baseContent = this.killConfirmation
+            ? this.renderKillConfirmation()
+            : 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
+                    ? "success"
+                    : /^Kill (failed|rejected):/.test(this.feedback.message)
+                        ? "error"
+                        : "warning", ` ${this.feedback.message}`),
+                ...baseContent.slice(0, Math.max(0, this.contentViewportRows() - 1)),
+            ]
+            : baseContent;
         const contentViewportRows = this.contentViewportRows();
         const selectorRows = selector.slice(1);
         for (let index = 0; index < Math.max(content.length, contentViewportRows); index += 1) {
@@ -215,7 +289,9 @@ export class ActorInspectorOverlay {
     }
     selectRun(run, index) {
         this.selectedRun = run;
+        this.turnCache = undefined;
         this.runIndex = index;
+        this.recipeScroll = 0;
         this.rowIndex = 0;
         this.subagentIndex = 0;
         this.communicationFrom = "all";
@@ -229,7 +305,67 @@ export class ActorInspectorOverlay {
         if (next)
             this.selectRun(next.run, nextIndex);
     }
+    requestKill(runs) {
+        this.feedback = undefined;
+        if (this.focus !== "runs") {
+            this.feedback = { ok: false, message: "Focus Run before using Kill." };
+            return;
+        }
+        const run = runs.find((item) => item.run === this.selectedRun);
+        if (!run) {
+            this.feedback = { ok: false, message: "Kill unavailable: no owned run." };
+            return;
+        }
+        if (!this.killRun) {
+            this.feedback = { ok: false, message: "Kill unavailable in this Inspector." };
+            return;
+        }
+        if (run.status !== "running") {
+            this.feedback = {
+                ok: false,
+                message: `Kill unavailable: run is ${run.status}.`,
+            };
+            return;
+        }
+        if (!run.runInstanceId) {
+            this.feedback = {
+                ok: false,
+                message: "Kill unavailable: run generation unavailable.",
+            };
+            return;
+        }
+        this.killConfirmation = {
+            run: run.run,
+            runInstanceId: run.runInstanceId,
+        };
+    }
+    confirmKill() {
+        const confirmation = this.killConfirmation;
+        this.killConfirmation = undefined;
+        if (!confirmation || !this.killRun) {
+            this.feedback = { ok: false, message: "Kill unavailable in this Inspector." };
+            return;
+        }
+        try {
+            this.feedback = this.killRun(confirmation.run, confirmation.runInstanceId);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.feedback = {
+                ok: false,
+                message: `Kill failed: ${message.replaceAll(/\s+/g, " ").slice(0, 160)}.`,
+            };
+        }
+    }
+    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."),
+        ];
+    }
     listItemCount() {
+        if (this.tab === "recipe")
+            return 0;
         return this.tab === "communications"
             ? this.communicationPreviews().length
             : this.turnItems().length;
@@ -239,24 +375,35 @@ export class ActorInspectorOverlay {
             const runControl = stripVTControlCharacters(this.renderRunControl());
             return Math.max(0, runControl.indexOf("Run:") - 2);
         }
-        const label = this.tab === "communications" ? "Messages" : "Turns";
+        const label = this.tab === "communications"
+            ? "Messages"
+            : this.tab === "turns"
+                ? "Turns"
+                : "Recipe";
         const tabs = stripVTControlCharacters(this.renderTabs());
         return Math.max(0, tabs.indexOf(label) - 2);
     }
     renderKeyHints() {
         const hint = (keys, description) => `${this.theme.fg("accent", keys)}${this.theme.fg("dim", ` ${description}`)}`;
+        if (this.killConfirmation)
+            return ` ${hint("y/enter", "confirm kill")}  ${hint("n/esc", "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")}`;
+        if (this.focus === "recipe")
+            return ` ${hint("↑↓/pgup/pgdn", "scroll")}  ${hint("↑ at top", "tabs")}  ${hint("←/esc", "tabs")}`;
         if (this.focus === "detail")
-            return this.tab === "turns" && this.detailView === "evidence"
-                ? ` ${hint("↑↓", "scroll")}  ${hint("→/enter", "readable")}  ${hint("←/esc", "back")}`
-                : ` ${hint("↑↓", "scroll")}  ${hint("←/esc", this.detailView === "transcript" ? "evidence" : "back")}`;
+            return ` ${hint("↑↓/pgup/pgdn", "scroll")}  ${hint("←/esc", "back")}`;
         if (this.focus === "list")
-            return ` ${hint("↑↓", "row")}  ${hint("→/enter", "open")}  ${hint("esc", "close")}`;
-        if (this.focus === "runs")
-            return ` ${hint("←→", "run")}  ${hint("↓", "tabs")}  ${hint("enter", "list")}  ${hint("esc", "close")}`;
+            return ` ${hint("↑↓/pgup/pgdn", "row")}  ${hint("→/enter", "open")}  ${hint("←", "tabs")}  ${hint("esc", "close")}`;
+        if (this.focus === "runs") {
+            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")}`;
+        }
         return ` ${hint("←→", "navigate")}  ${hint("↑↓", "change row")}  ${hint("enter", "select")}  ${hint("esc", "close")}`;
     }
     renderRunControl() {
@@ -306,7 +453,7 @@ export class ActorInspectorOverlay {
         const subagent = this.subagents()[this.subagentIndex] ?? "all";
         const messagesLabel = `Messages${messageFilters.length > 0 ? ` (${messageFilters.join(", ")})` : ""}`;
         const turnsLabel = `Turns${subagent === "all" ? "" : ` (${subagent})`}`;
-        return `${tab("communications", messagesLabel)} ${tab("turns", turnsLabel)}`;
+        return `${tab("recipe", "Recipe")} ${tab("communications", messagesLabel)} ${tab("turns", turnsLabel)}`;
     }
     renderRunSelector(width) {
         const runs = this.runs();
@@ -331,6 +478,8 @@ export class ActorInspectorOverlay {
             this.selectedRun = undefined;
             return [this.theme.fg("warning", " Selected run is no longer owned by this session")];
         }
+        if (this.tab === "recipe")
+            return this.renderRecipe(width);
         const rows = this.tab === "communications"
             ? this.communicationRows()
             : this.turnRows();
@@ -363,6 +512,28 @@ export class ActorInspectorOverlay {
                 : `   ${row}`;
         });
     }
+    renderRecipe(width) {
+        if (!this.selectedRun)
+            return [];
+        const recipe = Inspector.readActorInspectorRecipe(path.join(this.stateRoot, this.selectedRun));
+        const logicalLines = [
+            ...this.detailSection("Identity", this.readableValueLines(recipe.identity, "  ")),
+            ...(recipe.definition
+                ? this.detailSection("Recipe", this.readableValueLines(recipe.definition, "  "))
+                : []),
+            ...this.detailSection("Launch", this.readableValueLines(recipe.launch, "  ")),
+            ...(recipe.composition.length > 0
+                ? this.detailSection("Composition", this.readableValueLines(recipe.composition, "  "))
+                : []),
+            ...this.detailSection("Diagnostics", recipe.diagnostics),
+        ];
+        const wrapped = this.wrapDetailLines(logicalLines.length > 0 ? logicalLines : [" No persisted recipe evidence"], width);
+        const viewportRows = this.contentViewportRows();
+        const maxStart = Math.max(0, wrapped.lines.length - viewportRows);
+        this.recipeScroll = Math.min(this.recipeScroll, maxStart);
+        this.contentStripeIndices = wrapped.stripeIndices.slice(this.recipeScroll, this.recipeScroll + viewportRows);
+        return wrapped.lines.slice(this.recipeScroll, this.recipeScroll + viewportRows);
+    }
     communicationPreviews() {
         if (!this.selectedRun)
             return [];
@@ -419,16 +590,18 @@ export class ActorInspectorOverlay {
                 ["inbox", preview.inbox_status],
                 ["timestamp", preview.timestamp],
             ];
-            return fields
+            const lines = fields
                 .filter(([, value]) => value !== undefined)
                 .map(([label, value]) => truncateToWidth(` ${label.padEnd(12, " ")} ${typeof value === "string" ? value : JSON.stringify(value)}`, width, "…"));
+            const viewportRows = this.contentViewportRows();
+            const maxStart = Math.max(0, lines.length - viewportRows);
+            this.detailScroll = Math.min(this.detailScroll, maxStart);
+            return lines.slice(this.detailScroll, this.detailScroll + viewportRows);
         }
         const turn = this.detailTurn;
         if (!turn)
             return [this.theme.fg("warning", " Turn row is no longer available")];
-        const logicalLines = this.detailView === "transcript"
-            ? this.turnTranscriptLines(turn)
-            : this.turnEvidenceLines(turn);
+        const logicalLines = this.turnEvidenceLines(turn);
         const wrapped = this.wrapDetailLines(logicalLines, width);
         const viewportRows = this.contentViewportRows();
         const maxStart = Math.max(0, wrapped.lines.length - viewportRows);
@@ -452,9 +625,31 @@ export class ActorInspectorOverlay {
                 const leading = physicalLine.match(/^ */)?.[0] ?? "";
                 const content = physicalLine.slice(leading.length);
                 const contentWidth = Math.max(1, width - visibleWidth(leading));
-                const wrapped = visibleWidth(physicalLine) <= width
-                    ? [physicalLine]
-                    : wrapTextWithAnsi(content, contentWidth).map((visualLine) => `${leading}${visualLine}`);
+                const labeled = /^(\s*(?:-\s+)?[^:]+:\s+)(\S.*)$/u.exec(physicalLine);
+                let wrapped;
+                if (visibleWidth(physicalLine) > width &&
+                    labeled &&
+                    visibleWidth(labeled[1]) < width) {
+                    const prefix = labeled[1];
+                    const value = labeled[2];
+                    const firstWidth = Math.max(1, width - visibleWidth(prefix));
+                    const first = this.wrapPreferred(value, firstWidth)[0] ??
+                        this.takeVisiblePrefix(value, firstWidth);
+                    const remainder = value.slice(first.length).trimStart();
+                    const continuation = `${leading}  `;
+                    const continuationWidth = Math.max(1, width - visibleWidth(continuation));
+                    wrapped = [
+                        `${prefix}${first}`,
+                        ...(remainder
+                            ? this.wrapPreferred(remainder, continuationWidth).map((visualLine) => `${continuation}${visualLine}`)
+                            : []),
+                    ];
+                }
+                else {
+                    wrapped = visibleWidth(physicalLine) <= width
+                        ? [physicalLine]
+                        : this.wrapPreferred(content, contentWidth).map((visualLine) => `${leading}${visualLine}`);
+                }
                 for (const visualLine of wrapped) {
                     if (!visualLine.trim())
                         continue;
@@ -465,6 +660,40 @@ export class ActorInspectorOverlay {
         }
         return { lines: wrappedLines, stripeIndices };
     }
+    wrapPreferred(content, width) {
+        const lines = [];
+        let remaining = stripVTControlCharacters(content).trimEnd();
+        while (remaining && visibleWidth(remaining) > width) {
+            const candidate = this.takeVisiblePrefix(remaining, width);
+            let splitAt = -1;
+            let trimBoundary = false;
+            for (let index = 1; index < candidate.length; index += 1) {
+                if (/\s/u.test(candidate[index])) {
+                    splitAt = index + 1;
+                    trimBoundary = true;
+                }
+                else if (/[-+=/_,.:]/u.test(candidate[index])) {
+                    splitAt = index;
+                    trimBoundary = false;
+                }
+            }
+            if (splitAt <= 0)
+                splitAt = candidate.length;
+            const head = remaining.slice(0, splitAt).trimEnd();
+            if (!head) {
+                lines.push(candidate);
+                remaining = remaining.slice(candidate.length);
+                continue;
+            }
+            lines.push(head);
+            remaining = remaining.slice(splitAt);
+            if (trimBoundary)
+                remaining = remaining.trimStart();
+        }
+        if (remaining)
+            lines.push(remaining);
+        return lines;
+    }
     detailSection(title, content) {
         if (content.length === 0)
             return [];
@@ -508,9 +737,10 @@ export class ActorInspectorOverlay {
                 }
                 if (!item || typeof item !== "object")
                     return [`${indent}- ${String(item)}`];
+                const [first = "", ...rest] = this.readableValueLines(item, `${indent}  `, depth + 1);
                 return [
-                    `${indent}-`,
-                    ...this.readableValueLines(item, `${indent}  `, depth + 1),
+                    `${indent}- ${first.trimStart()}`,
+                    ...rest,
                 ];
             });
         }
@@ -543,7 +773,7 @@ export class ActorInspectorOverlay {
             : "";
         lines.push(` Subagent ${subagent}${stage}`, DETAIL_SECTION_BREAK);
         if (turn.userText)
-            lines.push(...this.detailSection("User", [turn.userText]));
+            lines.push(...this.detailSection("User", [this.readablePromptText(turn.userText)]));
         if (turn.thinking)
             lines.push(...this.detailSection("Thinking", [turn.thinking]));
         if (turn.assistantText)
@@ -586,12 +816,6 @@ export class ActorInspectorOverlay {
                     `  ${turn.promptFile}${turn.promptBytes ? ` (${turn.promptBytes} bytes)` : ""}`,
                 ]
                 : []),
-            ...(turn.recipeContext === undefined
-                ? []
-                : [
-                    "Recipe Context",
-                    ...this.readableValueLines(turn.recipeContext, "  "),
-                ]),
         ];
         lines.push(...this.detailSection("Provenance", provenance));
         return lines.length > 0 ? lines : [" No persisted turn evidence"];
@@ -600,34 +824,18 @@ export class ActorInspectorOverlay {
         const wrapped = /^\s*<file\b[^>]*>\s*([\s\S]*?)\s*<\/file>\s*$/i.exec(text);
         return wrapped?.[1]?.trim() || text;
     }
-    turnTranscriptLines(turn) {
-        const lines = [];
-        if (turn.userText)
-            lines.push(...this.detailSection("User", [this.readablePromptText(turn.userText)]));
-        if (turn.thinking)
-            lines.push(...this.detailSection("Thinking", [turn.thinking]));
-        if (turn.assistantText)
-            lines.push(...this.detailSection("Assistant", [turn.assistantText]));
-        for (const tool of turn.toolCalls) {
-            const content = [
-                ...(tool.arguments === undefined
-                    ? []
-                    : ["Input", ...this.readableValueLines(tool.arguments, "  ")]),
-                ...(tool.result === undefined
-                    ? []
-                    : ["Result", ...this.readableValueLines(tool.result, "  ")]),
-            ];
-            lines.push(...this.detailSection(`Tool (${tool.name}${tool.resultError ? ", Error" : ""})`, content));
-        }
-        if (turn.error)
-            lines.push(...this.detailSection("Error", [turn.error]));
-        return lines.length > 0 ? lines : [" No readable turn content"];
-    }
-    turnItems() {
+    allTurnItems() {
         if (!this.selectedRun)
             return [];
+        if (this.turnCache?.run === this.selectedRun)
+            return this.turnCache.turns;
+        const turns = this.readTurns(path.join(this.stateRoot, this.selectedRun));
+        this.turnCache = { run: this.selectedRun, turns };
+        return turns;
+    }
+    turnItems() {
         const selectedSubagent = this.subagents()[this.subagentIndex];
-        return Inspector.readActorInspectorTurns(path.join(this.stateRoot, this.selectedRun))
+        return this.allTurnItems()
             .filter((turn) => !selectedSubagent ||
             selectedSubagent === "all" ||
             turn.commandId === selectedSubagent)
@@ -662,7 +870,7 @@ export class ActorInspectorOverlay {
     subagents() {
         if (!this.selectedRun || this.tab !== "turns")
             return ["all"];
-        const ids = Inspector.readActorInspectorTurns(path.join(this.stateRoot, this.selectedRun)).map((turn) => turn.commandId);
+        const ids = this.allTurnItems().map((turn) => turn.commandId);
         return ["all", ...new Set(ids)];
     }
     valueOptions() {
@@ -795,17 +1003,11 @@ export class ActorInspectorOverlay {
         else
             this.detailTurn = this.turnItems()[this.rowIndex];
         this.detailScroll = 0;
-        this.detailView = "evidence";
         this.detailOpen = Boolean(this.detailCommunication || this.detailTurn);
         if (this.detailOpen)
             this.focus = "detail";
     }
     backDetail() {
-        if (this.detailView === "transcript") {
-            this.detailView = "evidence";
-            this.detailScroll = 0;
-            return;
-        }
         this.closeDetail();
     }
     closeDetail() {
@@ -813,7 +1015,6 @@ export class ActorInspectorOverlay {
         this.detailCommunication = undefined;
         this.detailTurn = undefined;
         this.detailScroll = 0;
-        this.detailView = "evidence";
         this.focus = "list";
     }
     border(left, title, right, width) {

package/dist/lib/inspector.d.ts

@@ -55,10 +55,19 @@ export interface ActorInspectorPreviewReadOptions {
 }
 export interface ActorInspectorRunItem {
     run: string;
+    runInstanceId?: string;
     status: string;
     updatedAt?: string;
 }
 export declare function readActorInspectorRuns(stateRoot: string, ownerId: string): ActorInspectorRunItem[];
+export interface ActorInspectorRecipeView {
+    composition: Array<Record<string, unknown>>;
+    definition?: Record<string, unknown>;
+    diagnostics: string[];
+    identity: Record<string, unknown>;
+    launch: Record<string, unknown>;
+}
+export declare function readActorInspectorRecipe(stateDir: string): ActorInspectorRecipeView;
 export interface ActorInspectorTurnItem extends SessionEvidence.SessionEvidenceTurn {
     commandId: string;
     diagnostics: string[];

package/dist/lib/inspector.js

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

package/dist/lib/observability.d.ts

@@ -17,6 +17,7 @@ export interface RunObservation {
     artifacts?: Record<string, string>;
     launchSource?: AsyncRuns.AsyncRunLaunchSource;
     modelPolicy?: Record<string, unknown>;
+    notificationPolicy?: "normal" | "silent";
     recipeFile?: string;
     terminalHandled?: boolean;
     retireWhen?: string;