@llblab/pi-actors 0.42.2 → 0.43.0

package/dist/lib/tools-response.js

@@ -4,7 +4,6 @@
  * Owns model-facing response helpers shared by public tool execution paths
  */
 import * as Limits from "./limits.js";
-import * as ToolsMailbox from "./tools-mailbox.js";
 export function withLeadingLineBreak(text) {
     return `\n${text.replace(/^\n+/, "")}`;
 }
@@ -76,14 +75,14 @@ function compactModelPolicy(value) {
         compactPolicyAxis("thinking", policy.thinking),
     ].filter((token) => Boolean(token));
 }
-export function actorRunNextActions(run) {
+export function runNextActions(run) {
     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`,
     ];
 }
 export function compactAsyncRunStatus(value) {
@@ -117,44 +116,11 @@ export function compactAsyncRunStatus(value) {
     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("|")}`);
     return `\n${tokens.join(" ")}`;
 }
-export function compactInboxMessages(messages, emptyLabel) {
-    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) {
-    return compactInboxMessages(messages, "branch inbox");
-}
-export function compactRunMailbox(run, mailbox, messages) {
-    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, artifacts) {
     const id = String(run ?? "").trim();
     if (!id || Object.keys(artifacts).length === 0)

package/dist/lib/tools-spawn.js

@@ -7,12 +7,10 @@ import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import * as AsyncRuns from "./async-runs.js";
 import { withFileMutationLock } from "./file-state.js";
-import * as Messages from "./messages.js";
 import * as ModelContext from "./model-context.js";
 import * as Paths from "./paths.js";
 import * as RecipesDiscovery from "./recipes-discovery.js";
 import * as RecipesUsage from "./recipes-usage.js";
-import * as Rooms from "./rooms.js";
 import * as Schema from "./schema.js";
 import * as ToolsResponse from "./tools-response.js";
 const asRecord = ToolsResponse.asRecord;
@@ -35,13 +33,7 @@ function draftRecipeName(run) {
     return `${run.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "spawn"}.json`;
 }
 function draftRecipeDefaults(values) {
-    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)));
     return Object.keys(defaults).length > 0 ? defaults : undefined;
 }
@@ -78,24 +70,26 @@ function enhanceSpawnRecipeError(error, recipe) {
         original_error: original,
     });
 }
-function runIdFromActorAddress(address) {
-    if (!address)
+function runIdFromTarget(target) {
+    if (!target)
         return undefined;
-    const parsed = Messages.parseActorAddress(address);
-    if (parsed.kind !== "run" || !parsed.value) {
-        throw new Error(`Expected run:<id> actor address, received: ${address}`);
+    if (!target.startsWith("run:")) {
+        throw new Error(`spawn.as accepts only run:<id>; received: ${target}`);
+    }
+    const run = target.slice(4);
+    if (!run || !/^[A-Za-z0-9_.-]+$/.test(run)) {
+        throw new Error(`invalid spawn Run target: ${target}`);
     }
-    return parsed.value;
+    return run;
 }
 export function createSpawnToolDefinition() {
     return {
         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.",
+        description: "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."),
-            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."),
+            artifacts: Schema.looseObjectSchema("Optional named artifact paths for the spawned Run."),
+            as: Schema.stringSchema("Optional Run identity in exact run:<id> form."),
             file: Schema.stringSchema("Optional template recipe JSON file. Bare names resolve under ~/.pi/agent/recipes."),
             recipe: Schema.stringSchema("Alias for file; template recipe JSON file/name to spawn."),
             template: Schema.unionSchema([
@@ -112,7 +106,7 @@ export function createSpawnToolDefinition() {
             if (input.state_dir !== undefined) {
                 throw new Error("spawn.state_dir is not supported; run state is runtime-owned so run:<id> remains addressable and retention-safe.");
             }
-            const runId = runIdFromActorAddress(typeof input.as === "string" ? input.as : undefined);
+            const runId = runIdFromTarget(typeof input.as === "string" ? input.as : undefined);
             const recipe = typeof input.file === "string"
                 ? input.file
                 : typeof input.recipe === "string"
@@ -123,11 +117,7 @@ export function createSpawnToolDefinition() {
                 meta = AsyncRuns.startRun({
                     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) } : {}),
@@ -151,14 +141,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/dist/lib/tools.js

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

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

@@ -0,0 +1,22 @@
+/**
+ * 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 { type RunArtifactDeclaration } from "./runs-artifacts.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;
+}
+export declare function projectRunTrace(stateDir: string, options?: {
+    artifacts?: Record<string, RunArtifactDeclaration>;
+    limit?: number;
+    source?: TraceSourceFilter;
+}): TraceItem[];

package/dist/lib/trace-projection.js

@@ -0,0 +1,165 @@
+/**
+ * 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.js";
+import * as Limits from "./limits.js";
+import { resolveArtifactManifest, } from "./runs-artifacts.js";
+import { tailFile } from "./runs-status.js";
+import * as SessionEvidence from "./session-evidence.js";
+import { readJsonFileResilient, readJsonlFileResilient, } from "./state-readers.js";
+const LIFECYCLE_PREFIXES = ["run.", "command."];
+const SOURCE_LIMIT = 100;
+function redact(value) {
+    return SessionEvidence.redactSessionEvidenceValue(value);
+}
+function sourceForEvent(event) {
+    return LIFECYCLE_PREFIXES.some((prefix) => event.kind.startsWith(prefix))
+        ? "lifecycle"
+        : "runtime";
+}
+function latestControlTimestamp(control) {
+    return (control.failed_at ??
+        control.handled_at ??
+        control.claimed_at ??
+        control.delivered_at ??
+        control.queued_at);
+}
+function diagnosticItems(diagnostics) {
+    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) {
+    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),
+    ];
+}
+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),
+    ];
+}
+function agentItems(stateDir) {
+    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",
+            kind: "agent.turn",
+            summary: summary || "Agent turn",
+            ...(turn.error ? { level: "error" } : {}),
+            detail: redact(turn),
+        };
+    });
+}
+function processItems(stateDir) {
+    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",
+                kind: `process.${stream}`,
+                summary: `${stream} (${stat.size} bytes)`,
+                ...(stream === "stderr" ? { level: "warning" } : {}),
+                detail: redact({ bytes: stat.size, path, tail }),
+            }];
+    });
+}
+function resultItems(stateDir) {
+    const path = join(stateDir, "result.json");
+    const read = readJsonFileResilient(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" } : {}),
+            detail: redact(read.value),
+        }, ...diagnosticItems(read.diagnostics)];
+}
+function artifactItems(stateDir, declarations) {
+    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" } : {}),
+        detail: redact({
+            exists: artifact.exists,
+            path: relative(stateDir, artifact.path).replaceAll("\\", "/"),
+            required: artifact.required,
+            ...(artifact.size !== undefined ? { size: artifact.size } : {}),
+        }),
+    }));
+}
+export function projectRunTrace(stateDir, options = {}) {
+    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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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",

package/dist/recipes/pipeline-checkpoint-continuation.json

@@ -18,20 +18,6 @@
     "mode": "degraded-new-branch",
     "tools": ""
   },
-  "mailbox": {
-    "accepts": [
-      "control.reply",
-      "control.revise",
-      "control.kill"
-    ],
-    "emits": [
-      "checkpoint.needs_input",
-      "checkpoint.continued",
-      "command.done",
-      "run.done",
-      "run.failed"
-    ]
-  },
   "template": [
     {
       "name": "checkpoint",

package/dist/recipes/pipeline-development-tasking.json

@@ -22,18 +22,6 @@
     "constraints": "Split into bounded mutation zones and preserve integrator ownership of shared contracts.",
     "tools": ""
   },
-  "mailbox": {
-    "accepts": [
-      "control.kill"
-    ],
-    "emits": [
-      "task_card.completed",
-      "pipeline.completed",
-      "command.done",
-      "run.done",
-      "run.failed"
-    ]
-  },
   "template": [
     {
       "name": "planner",

package/dist/recipes/pipeline-docs-maintenance.json

@@ -21,18 +21,6 @@
     "artifact_path": "./docs-maintenance.md",
     "tools": ""
   },
-  "mailbox": {
-    "accepts": [
-      "control.kill"
-    ],
-    "emits": [
-      "docs.completed",
-      "artifact.prepared",
-      "command.done",
-      "run.done",
-      "run.failed"
-    ]
-  },
   "template": [
     {
       "name": "docs_index",