@llblab/pi-actors 0.42.2 → 0.43.0

package/lib/tools-response.ts

@@ -5,7 +5,6 @@
  */
 
 import * as Limits from "./limits.ts";
-import * as ToolsMailbox from "./tools-mailbox.ts";
 
 export function withLeadingLineBreak(text: string): string {
   return `\n${text.replace(/^\n+/, "")}`;
@@ -91,13 +90,13 @@ function compactModelPolicy(value: unknown): string[] {
   ].filter((token): token is string => Boolean(token));
 }
 
-export function actorRunNextActions(run: unknown): string[] {
+export function runNextActions(run: unknown): string[] {
   const id = String(run ?? "").trim();
   if (!id) return [];
   return [
-    `inspect target=run:${id} view=status`,
-    `inspect target=run:${id} view=messages`,
-    `message to=run:${id} type=<actor.action>`,
+    `inspect target=run:${id} view=recipe`,
+    `inspect target=run:${id} view=trace`,
+    `inspect target=run:${id} view=control`,
   ];
 }
 
@@ -126,7 +125,7 @@ export function compactAsyncRunStatus(value: unknown): string {
   if (result.killed === true) tokens.push("killed=true");
   const draftRecipe = status.draft_recipe;
   if (draftRecipe) tokens.push(`draft_recipe=${String(draftRecipe)}`);
-  const nextActions = actorRunNextActions(run);
+  const nextActions = runNextActions(run);
   if (nextActions.length > 0)
     tokens.push(
       `next=${nextActions.map((action) => action.replaceAll(/\s+/g, "_")).join("|")}`,
@@ -134,52 +133,6 @@ export function compactAsyncRunStatus(value: unknown): string {
   return `\n${tokens.join(" ")}`;
 }
 
-export function compactInboxMessages(
-  messages: Array<Record<string, unknown>>,
-  emptyLabel: string,
-): string {
-  if (messages.length === 0) return `\n(no ${emptyLabel} messages)`;
-  return `\n${messages
-    .map((message) =>
-      [
-        ...(message.id ? [`id=${String(message.id)}`] : []),
-        `status=${String(message.status ?? "")}`,
-        `type=${String(message.type ?? "")}`,
-        `from=${String(message.from ?? "")}`,
-        `to=${String(message.to ?? "")}`,
-        ...(message.queued_at
-          ? [`queued_at=${String(message.queued_at)}`]
-          : []),
-        ...(message.sent_at ? [`sent_at=${String(message.sent_at)}`] : []),
-        ...(message.claimed_at
-          ? [`claimed_at=${String(message.claimed_at)}`]
-          : []),
-        ...(message.handled_at
-          ? [`handled_at=${String(message.handled_at)}`]
-          : []),
-        ...(message.failed_at
-          ? [`failed_at=${String(message.failed_at)}`]
-          : []),
-      ].join(" "),
-    )
-    .join("\n")}`;
-}
-
-export function compactBranchInbox(
-  messages: Array<Record<string, unknown>>,
-): string {
-  return compactInboxMessages(messages, "branch inbox");
-}
-
-export function compactRunMailbox(
-  run: string,
-  mailbox: Record<string, unknown>,
-  messages: Array<Record<string, unknown>>,
-): string {
-  const normalized = ToolsMailbox.normalizeMailboxContracts(mailbox);
-  return `\nrun=${run} accepts=${ToolsMailbox.mailboxTypes(normalized.accepts).join(",")} emits=${ToolsMailbox.mailboxTypes(normalized.emits).join(",")}${compactInboxMessages(messages, "run inbox")}`;
-}
-
 export function artifactNextActions(
   run: unknown,
   artifacts: Record<string, unknown>,

package/lib/tools-spawn.ts

@@ -9,12 +9,10 @@ import { join } from "node:path";
 
 import * as AsyncRuns from "./async-runs.ts";
 import { withFileMutationLock } from "./file-state.ts";
-import * as Messages from "./messages.ts";
 import * as ModelContext from "./model-context.ts";
 import * as Paths from "./paths.ts";
 import * as RecipesDiscovery from "./recipes-discovery.ts";
 import * as RecipesUsage from "./recipes-usage.ts";
-import * as Rooms from "./rooms.ts";
 import * as Schema from "./schema.ts";
 import * as ToolsResponse from "./tools-response.ts";
 
@@ -53,13 +51,7 @@ function draftRecipeName(run: string): string {
 function draftRecipeDefaults(
   values: Record<string, unknown>,
 ): Record<string, unknown> | undefined {
-  const ignored = new Set([
-    "actor_address",
-    "communication_file",
-    "default_room",
-    "run_id",
-    "state_dir",
-  ]);
+  const ignored = new Set(["run_id", "state_dir", "trace_file"]);
   const defaults = Object.fromEntries(
     Object.entries(values).filter(([key]) => !ignored.has(key)),
   );
@@ -117,15 +109,16 @@ function enhanceSpawnRecipeError(error: unknown, recipe: unknown): Error {
   );
 }
 
-function runIdFromActorAddress(
-  address: string | undefined,
-): string | undefined {
-  if (!address) return undefined;
-  const parsed = Messages.parseActorAddress(address);
-  if (parsed.kind !== "run" || !parsed.value) {
-    throw new Error(`Expected run:<id> actor address, received: ${address}`);
+function runIdFromTarget(target: string | undefined): string | undefined {
+  if (!target) return undefined;
+  if (!target.startsWith("run:")) {
+    throw new Error(`spawn.as accepts only run:<id>; received: ${target}`);
   }
-  return parsed.value;
+  const run = target.slice(4);
+  if (!run || !/^[A-Za-z0-9_.-]+$/.test(run)) {
+    throw new Error(`invalid spawn Run target: ${target}`);
+  }
+  return run;
 }
 
 export function createSpawnToolDefinition<
@@ -135,17 +128,14 @@ export function createSpawnToolDefinition<
     name: "spawn",
     label: "Spawn",
     description:
-      "Create an addressable actor from a recipe file or inline command template. Use instead of ad hoc shell backgrounding for work that may outlive this turn, needs steering/follow-up/artifacts, runs as a service, fans out, or should be inspected later. Currently spawns run:<id> actors backed by async runs.",
+      "Create one controllable Run from a Recipe file or inline command template.",
     parameters: Schema.objectSchema(
       {
         artifacts: Schema.looseObjectSchema(
-          "Optional named artifact paths for the spawned actor.",
+          "Optional named artifact paths for the spawned Run.",
         ),
         as: Schema.stringSchema(
-          "Optional actor address for the spawned run, e.g. run:<id>.",
-        ),
-        correlation_id: Schema.stringSchema(
-          "Optional workflow correlation id preserved in terminal follow-up delivery.",
+          "Optional Run identity in exact run:<id> form.",
         ),
         file: Schema.stringSchema(
           "Optional template recipe JSON file. Bare names resolve under ~/.pi/agent/recipes.",
@@ -187,7 +177,7 @@ export function createSpawnToolDefinition<
           "spawn.state_dir is not supported; run state is runtime-owned so run:<id> remains addressable and retention-safe.",
         );
       }
-      const runId = runIdFromActorAddress(
+      const runId = runIdFromTarget(
         typeof input.as === "string" ? input.as : undefined,
       );
       const recipe =
@@ -202,11 +192,7 @@ export function createSpawnToolDefinition<
           {
             file: recipe,
             launch_source: "spawn",
-            launch_correlation: {
-              ...(typeof input.correlation_id === "string"
-                ? { correlation_id: input.correlation_id } : {}),
-              tool_call_id: toolCallId,
-            },
+            launch_correlation: { tool_call_id: toolCallId },
             ownerId: getRunOwnerId(ctx),
             ...(input.transport_context
               ? { transport_context: asRecord(input.transport_context) } : {}),
@@ -238,14 +224,12 @@ export function createSpawnToolDefinition<
         throw enhanceSpawnRecipeError(error, recipe);
       }
       const draftRecipe = writeSpawnDraftRecipe(input, meta);
-      const nextActions = ToolsResponse.actorRunNextActions(meta.run);
+      const nextActions = ToolsResponse.runNextActions(meta.run);
       const details = {
         ...meta,
         ...(draftRecipe ? { draft_recipe: draftRecipe } : {}),
         next_actions: nextActions,
       };
-      Rooms.ensureDefaultRoom(meta.state_dir, String(meta.run));
-      Rooms.writeCommunicationSnapshot(meta.state_dir, String(meta.run));
       return {
         content: [
           {

package/lib/tools.ts

@@ -73,8 +73,7 @@ export function createCoreActorToolDefinitions<
       setActiveTools: deps.setActiveTools,
     }),
     ToolsSpawn.createSpawnToolDefinition<TContext>(),
-    ToolsMessage.createActorMessageToolDefinition<TContext>({
-      getTool: (name) => deps.getRuntimeTool(name),
+    ToolsMessage.createControlToolDefinition<TContext>({
       handleRuntimeMessage: deps.handleRuntimeMessage,
     }),
     ToolsInspect.createInspectToolDefinition<TContext>({

package/lib/trace-projection.ts

@@ -0,0 +1,221 @@
+/**
+ * Unified bounded Run Trace projection.
+ * Zones: causal evidence merge, source filtering, redaction, deterministic ordering
+ * Owns public Trace items; source journals and session parsing remain in their domains.
+ */
+
+import { existsSync, statSync } from "node:fs";
+import { join, relative } from "node:path";
+
+import * as ExecutionSessions from "./execution-sessions.ts";
+import * as Limits from "./limits.ts";
+import {
+  resolveArtifactManifest,
+  type RunArtifactDeclaration,
+} from "./runs-artifacts.ts";
+import type { RunControlRecord } from "./runs-controls.ts";
+import { tailFile } from "./runs-status.ts";
+import type { TraceEvent } from "./runs-trace.ts";
+import * as SessionEvidence from "./session-evidence.ts";
+import {
+  readJsonFileResilient,
+  readJsonlFileResilient,
+  type StateReadDiagnostic,
+} from "./state-readers.ts";
+
+export type TraceSource =
+  | "lifecycle"
+  | "control"
+  | "process"
+  | "agent"
+  | "artifact"
+  | "runtime";
+
+export type TraceSourceFilter = TraceSource | "all";
+
+export interface TraceItem {
+  id: string;
+  ts: string;
+  source: TraceSource;
+  kind: string;
+  summary: string;
+  level?: "info" | "warning" | "error";
+  detail: unknown;
+}
+
+const LIFECYCLE_PREFIXES = ["run.", "command."];
+const SOURCE_LIMIT = 100;
+
+function redact(value: unknown): unknown {
+  return SessionEvidence.redactSessionEvidenceValue(value);
+}
+
+function sourceForEvent(event: TraceEvent): TraceSource {
+  return LIFECYCLE_PREFIXES.some((prefix) => event.kind.startsWith(prefix))
+    ? "lifecycle"
+    : "runtime";
+}
+
+function latestControlTimestamp(control: RunControlRecord): string {
+  return (
+    control.failed_at ??
+    control.handled_at ??
+    control.claimed_at ??
+    control.delivered_at ??
+    control.queued_at
+  );
+}
+
+function diagnosticItems(diagnostics: StateReadDiagnostic[]): TraceItem[] {
+  return diagnostics.slice(-SOURCE_LIMIT).map((diagnostic, index) => ({
+    id: `diagnostic:${diagnostic.path}:${diagnostic.line ?? 0}:${index}`,
+    ts: new Date(0).toISOString(),
+    source: "runtime",
+    kind: "state.read_error",
+    summary: "Malformed or unreadable Run evidence",
+    level: "warning",
+    detail: redact(diagnostic),
+  }));
+}
+
+function traceEventItems(stateDir: string): TraceItem[] {
+  const read = readJsonlFileResilient<TraceEvent>(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 } : {}),
+      }),
+    } satisfies TraceItem)),
+    ...diagnosticItems(read.diagnostics),
+  ];
+}
+
+function controlItems(stateDir: string): TraceItem[] {
+  const read = readJsonlFileResilient<RunControlRecord>(
+    join(stateDir, "controls.jsonl"),
+  );
+  return [
+    ...read.records.slice(-SOURCE_LIMIT).map((control) => ({
+      id: `control:${control.id}`,
+      ts: latestControlTimestamp(control),
+      source: "control" as const,
+      kind: `control.${control.status}`,
+      summary: `${control.action} ${control.status}`,
+      ...(control.status === "failed" ? { level: "error" as const } : {}),
+      detail: redact(control),
+    })),
+    ...diagnosticItems(read.diagnostics),
+  ];
+}
+
+function agentItems(stateDir: string): TraceItem[] {
+  return ExecutionSessions.readExecutionTurns(stateDir)
+    .slice(-SOURCE_LIMIT)
+    .map((turn) => {
+      const text = turn.assistantText ?? turn.userText ?? "Agent turn";
+      const summary = text.replaceAll(/\s+/g, " ").trim().slice(0, 160);
+      return {
+        id: `agent:${turn.commandId}:${turn.sessionFile}:${turn.index}`,
+        ts: turn.timestamp ?? new Date(0).toISOString(),
+        source: "agent" as const,
+        kind: "agent.turn",
+        summary: summary || "Agent turn",
+        ...(turn.error ? { level: "error" as const } : {}),
+        detail: redact(turn),
+      };
+    });
+}
+
+function processItems(stateDir: string): TraceItem[] {
+  return ["stdout", "stderr"].flatMap((stream) => {
+    const path = join(stateDir, `${stream}.log`);
+    if (!existsSync(path)) return [];
+    const stat = statSync(path);
+    const tail = tailFile(path, Limits.DEFAULT_INSPECT_LINES);
+    if (!tail && stat.size === 0) return [];
+    return [{
+      id: `process:${stream}`,
+      ts: stat.mtime.toISOString(),
+      source: "process" as const,
+      kind: `process.${stream}`,
+      summary: `${stream} (${stat.size} bytes)`,
+      ...(stream === "stderr" ? { level: "warning" as const } : {}),
+      detail: redact({ bytes: stat.size, path, tail }),
+    }];
+  });
+}
+
+function resultItems(stateDir: string): TraceItem[] {
+  const path = join(stateDir, "result.json");
+  const read = readJsonFileResilient<Record<string, unknown>>(path, {});
+  if (Object.keys(read.value).length === 0) return diagnosticItems(read.diagnostics);
+  const stat = statSync(path);
+  const failed = Number(read.value.code ?? 0) !== 0;
+  return [{
+    id: "process:result",
+    ts:
+      typeof read.value.completedAt === "string"
+        ? read.value.completedAt
+        : stat.mtime.toISOString(),
+    source: "process",
+    kind: failed ? "process.failed" : "process.result",
+    summary: failed ? "Run process failed" : "Run process completed",
+    ...(failed ? { level: "error" as const } : {}),
+    detail: redact(read.value),
+  }, ...diagnosticItems(read.diagnostics)];
+}
+
+function artifactItems(
+  stateDir: string,
+  declarations: Record<string, RunArtifactDeclaration> | undefined,
+): TraceItem[] {
+  const manifest = resolveArtifactManifest(declarations);
+  if (!manifest) return [];
+  return Object.entries(manifest).slice(0, SOURCE_LIMIT).map(([name, artifact]) => ({
+    id: `artifact:${name}`,
+    ts: artifact.exists && existsSync(artifact.path)
+      ? statSync(artifact.path).mtime.toISOString()
+      : new Date(0).toISOString(),
+    source: "artifact",
+    kind: artifact.exists ? "artifact.ready" : "artifact.missing",
+    summary: `${name}: ${artifact.exists ? "ready" : "missing"}`,
+    ...(artifact.required && !artifact.exists ? { level: "warning" as const } : {}),
+    detail: redact({
+      exists: artifact.exists,
+      path: relative(stateDir, artifact.path).replaceAll("\\", "/"),
+      required: artifact.required,
+      ...(artifact.size !== undefined ? { size: artifact.size } : {}),
+    }),
+  }));
+}
+
+export function projectRunTrace(
+  stateDir: string,
+  options: {
+    artifacts?: Record<string, RunArtifactDeclaration>;
+    limit?: number;
+    source?: TraceSourceFilter;
+  } = {},
+): TraceItem[] {
+  const source = options.source ?? "all";
+  const items = [
+    ...traceEventItems(stateDir),
+    ...controlItems(stateDir),
+    ...agentItems(stateDir),
+    ...processItems(stateDir),
+    ...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)));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-actors",
-  "version": "0.42.2",
+  "version": "0.43.0",
   "private": false,
   "description": "Local Actor Kernel for Pi",
   "keywords": [
@@ -28,6 +28,7 @@
     "check": "node --experimental-strip-types -e \"await import('./index.ts'); console.log('pi-actors: extension import ok')\"",
     "conformance": "node scripts/conformance.mjs",
     "test": "node --experimental-strip-types --test --test-concurrency=1 tests/*.test.ts",
+    "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 scripts/validate-recipe.mjs recipes --all --qa --summary",
     "release:validate": "npm run validate && node scripts/release-gates.mjs",

package/recipes/draft-review.json

@@ -10,15 +10,5 @@
     "thinking": "{current_thinking}"
   },
   "description": "Read-only background reviewer for one immutable automatic draft-memory batch.",
-  "mailbox": {
-    "accepts": [
-      "control.kill"
-    ],
-    "emits": [
-      "command.done",
-      "run.done",
-      "run.failed"
-    ]
-  },
   "template": "pi -p --model {model} --thinking {thinking} --no-tools @{input_path} Review the attached immutable pi-actors draft batch. Evaluate every draft independently using launch history, universality, flexibility, parameterization, duplication, safety, and likely future usefulness. Treat draft and sha256 fields as batch-local opaque occurrence/content-group identifiers and return them verbatim. Choose exactly one promote or discard decision per draft; there is no selection quota. Promotion requires a unique absent snake_case target and targetSha256 null. Never return recipe content: the executor derives the exact immutable captured source. Invalid or secret-touching drafts must be discarded. Include assessment with launches, universality, flexibility, futureUsefulness, and safety. Do not mutate, move, register, or delete recipes. End stdout with DRAFT_REVIEW_RESULT on its own line followed by exactly one JSON object with batchId, createdAt, and decisions."
 }

package/recipes/lens-swarm.json

@@ -37,20 +37,6 @@
     "risk_policy": "Preserve minority high-impact risks and ideas; separate confirmed issues from hypotheses.",
     "output_format": "Markdown sections: Status (complete/degraded/insufficient_data), Summary, Consensus Findings, Minority Findings, Verification, Judge Notes, Risks, Next Actions."
   },
-  "mailbox": {
-    "accepts": [
-      "control.kill"
-    ],
-    "emits": [
-      "review.completed",
-      "verification.completed",
-      "merge.completed",
-      "judge.completed",
-      "command.done",
-      "run.done",
-      "run.failed"
-    ]
-  },
   "template": [
     {
       "name": "coordinator",

package/recipes/music-player.json

@@ -16,24 +16,15 @@
     "volume": "70",
     "player": "auto"
   },
-  "mailbox": {
-    "accepts": [
-      "control.stop",
-      "control.cancel",
-      "control.kill",
-      "player.play",
-      "player.pause",
-      "player.resume",
-      "player.toggle",
-      "player.next",
-      "player.previous",
-      "player.stop",
-      "player.status"
-    ],
-    "emits": [
-      "player.track",
-      "player.stopped"
-    ]
-  },
+  "control": [
+    "play",
+    "pause",
+    "resume",
+    "toggle",
+    "next",
+    "previous",
+    "stop",
+    "status"
+  ],
   "template": "{repo}/scripts/music-player.mjs {command} {source} {loop} {volume} {player} {state_dir}"
 }

package/recipes/pipeline-architect-coordinator.json

@@ -24,17 +24,6 @@
     "constraints": "Prefer small composable pieces, explicit contracts, and no broad workflow DSL.",
     "tools": ""
   },
-  "mailbox": {
-    "accepts": [
-      "control.kill"
-    ],
-    "emits": [
-      "pipeline.completed",
-      "command.done",
-      "run.done",
-      "run.failed"
-    ]
-  },
   "template": [
     {
       "parallel": true,

package/recipes/pipeline-artifact-bundle.json

@@ -4,8 +4,7 @@
     "artifactWrite": "pipeline-artifact-write.json",
     "manifest": "utility-artifact-manifest.json",
     "manifestWrite": "utility-artifact-write.json",
-    "validation": "utility-validation-wrapper.json",
-    "message": "utility-actor-message.json"
+    "validation": "utility-validation-wrapper.json"
   },
   "args": [
     "input:string",
@@ -33,18 +32,6 @@
     "validation_timeout_ms": "300000",
     "tools": ""
   },
-  "mailbox": {
-    "accepts": [
-      "control.kill"
-    ],
-    "emits": [
-      "artifact.bundle_ready",
-      "artifact.written",
-      "artifact.blocked",
-      "run.done",
-      "run.failed"
-    ]
-  },
   "artifacts": {
     "artifact": "{artifact_path}",
     "manifest": "{manifest_path}"
@@ -85,14 +72,6 @@
         "artifact_path": "{manifest_path}",
         "mode": "{write_mode}"
       }
-    },
-    {
-      "name": "message",
-      "values": {
-        "type": "artifact.bundle_ready",
-        "summary": "Artifact bundle ready: {artifact_path} with manifest {manifest_path}.",
-        "metadata": "{\"artifact\":\"{artifact_path}\",\"manifest\":\"{manifest_path}\"}"
-      }
     }
   ]
 }

package/recipes/pipeline-artifact-report.json

@@ -2,8 +2,7 @@
   "async": true,
   "imports": {
     "normalizer": "subagent-normalize.json",
-    "artifact": "subagent-artifact.json",
-    "message": "utility-actor-message.json"
+    "artifact": "subagent-artifact.json"
   },
   "args": [
     "input:string",
@@ -16,15 +15,6 @@
     "artifact_format": "Markdown sections: Summary, Findings, Evidence, Risks, Next Actions.",
     "tools": ""
   },
-  "mailbox": {
-    "accepts": [
-      "control.kill"
-    ],
-    "emits": [
-      "artifact.prepared",
-      "artifact.blocked"
-    ]
-  },
   "template": [
     {
       "name": "normalizer",
@@ -44,13 +34,6 @@
         "model": "{model}",
         "tools": "{tools}"
       }
-    },
-    {
-      "name": "message",
-      "values": {
-        "type": "artifact.prepared",
-        "summary": "Artifact prepared for path {artifact_path}."
-      }
     }
   ]
 }

package/recipes/pipeline-artifact-write.json

@@ -3,8 +3,7 @@
   "imports": {
     "normalizer": "subagent-normalize.json",
     "artifact": "subagent-artifact.json",
-    "writer": "utility-artifact-write.json",
-    "message": "utility-actor-message.json"
+    "writer": "utility-artifact-write.json"
   },
   "args": [
     "input:string",
@@ -19,15 +18,6 @@
     "write_mode": "create",
     "tools": ""
   },
-  "mailbox": {
-    "accepts": [
-      "control.kill"
-    ],
-    "emits": [
-      "artifact.written",
-      "artifact.blocked"
-    ]
-  },
   "artifacts": {
     "artifact": "{artifact_path}"
   },
@@ -58,13 +48,6 @@
         "artifact_path": "{artifact_path}",
         "mode": "{write_mode}"
       }
-    },
-    {
-      "name": "message",
-      "values": {
-        "type": "artifact.written",
-        "summary": "Artifact written to path {artifact_path} using mode {write_mode}."
-      }
     }
   ]
 }

package/recipes/pipeline-async-run-ops.json

@@ -22,18 +22,6 @@
     "artifact_path": "./async-run-ops.md",
     "tools": ""
   },
-  "mailbox": {
-    "accepts": [
-      "control.kill"
-    ],
-    "emits": [
-      "operations.completed",
-      "artifact.prepared",
-      "command.done",
-      "run.done",
-      "run.failed"
-    ]
-  },
   "template": [
     {
       "name": "snapshot",