@llblab/pi-actors 0.42.3 → 0.43.0

package/dist/lib/inspector-actions.js

@@ -1,5 +1,5 @@
 /**
- * Actor Inspector run actions.
+ * Actor Inspector actions for concrete Run instances.
  * Owns: exact-session run-action authorization, canonical kill routing, and bounded operator feedback.
  */
 import { join } from "node:path";
@@ -11,7 +11,7 @@ function bounded(value) {
         ? text
         : `${text.slice(0, FEEDBACK_LIMIT - 1)}…`;
 }
-export function killOwnedInspectorRun(ownerId, run, stateRoot, expectedRunInstanceId, deps) {
+export function killOwnedRunFromInspector(ownerId, run, stateRoot, expectedRunInstanceId, deps) {
     let stateDir;
     try {
         stateDir = join(stateRoot, safeRunId(run));

package/dist/lib/inspector-command.js

@@ -8,13 +8,13 @@ import * as InspectorActions from "./inspector-actions.js";
 import * as InspectorOverlay from "./inspector-overlay.js";
 import * as Paths from "./paths.js";
 export function registerActorInspectorCommand(pi, getRunOwnerId) {
-    pi.registerCommand("actors-inspector", {
-        description: "Open the keyboard-driven actor inspector overlay",
+    pi.registerCommand("actor-inspector", {
+        description: "Open the keyboard-driven Actor Inspector",
         handler: async (_args, ctx) => {
             ctx.ui.setWidget("zz-pi-actors-comms", undefined);
             await ctx.ui.custom((tui, theme, _keybindings, done) => new InspectorOverlay.ActorInspectorOverlay({
                 done,
-                killRun: (run, runInstanceId) => InspectorActions.killOwnedInspectorRun(getRunOwnerId(ctx), run, Paths.EXTENSION_RUNTIME_PATHS.runStateRoot, runInstanceId, {
+                killRun: (run, runInstanceId) => InspectorActions.killOwnedRunFromInspector(getRunOwnerId(ctx), run, Paths.EXTENSION_RUNTIME_PATHS.runStateRoot, runInstanceId, {
                     getRunStatus: AsyncRuns.getRunStatus,
                     killRun: AsyncRuns.killRun,
                 }),

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

@@ -1,21 +1,23 @@
 /**
- * Keyboard-driven actor inspector overlay.
- * Zones: overlay shell, tabs, owned-run/subagent selection, compact striped rows
- * Owns interactive TUI navigation; evidence parsing remains in inspector/session domains.
+ * Keyboard-driven Actor Inspector overlay for concrete Run instances.
+ * Zones: owned actor selection, Recipe/Trace/Control tabs, safe Run Kill confirmation
+ * Owns manual kernel navigation; evidence parsing and lifecycle mutation stay in ports.
  */
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { type TUI } from "@earendil-works/pi-tui";
-import * as Inspector from "./inspector.ts";
-export type ActorInspectorOverlayTab = "recipe" | "communications" | "turns";
-export interface ActorInspectorOverlayActionResult {
+import * as ActorInspector from "./inspector.ts";
+import * as TraceProjection from "./trace-projection.ts";
+export type ActorInspectorTab = "recipe" | "trace" | "control";
+export interface ActorInspectorActionResult {
     ok: boolean;
     message: string;
 }
 export interface ActorInspectorOverlayOptions {
     done: () => void;
-    killRun?: (run: string, runInstanceId: string) => ActorInspectorOverlayActionResult;
+    killRun?: (run: string, runInstanceId: string) => ActorInspectorActionResult;
     ownerId: string;
-    readTurns?: (stateDir: string) => Inspector.ActorInspectorTurnItem[];
+    readRuns?: typeof ActorInspector.readActorInspectorRuns;
+    readTrace?: typeof TraceProjection.projectRunTrace;
     stateRoot: string;
     theme: Theme;
     tui: TUI;
@@ -24,93 +26,73 @@ export declare class ActorInspectorOverlay {
     private readonly done;
     private readonly killRun?;
     private readonly ownerId;
-    private readonly readTurns;
+    private readonly readRuns;
+    private readonly readTrace;
     private readonly stateRoot;
     private readonly theme;
     private readonly tui;
     private readonly refreshTimer;
-    private runIndex;
-    private communicationChannel;
-    private communicationFrom;
-    private communicationUnread;
     private contentStripeIndices;
-    private detailCommunication?;
-    private detailOpen;
+    private documentScroll;
     private detailScroll;
-    private detailTurn?;
     private feedback?;
+    private focus;
     private killConfirmation?;
     private killDialogChoice;
-    private readonly readKeys;
-    private focus;
-    private filterControlIndex;
-    private menuLevel;
-    private selectorIndex;
-    private recipeScroll;
     private rowIndex;
-    private selectedRun?;
-    private subagentIndex;
-    private tab;
-    private turnCache?;
+    private runCache?;
+    private runIndex;
+    private selectorIndex;
+    private selectorMode?;
+    private tabIndex;
+    private traceCache?;
+    private traceDetail?;
+    private traceSourceIndex;
     constructor(options: ActorInspectorOverlayOptions);
+    dispose(): void;
+    invalidate(): void;
     handleInput(data: string): void;
     render(width: number): string[];
-    invalidate(): void;
-    dispose(): void;
+    private get tab();
     private runs;
-    private ensureSelectedRun;
     private contentViewportRows;
-    private selectRun;
+    private resetContentPosition;
     private cycleRun;
+    private handleScrollableInput;
+    private handleSelectorInput;
+    private openSourceSelector;
+    private cycleTraceSource;
     private requestKill;
-    private cancelKill;
+    private handleKillInput;
     private confirmKill;
     private renderKillDialog;
-    private listItemCount;
-    private selectorAnchor;
-    private renderKeyHints;
     private renderRunControl;
-    private activeMessageFilters;
     private renderTabs;
-    private renderRunSelector;
-    private renderTimeline;
-    private renderRecipe;
-    private communicationPreviews;
-    private communicationActorLabel;
-    private communicationFromOptions;
-    private communicationRows;
-    private renderDetail;
-    private wrapDetailLines;
-    private wrapPreferred;
-    private detailSection;
-    private readableValueLines;
-    private turnEvidenceLines;
-    private readablePromptText;
-    private allTurnItems;
-    private turnItems;
-    private turnRows;
-    private subagents;
-    private valueOptions;
-    private filterOptions;
-    private menuOptions;
-    private backMenu;
-    private openRunMenu;
-    private openFilterMenu;
-    private applyMenuOption;
-    private filterValue;
-    private currentFilterValue;
+    private renderContent;
+    private renderSelector;
     private renderMenuBox;
-    private renderFilterMenus;
-    private openDetail;
-    private backDetail;
-    private closeDetail;
+    private renderTraceList;
+    private renderTraceDetail;
+    private controlDocument;
+    private allTraceItems;
+    private traceSources;
+    private traceSource;
+    private traceItems;
+    private readRunMeta;
+    private documentProjection;
+    private inlineDocumentValue;
+    private labeledScalarLines;
+    private document;
+    private wrapDocument;
+    private styleDocumentLine;
+    private visiblePrefix;
+    private renderKeyHints;
+    private statusColor;
     private footerBorder;
-    private border;
     private stripeBackground;
     private stripedRow;
     private row;
-    private takeVisiblePrefix;
-    private dropVisiblePrefix;
-    private center;
+    private border;
     private fit;
+    private center;
 }