@llblab/pi-actors 0.43.0 → 0.43.1

package/dist/lib/runs-trace.js

@@ -1,11 +1,12 @@
 /**
  * Run Trace event journal.
- * Zones: structured event validation, bounded append, resilient bounded reads
- * Owns Run-local semantic Trace events; lifecycle projection and owner attention delivery stay in adapters.
+ * Zones: structured event validation, token-locked append-only writes, resilient bounded reads
+ * Owns canonical Run-local Trace persistence; lifecycle projection and owner attention delivery stay in adapters.
  */
 import { randomUUID } from "node:crypto";
 import { writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { withFileMutationLock } from "./file-state.js";
 import * as Limits from "./limits.js";
 import { readJsonlFileResilient } from "./state-readers.js";
 const KIND_PATTERN = /^[a-z][a-z0-9_-]*(?:\.[a-z0-9_-]+)*$/;
@@ -73,24 +74,27 @@ function normalizeTraceEventInput(input) {
     };
 }
 export function appendRunTraceEvent(stateDir, input) {
-    const normalized = normalizeTraceEventInput(input);
-    const event = {
-        id: randomUUID(),
-        ts: new Date().toISOString(),
-        ...normalized,
-    };
-    let encoded;
-    try {
-        encoded = JSON.stringify(event);
-    }
-    catch {
-        throw new Error("Trace event data must be JSON-serializable");
-    }
-    if (Buffer.byteLength(encoded) > Limits.TRACE_EVENT_MAX_BYTES) {
-        throw new Error(`Trace event exceeds ${Limits.TRACE_EVENT_MAX_BYTES} bytes`);
-    }
-    writeFileSync(runTraceFile(stateDir), `${encoded}\n`, { flag: "a" });
-    return event;
+    const path = runTraceFile(stateDir);
+    return withFileMutationLock(path, () => {
+        const normalized = normalizeTraceEventInput(input);
+        const event = {
+            id: randomUUID(),
+            ts: new Date().toISOString(),
+            ...normalized,
+        };
+        let encoded;
+        try {
+            encoded = JSON.stringify(event);
+        }
+        catch {
+            throw new Error("Trace event data must be JSON-serializable");
+        }
+        if (Buffer.byteLength(encoded) > Limits.TRACE_EVENT_MAX_BYTES) {
+            throw new Error(`Trace event exceeds ${Limits.TRACE_EVENT_MAX_BYTES} bytes`);
+        }
+        writeFileSync(path, `${encoded}\n`, { flag: "a" });
+        return event;
+    });
 }
 export function readRunTraceEvents(stateDir, limit = Limits.TRACE_EVENT_MAX_READ) {
     const records = readJsonlFileResilient(runTraceFile(stateDir)).records;

package/dist/lib/runtime-identity.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Immutable runtime package identity.
+ * Zones: source/installed package version resolution and Run-state schema marker
+ * Owns package-local identity reads; runtime status and Run persistence remain in their domains.
+ */
+export declare const RUN_STATE_SCHEMA: "run-kernel-v1";
+export declare function getPackageVersion(): string;

package/dist/lib/runtime-identity.js

@@ -0,0 +1,35 @@
+/**
+ * Immutable runtime package identity.
+ * Zones: source/installed package version resolution and Run-state schema marker
+ * Owns package-local identity reads; runtime status and Run persistence remain in their domains.
+ */
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+export const RUN_STATE_SCHEMA = "run-kernel-v1";
+let cachedVersion;
+export function getPackageVersion() {
+    if (cachedVersion)
+        return cachedVersion;
+    const moduleDir = dirname(fileURLToPath(import.meta.url));
+    for (const path of [
+        join(moduleDir, "..", "package.json"),
+        join(moduleDir, "..", "..", "package.json"),
+    ]) {
+        try {
+            const pkg = JSON.parse(readFileSync(path, "utf8"));
+            if (pkg.name === "@llblab/pi-actors" &&
+                typeof pkg.version === "string" &&
+                pkg.version.length > 0 &&
+                pkg.version.length <= 128 &&
+                pkg.version.trim() === pkg.version) {
+                cachedVersion = pkg.version;
+                return cachedVersion;
+            }
+        }
+        catch {
+            // Source and installed-dist modes resolve through different package ancestors.
+        }
+    }
+    throw new Error("pi-actors package identity is unavailable");
+}

package/dist/lib/runtime-triage.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Pure runtime Control triage policy.
+ * Zones: pending admission, status-age classification, terminal/replacement staleness
+ * Owns Control triage decisions; journal reads and owner filtering stay in adapters, while safe fields come from control-projection.
+ */
+import * as ControlProjection from "./control-projection.ts";
+export declare const RUNTIME_CONTROL_STALE_AFTER_MS: number;
+export interface RuntimeTriageRun {
+    run: string;
+    runInstanceId?: string;
+    status: string;
+}
+export interface RuntimePendingControl extends ControlProjection.ProjectedRunControl {
+    age_ms: number;
+    reason: "age_threshold_reached" | "run_generation_replaced" | "run_generation_unavailable" | "run_terminal" | "within_age_threshold";
+    run: string;
+    status: "queued" | "delivered" | "claimed";
+    status_at: string;
+}
+export interface RuntimeControlDiagnostic {
+    reason: "invalid_action" | "invalid_control_id" | "invalid_generation" | "invalid_record" | "invalid_status" | "invalid_status_timestamp";
+    run: string;
+}
+export interface RuntimeControlClassification {
+    diagnostic?: RuntimeControlDiagnostic;
+    pending?: RuntimePendingControl;
+    stale?: RuntimePendingControl;
+}
+export declare function classifyRuntimeControl(run: RuntimeTriageRun, value: unknown, nowMs: number): RuntimeControlClassification;

package/dist/lib/runtime-triage.js

@@ -0,0 +1,76 @@
+/**
+ * Pure runtime Control triage policy.
+ * Zones: pending admission, status-age classification, terminal/replacement staleness
+ * Owns Control triage decisions; journal reads and owner filtering stay in adapters, while safe fields come from control-projection.
+ */
+import * as ControlProjection from "./control-projection.js";
+export const RUNTIME_CONTROL_STALE_AFTER_MS = 5 * 60 * 1_000;
+const PENDING_STATUSES = new Set([
+    "queued",
+    "delivered",
+    "claimed",
+]);
+const TERMINAL_STATUSES = new Set(["handled", "failed"]);
+function diagnostic(run, reason) {
+    return { diagnostic: { reason, run } };
+}
+function statusTimestamp(record, status) {
+    if (status === "failed")
+        return record.failed_at;
+    if (status === "handled")
+        return record.handled_at;
+    if (status === "claimed")
+        return record.claimed_at;
+    if (status === "delivered")
+        return record.delivered_at;
+    return record.queued_at;
+}
+export function classifyRuntimeControl(run, value, nowMs) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return diagnostic(run.run, "invalid_record");
+    }
+    const record = value;
+    const status = record.status;
+    if (!PENDING_STATUSES.has(status) && !TERMINAL_STATUSES.has(status)) {
+        return diagnostic(run.run, "invalid_status");
+    }
+    if (typeof record.id !== "string" || !record.id) {
+        return diagnostic(run.run, "invalid_control_id");
+    }
+    if (typeof record.action !== "string" || !record.action) {
+        return diagnostic(run.run, "invalid_action");
+    }
+    if (typeof record.run_instance_id !== "string" || !record.run_instance_id) {
+        return diagnostic(run.run, "invalid_generation");
+    }
+    const timestamp = statusTimestamp(record, status);
+    const timestampMs = typeof timestamp === "string" ? Date.parse(timestamp) : Number.NaN;
+    if (!Number.isFinite(timestampMs)) {
+        return diagnostic(run.run, "invalid_status_timestamp");
+    }
+    if (TERMINAL_STATUSES.has(status))
+        return {};
+    const ageMs = Math.max(0, Math.floor(nowMs - timestampMs));
+    const staleReason = !run.runInstanceId
+        ? "run_generation_unavailable"
+        : record.run_instance_id !== run.runInstanceId
+            ? "run_generation_replaced"
+            : run.status !== "running"
+                ? "run_terminal"
+                : ageMs >= RUNTIME_CONTROL_STALE_AFTER_MS
+                    ? "age_threshold_reached"
+                    : undefined;
+    const projected = ControlProjection.projectRunControl(record);
+    const pending = {
+        ...projected,
+        age_ms: ageMs,
+        reason: staleReason ?? "within_age_threshold",
+        run: run.run,
+        status: status,
+        status_at: statusTimestamp(projected, status),
+    };
+    return {
+        pending,
+        ...(staleReason ? { stale: pending } : {}),
+    };
+}

package/dist/lib/tool-review-scheduler.js

@@ -264,7 +264,7 @@ export function applyApprovedToolReviewAtSessionBoundary(options = {}) {
                 ...state,
                 failedStage: "approval_state",
                 lastError: "approved review path is unavailable",
-                nextAction: "message to=tool:pi-actors type=review.retry body={\"scope\":\"tool\"}",
+                nextAction: "message target=runtime action=review.retry input={\"scope\":\"tool\"}",
                 phase: "processing_failed",
                 updatedAt: (options.now ?? (() => new Date()))().toISOString(),
             };
@@ -287,7 +287,7 @@ export function applyApprovedToolReviewAtSessionBoundary(options = {}) {
                     ...state,
                     failedStage: "transaction",
                     lastError: `tool review transaction remained ${transaction.phase}`,
-                    nextAction: "message to=tool:pi-actors type=review.retry body={\"scope\":\"tool\"}",
+                    nextAction: "message target=runtime action=review.retry input={\"scope\":\"tool\"}",
                     phase: "processing_failed",
                     updatedAt: (options.now ?? (() => new Date()))().toISOString(),
                 };
@@ -316,7 +316,7 @@ export function applyApprovedToolReviewAtSessionBoundary(options = {}) {
                     ...pending,
                     failedStage: "lineage",
                     lastError: error instanceof Error ? error.message : String(error),
-                    nextAction: "message to=tool:pi-actors type=review.retry body={\"scope\":\"tool\"}",
+                    nextAction: "message target=runtime action=review.retry input={\"scope\":\"tool\"}",
                 };
                 writeJsonAtomic(statePath, failedPending);
                 return { outcome: "lineage_pending", state: failedPending };
@@ -337,7 +337,7 @@ export function applyApprovedToolReviewAtSessionBoundary(options = {}) {
                 ...state,
                 failedStage: "transaction",
                 lastError: error instanceof Error ? error.message : String(error),
-                nextAction: "message to=tool:pi-actors type=review.retry body={\"scope\":\"tool\"}",
+                nextAction: "message target=runtime action=review.retry input={\"scope\":\"tool\"}",
                 phase: "processing_failed",
                 updatedAt: (options.now ?? (() => new Date()))().toISOString(),
             };
@@ -401,7 +401,7 @@ export function createToolReviewScheduler(deps) {
                             ...existing,
                             failedStage: processed.stage ?? "review_result",
                             lastError: processed.error ?? "automatic tool reviewer failed",
-                            nextAction: "message to=tool:pi-actors type=review.retry body={\"scope\":\"tool\"}",
+                            nextAction: "message target=runtime action=review.retry input={\"scope\":\"tool\"}",
                             phase: processed.outcome === "processing_failed"
                                 ? "processing_failed"
                                 : "failed",
@@ -437,7 +437,7 @@ export function createToolReviewScheduler(deps) {
                                 attempts: existing.attempts + 1,
                                 failedStage: "review_launch",
                                 lastError: error instanceof Error ? error.message : String(error),
-                                nextAction: "message to=tool:pi-actors type=review.retry body={\"scope\":\"tool\"}",
+                                nextAction: "message target=runtime action=review.retry input={\"scope\":\"tool\"}",
                                 phase: "failed",
                                 updatedAt: now().toISOString(),
                             });
@@ -471,7 +471,7 @@ export function createToolReviewScheduler(deps) {
                             failedStage: "review_launch",
                             inputPath: batch.inputPath,
                             lastError: error instanceof Error ? error.message : String(error),
-                            nextAction: "message to=tool:pi-actors type=review.retry body={\"scope\":\"tool\"}",
+                            nextAction: "message target=runtime action=review.retry input={\"scope\":\"tool\"}",
                             phase: "failed",
                             reviewerInputPath: batch.reviewerInputPath,
                             reviewId: batch.reviewId,

package/dist/lib/tools-inspect.js

@@ -5,6 +5,7 @@
  */
 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 * as Paths from "./paths.js";
@@ -13,6 +14,8 @@ 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 +26,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 +53,39 @@ 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 controlDiagnostics = [];
+    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);
+        controlDiagnostics.push(...journal.diagnostics.map((diagnostic) => ({
+            ...(diagnostic.line === undefined ? {} : { line: diagnostic.line }),
+            reason: diagnostic.line === undefined
+                ? "unreadable_control_journal"
+                : "invalid_control_json",
+            run: runId,
+        })));
+        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 +101,25 @@ 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,
+        control_diagnostic_count: controlDiagnostics.length,
+        control_diagnostics: controlDiagnostics.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`)
-                : []),
+            ...staleControls.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 +131,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)} 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")
@@ -182,7 +220,8 @@ function inspectRun(run, view, input, ctx, deps) {
             : undefined,
         recent_controls: RunsControls.readRunControlsFromStateDir(stateDir)
             .slice(-Math.max(1, Number(input.lines || 20)))
-            .reverse(),
+            .reverse()
+            .map(ControlProjection.projectRunControl),
     };
 }
 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,6 +5,7 @@
  */
 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";
@@ -39,6 +40,22 @@ 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 [
@@ -60,16 +77,19 @@ function traceEventItems(stateDir) {
 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),
-            source: "control",
-            kind: `control.${control.status}`,
-            summary: `${control.action} ${control.status}`,
-            ...(control.status === "failed" ? { level: "error" } : {}),
-            detail: redact(control),
-        })),
-        ...diagnosticItems(read.diagnostics),
+        ...read.records.slice(-SOURCE_LIMIT).map((control) => {
+            const projected = ControlProjection.projectRunControl(control);
+            return {
+                id: `control:${projected.id}`,
+                ts: latestControlTimestamp(projected),
+                source: "control",
+                kind: `control.${projected.status}`,
+                summary: `${projected.action} ${projected.status}`,
+                ...(projected.status === "failed" ? { level: "error" } : {}),
+                detail: projected,
+            };
+        }),
+        ...controlDiagnosticItems(read.diagnostics),
     ];
 }
 function agentItems(stateDir) {

package/dist/scripts/locker.mjs

@@ -9,13 +9,12 @@
  */
 
 import { spawnSync } from "node:child_process";
-import { createHash, randomUUID } from "node:crypto";
+import { createHash } from "node:crypto";
 import {
   appendFileSync,
   existsSync,
   mkdirSync,
   readFileSync,
-  rmSync,
 } from "node:fs";
 import { createServer } from "node:net";
 import { dirname, join, resolve } from "node:path";
@@ -35,6 +34,7 @@ async function importRuntimeModule(name) {
 
 const { acquireFileMutationLock, writeJsonAtomic, writeTextAtomic } =
   await importRuntimeModule("file-state");
+const { appendRunTraceEvent } = await importRuntimeModule("runs-trace");
 
 function parseArgs(argv) {
   const args = { mode: "serve", stateDir: "", leaseMs: 600000, lines: 20 };
@@ -59,7 +59,6 @@ async function runLocker(argv = process.argv.slice(2)) {
   const queuePath = join(stateDir, "queue.json");
   const locksPath = join(stateDir, "locks.json");
   const journalPath = join(stateDir, "journal.jsonl");
-  const tracePath = join(stateDir, "trace.jsonl");
   const controlsPath = join(stateDir, "controls.jsonl");
   const controlPath = join(stateDir, "control.fifo");
   let runInstanceId;
@@ -104,18 +103,13 @@ async function runLocker(argv = process.argv.slice(2)) {
   }
 
   function emitTrace(kind, summary, data = {}, level = "info") {
-    appendFileSync(
-      tracePath,
-      `${JSON.stringify({
-        attention: "followup",
-        data,
-        id: randomUUID(),
-        kind,
-        level,
-        summary,
-        ts: new Date().toISOString(),
-      })}\n`,
-    );
+    appendRunTraceEvent(stateDir, {
+      attention: "followup",
+      data,
+      kind,
+      level,
+      summary,
+    });
   }
 
   function now() {
@@ -454,7 +448,6 @@ async function runLocker(argv = process.argv.slice(2)) {
   }
 
   async function serveNamedPipe(endpoint) {
-    rmSync(endpoint.path, { force: true });
     let resolveStopped;
     const stopped = new Promise((resolve) => {
       resolveStopped = resolve;

package/dist/scripts/music-player.mjs

@@ -52,6 +52,7 @@ async function importRuntimeModule(name) {
 
 const { acquireFileMutationLock, writeTextAtomic } =
   await importRuntimeModule("file-state");
+const { appendRunTraceEvent } = await importRuntimeModule("runs-trace");
 
 const AUDIO_EXTENSIONS = new Set([
   ".aac",
@@ -420,18 +421,12 @@ function readText(path) {
 }
 
 function emitPlayerEvent(ctx, kind, summary, data = {}) {
-  writeText(
-    ctx.eventFile,
-    `${JSON.stringify({
-      data,
-      id: randomUUID(),
-      kind,
-      level: "info",
-      summary,
-      ts: new Date().toISOString(),
-    })}\n`,
-    "a",
-  );
+  appendRunTraceEvent(ctx.stateDir, {
+    data,
+    kind,
+    level: "info",
+    summary,
+  });
 }
 
 function emitTrackEvent(ctx, index, count, track, player) {
@@ -859,7 +854,6 @@ async function playMain(args) {
   const ctx = {
     commandFile: join(stateDir, "command.txt"),
     current: undefined,
-    eventFile: join(stateDir, "trace.jsonl"),
     controlsFile: join(stateDir, "controls.jsonl"),
     pidFile: join(stateDir, "current.pid"),
     playerControlFile: join(stateDir, "player-control.txt"),