@llblab/pi-actors 0.43.0 → 0.44.0

package/dist/lib/tools-inspect.js

@@ -3,16 +3,21 @@
  * Zones: Run Recipe/Trace/Control views and runtime/recipe/tool diagnostics
  * Owns exact inspect target/view dispatch; source projection stays in domain modules.
  */
+import { statSync } from "node:fs";
 import { join } from "node:path";
 import * as AsyncRuns from "./async-runs.js";
+import * as ControlProjection from "./control-projection.js";
 import * as Inspector from "./inspector.js";
 import * as Limits from "./limits.js";
+import { computeRunControlCapacity } from "./run-evidence-policy.js";
 import * as Paths from "./paths.js";
 import * as RecipesDiscovery from "./recipes-discovery.js";
 import * as ReviewDiagnostics from "./review-diagnostics.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 RuntimeIdentity from "./runtime-identity.js";
+import * as RuntimeTriage from "./runtime-triage.js";
 import * as Schema from "./schema.js";
 import * as ToolsAccess from "./tools-access.js";
 import * as ToolsResponse from "./tools-response.js";
@@ -23,7 +28,8 @@ function runtimeStatus() {
     return {
         automatic_review: process.env.PI_ACTORS_AUTOMATIC_REVIEW !== "off",
         run_root: Paths.getRunStateRoot(),
-        version: process.env.npm_package_version ?? "unknown",
+        state_schema: RuntimeIdentity.RUN_STATE_SCHEMA,
+        version: RuntimeIdentity.getPackageVersion(),
     };
 }
 function runtimeRuns(ctx, deps, status) {
@@ -49,14 +55,47 @@ function runtimeTriage(ctx, deps) {
     const inventory = runtimeRuns(ctx, deps, undefined);
     const runs = inventory.runs;
     const failed = runs.filter((run) => run.status === "failed");
-    const staleControls = runs.flatMap((run) => {
+    const pendingControls = [];
+    const staleControls = [];
+    const backpressuredRuns = [];
+    const controlDiagnostics = [];
+    const traceDiagnostics = [];
+    const nowMs = Date.now();
+    for (const run of runs) {
         const stateDir = typeof run.state_dir === "string" ? run.state_dir : undefined;
         if (!stateDir)
-            return [];
-        return RunsControls.readRunControlsFromStateDir(stateDir)
-            .filter((control) => control.status === "queued" || control.status === "claimed")
-            .map((control) => ({ run: run.run, control }));
-    });
+            continue;
+        const runId = String(run.run ?? "unknown");
+        const journal = RunsControls.readRunControlJournalFromStateDir(stateDir);
+        const capacity = computeRunControlCapacity(journal.records);
+        controlDiagnostics.push(...journal.diagnostics.map((diagnostic) => ({
+            ...(diagnostic.line === undefined ? {} : { line: diagnostic.line }),
+            reason: diagnostic.line === undefined ? "unreadable_control_journal" : "invalid_control_json", run: runId,
+        })));
+        if (capacity.backpressured)
+            backpressuredRuns.push({
+                run: runId, pending: capacity.pending, pending_limit: capacity.limit,
+                journal_bytes: statSync(RunsControls.runControlsFile(stateDir)).size,
+            });
+        const traceSummary = RunsTrace.summarizeRunTraceJournal(RunsTrace.readRunTraceJournal(stateDir));
+        if (!traceSummary.history_complete)
+            traceDiagnostics.push({ run: runId, ...traceSummary });
+        for (const control of journal.records) {
+            const classified = RuntimeTriage.classifyRuntimeControl({
+                run: runId,
+                ...(typeof run.run_instance_id === "string"
+                    ? { runInstanceId: run.run_instance_id }
+                    : {}),
+                status: String(run.status ?? "unknown"),
+            }, control, nowMs);
+            if (classified.pending)
+                pendingControls.push(classified.pending);
+            if (classified.stale)
+                staleControls.push(classified.stale);
+            if (classified.diagnostic)
+                controlDiagnostics.push({ ...classified.diagnostic });
+        }
+    }
     const attentionEvents = runs.flatMap((run) => {
         const stateDir = typeof run.state_dir === "string" ? run.state_dir : undefined;
         if (!stateDir)
@@ -72,16 +111,26 @@ function runtimeTriage(ctx, deps) {
             ts: event.ts,
         }));
     });
+    const boundedStaleControls = staleControls.slice(0, 40);
+    const staleKeys = new Set(boundedStaleControls.map((control) => `${control.run}\0${control.run_instance_id}\0${control.id}`));
+    const boundedPendingControls = [
+        ...boundedStaleControls,
+        ...pendingControls.filter((control) => !staleKeys.has(`${control.run}\0${control.run_instance_id}\0${control.id}`)),
+    ].slice(0, 40);
     return {
         ...inventory,
         failed_runs: failed,
-        stale_controls: staleControls.slice(0, 40),
+        pending_control_count: pendingControls.length,
+        pending_controls: boundedPendingControls,
+        stale_control_count: staleControls.length,
+        stale_controls: boundedStaleControls,
+        backpressured_run_count: backpressuredRuns.length, backpressured_runs: backpressuredRuns.slice(0, 40),
+        control_diagnostic_count: controlDiagnostics.length, control_diagnostics: controlDiagnostics.slice(0, 40),
+        trace_diagnostic_count: traceDiagnostics.length, trace_diagnostics: traceDiagnostics.slice(0, 40),
         attention_events: attentionEvents.slice(-40).reverse(),
         next_actions: [
             ...(failed.length ? ["inspect target=runtime view=runs status=failed"] : []),
-            ...(staleControls.length
-                ? staleControls.slice(0, 3).map((entry) => `inspect target=run:${String(entry.run)} view=control`)
-                : []),
+            ...new Set([...staleControls, ...backpressuredRuns].slice(0, 3).map((entry) => `inspect target=run:${entry.run} view=control`)),
             ...(attentionEvents.length
                 ? attentionEvents.slice(-3).map((entry) => `inspect target=run:${String(entry.run)} view=trace source=runtime`)
                 : []),
@@ -93,9 +142,9 @@ function compactRuntime(view, details) {
         return `\nruntime runs=${details.runs?.length ?? 0}`;
     }
     if (view === "triage") {
-        return `\nruntime failed=${details.failed_runs?.length ?? 0} stale_controls=${details.stale_controls?.length ?? 0} attention=${details.attention_events?.length ?? 0}`;
+        return `\nruntime failed=${details.failed_runs?.length ?? 0} pending_controls=${Number(details.pending_control_count ?? 0)} stale_controls=${Number(details.stale_control_count ?? 0)} backpressured=${Number(details.backpressured_run_count ?? 0)} incomplete_trace=${Number(details.trace_diagnostic_count ?? 0)} attention=${details.attention_events?.length ?? 0}`;
     }
-    return `\nruntime version=${String(details.version ?? "unknown")} automatic_review=${String(details.automatic_review)}`;
+    return `\nruntime version=${String(details.version)} state_schema=${String(details.state_schema)} automatic_review=${String(details.automatic_review)}`;
 }
 function inspectRuntime(view, input, ctx, deps) {
     if (view === "status")
@@ -161,8 +210,8 @@ function inspectRun(run, view, input, ctx, deps) {
             throw new Error(`unsupported Trace source: ${source}`);
         }
         return {
-            run,
-            source,
+            run, source,
+            summary: RunsTrace.summarizeRunTraceJournal(RunsTrace.readRunTraceJournal(stateDir)),
             items: TraceProjection.projectRunTrace(stateDir, {
                 artifacts: status.artifacts,
                 limit: Number(input.lines || Limits.DEFAULT_INSPECT_LINES),
@@ -171,18 +220,42 @@ function inspectRun(run, view, input, ctx, deps) {
         };
     }
     const runInstanceId = String(status.run_instance_id ?? "");
+    const journal = RunsControls.readRunControlJournalFromStateDir(stateDir);
+    const capacity = computeRunControlCapacity(journal.records);
+    const structuralDiagnostics = journal.records.flatMap((value) => {
+        const classified = RuntimeTriage.classifyRuntimeControl({ run,
+            runInstanceId: runInstanceId || undefined, status: String(status.status ?? "unknown") }, value, Date.now());
+        return classified.diagnostic ? [classified.diagnostic.reason] : [];
+    });
+    let journalBytes = 0;
+    try {
+        journalBytes = statSync(RunsControls.runControlsFile(stateDir)).size;
+    }
+    catch { }
+    const diagnostics = [...journal.diagnostics.map((item) => ({
+            ...(item.line === undefined ? {} : { line: item.line }),
+            reason: item.line === undefined ? "unreadable_control_journal" : "invalid_control_json",
+        })), ...structuralDiagnostics.map((reason) => ({ reason }))].slice(0, 40);
+    const nowMs = Date.now();
+    const stalePending = journal.records.reduce((count, control) => count + Number(Boolean(RuntimeTriage.classifyRuntimeControl({ run, runInstanceId: runInstanceId || undefined,
+        status: String(status.status ?? "unknown") }, control, nowMs).stale)), 0);
     return {
         run,
         run_instance_id: runInstanceId,
         status: status.status,
+        pending: capacity.pending, pending_limit: capacity.limit,
+        available: capacity.available, backpressured: capacity.backpressured,
+        journal_bytes: journalBytes, journal_limit: Limits.RUN_CONTROL_JOURNAL_MAX_BYTES,
+        ...(capacity.oldest_pending_at ? { oldest_pending_at: capacity.oldest_pending_at } : {}),
+        stale_pending: stalePending,
+        diagnostics,
         actor_actions: Array.isArray(status.control) ? status.control : [],
         runtime_actions: status.status === "running" ? ["kill"] : ["archive", "prune"],
         endpoint: runInstanceId
             ? RunControlDelivery.readRunControlEndpoint(stateDir, runInstanceId)
             : undefined,
-        recent_controls: RunsControls.readRunControlsFromStateDir(stateDir)
-            .slice(-Math.max(1, Number(input.lines || 20)))
-            .reverse(),
+        recent_controls: journal.records.slice(-Math.max(1, Number(input.lines || 20))).reverse()
+            .map((control) => ControlProjection.projectRunControl(control)),
     };
 }
 function inspectTool(name, view, deps) {

package/dist/lib/tools-message.d.ts

@@ -4,7 +4,6 @@
  * Owns public Control execution; journaling, delivery, and lifecycle mutation stay in Run domains.
  */
 export interface ControlToolDeps {
-    getTool?: (name: string) => unknown;
-    handleRuntimeMessage?: (action: string, input: unknown) => Record<string, unknown>;
+    handleRuntimeControl?: (action: string, input: unknown) => Record<string, unknown>;
 }
 export declare function createControlToolDefinition<TContext = unknown>(deps?: ControlToolDeps): any;

package/dist/lib/tools-message.js

@@ -45,11 +45,11 @@ export function createControlToolDefinition(deps = {}) {
         description: "Apply one Control action to an existing Run or the pi-actors runtime.",
         parameters: Schema.objectSchema({
             target: Schema.stringSchema("Run target run:<id>, or literal runtime."),
-            action: Schema.stringSchema("Lowercase semantic Control action."),
+            action: Schema.stringSchema("Lowercase ASCII Control action, at most 64 characters."),
             input: Schema.unionSchema([
-                Schema.stringSchema("Optional Control input string."),
-                Schema.looseObjectSchema("Optional structured Control input."),
-                Schema.arraySchema("Optional structured Control input array."),
+                Schema.stringSchema("Optional Control input string; serialized JSON must fit 380 bytes."),
+                Schema.looseObjectSchema("Optional structured Control input; serialized JSON must fit 380 bytes."),
+                Schema.arraySchema("Optional structured Control input array; serialized JSON must fit 380 bytes."),
             ]),
             verbose: Schema.booleanSchema("Return full JSON instead of compact text."),
         }, ["target", "action"]),
@@ -60,10 +60,10 @@ export function createControlToolDefinition(deps = {}) {
                 if (request.action !== "review.retry" && request.action !== "review.reset") {
                     throw new Error(`unsupported runtime Control action: ${request.action}; use review.retry or review.reset`);
                 }
-                if (!deps.handleRuntimeMessage) {
+                if (!deps.handleRuntimeControl) {
                     throw new Error("runtime Control is unavailable");
                 }
-                result = deps.handleRuntimeMessage(request.action, request.input);
+                result = deps.handleRuntimeControl(request.action, request.input);
             }
             else {
                 const run = request.target.slice(4);

package/dist/lib/tools-response.d.ts

@@ -12,7 +12,6 @@ export declare function compactPreview(value: unknown, maxLength?: number): stri
 export declare function compactNextActions(actions: string[]): string;
 export declare function runNextActions(run: unknown): string[];
 export declare function compactAsyncRunStatus(value: unknown): string;
-export declare function artifactNextActions(run: unknown, artifacts: Record<string, unknown>): string[];
 export declare function maybeJsonText(value: unknown, verbose: boolean | undefined, compact: string): string;
 export declare function compactRecipeImports(summary: Record<string, unknown>): string;
 export declare function compactRecipeDoctor(summary: Record<string, unknown>): string;

package/dist/lib/tools-response.js

@@ -121,15 +121,6 @@ export function compactAsyncRunStatus(value) {
         tokens.push(`next=${nextActions.map((action) => action.replaceAll(/\s+/g, "_")).join("|")}`);
     return `\n${tokens.join(" ")}`;
 }
-export function artifactNextActions(run, artifacts) {
-    const id = String(run ?? "").trim();
-    if (!id || Object.keys(artifacts).length === 0)
-        return [];
-    return [
-        `inspect target=run:${id} view=artifacts verbose=true`,
-        `inspect target=run:${id} view=messages`,
-    ];
-}
 export function maybeJsonText(value, verbose, compact) {
     return verbose ? jsonText(value) : compact;
 }

package/dist/lib/tools.d.ts

@@ -15,7 +15,7 @@ export interface CoreActorToolDefinitionDeps<TContext extends RuntimeToolContext
     configPath: string;
     getActiveTools: () => string[];
     getRuntimeTool: (name: string) => unknown;
-    handleRuntimeMessage?: (type: string, body: unknown) => Record<string, unknown>;
+    handleRuntimeControl?: (action: string, input: unknown) => Record<string, unknown>;
     registryRuntime: Pick<RegisterToolRuntimeDeps<TContext>, "getToolNameBlocker" | "getTools" | "notify" | "registerRuntimeTool">;
     setActiveTools: (toolNames: string[]) => void;
 }

package/dist/lib/tools.js

@@ -37,7 +37,7 @@ export function createCoreActorToolDefinitions(deps) {
         }),
         ToolsSpawn.createSpawnToolDefinition(),
         ToolsMessage.createControlToolDefinition({
-            handleRuntimeMessage: deps.handleRuntimeMessage,
+            handleRuntimeControl: deps.handleRuntimeControl,
         }),
         ToolsInspect.createInspectToolDefinition({
             getTool: (name) => deps.getRuntimeTool(name),

package/dist/lib/trace-projection.js

@@ -5,14 +5,25 @@
  */
 import { existsSync, statSync } from "node:fs";
 import { join, relative } from "node:path";
+import * as ControlProjection from "./control-projection.js";
 import * as ExecutionSessions from "./execution-sessions.js";
 import * as Limits from "./limits.js";
 import { resolveArtifactManifest, } from "./runs-artifacts.js";
+import * as RunsControls from "./runs-controls.js";
 import { tailFile } from "./runs-status.js";
+import * as RunsTrace from "./runs-trace.js";
 import * as SessionEvidence from "./session-evidence.js";
-import { readJsonFileResilient, readJsonlFileResilient, } from "./state-readers.js";
+import { readJsonFileResilient, } from "./state-readers.js";
 const LIFECYCLE_PREFIXES = ["run.", "command."];
 const SOURCE_LIMIT = 100;
+const SOURCE_RANK = {
+    lifecycle: 6,
+    control: 5,
+    process: 4,
+    agent: 3,
+    artifact: 2,
+    runtime: 1,
+};
 function redact(value) {
     return SessionEvidence.redactSessionEvidenceValue(value);
 }
@@ -21,6 +32,21 @@ function sourceForEvent(event) {
         ? "lifecycle"
         : "runtime";
 }
+function ordered(item, sourceKey, ordinal) {
+    return { item, ordinal, sourceKey };
+}
+function compareTraceItems(left, right) {
+    const timestamp = right.item.ts.localeCompare(left.item.ts);
+    if (timestamp)
+        return timestamp;
+    if (left.sourceKey === right.sourceKey) {
+        const ordinal = right.ordinal - left.ordinal;
+        if (ordinal)
+            return ordinal;
+    }
+    return SOURCE_RANK[right.item.source] - SOURCE_RANK[left.item.source] ||
+        right.item.id.localeCompare(left.item.id);
+}
 function latestControlTimestamp(control) {
     return (control.failed_at ??
         control.handled_at ??
@@ -39,37 +65,74 @@ function diagnosticItems(diagnostics) {
         detail: redact(diagnostic),
     }));
 }
+function controlDiagnosticItems(diagnostics) {
+    return diagnostics.slice(-SOURCE_LIMIT).map((diagnostic, index) => ({
+        id: `control-diagnostic:${diagnostic.line ?? 0}:${index}`,
+        ts: new Date(0).toISOString(),
+        source: "runtime",
+        kind: "state.read_error",
+        summary: "Malformed or unreadable Control evidence",
+        level: "warning",
+        detail: {
+            ...(diagnostic.line === undefined ? {} : { line: diagnostic.line }),
+            reason: diagnostic.line === undefined
+                ? "unreadable_control_journal"
+                : "invalid_control_json",
+        },
+    }));
+}
 function traceEventItems(stateDir) {
-    const read = readJsonlFileResilient(join(stateDir, "trace.jsonl"));
-    return [
-        ...read.records.slice(-SOURCE_LIMIT).map((event) => ({
-            id: event.id,
-            ts: event.ts,
-            source: sourceForEvent(event),
-            kind: event.kind,
-            summary: event.summary ?? event.kind,
-            ...(event.level ? { level: event.level } : {}),
-            detail: redact({
-                ...(event.attention ? { attention: event.attention } : {}),
-                ...(event.data !== undefined ? { data: event.data } : {}),
-            }),
-        })),
-        ...diagnosticItems(read.diagnostics),
-    ];
+    const read = RunsTrace.readRunTraceJournal(stateDir);
+    const retained = read.events.slice(-SOURCE_LIMIT);
+    const projected = retained.map(({ event, ordinal }) => ordered({
+        id: event.id,
+        ts: event.ts,
+        source: sourceForEvent(event),
+        kind: event.kind,
+        summary: event.summary ?? event.kind,
+        ...(event.level ? { level: event.level } : {}),
+        detail: redact({
+            ...(event.attention ? { attention: event.attention } : {}),
+            ...(event.data !== undefined ? { data: event.data } : {}),
+        }),
+    }, "trace", ordinal));
+    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) {
+        diagnostics.push(ordered({
+            id: "runtime:trace-history-incomplete",
+            ts: new Date(0).toISOString(),
+            source: "runtime",
+            kind: "runtime.trace_history_incomplete",
+            summary: "Trace history is incomplete",
+            level: "warning",
+            detail: {
+                omitted_prefix_bytes: read.omittedPrefixBytes,
+                read_bytes: read.readBytes,
+                retained_events: read.events.length,
+            },
+        }, "trace", 0));
+    }
+    return [...projected, ...diagnostics];
 }
 function controlItems(stateDir) {
-    const read = readJsonlFileResilient(join(stateDir, "controls.jsonl"));
-    return [
-        ...read.records.slice(-SOURCE_LIMIT).map((control) => ({
-            id: `control:${control.id}`,
-            ts: latestControlTimestamp(control),
+    const read = RunsControls.readRunControlJournalFromStateDir(stateDir);
+    const start = Math.max(0, read.records.length - SOURCE_LIMIT);
+    const projected = read.records.slice(start).map((control, index) => {
+        const value = ControlProjection.projectRunControl(control);
+        return ordered({
+            id: `control:${value.id}`,
+            ts: latestControlTimestamp(value),
             source: "control",
-            kind: `control.${control.status}`,
-            summary: `${control.action} ${control.status}`,
-            ...(control.status === "failed" ? { level: "error" } : {}),
-            detail: redact(control),
-        })),
-        ...diagnosticItems(read.diagnostics),
+            kind: `control.${value.status}`,
+            summary: `${value.action} ${value.status}`,
+            ...(value.status === "failed" ? { level: "error" } : {}),
+            detail: value,
+        }, "control", start + index + 1);
+    });
+    return [
+        ...projected,
+        ...controlDiagnosticItems(read.diagnostics).map((item, index) => ordered(item, "control", read.records.length + index + 1)),
     ];
 }
 function agentItems(stateDir) {
@@ -78,7 +141,7 @@ function agentItems(stateDir) {
         .map((turn) => {
         const text = turn.assistantText ?? turn.userText ?? "Agent turn";
         const summary = text.replaceAll(/\s+/g, " ").trim().slice(0, 160);
-        return {
+        return ordered({
             id: `agent:${turn.commandId}:${turn.sessionFile}:${turn.index}`,
             ts: turn.timestamp ?? new Date(0).toISOString(),
             source: "agent",
@@ -86,7 +149,7 @@ function agentItems(stateDir) {
             summary: summary || "Agent turn",
             ...(turn.error ? { level: "error" } : {}),
             detail: redact(turn),
-        };
+        }, "agent", turn.index);
     });
 }
 function processItems(stateDir) {
@@ -98,7 +161,7 @@ function processItems(stateDir) {
         const tail = tailFile(path, Limits.DEFAULT_INSPECT_LINES);
         if (!tail && stat.size === 0)
             return [];
-        return [{
+        return [ordered({
                 id: `process:${stream}`,
                 ts: stat.mtime.toISOString(),
                 source: "process",
@@ -106,17 +169,18 @@ function processItems(stateDir) {
                 summary: `${stream} (${stat.size} bytes)`,
                 ...(stream === "stderr" ? { level: "warning" } : {}),
                 detail: redact({ bytes: stat.size, path, tail }),
-            }];
+            }, `process:${stream}`, 1)];
     });
 }
 function resultItems(stateDir) {
     const path = join(stateDir, "result.json");
     const read = readJsonFileResilient(path, {});
-    if (Object.keys(read.value).length === 0)
-        return diagnosticItems(read.diagnostics);
+    if (Object.keys(read.value).length === 0) {
+        return diagnosticItems(read.diagnostics).map((item, index) => ordered(item, "process:result", index));
+    }
     const stat = statSync(path);
     const failed = Number(read.value.code ?? 0) !== 0;
-    return [{
+    return [ordered({
             id: "process:result",
             ts: typeof read.value.completedAt === "string"
                 ? read.value.completedAt
@@ -126,13 +190,13 @@ function resultItems(stateDir) {
             summary: failed ? "Run process failed" : "Run process completed",
             ...(failed ? { level: "error" } : {}),
             detail: redact(read.value),
-        }, ...diagnosticItems(read.diagnostics)];
+        }, "process:result", 1), ...diagnosticItems(read.diagnostics).map((item, index) => ordered(item, "process:result", index + 2))];
 }
 function artifactItems(stateDir, declarations) {
     const manifest = resolveArtifactManifest(declarations);
     if (!manifest)
         return [];
-    return Object.entries(manifest).slice(0, SOURCE_LIMIT).map(([name, artifact]) => ({
+    return Object.entries(manifest).slice(0, SOURCE_LIMIT).map(([name, artifact], index) => ordered({
         id: `artifact:${name}`,
         ts: artifact.exists && existsSync(artifact.path)
             ? statSync(artifact.path).mtime.toISOString()
@@ -147,7 +211,7 @@ function artifactItems(stateDir, declarations) {
             required: artifact.required,
             ...(artifact.size !== undefined ? { size: artifact.size } : {}),
         }),
-    }));
+    }, "artifact", index + 1));
 }
 export function projectRunTrace(stateDir, options = {}) {
     const source = options.source ?? "all";
@@ -159,7 +223,9 @@ export function projectRunTrace(stateDir, options = {}) {
         ...resultItems(stateDir),
         ...artifactItems(stateDir, options.artifacts),
     ]
-        .filter((item) => source === "all" || item.source === source)
-        .sort((left, right) => right.ts.localeCompare(left.ts) || right.id.localeCompare(left.id));
-    return items.slice(0, Math.max(1, Math.min(options.limit ?? 100, 200)));
+        .filter(({ item }) => source === "all" || item.source === source)
+        .sort(compareTraceItems);
+    return items
+        .slice(0, Math.max(1, Math.min(options.limit ?? 100, 200)))
+        .map(({ item }) => item);
 }

package/dist/scripts/conformance.mjs

@@ -15,6 +15,11 @@ const conformanceSuites = [
   "tests/control.test.ts",
   "tests/runs-controls.test.ts",
   "tests/runs-trace.test.ts",
+  "tests/observability.test.ts",
+  "tests/async-run-control.test.ts",
+  "tests/run-kernel-dogfood.test.ts",
+  "tests/installed.scripts.test.ts",
+  "tests/inspector-overlay.test.ts",
   "tests/tools-inspect-kernel.test.ts",
   "tests/recipes-discovery.test.ts",
   "tests/review-swarm-dogfood.test.ts",