@llblab/pi-actors 0.49.2 → 0.50.0

package/lib/inspector-overlay.ts

@@ -10,6 +10,7 @@ import * as path from "node:path";
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import {
   matchesKey,
+  sliceByColumn,
   truncateToWidth,
   visibleWidth,
   type TUI,
@@ -30,6 +31,11 @@ export type ActorInspectorTab = "recipe" | "trace" | "control";
 type InspectorFocus = "runs" | "tabs" | "document" | "list" | "detail" | "select";
 type SelectorMode = "run" | "source";
 
+interface SelectorOption {
+  content: string;
+  preserveColors?: boolean;
+}
+
 export interface ActorInspectorActionResult {
   ok: boolean;
   message: string;
@@ -73,6 +79,7 @@ export class ActorInspectorOverlay {
   private readonly theme: Theme;
   private readonly tui: TUI;
   private readonly refreshTimer: NodeJS.Timeout;
+  private contentSelectedRows = new Set<number>();
   private contentStripeIndices: number[] = [];
   private documentScroll = 0;
   private detailScroll = 0;
@@ -244,10 +251,11 @@ export class ActorInspectorOverlay {
     if (this.killConfirmation) return this.renderKillDialog(innerWidth);
 
     const lines = [this.border("╭", " Actor Inspector ", "╮", innerWidth)];
-    lines.push(this.row(this.renderRunControl(run, runs.length - this.runIndex), innerWidth));
+    lines.push(this.row(this.renderRunControl(run, runs.length - this.runIndex - 1), innerWidth));
     lines.push(this.row(this.renderTabs(run), innerWidth));
     lines.push(this.border("├", "", "┤", innerWidth));
 
+    this.contentSelectedRows.clear();
     this.contentStripeIndices = [];
     let content = this.renderContent(run, innerWidth);
     if (this.feedback) {
@@ -257,6 +265,9 @@ export class ActorInspectorOverlay {
           ? "error"
           : "warning";
       content = [this.theme.fg(color, ` ${this.feedback.message}`), ...content];
+      this.contentSelectedRows = new Set(
+        [...this.contentSelectedRows].map((index) => index + 1),
+      );
       this.contentStripeIndices = [0, ...this.contentStripeIndices];
     }
     const viewportRows = this.contentViewportRows();
@@ -266,9 +277,27 @@ export class ActorInspectorOverlay {
         content[index] ?? "",
         innerWidth,
         this.contentStripeIndices[index] ?? index,
+        this.contentSelectedRows.has(index),
       ));
     }
     lines.push(this.footerBorder(this.renderKeyHints(), innerWidth));
+    if (this.focus === "select") {
+      const runSelector = this.selectorMode === "run";
+      const startRow = runSelector ? 2 : 3;
+      const horizontalOffset = runSelector ? 4 : 12;
+      const availableRows = Math.max(3, lines.length - startRow - 1);
+      const menu = this.renderSelector(run, availableRows);
+      for (const [offset, menuLine] of menu.entries()) {
+        const target = startRow + offset;
+        if (target >= lines.length - 1) break;
+        lines[target] = this.compositeMenuLine(
+          lines[target]!,
+          menuLine,
+          innerWidth,
+          horizontalOffset,
+        );
+      }
+    }
     return lines;
   }
 
@@ -428,10 +457,10 @@ export class ActorInspectorOverlay {
   private renderKillDialog(innerWidth: number): string[] {
     const confirmation = this.killConfirmation!;
     const cancel = this.killDialogChoice === "cancel"
-      ? this.theme.bg("customMessageBg", this.theme.fg("accent", "  Cancel  "))
+      ? this.theme.bg("selectedBg", this.theme.fg("accent", "  Cancel  "))
       : this.theme.fg("muted", "  Cancel  ");
     const kill = this.killDialogChoice === "kill"
-      ? this.theme.bg("customMessageBg", this.theme.fg("error", "  Kill actor  "))
+      ? this.theme.bg("selectedBg", this.theme.fg("error", "  Kill actor  "))
       : this.theme.fg("error", "  Kill actor  ");
     const body = [
       "",
@@ -464,23 +493,32 @@ export class ActorInspectorOverlay {
     const suffix = active ? this.theme.fg("accent", " → ") : "   ";
     if (!run) {
       const empty = this.theme.fg("muted", `${prefix}Run: none${suffix}`);
-      return this.focus === "runs" ? this.theme.bg("customMessageBg", empty) : empty;
+      return active ? this.theme.bg("selectedBg", empty) : empty;
     }
     const value = `${prefix}${this.theme.fg("muted", "Run: ")}${this.theme.fg("text", `#${sequence}`)}  ${this.theme.fg("accent", run.run)}  ${this.theme.fg(this.statusColor(run.status), run.status)}${suffix}`;
-    return this.focus === "runs" ? this.theme.bg("customMessageBg", value) : value;
+    return active ? this.theme.bg("selectedBg", value) : value;
   }
 
   private renderTabs(run?: ActorInspector.ActorInspectorRunItem): string {
     const source = this.traceSource(run);
     return TABS.map((tab, index) => {
       const base = `${tab[0]!.toUpperCase()}${tab.slice(1)}`;
-      const label = tab === "trace" && source !== "all" ? `${base} (${source})` : base;
+      const label = tab === "trace" && source !== "all" ? `${base}: ${source}` : base;
       const selected = index === this.tabIndex;
-      const display = selected && this.focus !== "runs" ? `[ ${label} ]` : `  ${label}  `;
-      const value = ` ${display} `;
-      if (!selected) return this.theme.fg("muted", value);
-      const colored = this.theme.fg("accent", value);
-      return this.focus === "tabs" ? this.theme.bg("customMessageBg", colored) : colored;
+      const bracketed = selected && this.focus !== "runs";
+      if (!selected) {
+        const display = bracketed ? `[ ${label} ]` : `  ${label}  `;
+        return this.theme.fg("muted", ` ${display} `);
+      }
+      const coloredLabel = tab === "trace" && source !== "all"
+        ? `${this.theme.fg("accent", `${base}:`)} ${this.theme.fg("text", source)}`
+        : this.theme.fg("accent", label);
+      const colored = bracketed
+        ? ` ${this.theme.fg("accent", "[ ")}${coloredLabel}${this.theme.fg("accent", " ]")} `
+        : `   ${coloredLabel}   `;
+      const active = this.focus === "tabs"
+        || (this.focus === "select" && this.selectorMode === "source");
+      return active ? this.theme.bg("selectedBg", colored) : colored;
     }).join(" ");
   }
 
@@ -489,7 +527,6 @@ export class ActorInspectorOverlay {
     width: number,
   ): string[] {
     if (!run) return [this.theme.fg("muted", " No owned actor runs")];
-    if (this.focus === "select") return this.renderSelector(run);
     if (this.focus === "detail") return this.renderTraceDetail(width);
     if (this.tab === "trace") return this.renderTraceList(run);
     const stateDir = path.join(this.stateRoot, run.run);
@@ -509,31 +546,64 @@ export class ActorInspectorOverlay {
     );
   }
 
-  private renderSelector(run: ActorInspector.ActorInspectorRunItem): string[] {
+  private renderSelector(
+    run: ActorInspector.ActorInspectorRunItem,
+    availableRows: number,
+  ): string[] {
     const options = this.selectorMode === "run"
-      ? this.runs().map((item) => `run:${item.run}  ${item.status}`)
-      : this.traceSources(run).map((source) => `Trace source: ${source}`);
-    const lines = this.renderMenuBox(options, this.selectorIndex);
-    this.contentStripeIndices = lines.map(() => 0);
-    return lines;
+      ? this.runSelectorOptions()
+      : this.traceSources(run).map((source) => ({
+        content: `${this.theme.fg("accent", "Trace:")} ${this.theme.fg("text", source)}`,
+        preserveColors: true,
+      }));
+    return this.renderMenuBox(options, this.selectorIndex, availableRows);
   }
 
-  private renderMenuBox(options: string[], focusedIndex: number): string[] {
+  private runSelectorOptions(): SelectorOption[] {
+    const runs = this.runs();
+    const sequenceWidth = Math.max(
+      2,
+      ...runs.map((_item, index) => `#${runs.length - index - 1}`.length),
+    );
+    const runWidth = Math.max(1, ...runs.map((item) => visibleWidth(item.run)));
+    return runs.map((item, index) => ({
+      content: [
+        this.theme.fg("text", this.fit(`#${runs.length - index - 1}`, sequenceWidth)),
+        this.theme.fg("accent", this.fit(item.run, runWidth)),
+        this.theme.fg(this.statusColor(item.status), item.status),
+      ].join("  "),
+      preserveColors: true,
+    }));
+  }
+
+  private renderMenuBox(
+    options: SelectorOption[],
+    focusedIndex: number,
+    availableRows: number,
+  ): string[] {
     if (options.length === 0) return [this.theme.fg("muted", " No options")];
-    const visibleLimit = Math.max(1, Math.min(this.contentViewportRows(), options.length));
+    const visibleLimit = Math.max(
+      1,
+      Math.min(availableRows - 2, options.length),
+    );
     const maxStart = Math.max(0, options.length - visibleLimit);
     const start = Math.max(0, Math.min(focusedIndex - Math.floor(visibleLimit / 2), maxStart));
     const visible = options.slice(start, start + visibleLimit);
-    const width = Math.max(8, ...options.map((option) => visibleWidth(option) + 4));
+    const width = Math.max(8, ...options.map((option) => visibleWidth(option.content) + 4));
     const border = (left: string, right: string, marker = "") =>
       this.theme.fg("borderAccent", `${left}${marker}${"─".repeat(Math.max(0, width - visibleWidth(marker)))}${right}`);
     return [
       border("╭", "╮", start > 0 ? "↑" : ""),
       ...visible.map((option, offset) => {
         const index = start + offset;
-        const row = this.fit(`${index === focusedIndex ? " ▶ " : "   "}${option}`, width);
-        const colored = index === focusedIndex ? this.theme.fg("accent", row) : row;
-        const styled = index === focusedIndex ? this.theme.bg("customMessageBg", colored) : colored;
+        const marker = index === focusedIndex
+          ? this.theme.fg("accent", " ▶ ")
+          : "   ";
+        const row = this.fit(`${marker}${option.content}`, width);
+        const colored = index === focusedIndex && !option.preserveColors
+          ? this.theme.fg("accent", row)
+          : row;
+        const styled = index === focusedIndex ? this.theme.bg("selectedBg", colored) : colored;
         return `${this.theme.fg("borderAccent", "│")}${styled}${this.theme.fg("borderAccent", "│")}`;
       }),
       border("╰", "╯", start + visible.length < options.length ? "↓" : ""),
@@ -562,6 +632,14 @@ export class ActorInspectorOverlay {
     this.contentStripeIndices = items
       .slice(start, start + viewportRows)
       .map((_item, offset) => start + offset);
+    const selectedViewportRow = banner.length + this.rowIndex - start;
+    if (
+      this.focus === "list" &&
+      selectedViewportRow >= banner.length &&
+      selectedViewportRow < viewportRows
+    ) {
+      this.contentSelectedRows.add(selectedViewportRow);
+    }
     return [...banner, ...items.slice(start, start + viewportRows - banner.length).map((item, offset) => {
       const index = start + offset;
       const detail = item.detail && typeof item.detail === "object"
@@ -575,7 +653,7 @@ export class ActorInspectorOverlay {
       const prefix = this.focus === "list" && index === this.rowIndex
         ? this.theme.fg("accent", " ▶ ")
         : "   ";
-      const row = `${prefix}${this.theme.fg("text", `#${items.length - index}`)} ${marker} ${this.theme.fg("muted", item.source)}/${this.theme.fg(item.level === "error" ? "error" : "accent", item.kind)}  ${this.theme.fg("text", item.summary)}`;
+      const row = `${prefix}${this.theme.fg("text", `#${items.length - index - 1}`)} ${marker} ${this.theme.fg("muted", item.source)}/${this.theme.fg(item.level === "error" ? "error" : "accent", item.kind)}  ${this.theme.fg("text", item.summary)}`;
       return this.focus === "list" && index === this.rowIndex
         ? this.theme.fg("accent", row)
         : row;
@@ -734,11 +812,24 @@ export class ActorInspectorOverlay {
       return [
         `${indent}[`,
         ...value.flatMap((item, index) => {
-          const marker = `${indent}  - #${index + 1}`;
+          const itemDepth = depth + 1;
+          const itemIndent = "  ".repeat(itemDepth);
+          const marker = `#${index}`;
           const itemInline = this.inlineDocumentValue(item);
-          return itemInline !== undefined
-            ? [`${marker}: ${itemInline}`]
-            : [marker, ...this.document(item, depth + 2)];
+          let lines: string[];
+          if (itemInline !== undefined) {
+            lines = [`${itemIndent}${marker}: ${itemInline}`];
+          } else if (item && typeof item === "object") {
+            const nested = this.document(item, itemDepth);
+            lines = [
+              `${itemIndent}${marker}: ${nested[0]!.slice(itemIndent.length)}`,
+              ...nested.slice(1),
+            ];
+          } else {
+            lines = this.labeledScalarLines(marker, item, itemDepth);
+          }
+          if (index < value.length - 1) lines[lines.length - 1] += ",";
+          return lines;
         }),
         `${indent}]`,
       ];
@@ -792,9 +883,13 @@ export class ActorInspectorOverlay {
   private styleDocumentLine(line: string): string {
     const indent = line.match(/^ */u)?.[0] ?? "";
     const content = line.slice(indent.length);
-    if (/^- #\d+$/u.test(content) || content.endsWith(":")) {
+    if (content.endsWith(":")) {
       return `${indent}${this.theme.fg("accent", content)}`;
     }
+    const indexed = /^(#\d+:)(.*)$/u.exec(content);
+    if (indexed) {
+      return `${indent}${this.theme.fg("accent", indexed[1])}${this.theme.fg("text", indexed[2])}`;
+    }
     const labeled = /^([^:]+:)(.*)$/u.exec(content);
     if (labeled) {
       return `${indent}${this.theme.fg("muted", labeled[1])}${this.theme.fg("text", labeled[2])}`;
@@ -868,13 +963,46 @@ export class ActorInspectorOverlay {
     return `${this.theme.fg("borderAccent", `╰${prefix}`)}${content}${this.theme.fg("borderAccent", `${suffix}${fill}╯`)}`;
   }
 
+  private compositeMenuLine(
+    baseLine: string,
+    menuLine: string,
+    innerWidth: number,
+    horizontalOffset: number,
+  ): string {
+    const offset = Math.max(0, Math.min(horizontalOffset, innerWidth));
+    const menuWidth = Math.min(innerWidth - offset, visibleWidth(menuLine));
+    const baseInner = sliceByColumn(baseLine, 1, innerWidth, true);
+    const prefix = sliceByColumn(baseInner, 0, offset, true);
+    const suffixStart = offset + menuWidth;
+    const suffix = sliceByColumn(
+      baseInner,
+      suffixStart,
+      Math.max(0, innerWidth - suffixStart),
+      true,
+    );
+    const remainder = this.fit(suffix, innerWidth - suffixStart);
+    return `${this.theme.fg("borderAccent", "│")}${this.fit(prefix, offset)}${truncateToWidth(menuLine, menuWidth, "")}${remainder}${this.theme.fg("borderAccent", "│")}`;
+  }
+
   private stripeBackground(content: string, index: number): string {
     return index % 2 === 0 ? content : this.theme.bg("customMessageBg", content);
   }
 
-  private stripedRow(content: string, width: number, index: number): string {
-    const fitted = this.fit(content, width);
-    return `${this.theme.fg("borderAccent", "│")}${this.stripeBackground(fitted, index)}${this.theme.fg("borderAccent", "│")}`;
+  private stripedRow(
+    content: string,
+    width: number,
+    index: number,
+    selected: boolean,
+  ): string {
+    if (!selected) {
+      const fitted = this.fit(content, width);
+      return `${this.theme.fg("borderAccent", "│")}${this.stripeBackground(fitted, index)}${this.theme.fg("borderAccent", "│")}`;
+    }
+    const selectedContent = truncateToWidth(`${content} `, width, "");
+    const remainder = " ".repeat(
+      Math.max(0, width - visibleWidth(selectedContent)),
+    );
+    return `${this.theme.fg("borderAccent", "│")}${this.theme.bg("selectedBg", selectedContent)}${this.stripeBackground(remainder, index)}${this.theme.fg("borderAccent", "│")}`;
   }
 
   private row(content: string, width: number): string {

package/lib/limits.ts

@@ -12,6 +12,7 @@ export const CONTROL_INPUT_MAX_BYTES = 380;
 export const CONTROL_WIRE_MAX_BYTES = 512;
 export const INSPECTOR_BODY_PREVIEW_CHARS = 320;
 export const DOCTOR_ACTION_PREVIEW_CHARS = 72;
+export const SESSION_EVIDENCE_MAX_BYTES = 4 * 1024 * 1024;
 export const SESSION_EVIDENCE_MAX_TURNS = 100;
 export const SESSION_EVIDENCE_TEXT_CHARS = 4_000;
 export const SESSION_EVIDENCE_MAX_TOOL_CALLS = 100;

package/lib/runs-artifacts.ts

@@ -4,7 +4,12 @@
  */
 
 import { createHash } from "node:crypto";
-import { readFileSync } from "node:fs";
+import {
+  closeSync,
+  fstatSync,
+  openSync,
+  readSync,
+} from "node:fs";
 
 import { substituteCommandTemplateToken } from "./command-templates.ts";
 
@@ -22,6 +27,31 @@ export interface RunArtifactManifestEntry {
   size?: number;
 }
 
+function hashArtifactFile(path: string): { sha256: string; size: number } {
+  const fd = openSync(path, "r");
+  try {
+    const size = fstatSync(fd).size;
+    const hash = createHash("sha256");
+    const chunk = Buffer.allocUnsafe(64 * 1024);
+    let position = 0;
+    while (position < size) {
+      const bytesRead = readSync(
+        fd,
+        chunk,
+        0,
+        Math.min(chunk.byteLength, size - position),
+        position,
+      );
+      if (bytesRead === 0) break;
+      hash.update(chunk.subarray(0, bytesRead));
+      position += bytesRead;
+    }
+    return { sha256: hash.digest("hex"), size: position };
+  } finally {
+    closeSync(fd);
+  }
+}
+
 export function resolveArtifactPaths(
   artifacts: Record<string, RunArtifactDeclaration> | undefined,
   values: Record<string, unknown>,
@@ -64,7 +94,7 @@ export function resolveArtifactManifest(
       typeof artifact === "string" ? { path: artifact } : artifact;
     if (!declaration?.path) continue;
     try {
-      const content = readFileSync(declaration.path);
+      const hashed = hashArtifactFile(declaration.path);
       manifest[name] = {
         exists: true,
         ...(declaration.kind ? { kind: declaration.kind } : {}),
@@ -75,8 +105,8 @@ export function resolveArtifactManifest(
         ...(declaration.required !== undefined
           ? { required: declaration.required }
           : {}),
-        sha256: createHash("sha256").update(content).digest("hex"),
-        size: content.byteLength,
+        sha256: hashed.sha256,
+        size: hashed.size,
       };
     } catch {
       manifest[name] = {

package/lib/session-evidence.ts

@@ -55,6 +55,7 @@ export interface SessionEvidence {
 }
 
 export interface SessionEvidenceReadOptions {
+  maxBytes?: number;
   maxTextChars?: number;
   maxToolCalls?: number;
   maxTurns?: number;
@@ -195,6 +196,10 @@ export function readSessionEvidence(
   path: string,
   options: SessionEvidenceReadOptions = {},
 ): SessionEvidence {
+  const maxBytes = Math.max(
+    1,
+    options.maxBytes ?? Limits.SESSION_EVIDENCE_MAX_BYTES,
+  );
   const maxTextChars = Math.max(
     1,
     options.maxTextChars ?? Limits.SESSION_EVIDENCE_TEXT_CHARS,
@@ -207,7 +212,7 @@ export function readSessionEvidence(
     1,
     options.maxTurns ?? Limits.SESSION_EVIDENCE_MAX_TURNS,
   );
-  const read = readJsonlFileResilient<SessionEntry>(path);
+  const read = readJsonlFileResilient<SessionEntry>(path, { maxBytes });
   const diagnostics = [...read.diagnostics];
   const header = read.records.find((entry) => entry.type === "session");
   const branch = activeBranch(read.records, path, diagnostics);
@@ -296,7 +301,7 @@ export function readSessionEvidence(
     path,
     ...(header ? { session: asRecord(header) } : {}),
     totalTurns: turns.length,
-    truncated: turns.length > visibleTurns.length,
+    truncated: read.truncated === true || turns.length > visibleTurns.length,
     turns: visibleTurns,
   };
 }

package/lib/state-readers.ts

@@ -4,7 +4,13 @@
  * Owns best-effort JSON and JSONL parsing helpers for operator-facing state reads.
  */
 
-import { readFileSync } from "node:fs";
+import {
+  closeSync,
+  fstatSync,
+  openSync,
+  readFileSync,
+  readSync,
+} from "node:fs";
 
 export interface StateReadDiagnostic {
   line?: number;
@@ -20,6 +26,11 @@ export interface JsonReadResult<T> {
 export interface JsonlReadResult<T> {
   diagnostics: StateReadDiagnostic[];
   records: T[];
+  truncated?: boolean;
+}
+
+export interface JsonlReadOptions {
+  maxBytes?: number;
 }
 
 function isEnoent(error: unknown): boolean {
@@ -30,6 +41,31 @@ function diagnosticMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 
+function readTextFileCapped(path: string, maxBytes: number | undefined): string {
+  if (maxBytes === undefined) return readFileSync(path, "utf8");
+  const limit = Math.max(0, Math.floor(maxBytes));
+  const fd = openSync(path, "r");
+  try {
+    const size = fstatSync(fd).size;
+    if (size > limit) {
+      throw Object.assign(
+        new Error(`file exceeds bounded read limit (${size} > ${limit} bytes)`),
+        { code: "EFBIG" },
+      );
+    }
+    const content = Buffer.allocUnsafe(size);
+    let offset = 0;
+    while (offset < size) {
+      const bytesRead = readSync(fd, content, offset, size - offset, offset);
+      if (bytesRead === 0) break;
+      offset += bytesRead;
+    }
+    return content.subarray(0, offset).toString("utf8");
+  } finally {
+    closeSync(fd);
+  }
+}
+
 export function readJsonFileResilient<T>(path: string, fallback: T): JsonReadResult<T> {
   try {
     return {
@@ -50,11 +86,14 @@ export function readJsonFileResilient<T>(path: string, fallback: T): JsonReadRes
   }
 }
 
-export function readJsonlFileResilient<T>(path: string): JsonlReadResult<T> {
+export function readJsonlFileResilient<T>(
+  path: string,
+  options: JsonlReadOptions = {},
+): JsonlReadResult<T> {
   try {
     const records: T[] = [];
     const diagnostics: StateReadDiagnostic[] = [];
-    const lines = readFileSync(path, "utf8").split("\n");
+    const lines = readTextFileCapped(path, options.maxBytes).split("\n");
     for (const [index, line] of lines.entries()) {
       if (!line.trim()) continue;
       try {
@@ -78,6 +117,9 @@ export function readJsonlFileResilient<T>(path: string): JsonlReadResult<T> {
         },
       ],
       records: [],
+      ...((error as NodeJS.ErrnoException).code === "EFBIG"
+        ? { truncated: true }
+        : {}),
     };
   }
 }

package/lib/tools-access.ts

@@ -17,8 +17,11 @@ export function getContextSessionId(ctx: unknown): string | undefined {
 export function requireContextSessionId(ctx: unknown, actor: string): string {
   const sessionId = getContextSessionId(ctx);
   if (!sessionId) {
-    throw new Error(
-      `${actor} requires a current coordinator session; use session:<id> or session:all for explicit session inventory.`,
+    throw Object.assign(
+      new Error(
+        `${actor} reason=session_unavailable requires a current coordinator session; retry from an active coordinator session.`,
+      ),
+      { reason: "session_unavailable" },
     );
   }
   return sessionId;
@@ -33,16 +36,13 @@ export function sessionMismatchError(input: {
   const ownerSession = input.expectedSession ?? "none";
   const currentSession = input.currentSession ?? "none";
   const actor = input.run ? `run:${input.run}` : (input.target ?? "session");
-  const hintTarget = input.expectedSession
-    ? `session:${input.expectedSession}`
-    : "session:all";
   return Object.assign(
     new Error(
-      `${actor} reason=session_mismatch owner_session=${ownerSession} current_session=${currentSession} hint=inspect_session:${input.expectedSession ?? "all"}`,
+      `${actor} reason=session_mismatch owner_session=${ownerSession} current_session=${currentSession} hint=inspect_runtime_runs`,
     ),
     {
       current_session: input.currentSession,
-      hint: `inspect target=${hintTarget} view=status`,
+      hint: "inspect target=runtime view=runs",
       owner_session: input.expectedSession,
       reason: "session_mismatch",
       run: input.run,
@@ -51,18 +51,32 @@ export function sessionMismatchError(input: {
   );
 }
 
-export function assertRunAccessibleToContext(
+export function assertRunStatusAccessibleToContext(
   runId: string,
+  status: Record<string, unknown>,
   ctx: unknown,
 ): Record<string, unknown> {
-  const status = AsyncRuns.getRunStatus(runId);
-  const sessionId = getContextSessionId(ctx);
-  if (sessionId && status.ownerId && status.ownerId !== sessionId) {
+  const sessionId = requireContextSessionId(ctx, `run:${runId}`);
+  const ownerId = typeof status.ownerId === "string" && status.ownerId
+    ? status.ownerId
+    : undefined;
+  if (ownerId !== sessionId) {
     throw sessionMismatchError({
       currentSession: sessionId,
-      expectedSession: String(status.ownerId),
+      expectedSession: ownerId,
       run: runId,
     });
   }
   return status;
 }
+
+export function assertRunAccessibleToContext(
+  runId: string,
+  ctx: unknown,
+): Record<string, unknown> {
+  return assertRunStatusAccessibleToContext(
+    runId,
+    AsyncRuns.getRunStatus(runId),
+    ctx,
+  );
+}

package/lib/tools-inspect.ts

@@ -42,7 +42,7 @@ export interface InspectToolDeps<TContext = unknown> {
 
 function runtimeStatus(): Record<string, unknown> {
   return {
-    automatic_review: process.env.PI_ACTORS_AUTOMATIC_REVIEW !== "off",
+    automatic_review: Paths.isAutomaticRecipeReviewEnabled(),
     run_root: Paths.getRunStateRoot(),
     state_schema: RuntimeIdentity.RUN_STATE_SCHEMA,
     version: RuntimeIdentity.getPackageVersion(),
@@ -54,7 +54,7 @@ function runtimeRuns(
   deps: InspectToolDeps,
   status: string | undefined,
 ): Record<string, unknown> {
-  const session = ToolsAccess.getContextSessionId(ctx);
+  const session = ToolsAccess.requireContextSessionId(ctx, "runtime Run inventory");
   const listed = deps.listRuns
     ? deps.listRuns()
     : AsyncRuns.listRuns(undefined, status);
@@ -68,8 +68,8 @@ function runtimeRuns(
         return run;
       }
     })
-    .filter((run) => !session || !run.ownerId || run.ownerId === session);
-  return { ...(session ? { owner_session: session } : {}), runs };
+    .filter((run) => run.ownerId === session);
+  return { owner_session: session, runs };
 }
 
 function runtimeTriage(
@@ -463,7 +463,11 @@ function inspectRun(
     throw new Error("inspect run:<id> supports view=recipe, view=trace, or view=control.");
   }
   const status = deps.getRunStatus
-    ? deps.getRunStatus(run)
+    ? ToolsAccess.assertRunStatusAccessibleToContext(
+        run,
+        deps.getRunStatus(run),
+        ctx,
+      )
     : ToolsAccess.assertRunAccessibleToContext(run, ctx);
   const stateDir = String(status.state_dir);
   if (view === "recipe") {

package/lib/tools-message.ts

@@ -46,6 +46,7 @@ function runNextActions(run: string, result: Record<string, unknown>): string[]
 }
 
 export interface ControlToolDeps {
+  getRunStatus?: (run: string) => Record<string, unknown>;
   handleRuntimeControl?: (
     action: string,
     input: unknown,
@@ -94,7 +95,13 @@ export function createControlToolDefinition<TContext = unknown>(
         result = deps.handleRuntimeControl(request.action, request.input);
       } else {
         const run = request.target.slice(4);
-        const status = ToolsAccess.assertRunAccessibleToContext(run, ctx);
+        const status = deps.getRunStatus
+          ? ToolsAccess.assertRunStatusAccessibleToContext(
+              run,
+              deps.getRunStatus(run),
+              ctx,
+            )
+          : ToolsAccess.assertRunAccessibleToContext(run, ctx);
         const runInstanceId =
           typeof status.run_instance_id === "string"
             ? status.run_instance_id

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-actors",
-  "version": "0.49.2",
+  "version": "0.50.0",
   "private": false,
   "description": "Local Actor Kernel for Pi",
   "keywords": [