@llblab/pi-actors 0.43.1 → 0.45.0

package/README.md

@@ -84,7 +84,7 @@ Persist a trusted command template or Recipe-backed capability under `~/.pi/agen
 
 Recipes can declare:
 
-- args and typed defaults;
+- named typed args, inline fallbacks, configuration `defaults`, and composition `values`;
 - imports and command-template composition;
 - retry, failure, recovery, repeat, concurrency, and timeout policy;
 - artifact paths;
@@ -103,6 +103,8 @@ Example controlled Recipe:
 
 Ordinary one-shot Recipes should omit `control`. Recipe imports compose definitions inside one Run; they do not create peer actors.
 
+File-backed Recipes receive immutable `{recipe_dir}`; Recipes under a Pi-active Skill also receive `{skill_dir}`. Use `std:<recipe>` for an exact packaged component and `skill:<skill>/<recipe-path>` for an exact active-Skill component. Skill Recipes are namespaced reusable components and do not become tools automatically.
+
 String command-template leaves execute directly without shell interpretation. Use template arrays for sequencing or an explicit trusted shell/script when shell semantics matter.
 
 ## Trace
@@ -121,13 +123,13 @@ String command-template leaves execute directly without shell interpretation. Us
 }
 ```
 
-Trace fields are exact: `id`, `ts`, `kind`, and optional `summary`, `data`, `level`, `attention`. Address, sender, recipient, reply, and routing fields fail validation. The canonical append authority validates and size-checks under a cross-process mutation lock before one append-only JSONL write; first-party scripts never append this file directly.
+Trace fields are exact: `id`, `ts`, `kind`, and optional `summary`, `data`, `level`, `attention`. Address, sender, recipient, reply, and routing fields fail validation. Trace is a bounded retained suffix, not an audit archive: the canonical authority appends within 2,048 events and 4 MiB or atomically keeps the newest suffix plus one warning-only `runtime.trace_compacted` marker. That marker means older history was discarded; `result.json`, `execution.json`, terminal state, and declared artifacts retain their own authority. `inspect view=trace` reports whether retained history is complete. Reads are newline-safe and deterministic; first-party scripts never write this file directly.
 
-Use `attention: "notify"` for visible status and `attention: "followup"` only when the coordinator needs semantic follow-up context. Store large evidence in artifacts or bounded execution captures.
+Attention is a live wake hint, not a durable queue: persist recovery state or an artifact first. Use `attention: "notify"` for visible status and `attention: "followup"` only when the coordinator needs semantic follow-up context; compaction may discard older hints. Store large evidence in artifacts or bounded execution captures.
 
 ## Control
 
-Controls persist to `controls.jsonl` before transport. Token-owned dead-process-reclaiming locks serialize atomic journal replacements. Every record carries the immutable `run_instance_id`; expected-status fencing advances outcomes monotonically through queued/delivered/claimed/handled/failed evidence, while a fast consumer may claim or handle before the sender adds independent delivery-time evidence.
+Controls persist to `controls.jsonl` before transport. One token-owned lock rejects a 65th pending Control or 1 MiB rewrite before admission, fails closed on malformed or stale-generation evidence, and atomically admits one record. Canonical transitions retain a 128-terminal tail, expected-state fencing, and 4 KiB errors. Admitted nonterminal Controls never expire automatically. Every record carries immutable `run_instance_id`. `inspect view=control` reports pending capacity, saturation, stale work, journal bytes, and bounded diagnostics. If a stuck Run is saturated, use runtime-owned `kill`; it bypasses actor-local capacity and creates no synthetic Control.
 
 Long-lived services publish `control-endpoint.json` only when ready:
 
@@ -159,7 +161,7 @@ Core files:
 - `execution.json` — command/session provenance and complete-capture references;
 - `result.json`, command logs, progress, and declared artifacts.
 
-The runtime preserves owner filtering, process-identity verification, lifecycle locking, shutdown kill, terminal reconciliation, bounded captures, owned Pi sessions, path containment, and redaction.
+The runtime preserves owner filtering, process-identity verification, lifecycle locking, shutdown kill independent of actor-local Control capacity, terminal reconciliation, bounded captures, owned Pi sessions, path containment, and redaction. Trace/Control quotas do not constrain user-declared artifacts, repositories, media sources, complete captures, or actor-owned workload state. Restart clears generation-local Trace, Control, endpoint, execution, and terminal evidence; archive preserves the bounded tree, while prune preserves only requested artifacts.
 
 ## Actor Inspector
 
@@ -197,7 +199,7 @@ npm run validate
 npm run test:preservation
 ```
 
-See the [documentation index](./docs/README.md), [Run lifecycle](./docs/async-runs.md), [Recipe library](./docs/recipe-library.md), and [0.43 baseline](./docs/0.43-baseline.md).
+See the [documentation index](./docs/README.md), [Run lifecycle](./docs/async-runs.md), and [Recipe library](./docs/recipe-library.md).
 
 Project context: [AGENTS.md](./AGENTS.md) · [BACKLOG.md](./BACKLOG.md) · [CHANGELOG.md](./CHANGELOG.md).
 

package/dist/index.js

@@ -10,6 +10,7 @@ import * as InspectorCommand from "./lib/inspector-command.js";
 import * as Paths from "./lib/paths.js";
 import * as Pi from "./lib/pi.js";
 import * as Prompts from "./lib/prompts.js";
+import * as RecipesReferences from "./lib/recipes-references.js";
 import * as RunUiRuntime from "./lib/run-ui-runtime.js";
 import * as Runtime from "./lib/runtime.js";
 import * as Temp from "./lib/temp.js";
@@ -99,9 +100,12 @@ export default function toolRegistryExtension(pi) {
         runUiRuntime.shutdown(event.reason, ctx);
     });
     InspectorCommand.registerActorInspectorCommand(pi, getRunOwnerId);
-    pi.on("before_agent_start", async (event) => ({
-        systemPrompt: `${event.systemPrompt}\n\n${Prompts.ONBOARDING_SYSTEM_PROMPT}`,
-    }));
+    pi.on("before_agent_start", async (event) => {
+        RecipesReferences.setActiveSkillRecipeSources(event.systemPromptOptions.skills ?? []);
+        return {
+            systemPrompt: `${event.systemPrompt}\n\n${Prompts.ONBOARDING_SYSTEM_PROMPT}`,
+        };
+    });
     Pi.registerToolDefinitions(pi, Tools.createCoreActorToolDefinitions({
         configPath: Paths.EXTENSION_RUNTIME_PATHS.configPath,
         getActiveTools: () => pi.getActiveTools(),

package/dist/lib/async-runs.d.ts

@@ -38,6 +38,8 @@ export interface AsyncRunStartParams {
     template?: CommandTemplateValue;
     args?: string[];
     defaults?: Record<string, unknown>;
+    recipe_dir?: string;
+    skill_dir?: string;
     parallel?: boolean;
     concurrency?: number | string;
     min_successful?: number | string;

package/dist/lib/async-runs.js

@@ -12,6 +12,7 @@ import { CURRENT_MODEL_VALUE_KEY, CURRENT_THINKING_VALUE_KEY, describeCurrentPol
 import * as Paths from "./paths.js";
 import * as RecipesReferences from "./recipes-references.js";
 import * as RecipesUsage from "./recipes-usage.js";
+import * as Schema from "./schema.js";
 import { resolveArtifactPaths, } from "./runs-artifacts.js";
 import { safeRunId } from "./runs-identity.js";
 import { buildTerminalProgress, markTerminalHandled, signalOwnedRunProcess, } from "./runs-control.js";
@@ -23,7 +24,6 @@ import * as RunsStart from "./runs-start.js";
 import { appendRunTraceEvent } from "./runs-trace.js";
 import * as RunsIndex from "./runs-index.js";
 import * as RunsParentTeardown from "./runs-parent-teardown.js";
-import { appendRunControlInStateDir, updateRunControlStatusInStateDir, } from "./runs-controls.js";
 import { deliverRunControl, } from "./runs-control-delivery.js";
 import { buildRunStatus, tailFile, } from "./runs-status.js";
 import { readJsonFileResilient } from "./state-readers.js";
@@ -152,7 +152,14 @@ function resolveStartParams(params) {
             fileParams.run_id ||
             fileParams.name ||
             getRunIdFromFile(fileParams.file),
-        values: { ...(fileParams.values ?? {}), ...(params.values ?? {}) },
+        values: {
+            ...(fileParams.values ?? {}),
+            ...(params.values ?? {}),
+            ...(fileParams.recipe_dir
+                ? { recipe_dir: fileParams.recipe_dir }
+                : {}),
+            ...(fileParams.skill_dir ? { skill_dir: fileParams.skill_dir } : {}),
+        },
     };
 }
 function readJson(path) {
@@ -250,13 +257,34 @@ export function startRun(params, cwd) {
         !isAbsolute(recipeRelation)
         ? dirname(packagedRecipeRoot)
         : undefined;
-    const values = {
+    const argSpec = Schema.parseToolArgDeclarationList(startParams.args ?? []);
+    if (argSpec.error)
+        throw new Error(argSpec.error);
+    const declaredArgs = new Set(argSpec.args);
+    for (const key of Object.keys(startParams.defaults ?? {})) {
+        if (declaredArgs.size > 0 && !declaredArgs.has(key))
+            throw new Error(`Unknown Recipe default argument: ${key}`);
+    }
+    const values = Schema.normalizeRuntimeValues({
+        ...argSpec.defaults,
+        ...(startParams.defaults || {}),
         ...(packagedRepo ? { repo: packagedRepo } : {}),
         ...(startParams.values || {}),
         run_id: run,
         state_dir: stateDir,
         trace_file: join(stateDir, "trace.jsonl"),
-    };
+    }, argSpec.argTypes);
+    const runtimeTemplate = resolved.template &&
+        typeof resolved.template === "object" &&
+        !Array.isArray(resolved.template)
+        ? {
+            ...resolved.template,
+            defaults: {
+                ...(resolved.template.defaults ?? {}),
+                ...values,
+            },
+        }
+        : resolved.template;
     const modelPolicy = describeCurrentPolicyProvenance({
         defaults: startParams.defaults,
         template: resolved.template,
@@ -313,7 +341,7 @@ export function startRun(params, cwd) {
             state_schema: RuntimeIdentity.RUN_STATE_SCHEMA,
             status: "running",
             ...(startParams.tool ? { tool: startParams.tool } : {}),
-            template: resolved.template,
+            template: runtimeTemplate,
             values,
             model_policy: modelPolicy,
             ...(artifacts ? { artifacts } : {}),
@@ -576,57 +604,36 @@ function stopRun(runOrDir, signal, event, expected = {}) {
             status.run_instance_id !== expected.runInstanceId) {
             return { stopped: false, reason: "run generation changed", status };
         }
-        const control = event === "run.kill" && typeof status.run_instance_id === "string"
-            ? appendRunControlInStateDir(stateDir, {
-                action: "kill",
-                run_instance_id: status.run_instance_id,
-            })
-            : undefined;
-        if (control) {
-            updateRunControlStatusInStateDir(stateDir, control.id, "claimed", {}, ["queued"]);
-        }
-        const finish = (result) => {
-            if (!control)
-                return result;
-            const handled = result.stopped === true;
-            updateRunControlStatusInStateDir(stateDir, control.id, handled ? "handled" : "failed", handled ? {} : { error: String(result.reason ?? "kill rejected") }, ["claimed"]);
-            return { ...result, control_id: control.id };
-        };
         const pid = Number(status.pid || 0);
         if (status.status !== "running" && status.status !== "exited") {
-            return finish({ stopped: false, reason: "not running", status });
+            return { stopped: false, reason: "not running", status };
         }
         const identity = verifyRunProcessIdentity(pid, status.process_identity);
         if (status.status === "exited") {
             if (identity.status === "owner_mismatch" ||
                 identity.status === "unsupported_proof") {
-                return finish({
+                return {
                     stopped: false,
                     reason: identity.status.replaceAll("_", " "),
                     process_identity_status: identity.status,
                     status,
-                });
+                };
             }
-            return finish({ stopped: false, reason: "not running", status });
+            return { stopped: false, reason: "not running", status };
         }
         if (!identity.valid) {
-            return finish({
+            return {
                 stopped: false,
                 reason: identity.status.replaceAll("_", " "),
                 process_identity_status: identity.status,
                 status,
-            });
+            };
         }
         let signalResult;
         try {
             signalResult = signalOwnedRunProcess(pid, signal, status.process_identity);
         }
         catch (error) {
-            if (control) {
-                updateRunControlStatusInStateDir(stateDir, control.id, "failed", {
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
             throw error;
         }
         appendRunTraceEvent(stateDir, {
@@ -643,13 +650,13 @@ function stopRun(runOrDir, signal, event, expected = {}) {
             finalizeInterruptedExecution(stateDir, "cancelled", signal);
             markTerminalProgress(stateDir, "cancelled");
         }
-        return finish({
+        return {
             stopped: true,
             pid,
             signal,
             ...signalResult,
             state_dir: stateDir,
-        });
+        };
     }
     finally {
         releaseControlLock();

package/dist/lib/config.js

@@ -149,6 +149,7 @@ export function normalizeStoredTool(key, value, reservedToolNames) {
             template: argTemplate,
         };
     const inferredArgTypes = Schema.getTemplateArgTypes(argTemplateConfig);
+    Schema.assertCompatibleToolArgTypes(inferredArgTypes, declarations.argTypes);
     const argTypes = { ...inferredArgTypes, ...declarations.argTypes };
     const cfg = {
         name,

package/dist/lib/file-state.d.ts

@@ -12,5 +12,7 @@ export interface FileMutationLockOptions {
 }
 export declare function acquireFileMutationLock(path: string, options?: FileMutationLockOptions): () => void;
 export declare function withFileMutationLock<T>(path: string, mutate: () => T, options?: FileMutationLockOptions): T;
-export declare function writeTextAtomic(path: string, content: string): void;
+export declare function writeTextAtomic(path: string, content: string, options?: {
+    onBeforeReplace?(): void;
+}): void;
 export declare function writeJsonAtomic(path: string, value: unknown): void;

package/dist/lib/file-state.js

@@ -8,8 +8,11 @@ import { createHash, randomUUID } from "node:crypto";
 import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, dirname, join, parse, resolve } from "node:path";
-const FILE_MUTATION_LOCK_TIMEOUT_MS = process.platform === "win32" ? 15000 : 5000;
+const FILE_MUTATION_LOCK_TIMEOUT_MS = process.platform === "win32" ? 30000 : 15000;
 const FILE_MUTATION_LOCK_STALE_MS = 30000;
+const FILE_MUTATION_LOCK_RECLAIM_POLL_MS = 100;
+const FILE_MUTATION_LOCK_REMOVAL_GRACE_MS = 250;
+const FILE_MUTATION_LOCK_MAX_WAIT_MS = 50;
 const FILE_MUTATION_LOCK_ROOT = join(tmpdir(), "pi-actors-file-locks");
 function canonicalMutationPath(path) {
     const absolute = resolve(path);
@@ -65,7 +68,8 @@ function lockOwnerStatus(lockPath) {
             return "unknown";
         try {
             process.kill(pid, 0);
-            if (Date.now() - statSync(lockPath).mtimeMs > 50 && isZombieProcess(pid))
+            if (Date.now() - statSync(lockPath).mtimeMs > FILE_MUTATION_LOCK_REMOVAL_GRACE_MS &&
+                isZombieProcess(pid))
                 return "dead";
             return "alive";
         }
@@ -132,8 +136,10 @@ function tryReclaimRemovalBoundary(reclaimPath) {
     if (!existsSync(reclaimPath))
         return;
     try {
-        const inspectedToken = readLockToken(reclaimPath);
         const age = Date.now() - statSync(reclaimPath).mtimeMs;
+        if (age <= FILE_MUTATION_LOCK_REMOVAL_GRACE_MS)
+            return;
+        const inspectedToken = readLockToken(reclaimPath);
         const ownerStatus = lockOwnerStatus(reclaimPath);
         if ((ownerStatus === "dead" ||
             (ownerStatus === "unknown" && age > FILE_MUTATION_LOCK_STALE_MS)) &&
@@ -200,6 +206,8 @@ export function acquireFileMutationLock(path, options = {}) {
     const token = randomUUID();
     const pendingPath = prepareLockBoundary(lockPath, token, options.onBeforeLockPublish);
     let contentionReported = false;
+    let nextReclaimAt = 0;
+    let waitMs = 10;
     try {
         for (;;) {
             try {
@@ -211,13 +219,22 @@ export function acquireFileMutationLock(path, options = {}) {
                     contentionReported = true;
                     options.onContention?.();
                 }
-                tryReclaimMutationLock(lockPath, options);
-                if (Date.now() >= deadline) {
+                const now = Date.now();
+                if (now >= nextReclaimAt) {
+                    nextReclaimAt = now + FILE_MUTATION_LOCK_RECLAIM_POLL_MS;
+                    if (tryReclaimMutationLock(lockPath, options)) {
+                        waitMs = 10;
+                        continue;
+                    }
+                }
+                if (now >= deadline) {
                     throw new Error(`Timed out waiting for file mutation lock: ${canonicalMutationPath(path)}`, {
                         cause: error,
                     });
                 }
-                Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+                const jitter = Math.floor(Math.random() * Math.max(1, Math.floor(waitMs / 2)));
+                Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, waitMs + jitter);
+                waitMs = Math.min(FILE_MUTATION_LOCK_MAX_WAIT_MS, waitMs + 5);
             }
         }
     }
@@ -256,11 +273,12 @@ export function withFileMutationLock(path, mutate, options = {}) {
         release();
     }
 }
-export function writeTextAtomic(path, content) {
+export function writeTextAtomic(path, content, options = {}) {
     mkdirSync(dirname(path), { recursive: true });
     const tempPath = `${path}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
     try {
         writeFileSync(tempPath, content, "utf8");
+        options.onBeforeReplace?.();
         renameSync(tempPath, path);
     }
     catch (error) {

package/dist/lib/inspector-overlay.js

@@ -3,13 +3,17 @@
  * 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 { readFileSync } from "node:fs";
+import { readFileSync, statSync } from "node:fs";
 import * as path from "node:path";
 import { matchesKey, truncateToWidth, visibleWidth, } from "@earendil-works/pi-tui";
 import * as ActorInspector from "./inspector.js";
 import * as ControlProjection from "./control-projection.js";
 import * as RunsControls from "./runs-controls.js";
 import * as RunControlDelivery from "./runs-control-delivery.js";
+import * as RunsTrace from "./runs-trace.js";
+import * as Limits from "./limits.js";
+import { computeRunControlCapacity } from "./run-evidence-policy.js";
+import * as RuntimeTriage from "./runtime-triage.js";
 import * as TraceProjection from "./trace-projection.js";
 const TABS = ["recipe", "trace", "control"];
 const TRACE_SOURCES = [
@@ -21,9 +25,6 @@ const TRACE_SOURCES = [
     "artifact",
     "runtime",
 ];
-function newestTraceItems(items) {
-    return [...items].sort((left, right) => right.ts.localeCompare(left.ts) || right.id.localeCompare(left.id));
-}
 export class ActorInspectorOverlay {
     done;
     killRun;
@@ -410,7 +411,7 @@ export class ActorInspectorOverlay {
             `${this.theme.fg("muted", "Run:")} ${this.theme.fg("accent", `run:${confirmation.run}`)}`,
             `${this.theme.fg("muted", "Current status:")} ${this.theme.fg("warning", confirmation.status)}`,
             "",
-            this.theme.fg("text", "This sends canonical kill Control."),
+            this.theme.fg("text", "This invokes generation-fenced runtime kill."),
             "",
             `${cancel}    ${kill}`,
             "",
@@ -501,8 +502,10 @@ export class ActorInspectorOverlay {
     }
     renderTraceList(run) {
         const items = this.traceItems(run);
+        const summary = RunsTrace.summarizeRunTraceJournal(RunsTrace.readRunTraceJournal(path.join(this.stateRoot, run.run)));
+        const banner = summary.history_complete ? [] : [this.theme.fg("warning", ` ! Trace history incomplete: ${summary.compacted ? `${summary.compactions_total} compaction(s), ` : ""}${summary.dropped_event_count_exact ? summary.dropped_events : "unknown"} dropped event(s), ${summary.dropped_bytes} bytes`)];
         if (items.length === 0)
-            return [this.theme.fg("muted", " No Trace evidence")];
+            return [...banner, this.theme.fg("muted", " No Trace evidence")];
         if (this.selectedTraceId) {
             const selectedIndex = items.findIndex((item) => item.id === this.selectedTraceId);
             if (selectedIndex >= 0)
@@ -520,24 +523,24 @@ export class ActorInspectorOverlay {
         this.contentStripeIndices = items
             .slice(start, start + viewportRows)
             .map((_item, offset) => start + offset);
-        return items.slice(start, start + viewportRows).map((item, offset) => {
-            const index = start + offset;
-            const detail = item.detail && typeof item.detail === "object"
-                ? item.detail
-                : {};
-            const marker = item.level === "error"
-                ? this.theme.fg("error", "!")
-                : detail.attention
-                    ? this.theme.fg("warning", "A")
-                    : " ";
-            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)}`;
-            return this.focus === "list" && index === this.rowIndex
-                ? this.theme.fg("accent", row)
-                : row;
-        });
+        return [...banner, ...items.slice(start, start + viewportRows - banner.length).map((item, offset) => {
+                const index = start + offset;
+                const detail = item.detail && typeof item.detail === "object"
+                    ? item.detail
+                    : {};
+                const marker = item.level === "error"
+                    ? this.theme.fg("error", "!")
+                    : detail.attention
+                        ? this.theme.fg("warning", "A")
+                        : " ";
+                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)}`;
+                return this.focus === "list" && index === this.rowIndex
+                    ? this.theme.fg("accent", row)
+                    : row;
+            })];
     }
     renderTraceDetail(width) {
         if (!this.traceDetail)
@@ -553,16 +556,29 @@ export class ActorInspectorOverlay {
             ? RunControlDelivery.readRunControlEndpoint(stateDir, run.runInstanceId)
             : undefined;
         const meta = this.readRunMeta(stateDir);
+        const journal = RunsControls.readRunControlJournalFromStateDir(stateDir);
+        const capacity = computeRunControlCapacity(journal.records);
+        const stalePending = journal.records.reduce((count, control) => count + Number(Boolean(RuntimeTriage.classifyRuntimeControl({ run: run.run,
+            runInstanceId: run.runInstanceId, status: run.status }, control, Date.now()).stale)), 0);
         return {
             status: run.status,
             run_instance_id: run.runInstanceId,
+            pending: capacity.pending, pending_limit: capacity.limit,
+            available: capacity.available, backpressured: capacity.backpressured,
+            journal_bytes: (() => { try {
+                return statSync(RunsControls.runControlsFile(stateDir)).size;
+            }
+            catch {
+                return 0;
+            } })(),
+            journal_limit: Limits.RUN_CONTROL_JOURNAL_MAX_BYTES,
+            stale_pending: stalePending,
+            diagnostics: journal.diagnostics.map((item) => item.line === undefined
+                ? { reason: "unreadable_control_journal" } : { line: item.line, reason: "invalid_control_json" }),
             actor_actions: Array.isArray(meta.control) ? meta.control : [],
             runtime_actions: run.status === "running" ? ["kill"] : ["archive", "prune"],
             endpoint,
-            recent_controls: RunsControls.readRunControlsFromStateDir(stateDir)
-                .slice(-20)
-                .reverse()
-                .map(ControlProjection.projectRunControl),
+            recent_controls: journal.records.slice(-20).reverse().map((control) => ControlProjection.projectRunControl(control)),
         };
     }
     allTraceItems(run) {
@@ -572,10 +588,10 @@ export class ActorInspectorOverlay {
             this.traceCache.runInstanceId === run.runInstanceId) {
             return this.traceCache.items;
         }
-        const items = newestTraceItems(this.readTrace(path.join(this.stateRoot, run.run), {
+        const items = this.readTrace(path.join(this.stateRoot, run.run), {
             limit: 100,
             source: "all",
-        }));
+        });
         this.traceCache = { run: run.run, runInstanceId: run.runInstanceId, items };
         return items;
     }

package/dist/lib/inspector.js

@@ -56,7 +56,12 @@ export function readActorInspectorRecipe(stateDir) {
         !Array.isArray(primary.recipe)
         ? primary.recipe
         : undefined;
-    const redactedRecord = (value) => SessionEvidence.redactSessionEvidenceValue(Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined)));
+    const redactedRecord = (value) => SessionEvidence.redactSessionEvidenceValue(Object.fromEntries(Object.entries(value).filter(([key, entry]) => entry !== undefined &&
+        key !== "recipe_dir" &&
+        key !== "skill_dir")));
+    const launchValues = meta.values && typeof meta.values === "object" && !Array.isArray(meta.values)
+        ? Object.fromEntries(Object.entries(meta.values).filter(([key]) => key !== "recipe_dir" && key !== "skill_dir"))
+        : meta.values;
     return {
         composition: contexts.map((entry) => redactedRecord({
             ...(typeof entry.alias === "string" ? { alias: entry.alias } : {}),
@@ -64,6 +69,7 @@ export function readActorInspectorRecipe(stateDir) {
             file: entry.file,
             import_path: entry.import_path,
             name: entry.name,
+            qualified_name: entry.qualified_name,
         })),
         ...(definition ? { definition: redactedRecord(definition) } : {}),
         diagnostics: result.diagnostics.map((diagnostic) => diagnostic.message),
@@ -76,7 +82,7 @@ export function readActorInspectorRecipe(stateDir) {
         launch: redactedRecord({
             cwd: meta.cwd,
             template: meta.template,
-            values: meta.values,
+            values: launchValues,
             model_policy: meta.model_policy,
             control: meta.control,
             artifacts: meta.artifacts,

package/dist/lib/limits.d.ts

@@ -16,3 +16,13 @@ export declare const SESSION_EVIDENCE_TEXT_CHARS = 4000;
 export declare const SESSION_EVIDENCE_MAX_TOOL_CALLS = 100;
 export declare const TRACE_EVENT_MAX_BYTES: number;
 export declare const TRACE_EVENT_MAX_READ = 200;
+export declare const TRACE_JOURNAL_MAX_EVENTS = 2048;
+export declare const TRACE_JOURNAL_TARGET_EVENTS = 1536;
+export declare const TRACE_JOURNAL_MAX_BYTES: number;
+export declare const TRACE_JOURNAL_TARGET_BYTES: number;
+export declare const RUN_CONTROL_PENDING_LIMIT = 64;
+export declare const RUN_CONTROL_TERMINAL_LIMIT = 128;
+export declare const RUN_CONTROL_ERROR_MAX_BYTES: number;
+export declare const RUN_CONTROL_JOURNAL_MAX_BYTES: number;
+export declare const RUN_RETENTION_MAX_RECORDS = 256;
+export declare const RUN_RETENTION_MAX_BYTES: number;

package/dist/lib/limits.js

@@ -16,3 +16,13 @@ export const SESSION_EVIDENCE_TEXT_CHARS = 4_000;
 export const SESSION_EVIDENCE_MAX_TOOL_CALLS = 100;
 export const TRACE_EVENT_MAX_BYTES = 64 * 1024;
 export const TRACE_EVENT_MAX_READ = 200;
+export const TRACE_JOURNAL_MAX_EVENTS = 2_048;
+export const TRACE_JOURNAL_TARGET_EVENTS = 1_536;
+export const TRACE_JOURNAL_MAX_BYTES = 4 * 1024 * 1024;
+export const TRACE_JOURNAL_TARGET_BYTES = 3 * 1024 * 1024;
+export const RUN_CONTROL_PENDING_LIMIT = 64;
+export const RUN_CONTROL_TERMINAL_LIMIT = 128;
+export const RUN_CONTROL_ERROR_MAX_BYTES = 4 * 1024;
+export const RUN_CONTROL_JOURNAL_MAX_BYTES = 1024 * 1024;
+export const RUN_RETENTION_MAX_RECORDS = 256;
+export const RUN_RETENTION_MAX_BYTES = 1024 * 1024;

package/dist/lib/observability.d.ts

@@ -42,7 +42,7 @@ export interface RunSummary {
 }
 export interface RunUiObservationState {
     attentionEventIds: Map<string, Set<string>>;
-    eventLines: Map<string, number>;
+    legacyEventLines: Map<string, number>;
     frame: number;
     observed: Map<string, RunObservedStatus>;
 }
@@ -62,6 +62,7 @@ export interface RunUiNotificationSink {
     }): void;
 }
 export declare function createRunUiObservationState(): RunUiObservationState;
+export declare function primeRunAttentionState(state: RunUiObservationState, ownerId: string, stateRoot?: string): void;
 export declare function readRunUiSnapshot(state: RunUiObservationState, ownerId: string, options?: {
     includeAttention?: boolean;
     stateRoot?: string;
@@ -74,6 +75,7 @@ export declare function reconcileRunTerminalNotifications(input: {
     sink: RunUiNotificationSink;
     state: RunUiObservationState;
     stateRoot?: string;
+    includeAttention?: boolean;
 }): RunUiSnapshot;
 export declare function deliverRunAttentionNotifications(events: RunAttentionEvent[], sink: RunUiNotificationSink): void;
 export interface RunRetirementCandidate {
@@ -173,7 +175,7 @@ export declare function findRunRetirementCandidates(summary: RunSummary): RunRet
 export declare function executeRunRetirements(summary: RunSummary, options: RunRetirementExecutorOptions): Promise<RunRetirementExecution[]>;
 export declare function detectRunTransitions(previous: Map<string, RunObservedStatus>, summary: RunSummary): RunTransition[];
 export declare function pruneRunObservationState(previousStatuses: Map<string, RunObservedStatus>, previousLineCounts: Map<string, number>, summary: RunSummary, terminalRuns?: Iterable<string>, seenEventIds?: Map<string, Set<string>>): void;
-export declare function detectRunAttentionEvents(previousLineCounts: Map<string, number>, summary: RunSummary, seenEventIds?: Map<string, Set<string>>): RunAttentionEvent[];
+export declare function detectRunAttentionEvents(legacyLineCounts: Map<string, number>, summary: RunSummary, seenEventIds?: Map<string, Set<string>>, prime?: boolean): RunAttentionEvent[];
 export declare function getRunAttentionNotificationType(event: RunAttentionEvent): RunTransitionNotificationType;
 export declare function shouldNotifyRunAttentionEvent(event: RunAttentionEvent): boolean;
 export declare function shouldSendRunAttentionFollowUp(event: RunAttentionEvent): boolean;