@llblab/pi-actors 0.42.2 → 0.43.0

package/lib/execution-sessions.ts

@@ -0,0 +1,111 @@
+/**
+ * Run-owned execution session evidence.
+ * Zones: execution manifest session discovery, canonical containment, rich turn correlation
+ * Owns reusable agent-turn loading; Trace and TUI projection stay in their adapters.
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+import * as SessionEvidence from "./session-evidence.ts";
+import { readJsonFileResilient } from "./state-readers.ts";
+
+export interface ExecutionTurnItem extends SessionEvidence.SessionEvidenceTurn {
+  commandId: string;
+  diagnostics: string[];
+  promptBytes?: number;
+  promptFile?: string;
+  recipeContext?: unknown;
+  sessionFile: string;
+  sessionTruncated: boolean;
+  stage?: string;
+}
+
+function ownedSessionPath(
+  stateDir: string,
+  sessionFile: string,
+): string | undefined {
+  if (path.isAbsolute(sessionFile)) return undefined;
+  const sessionsRoot = path.resolve(stateDir, "sessions");
+  const resolved = path.resolve(stateDir, sessionFile);
+  if (!resolved.startsWith(`${sessionsRoot}${path.sep}`)) return undefined;
+  try {
+    const canonicalRoot = fs.realpathSync(sessionsRoot);
+    const canonicalFile = fs.realpathSync(resolved);
+    return canonicalFile.startsWith(`${canonicalRoot}${path.sep}`)
+      ? canonicalFile
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export function readExecutionTurns(stateDir: string): ExecutionTurnItem[] {
+  const execution = readJsonFileResilient<Record<string, unknown>>(
+    path.join(stateDir, "execution.json"),
+    {},
+  ).value;
+  const commands = Array.isArray(execution.commands)
+    ? (execution.commands as Array<Record<string, unknown>>)
+    : [];
+  const recordedFiles = new Set(
+    commands.flatMap((command) =>
+      (Array.isArray(command.session_files) ? command.session_files : []).filter(
+        (file): file is string => typeof file === "string",
+      ),
+    ),
+  );
+  let discoveredCommands: Array<Record<string, unknown>> = [];
+  try {
+    const sessionsDir = path.join(stateDir, "sessions");
+    discoveredCommands = fs
+      .readdirSync(sessionsDir, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory())
+      .flatMap((entry) => {
+        const files = fs
+          .readdirSync(path.join(sessionsDir, entry.name), {
+            withFileTypes: true,
+          })
+          .filter((file) => file.isFile() && file.name.endsWith(".jsonl"))
+          .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" }]
+          : [];
+      });
+  } catch {
+    discoveredCommands = [];
+  }
+  return [...commands, ...discoveredCommands]
+    .flatMap((command) =>
+      (Array.isArray(command.session_files) ? command.session_files : [])
+        .filter((file): file is string => typeof file === "string")
+        .flatMap((file) => {
+          const sessionPath = ownedSessionPath(stateDir, file);
+          if (!sessionPath) return [];
+          const session = SessionEvidence.readSessionEvidence(sessionPath);
+          return session.turns.map((turn) => ({
+            ...turn,
+            commandId: String(command.id ?? "unknown"),
+            diagnostics: session.diagnostics.map((item) =>
+              `${item.line === undefined ? "" : `line ${item.line}: `}${item.message}`,
+            ),
+            ...(typeof command.prompt_bytes === "number"
+              ? { promptBytes: command.prompt_bytes }
+              : {}),
+            ...(typeof command.prompt_file === "string"
+              ? { promptFile: command.prompt_file }
+              : {}),
+            ...(command.recipe_context !== undefined
+              ? { recipeContext: command.recipe_context }
+              : {}),
+            sessionFile: file,
+            sessionTruncated: session.truncated,
+            ...(typeof command.stage === "string"
+              ? { stage: command.stage }
+              : {}),
+          }));
+        }),
+    )
+    .map((turn, index) => ({ ...turn, index: index + 1 }));
+}

package/lib/file-state.ts

@@ -7,6 +7,7 @@
 import { createHash, randomUUID } from "node:crypto";
 import {
   existsSync,
+  lstatSync,
   mkdirSync,
   readFileSync,
   realpathSync,
@@ -25,8 +26,16 @@ const FILE_MUTATION_LOCK_ROOT = join(tmpdir(), "pi-actors-file-locks");
 
 function canonicalMutationPath(path: string): string {
   const absolute = resolve(path);
-  const suffix: string[] = [];
-  let existing = absolute;
+  try {
+    if (lstatSync(absolute).isSymbolicLink()) {
+      const target = realpathSync.native(absolute);
+      return process.platform === "win32" ? target.toLowerCase() : target;
+    }
+  } catch {
+    /* Materialization may race lock-key derivation; canonicalize through the parent. */
+  }
+  const suffix: string[] = [basename(absolute)];
+  let existing = dirname(absolute);
   while (!existsSync(existing)) {
     const parent = dirname(existing);
     if (parent === existing || existing === parse(existing).root) break;
@@ -235,11 +244,11 @@ export function withFileMutationLock<T>(
   }
 }
 
-export function writeJsonAtomic(path: string, value: unknown): void {
+export function writeTextAtomic(path: string, content: string): void {
   mkdirSync(dirname(path), { recursive: true });
   const tempPath = `${path}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
   try {
-    writeFileSync(tempPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+    writeFileSync(tempPath, content, "utf8");
     renameSync(tempPath, path);
   } catch (error) {
     try {
@@ -250,3 +259,7 @@ export function writeJsonAtomic(path: string, value: unknown): void {
     throw error;
   }
 }
+
+export function writeJsonAtomic(path: string, value: unknown): void {
+  writeTextAtomic(path, `${JSON.stringify(value, null, 2)}\n`);
+}

package/lib/inspector-actions.ts

@@ -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.
  */
 
@@ -29,7 +29,7 @@ function bounded(value: unknown): string {
     : `${text.slice(0, FEEDBACK_LIMIT - 1)}…`;
 }
 
-export function killOwnedInspectorRun(
+export function killOwnedRunFromInspector(
   ownerId: string,
   run: string,
   stateRoot: string,

package/lib/inspector-command.ts

@@ -14,8 +14,8 @@ export function registerActorInspectorCommand(
   pi: Pi.ExtensionAPI,
   getRunOwnerId: (ctx: Pi.ExtensionContext) => string,
 ): void {
-  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<void>(
@@ -23,7 +23,7 @@ export function registerActorInspectorCommand(
           new InspectorOverlay.ActorInspectorOverlay({
             done,
             killRun: (run, runInstanceId) =>
-              InspectorActions.killOwnedInspectorRun(
+              InspectorActions.killOwnedRunFromInspector(
                 getRunOwnerId(ctx),
                 run,
                 Paths.EXTENSION_RUNTIME_PATHS.runStateRoot,