@llblab/pi-actors 0.53.0 → 0.53.2

package/AGENTS.md

@@ -44,6 +44,8 @@ Pi host
 
 `index.ts` wires Pi ports and must not own domain behavior. Keep the local TypeScript import graph acyclic. For architecture-affecting work, load and follow `.agents/skills/domain-dag/SKILL.md`; its validator is local agent tooling, not an npm, CI, or release gate.
 
+The committed `dist/` tree is required for npm and git package installs. `npm run build` compiles into a temporary candidate and atomically replaces the distributive; `npm run build:check` must reject source/artifact drift without rewriting the working tree.
+
 ## Key Domains
 
 - `extension-runtime.ts`: low-level Pi session lifecycle, tool adaptation, and runtime service composition behind the thin `index.ts` event-registration root.
@@ -84,7 +86,7 @@ Canonical event:
 {"id":"…","ts":"…","kind":"…","summary":"…","data":{},"level":"info","attention":"notify"}
 ```
 
-Trace is a bounded retained suffix, not an audit archive. Every first-party writer must call `appendRunTraceEvent`; under the canonical token-owned lock it appends within both fixed bounds or atomically retains the newest suffix plus one cumulative warning-only `runtime.trace_compacted` marker. The marker means older history was discarded; terminal/result/execution/artifact files remain authoritative independently. Reads are newline-safe and order equal timestamps by same-source ordinal, fixed source rank, then stable id without exposing ordering metadata. Never write `trace.jsonl` directly. Generic command lifecycle is Trace-only: `command.done` preserves complete bounded execution evidence but never requests or projects any attention value, and Recipe grammar has no command-completion delivery switch. Semantic attention is explicit: `notify` is visible status, `followup` is an ordinary checkpoint hint, and actor-authored `steer` is durable urgent delivery at Pi's next safe boundary. Never infer attention from status or exit code. Admit steer by exact event and Run generation before `deliverAs: "steer"`; acknowledge only its exact model-bound context envelope, and preserve the later root-terminal completion batch. Sequence, parallel, repeat, and import branches remain internal, while each separately launched Run owns a separate generation.
+Trace is a bounded retained suffix, not an audit archive. Every first-party writer must call `appendRunTraceEvent`; under the canonical token-owned lock it appends within both fixed bounds or atomically retains the newest suffix plus one cumulative warning-only `runtime.trace_compacted` marker. The marker means older history was discarded; terminal/result/execution/artifact files remain authoritative independently. Reads are newline-safe and order equal timestamps by same-source ordinal, fixed source rank, then stable id without exposing ordering metadata. Actor Inspector derives stable source-local row sequences before applying its visible-tail bound, including cumulative compaction offsets for canonical Trace, so appends never renumber retained rows. Never write `trace.jsonl` directly. Generic command lifecycle is Trace-only: `command.done` preserves complete bounded execution evidence but never requests or projects any attention value, and Recipe grammar has no command-completion delivery switch. Semantic attention is explicit: `notify` is visible status, `followup` is an ordinary checkpoint hint, and actor-authored `steer` is durable urgent delivery at Pi's next safe boundary. Never infer attention from status or exit code. Admit steer by exact event and Run generation before `deliverAs: "steer"`; acknowledge only its exact model-bound context envelope, and preserve the later root-terminal completion batch. Sequence, parallel, repeat, and import branches remain internal, while each separately launched Run owns a separate generation.
 
 ### Control
 
@@ -150,4 +152,5 @@ When deferred Run results gate the next step, wait for their completion batch. I
 - Before release run the normal product validation and dependency audit. Use the project-local Domain DAG Skill during architecture-affecting development, not as publication automation.
 - `.github/workflows/release.yml` owns the immutable sequence reusable validation → npm Trusted Publisher publication/verification → GitHub Release convergence; follow [docs/releasing.md](docs/releasing.md).
 - Keep npm publication tokenless: use the exact npm Trusted Publisher binding and job-scoped OIDC permission, never a long-lived npm token or token fallback.
+- Manifest-loaded packages expose bundled Skills only through `pi.skills`, preserving package resource filters and package-owned provenance. Only a checkout auto-discovered directly below a user or project Pi `extensions/` root may contribute its source Skill root through `resources_discover`; compiled-vs-source filename shape does not determine ownership.
 - Until a stable version beyond `1.x`, prefer clean breaking simplification over compatibility aliases or renamed legacy abstractions.

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 > Each release keeps at most 8 outcome records of at most 512 characters.
 
+## Unreleased
+
+## 0.53.2: Stable Inspector Trace Sequences
+
+- `Stable Inspector Trace Sequences`: Actor Inspector now numbers Trace rows from stable source-local chronology before applying the 100-row projection bound. Canonical Trace rows include cumulative compaction offsets and owned Pi turns retain their native sequence, so adding `#100` no longer renumbers the previous `#99`; newest-first ordering, source filters, public Trace JSON, and focus-by-id remain unchanged.
+
+## 0.53.1: Filterable Skills and drift-safe Git installs
+
+- `Filterable Packaged Skills`: Manifest-loaded runtime leaves all six bundled Skills to `pi.skills`, preserving filters and provenance. Auto-discovered checkouts contribute source Skills even when Pi selects compiled code; resolver regressions cover both modes. Unsupported source manifest aliases are removed, and the committed distributive supports git installs with drift-checking atomic builds.
+
 ## 0.53.0: Tree-Compressed Completion Delivery
 
 - `Quiet Draft Reloads`: Keeps automatic Recipe reload active for draft-directory changes while showing “Recipe tools refreshed” only for active non-draft Recipe changes or registry-root replacement, so ordinary spawn draft capture no longer produces misleading tool-refresh noise.

package/README.md

@@ -31,7 +31,7 @@ For local development:
 pi install /path/to/pi-actors
 ```
 
-The package contributes the extension and six capability-owning Skills for actors, artifacts, music playback, project work, Recipe memory, and swarm orchestration.
+The package contributes the extension and six capability-owning Skills for actors, artifacts, music playback, project work, Recipe memory, and swarm orchestration. Manifest-loaded packages expose those Skills through the package manifest so Pi resource filters and package provenance remain authoritative; a checkout auto-discovered directly under Pi's user or project extensions directory contributes its source Skills even when Pi selects the checkout's compiled entrypoint.
 
 ## Public Tools
 
@@ -238,7 +238,7 @@ npm run validate
 npm run test:preservation
 ```
 
-The build produces the JavaScript runtime used by detached Actor processes in npm installations. Pi can load a TypeScript extension entrypoint, but standalone Node processes cannot type-strip modules under `node_modules`; keeping compiled Run modules preserves process isolation without a runtime TypeScript loader.
+The atomic build produces the committed JavaScript runtime used by npm and git installs; `npm run build:check` verifies that `dist/` matches source without rewriting it. Pi can load a TypeScript extension entrypoint, but standalone Node processes cannot type-strip modules under `node_modules`; keeping compiled Run modules preserves process isolation without a runtime TypeScript loader.
 
 See the [documentation index](./docs/README.md), [Run lifecycle](./docs/async-runs.md), and [Recipe library](./docs/recipe-library.md).
 

package/dist/index.js

@@ -5,9 +5,12 @@
  */
 import * as ExtensionRuntime from "./lib/extension-runtime.js";
 import * as InspectorCommand from "./lib/inspector-command.js";
+import * as Paths from "./lib/paths.js";
 export default function toolRegistryExtension(pi) {
     const runtime = ExtensionRuntime.createActorExtensionRuntime(pi);
-    pi.on("resources_discover", async () => runtime.discoverResources(import.meta.url));
+    if (Paths.isRawExtensionCheckout(import.meta.url)) {
+        pi.on("resources_discover", async () => runtime.discoverResources(import.meta.url));
+    }
     pi.on("session_start", async (_event, ctx) => runtime.onSessionStart(ctx));
     pi.on("agent_settled", async (_event, ctx) => runtime.onAgentSettled(ctx));
     pi.on("context", async (event, ctx) => ({

package/dist/lib/inspector-overlay.js

@@ -583,7 +583,8 @@ 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 - 1}`)} ${marker} ${this.theme.fg("muted", item.source)}/${this.theme.fg(item.level === "error" ? "error" : "accent", item.kind)}  ${this.theme.fg("text", item.summary)}`;
+                const sequence = item[TraceProjection.TRACE_ITEM_SEQUENCE] ?? items.length - index - 1;
+                const row = `${prefix}${this.theme.fg("text", `#${sequence}`)} ${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;

package/dist/lib/paths.d.ts

@@ -21,6 +21,12 @@ export declare function getToolReviewStatePath(agentDir?: string): string;
 export declare function getToolReviewBatchDir(reviewId: string, agentDir?: string): string;
 export declare function getExtensionRuntimePaths(agentDir?: string): ExtensionRuntimePaths;
 export declare const EXTENSION_RUNTIME_PATHS: ExtensionRuntimePaths;
+export declare function getExtensionPackageRoot(extensionUrl: string): string;
+export interface RawExtensionCheckoutOptions {
+    agentDir?: string;
+    cwd?: string;
+}
+export declare function isRawExtensionCheckout(extensionUrl: string, options?: RawExtensionCheckoutOptions): boolean;
 export declare function getExtensionSkillsDir(extensionUrl: string): string;
 export declare function getExistingExtensionSkillPaths(extensionUrl: string): string[];
 export declare function getRecipeRoot(agentDir?: string): string;

package/dist/lib/paths.js

@@ -57,8 +57,26 @@ export function getExtensionRuntimePaths(agentDir = getAgentDir()) {
     };
 }
 export const EXTENSION_RUNTIME_PATHS = getExtensionRuntimePaths();
+export function getExtensionPackageRoot(extensionUrl) {
+    let current = dirname(fileURLToPath(extensionUrl));
+    while (true) {
+        if (existsSync(join(current, "package.json")))
+            return current;
+        const parent = dirname(current);
+        if (parent === current)
+            return dirname(fileURLToPath(extensionUrl));
+        current = parent;
+    }
+}
+export function isRawExtensionCheckout(extensionUrl, options = {}) {
+    const packageRoot = resolve(getExtensionPackageRoot(extensionUrl));
+    const agentDir = resolve(options.agentDir ?? getAgentDir());
+    const cwd = resolve(options.cwd ?? process.cwd());
+    return dirname(packageRoot) === join(agentDir, "extensions") ||
+        dirname(packageRoot) === join(cwd, ".pi", "extensions");
+}
 export function getExtensionSkillsDir(extensionUrl) {
-    return join(dirname(fileURLToPath(extensionUrl)), "skills");
+    return join(getExtensionPackageRoot(extensionUrl), "skills");
 }
 export function getExistingExtensionSkillPaths(extensionUrl) {
     const skillsDir = getExtensionSkillsDir(extensionUrl);

package/dist/lib/trace-projection.d.ts

@@ -6,9 +6,11 @@
 import { type RunArtifactDeclaration } from "./runs-artifacts.ts";
 export type TraceSource = "lifecycle" | "control" | "process" | "agent" | "artifact" | "runtime";
 export type TraceSourceFilter = TraceSource | "all";
+export declare const TRACE_ITEM_SEQUENCE: unique symbol;
 export interface TraceItem {
     id: string;
     ts: string;
+    [TRACE_ITEM_SEQUENCE]?: number;
     source: TraceSource;
     kind: string;
     summary: string;

package/dist/lib/trace-projection.js

@@ -14,6 +14,7 @@ import { tailFile } from "./runs-status.js";
 import * as RunsTrace from "./runs-trace.js";
 import * as SessionEvidence from "./session-evidence.js";
 import { readJsonFileResilient, } from "./state-readers.js";
+export const TRACE_ITEM_SEQUENCE = Symbol("trace-item-sequence");
 const LIFECYCLE_PREFIXES = ["run.", "command."];
 const SOURCE_LIMIT = 100;
 const SOURCE_RANK = {
@@ -32,7 +33,8 @@ function sourceForEvent(event) {
         ? "lifecycle"
         : "runtime";
 }
-function ordered(item, sourceKey, ordinal) {
+function ordered(item, sourceKey, ordinal, sequence = ordinal) {
+    Object.defineProperty(item, TRACE_ITEM_SEQUENCE, { value: sequence });
     return { item, ordinal, sourceKey };
 }
 function compareTraceItems(left, right) {
@@ -83,6 +85,8 @@ function controlDiagnosticItems(diagnostics) {
 }
 function traceEventItems(stateDir) {
     const read = RunsTrace.readRunTraceJournal(stateDir);
+    const summary = RunsTrace.summarizeRunTraceJournal(read);
+    const sequenceOffset = summary.dropped_events + Math.max(0, summary.compactions_total - 1);
     const retained = read.events.slice(-SOURCE_LIMIT);
     const projected = retained.map(({ event, ordinal }) => ordered({
         id: event.id,
@@ -95,7 +99,7 @@ function traceEventItems(stateDir) {
             ...(event.attention ? { attention: event.attention } : {}),
             ...(event.data !== undefined ? { data: event.data } : {}),
         }),
-    }, "trace", ordinal));
+    }, "trace", ordinal, sequenceOffset + Math.max(0, ordinal - 1)));
     const diagnostics = diagnosticItems(read.diagnostics).map((item, index) => ordered(item, "trace", read.events.length + index + 1));
     const hasMarker = read.events.some(({ event }) => event.kind === "runtime.trace_compacted");
     if (read.omittedPrefixBytes > 0 && !hasMarker) {
@@ -128,7 +132,7 @@ function controlItems(stateDir) {
             summary: `${value.action} ${value.status}`,
             ...(value.status === "failed" ? { level: "error" } : {}),
             detail: value,
-        }, "control", start + index + 1);
+        }, "control", start + index + 1, start + index);
     });
     return [
         ...projected,
@@ -153,7 +157,7 @@ function agentItems(stateDir) {
     });
 }
 function processItems(stateDir) {
-    return ["stdout", "stderr"].flatMap((stream) => {
+    return ["stdout", "stderr"].flatMap((stream, index) => {
         const path = join(stateDir, `${stream}.log`);
         if (!existsSync(path))
             return [];
@@ -169,7 +173,7 @@ function processItems(stateDir) {
                 summary: `${stream} (${stat.size} bytes)`,
                 ...(stream === "stderr" ? { level: "warning" } : {}),
                 detail: redact({ bytes: stat.size, path, tail }),
-            }, `process:${stream}`, 1)];
+            }, `process:${stream}`, 1, index)];
     });
 }
 function resultItems(stateDir) {
@@ -190,7 +194,7 @@ function resultItems(stateDir) {
             summary: failed ? "Run process failed" : "Run process completed",
             ...(failed ? { level: "error" } : {}),
             detail: redact(read.value),
-        }, "process:result", 1), ...diagnosticItems(read.diagnostics).map((item, index) => ordered(item, "process:result", index + 2))];
+        }, "process:result", 1, 2), ...diagnosticItems(read.diagnostics).map((item, index) => ordered(item, "process:result", index + 2))];
 }
 function artifactItems(stateDir, declarations) {
     const manifest = resolveArtifactManifest(declarations);
@@ -211,7 +215,7 @@ function artifactItems(stateDir, declarations) {
             required: artifact.required,
             ...(artifact.size !== undefined ? { size: artifact.size } : {}),
         }),
-    }, "artifact", index + 1));
+    }, "artifact", index + 1, index));
 }
 export function projectRunTrace(stateDir, options = {}) {
     const source = options.source ?? "all";

package/dist/scripts/build-dist.mjs

@@ -1,47 +1,40 @@
 #!/usr/bin/env node
 
 /**
- * Build the JavaScript-only distributive tree.
- *
- * This is intentionally standalone: it is package/build glue, not reusable
- * actor-domain behavior. It cleans dist, compiles TypeScript, mirrors runtime
- * assets, and syntax-checks packaged scripts.
+ * Builds or verifies the JavaScript-only distributive tree without exposing a
+ * partial tree to Pi or destroying the previous distributive on failure.
  */
 
 import { spawnSync } from "node:child_process";
 import {
   cpSync,
+  existsSync,
   mkdirSync,
+  mkdtempSync,
+  readFileSync,
   readdirSync,
+  renameSync,
   rmSync,
   writeFileSync,
 } from "node:fs";
-import { join } from "node:path";
+import { join, relative } from "node:path";
+
+const DIST_DIR = "dist";
+const checkOnly = process.argv.includes("--check");
 
 function run(command, args) {
   const result = spawnSync(command, args, { stdio: "inherit" });
   if (result.error) throw result.error;
-  if (result.status !== 0) process.exit(result.status ?? 1);
+  if (result.status !== 0) {
+    throw new Error(`${command} exited with status ${result.status ?? "unknown"}.`);
+  }
 }
 
-rmSync("dist", { recursive: true, force: true });
-mkdirSync("dist", { recursive: true });
-
-run(process.execPath, [
-  join("node_modules", "typescript", "bin", "tsc"),
-  "-p",
-  "tsconfig.build.json",
-]);
-
-mkdirSync(join("dist", "pi-actors"), { recursive: true });
-writeFileSync(
-  join("dist", "pi-actors", "index.js"),
-  'export { default } from "../index.js";\n',
-  "utf8",
-);
-
-for (const dir of ["scripts", "fixtures", "skills"]) {
-  cpSync(dir, join("dist", dir), { recursive: true });
+function listFiles(root, current = root) {
+  return readdirSync(current, { withFileTypes: true }).flatMap((entry) => {
+    const path = join(current, entry.name);
+    return entry.isDirectory() ? listFiles(root, path) : [relative(root, path)];
+  }).sort();
 }
 
 function listModuleScripts(root) {
@@ -52,9 +45,80 @@ function listModuleScripts(root) {
   });
 }
 
-const builtScripts = [
-  ...listModuleScripts(join("dist", "scripts")),
-  ...listModuleScripts(join("dist", "skills")),
-];
+function normalizeTextFiles(root) {
+  const textSuffixes = [".js", ".ts", ".mjs", ".json", ".md"];
+  for (const path of listFiles(root)) {
+    if (!textSuffixes.some((suffix) => path.endsWith(suffix))) continue;
+    const absolutePath = join(root, path);
+    const source = readFileSync(absolutePath, "utf8");
+    const normalized = source.replace(/\r\n?/g, "\n");
+    if (normalized !== source) writeFileSync(absolutePath, normalized, "utf8");
+  }
+}
+
+function assertTreesEqual(expectedRoot, actualRoot) {
+  if (!existsSync(expectedRoot)) {
+    throw new Error(`${expectedRoot} is missing; run npm run build.`);
+  }
+  const expectedFiles = listFiles(expectedRoot);
+  const actualFiles = listFiles(actualRoot);
+  if (JSON.stringify(expectedFiles) !== JSON.stringify(actualFiles)) {
+    throw new Error("dist file inventory is stale; run npm run build.");
+  }
+  for (const path of expectedFiles) {
+    if (!readFileSync(join(expectedRoot, path)).equals(readFileSync(join(actualRoot, path)))) {
+      throw new Error(`dist/${path} is stale; run npm run build.`);
+    }
+  }
+}
+
+function replaceDist(candidate) {
+  const backup = `.dist-backup-${process.pid}-${Date.now()}`;
+  const hadDist = existsSync(DIST_DIR);
+  if (hadDist) renameSync(DIST_DIR, backup);
+  try {
+    renameSync(candidate, DIST_DIR);
+    if (hadDist) rmSync(backup, { recursive: true, force: true });
+  } catch (error) {
+    if (hadDist && existsSync(backup) && !existsSync(DIST_DIR)) {
+      renameSync(backup, DIST_DIR);
+    }
+    throw error;
+  }
+}
 
-run(process.execPath, ["--check", ...builtScripts]);
+const candidate = mkdtempSync(join(process.cwd(), ".dist-build-"));
+try {
+  run(process.execPath, [
+    join("node_modules", "typescript", "bin", "tsc"),
+    "-p",
+    "tsconfig.build.json",
+    "--outDir",
+    candidate,
+  ]);
+
+  mkdirSync(join(candidate, "pi-actors"), { recursive: true });
+  writeFileSync(
+    join(candidate, "pi-actors", "index.js"),
+    'export { default } from "../index.js";\n',
+    "utf8",
+  );
+  normalizeTextFiles(candidate);
+  for (const dir of ["scripts", "fixtures", "skills"]) {
+    cpSync(dir, join(candidate, dir), { recursive: true });
+  }
+  const builtScripts = [
+    ...listModuleScripts(join(candidate, "scripts")),
+    ...listModuleScripts(join(candidate, "skills")),
+  ];
+  run(process.execPath, ["--check", ...builtScripts]);
+
+  if (checkOnly) {
+    assertTreesEqual(DIST_DIR, candidate);
+    console.log("pi-actors: dist is current");
+  } else {
+    replaceDist(candidate);
+  }
+} finally {
+  rmSync(candidate, { recursive: true, force: true });
+}

package/docs/actor-inspector.md

@@ -25,7 +25,7 @@ Captured Recipe evidence belongs to the Run generation and does not change when
 
 Shows the unified bounded Trace projection. Sources include lifecycle/runtime observations, Controls, owned Pi turns, command-log tails, results, artifacts, and diagnostics. The source selector displays only `all` plus sources present in the current projection from `lifecycle`, `control`, `process`, `agent`, `artifact`, and `runtime`. Select a row to open structured detail.
 
-Trace ordering stays deterministic and newest-first: timestamp descending, same-source physical ordinal descending, fixed internal source rank, then stable id. Internal ordinals are never displayed or interpreted as cross-source causality. Row numbers are zero-based chronological identities even though display is newest-first: the oldest visible event is `#0` and the newest carries the highest number. The summary states whether retained history is complete; `runtime.trace_compacted` means older history was discarded and shows bounded cumulative drop evidence. Terminal/result/execution/artifact evidence keeps its own authority. The projection applies path containment and redaction before rendering.
+Trace ordering stays deterministic and newest-first: timestamp descending, same-source physical ordinal descending, fixed internal source rank, then stable id. Row numbers use stable zero-based source sequences rather than positions inside the visible 100-row tail: when `#100` arrives, the existing `#99` remains `#99`. Canonical journal rows reconstruct their absolute sequence from retained ordinals plus cumulative compaction evidence; owned Pi turns keep their native turn sequence. Sequences are source-local and never imply cross-source causality. The summary states whether retained history is complete; `runtime.trace_compacted` means older history was discarded and shows bounded cumulative drop evidence. Terminal/result/execution/artifact evidence keeps its own authority. The projection applies path containment and redaction before rendering.
 
 ## Control
 

package/index.ts

@@ -6,13 +6,16 @@
 
 import * as ExtensionRuntime from "./lib/extension-runtime.ts";
 import * as InspectorCommand from "./lib/inspector-command.ts";
+import * as Paths from "./lib/paths.ts";
 import * as Pi from "./lib/pi.ts";
 
 export default function toolRegistryExtension(pi: Pi.ExtensionAPI) {
   const runtime = ExtensionRuntime.createActorExtensionRuntime(pi);
-  pi.on("resources_discover", async () =>
-    runtime.discoverResources(import.meta.url),
-  );
+  if (Paths.isRawExtensionCheckout(import.meta.url)) {
+    pi.on("resources_discover", async () =>
+      runtime.discoverResources(import.meta.url),
+    );
+  }
   pi.on("session_start", async (_event, ctx) => runtime.onSessionStart(ctx));
   pi.on("agent_settled", async (_event, ctx) => runtime.onAgentSettled(ctx));
   pi.on("context", async (event, ctx) => ({

package/lib/inspector-overlay.ts

@@ -653,7 +653,8 @@ 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 - 1}`)} ${marker} ${this.theme.fg("muted", item.source)}/${this.theme.fg(item.level === "error" ? "error" : "accent", item.kind)}  ${this.theme.fg("text", item.summary)}`;
+      const sequence = item[TraceProjection.TRACE_ITEM_SEQUENCE] ?? items.length - index - 1;
+      const row = `${prefix}${this.theme.fg("text", `#${sequence}`)} ${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;

package/lib/paths.ts

@@ -93,8 +93,34 @@ export function getExtensionRuntimePaths(
 
 export const EXTENSION_RUNTIME_PATHS = getExtensionRuntimePaths();
 
+export function getExtensionPackageRoot(extensionUrl: string): string {
+  let current = dirname(fileURLToPath(extensionUrl));
+  while (true) {
+    if (existsSync(join(current, "package.json"))) return current;
+    const parent = dirname(current);
+    if (parent === current) return dirname(fileURLToPath(extensionUrl));
+    current = parent;
+  }
+}
+
+export interface RawExtensionCheckoutOptions {
+  agentDir?: string;
+  cwd?: string;
+}
+
+export function isRawExtensionCheckout(
+  extensionUrl: string,
+  options: RawExtensionCheckoutOptions = {},
+): boolean {
+  const packageRoot = resolve(getExtensionPackageRoot(extensionUrl));
+  const agentDir = resolve(options.agentDir ?? getAgentDir());
+  const cwd = resolve(options.cwd ?? process.cwd());
+  return dirname(packageRoot) === join(agentDir, "extensions") ||
+    dirname(packageRoot) === join(cwd, ".pi", "extensions");
+}
+
 export function getExtensionSkillsDir(extensionUrl: string): string {
-  return join(dirname(fileURLToPath(extensionUrl)), "skills");
+  return join(getExtensionPackageRoot(extensionUrl), "skills");
 }
 
 export function getExistingExtensionSkillPaths(extensionUrl: string): string[] {

package/lib/trace-projection.ts

@@ -34,9 +34,12 @@ export type TraceSource =
 
 export type TraceSourceFilter = TraceSource | "all";
 
+export const TRACE_ITEM_SEQUENCE = Symbol("trace-item-sequence");
+
 export interface TraceItem {
   id: string;
   ts: string;
+  [TRACE_ITEM_SEQUENCE]?: number;
   source: TraceSource;
   kind: string;
   summary: string;
@@ -75,7 +78,9 @@ function ordered(
   item: TraceItem,
   sourceKey: string,
   ordinal: number,
+  sequence = ordinal,
 ): OrderedTraceItem {
+  Object.defineProperty(item, TRACE_ITEM_SEQUENCE, { value: sequence });
   return { item, ordinal, sourceKey };
 }
 
@@ -133,6 +138,8 @@ function controlDiagnosticItems(
 
 function traceEventItems(stateDir: string): OrderedTraceItem[] {
   const read = RunsTrace.readRunTraceJournal(stateDir);
+  const summary = RunsTrace.summarizeRunTraceJournal(read);
+  const sequenceOffset = summary.dropped_events + Math.max(0, summary.compactions_total - 1);
   const retained = read.events.slice(-SOURCE_LIMIT);
   const projected = retained.map(({ event, ordinal }) => ordered({
     id: event.id,
@@ -145,7 +152,7 @@ function traceEventItems(stateDir: string): OrderedTraceItem[] {
       ...(event.attention ? { attention: event.attention } : {}),
       ...(event.data !== undefined ? { data: event.data } : {}),
     }),
-  }, "trace", ordinal));
+  }, "trace", ordinal, sequenceOffset + Math.max(0, ordinal - 1)));
   const diagnostics = diagnosticItems(read.diagnostics).map((item, index) =>
     ordered(item, "trace", read.events.length + index + 1)
   );
@@ -183,7 +190,7 @@ function controlItems(stateDir: string): OrderedTraceItem[] {
       summary: `${value.action} ${value.status}`,
       ...(value.status === "failed" ? { level: "error" as const } : {}),
       detail: value,
-    }, "control", start + index + 1);
+    }, "control", start + index + 1, start + index);
   });
   return [
     ...projected,
@@ -212,7 +219,7 @@ function agentItems(stateDir: string): OrderedTraceItem[] {
 }
 
 function processItems(stateDir: string): OrderedTraceItem[] {
-  return ["stdout", "stderr"].flatMap((stream) => {
+  return ["stdout", "stderr"].flatMap((stream, index) => {
     const path = join(stateDir, `${stream}.log`);
     if (!existsSync(path)) return [];
     const stat = statSync(path);
@@ -226,7 +233,7 @@ function processItems(stateDir: string): OrderedTraceItem[] {
       summary: `${stream} (${stat.size} bytes)`,
       ...(stream === "stderr" ? { level: "warning" as const } : {}),
       detail: redact({ bytes: stat.size, path, tail }),
-    }, `process:${stream}`, 1)];
+    }, `process:${stream}`, 1, index)];
   });
 }
 
@@ -250,7 +257,7 @@ function resultItems(stateDir: string): OrderedTraceItem[] {
     summary: failed ? "Run process failed" : "Run process completed",
     ...(failed ? { level: "error" as const } : {}),
     detail: redact(read.value),
-  }, "process:result", 1), ...diagnosticItems(read.diagnostics).map(
+  }, "process:result", 1, 2), ...diagnosticItems(read.diagnostics).map(
     (item, index) => ordered(item, "process:result", index + 2),
   )];
 }
@@ -277,7 +284,7 @@ function artifactItems(
         required: artifact.required,
         ...(artifact.size !== undefined ? { size: artifact.size } : {}),
       }),
-    }, "artifact", index + 1),
+    }, "artifact", index + 1, index),
   );
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-actors",
-  "version": "0.53.0",
+  "version": "0.53.2",
   "private": false,
   "description": "Local Actor Kernel for Pi",
   "keywords": [
@@ -31,9 +31,10 @@
     "test:preservation": "node --experimental-strip-types --test --test-concurrency=1 tests/async-runs.test.ts tests/observability.test.ts tests/session-evidence.test.ts tests/inspector-security.test.ts tests/inspector-overlay.test.ts tests/review-control.test.ts",
     "pack:dry": "npm pack --dry-run",
     "recipes:qa": "node skills/actors/scripts/validate-recipe.mjs skills --skills --qa --summary",
-    "validate": "npx tsc --noEmit && npm run recipes:qa && npm run build && npm run check && npm test && npm run conformance && npm run pack:dry",
+    "validate": "npx tsc --noEmit && npm run recipes:qa && npm run build:check && npm run check && npm test && npm run conformance && npm run pack:dry",
     "audit:dependencies": "npm audit --audit-level=high --omit=peer",
     "build": "node scripts/build-dist.mjs",
+    "build:check": "node scripts/build-dist.mjs --check",
     "prepack": "npm run build"
   },
   "files": [
@@ -54,15 +55,9 @@
     "extensions": [
       "./dist/pi-actors/index.js"
     ],
-    "sourceExtensions": [
-      "./index.ts"
-    ],
     "skills": [
       "./dist/skills"
     ],
-    "sourceSkills": [
-      "./skills"
-    ],
     "image": "https://raw.githubusercontent.com/llblab/pi-actors/main/banner.jpg"
   },
   "peerDependencies": {

package/scripts/build-dist.mjs

@@ -1,47 +1,40 @@
 #!/usr/bin/env node
 
 /**
- * Build the JavaScript-only distributive tree.
- *
- * This is intentionally standalone: it is package/build glue, not reusable
- * actor-domain behavior. It cleans dist, compiles TypeScript, mirrors runtime
- * assets, and syntax-checks packaged scripts.
+ * Builds or verifies the JavaScript-only distributive tree without exposing a
+ * partial tree to Pi or destroying the previous distributive on failure.
  */
 
 import { spawnSync } from "node:child_process";
 import {
   cpSync,
+  existsSync,
   mkdirSync,
+  mkdtempSync,
+  readFileSync,
   readdirSync,
+  renameSync,
   rmSync,
   writeFileSync,
 } from "node:fs";
-import { join } from "node:path";
+import { join, relative } from "node:path";
+
+const DIST_DIR = "dist";
+const checkOnly = process.argv.includes("--check");
 
 function run(command, args) {
   const result = spawnSync(command, args, { stdio: "inherit" });
   if (result.error) throw result.error;
-  if (result.status !== 0) process.exit(result.status ?? 1);
+  if (result.status !== 0) {
+    throw new Error(`${command} exited with status ${result.status ?? "unknown"}.`);
+  }
 }
 
-rmSync("dist", { recursive: true, force: true });
-mkdirSync("dist", { recursive: true });
-
-run(process.execPath, [
-  join("node_modules", "typescript", "bin", "tsc"),
-  "-p",
-  "tsconfig.build.json",
-]);
-
-mkdirSync(join("dist", "pi-actors"), { recursive: true });
-writeFileSync(
-  join("dist", "pi-actors", "index.js"),
-  'export { default } from "../index.js";\n',
-  "utf8",
-);
-
-for (const dir of ["scripts", "fixtures", "skills"]) {
-  cpSync(dir, join("dist", dir), { recursive: true });
+function listFiles(root, current = root) {
+  return readdirSync(current, { withFileTypes: true }).flatMap((entry) => {
+    const path = join(current, entry.name);
+    return entry.isDirectory() ? listFiles(root, path) : [relative(root, path)];
+  }).sort();
 }
 
 function listModuleScripts(root) {
@@ -52,9 +45,80 @@ function listModuleScripts(root) {
   });
 }
 
-const builtScripts = [
-  ...listModuleScripts(join("dist", "scripts")),
-  ...listModuleScripts(join("dist", "skills")),
-];
+function normalizeTextFiles(root) {
+  const textSuffixes = [".js", ".ts", ".mjs", ".json", ".md"];
+  for (const path of listFiles(root)) {
+    if (!textSuffixes.some((suffix) => path.endsWith(suffix))) continue;
+    const absolutePath = join(root, path);
+    const source = readFileSync(absolutePath, "utf8");
+    const normalized = source.replace(/\r\n?/g, "\n");
+    if (normalized !== source) writeFileSync(absolutePath, normalized, "utf8");
+  }
+}
+
+function assertTreesEqual(expectedRoot, actualRoot) {
+  if (!existsSync(expectedRoot)) {
+    throw new Error(`${expectedRoot} is missing; run npm run build.`);
+  }
+  const expectedFiles = listFiles(expectedRoot);
+  const actualFiles = listFiles(actualRoot);
+  if (JSON.stringify(expectedFiles) !== JSON.stringify(actualFiles)) {
+    throw new Error("dist file inventory is stale; run npm run build.");
+  }
+  for (const path of expectedFiles) {
+    if (!readFileSync(join(expectedRoot, path)).equals(readFileSync(join(actualRoot, path)))) {
+      throw new Error(`dist/${path} is stale; run npm run build.`);
+    }
+  }
+}
+
+function replaceDist(candidate) {
+  const backup = `.dist-backup-${process.pid}-${Date.now()}`;
+  const hadDist = existsSync(DIST_DIR);
+  if (hadDist) renameSync(DIST_DIR, backup);
+  try {
+    renameSync(candidate, DIST_DIR);
+    if (hadDist) rmSync(backup, { recursive: true, force: true });
+  } catch (error) {
+    if (hadDist && existsSync(backup) && !existsSync(DIST_DIR)) {
+      renameSync(backup, DIST_DIR);
+    }
+    throw error;
+  }
+}
 
-run(process.execPath, ["--check", ...builtScripts]);
+const candidate = mkdtempSync(join(process.cwd(), ".dist-build-"));
+try {
+  run(process.execPath, [
+    join("node_modules", "typescript", "bin", "tsc"),
+    "-p",
+    "tsconfig.build.json",
+    "--outDir",
+    candidate,
+  ]);
+
+  mkdirSync(join(candidate, "pi-actors"), { recursive: true });
+  writeFileSync(
+    join(candidate, "pi-actors", "index.js"),
+    'export { default } from "../index.js";\n',
+    "utf8",
+  );
+  normalizeTextFiles(candidate);
+  for (const dir of ["scripts", "fixtures", "skills"]) {
+    cpSync(dir, join(candidate, dir), { recursive: true });
+  }
+  const builtScripts = [
+    ...listModuleScripts(join(candidate, "scripts")),
+    ...listModuleScripts(join(candidate, "skills")),
+  ];
+  run(process.execPath, ["--check", ...builtScripts]);
+
+  if (checkOnly) {
+    assertTreesEqual(DIST_DIR, candidate);
+    console.log("pi-actors: dist is current");
+  } else {
+    replaceDist(candidate);
+  }
+} finally {
+  rmSync(candidate, { recursive: true, force: true });
+}