@llblab/pi-actors 0.14.3 → 0.16.0

package/docs/task-first-recipes.md

@@ -30,13 +30,13 @@ scope snapshot → changelog/package check → release lens reviews → risk ver
 
 Likely needed cells:
 
-- package metadata reader
-- changelog section extractor
-- package contents summarizer
-- validation command wrapper
-- release-risk reviewer
-- readiness merger/judge
-- release checklist artifact writer
+- Package metadata reader
+- Changelog section extractor
+- Package contents summarizer
+- Validation command wrapper
+- Release-risk reviewer
+- Readiness merger/judge
+- Release checklist artifact writer
 
 Existing seeds:
 
@@ -49,7 +49,7 @@ Existing seeds:
 
 Implemented seed:
 
-- `pipeline-release-readiness`: changelog section → package summary → validation wrapper → release review coordinator → artifact report.
+- `pipeline-release-readiness`: changelog section → package summary → packaged skill summary → validation wrapper → release review coordinator → artifact report.
 
 ### Repository Health Cell
 
@@ -63,12 +63,12 @@ git status/log → package/docs/backlog snapshot → validation summary → heal
 
 Likely needed cells:
 
-- git status/log utility
-- package version reader
-- backlog open/blocked extractor
-- docs index checker
-- validation summary normalizer
-- next-action recommender
+- Git status/log utility
+- Package version reader
+- Backlog open/blocked extractor
+- Docs index checker
+- Validation summary normalizer
+- Next-action recommender
 
 Existing seeds:
 
@@ -93,11 +93,11 @@ run-state summary → actor-message tail → stale/active classification → rec
 
 Likely needed cells:
 
-- run summary helper
+- Run summary helper
 - JSONL actor-message tailer
-- stale-run classifier
-- control-message recommender
-- run report artifact
+- Stale-run classifier
+- Control-message recommender
+- Run report artifact
 
 Existing seeds:
 
@@ -122,13 +122,13 @@ question framing → evidence map → contradiction map → claim verification
 
 Likely needed cells:
 
-- question framer
-- source inventory utility
-- evidence mapper
-- contradiction mapper
-- verifier
-- synthesis merger
-- limitations normalizer
+- Question framer
+- Source inventory utility
+- Evidence mapper
+- Contradiction mapper
+- Verifier
+- Synthesis merger
+- Limitations normalizer
 
 Existing seeds:
 
@@ -149,11 +149,11 @@ goal → mutation zones → task cards → validation gates → conflict risks
 
 Likely needed cells:
 
-- mutation-zone planner
-- task-card generator
-- ownership/conflict checker
-- validation-gate normalizer
-- integrator handoff artifact
+- Mutation-zone planner
+- Task-card generator
+- Ownership/conflict checker
+- Validation-gate normalizer
+- Integrator handoff artifact
 
 Existing seeds:
 
@@ -173,11 +173,11 @@ doc file inventory → index diff → stale link/routing review → rewrite sugg
 
 Likely needed cells:
 
-- markdown index utility
-- link checker wrapper
-- docs consistency reviewer
-- docs update planner
-- docs artifact writer
+- Markdown index utility
+- Link checker wrapper
+- Docs consistency reviewer
+- Docs update planner
+- Docs artifact writer
 
 Existing seeds:
 
@@ -202,10 +202,10 @@ media scan → playlist build → playback start → message summary → control
 
 Likely needed cells:
 
-- playlist builder
-- music player
-- run/message summary
-- control recommender
+- Playlist builder
+- Music player
+- Run/message summary
+- Control recommender
 
 Existing seeds:
 
@@ -226,8 +226,9 @@ Prefer adding a high-level recipe when at least three cells already exist and th
 
 Good next candidates for the standard library after the first task-first wave:
 
-1. Package/release metadata enrichment: implemented in `pipeline-release-readiness` by adding `utility-package-summary` between changelog extraction and validation, making release-readiness reports more evidence-rich without adding publish automation.
-2. Artifact packaging and manifesting: implemented as `pipeline-artifact-bundle`, which composes optional validation, `pipeline-artifact-write`, `utility-artifact-manifest`, deterministic manifest writing, and an actor-message handoff when the caller explicitly requests filesystem writes.
-3. Async run cleanup planning: extend async-run operations with stale-run classification and recommended `message`, `cancel`, or `kill` controls, keeping actual control execution operator-gated.
+1. Package/release metadata enrichment: implemented in `pipeline-release-readiness` by adding `utility-package-summary` and `utility-skill-summary` between changelog extraction and validation, making release-readiness reports more evidence-rich without adding publish automation.
+2. Evidence-only release summary: implemented as `pipeline-release-summary`, which composes changelog/package/skill/validation evidence into a release summary, risk checklist, and PR body draft artifact while leaving commit, PR, merge, tag, and publish actions to explicit release gates.
+3. Artifact packaging and manifesting: implemented as `pipeline-artifact-bundle`, which composes optional validation, `pipeline-artifact-write`, `utility-artifact-manifest`, deterministic manifest writing, and an actor-message handoff when the caller explicitly requests filesystem writes.
+4. Async run cleanup planning: extend async-run operations with stale-run classification and recommended `message`, `cancel`, or `kill` controls, keeping actual control execution operator-gated.
 
-Each candidate should land with the minimum missing cells rather than a broad one-shot framework. Already implemented task-first seeds include `pipeline-release-readiness`, `pipeline-repo-health`, `pipeline-async-run-ops`, `pipeline-docs-maintenance`, `pipeline-media-library`, and `pipeline-artifact-bundle`.
+Each candidate should land with the minimum missing cells rather than a broad one-shot framework. Already implemented task-first seeds include `pipeline-release-readiness`, `pipeline-release-summary`, `pipeline-repo-health`, `pipeline-async-run-ops`, `pipeline-docs-maintenance`, `pipeline-media-library`, and `pipeline-artifact-bundle`.

package/docs/template-recipes.md

@@ -21,6 +21,8 @@ A recipe wraps one command-template tree. The wrapped `template` keeps the norma
 
 Layer boundary: `imports`, `{ "name": "alias" }` imported-recipe nodes, `{alias.defaults.key}` references, fallback expressions, and recipe-local ternaries are recipe-loading features. They resolve before the command-template graph runs and do not extend the portable Command Template Standard. Typed imports are recipe definitions: they expose the imported recipe's command-template-shaped metadata (`template`, `args`, `defaults`, flags, and `values`), while async-run launch fields such as `async` and `state_dir` remain lifecycle configuration for starting a run, not part of the imported execution graph.
 
+Packaged recipes are the pi-actors recipe standard library: declarative actor config components that can be imported, launched, inspected, overridden, or composed by user recipes. Treat them as stable building blocks rather than user-local policy.
+
 ## Layer Ownership
 
 Template-recipe standard owns:
@@ -67,6 +69,36 @@ Async recipe:
 
 `name` names the saved definition when an explicit name is needed. File-backed recipes usually omit it because the filename is the canonical recipe id. `template` is the command-template tree. `async: true` selects detached run mode when the recipe is invoked through a registered tool.
 
+## Discovery Priority
+
+Recipe priority only matters when two discovered recipes have the same filename id. The conceptual ladder from lowest to highest priority is:
+
+1. No recipe for that id.
+2. Packaged pi-actors recipe components, acting as the standard library.
+3. Explicitly referenced ad hoc user recipe files located outside `~/.pi/agent/recipes`.
+4. User recipe files under `~/.pi/agent/recipes/*.json`.
+
+The high-priority user recipe directory is also the default tool set: recipes placed there are agent tools unless they explicitly set `tool: false`. This preserves the old advantage of a tool-only registry because listing `~/.pi/agent/recipes` shows the operator-managed tool surface. Packaged and ad hoc recipes are recipe components by default; they opt into agent-tool exposure with `tool: true`.
+
+Higher-priority files shadow lower-priority files with the same basename. A highest-priority invalid recipe is still visible and blocks fallback so operators do not accidentally run packaged behavior when a user override is broken. A highest-priority recipe with `disabled: true` also blocks fallback and intentionally disables that id.
+
+## Usage Metadata
+
+User-owned recipes may accumulate extension-maintained usage metadata:
+
+```json
+{
+  "usage": {
+    "calls": 12,
+    "last_called": "2026-05-22T10:30:00.000Z"
+  }
+}
+```
+
+The extension increments `usage.calls` and updates `usage.last_called` when it starts that concrete recipe, either through a recipe-backed tool call or a direct async recipe-file run. Agents should treat these fields as cleanup evidence, not as authored recipe contract. Packaged standard-library recipes are not mutated for usage metadata.
+
+There is intentionally no failure counter in the recipe contract. A failed launch can reflect caller misuse, missing runtime values, or an environmental problem rather than recipe uselessness. Cleanup decisions should be explicit operator work: keep as a tool, set `tool: false`, merge, delete, or archive.
+
 For object form, keep `template` last. Recipe metadata comes first; executable content stays last.
 
 ## Named Artifacts
@@ -95,7 +127,12 @@ Use recipe-level `mailbox` to document the semantic messages a recipe actor acce
 ```json
 {
   "mailbox": {
-    "accepts": ["control.continue", "control.revise", "control.approve", "control.stop"],
+    "accepts": [
+      "control.continue",
+      "control.revise",
+      "control.approve",
+      "control.stop"
+    ],
     "emits": ["checkpoint.needs_scope", "branch.done", "run.done"]
   }
 }
@@ -166,34 +203,19 @@ Call-time params override file params. `values` are merged with file values; cal
 
 ## Registered Recipe Tools
 
-A registered tool can point at an actor recipe by storing the recipe path or name in `template`:
+A registered tool is a recipe file exposed as an agent tool. User recipes under `~/.pi/agent/recipes/*.json` are tools by default; packaged/ad hoc recipes opt in with `tool: true`:
 
 ```json
 {
-  "docs_review": {
-    "description": "Start an async docs review actor",
-    "args": ["scope:path", "model:string=openai-codex/gpt-5.5"],
-    "template": "docs-review.json"
-  }
-}
-```
-
-If `docs-review.json` contains `async: true`, calling `docs_review` starts a detached actor run and returns metadata. If `async` is omitted or false, calling `docs_review` executes the recipe foreground and returns normal tool output.
-
-A registered tool may also co-locate an actor recipe directly in `actors-tools.json`:
-
-```json
-{
-  "review_docs": {
-    "description": "Start an async docs review",
-    "name": "review-docs",
-    "async": true,
-    "template": "review {scope}"
-  }
+  "description": "Start an async docs review actor",
+  "tool": true,
+  "async": true,
+  "args": ["scope:path", "model:string"],
+  "template": "review {scope} --model {model}"
 }
 ```
 
-The co-located entry must still own `template` directly and must not define `tool`.
+If a tool recipe contains `async: true`, calling the tool starts a detached actor run and returns metadata. If `async` is omitted or false, calling the tool executes the recipe foreground and returns normal tool output.
 
 ## Values And Public Args
 

package/docs/tool-registry.md

@@ -1,39 +1,49 @@
 # Tool Registry
 
-`pi-actors` stores registered actor-control command-template tools and template-recipe launchers in `~/.pi/agent/actors-tools.json` and registers them automatically on session start.
+`pi-actors` stores persistent agent tools as recipe files under `~/.pi/agent/recipes/*.json` and registers the active tool set automatically on session start.
 
-This document is the local adaptation of the portable [Command Template Standard](./command-templates.md).
+This document is the local adaptation of the portable [Command Template Standard](./command-templates.md) and the recipe-file runtime described in [Template Recipe Standard](./template-recipes.md).
 
-## Rename Migration
+## Registry Model
 
-`pi-actors` reads only `~/.pi/agent/actors-tools.json` as its registry source. When moving from `pi-auto-tools`, copy the previous registry explicitly:
+The 0.16 registry source is file-discovered recipes, not a live tool-only JSON file:
 
-```bash
-cp ~/.pi/agent/auto-tools.json ~/.pi/agent/actors-tools.json
-```
+- `~/.pi/agent/recipes/*.json` is the highest-priority user recipe root and the operator-managed tool set.
+- Recipes in that root are tools by default.
+- `tool: false` keeps a user recipe file recipe-only.
+- Packaged pi-actors recipes are the lower-priority standard library of declarative actor config components.
+- Packaged or ad hoc recipes opt into tool exposure with `tool: true`.
+- Recipe identity is the filename basename; `~/.pi/agent/recipes/docs_review.json` has id/tool name `docs_review`.
+
+`~/.pi/agent/actors-tools.json` is legacy compatibility input. On startup, pi-actors migrates it into recipe files when possible, writes a migration report, and archives the source only when migration has no conflicts or invalid generated recipes.
+
+Because the user recipe directory is sticky agent muscle memory, runtime launches update `usage.calls` and `usage.last_called` on user-owned recipe files. Use that evidence during focused cleanup passes: keep valuable tools, set `tool: false` for useful components that should leave the active tool surface, merge duplicates, or delete/archive low-value files. The extension does not maintain a failure counter and agents should not silently clean tools during unrelated work.
 
-If a short-lived `~/.pi/agent/tools.json` file exists from the early `pi-actors` rename window, copy that file instead:
+`register_tool` is the preferred agent-facing mutation API. It creates, updates, and deletes recipe files in `~/.pi/agent/recipes`; agents do not need to edit the files directly for normal registration. Direct file edits are still valid for operators and advanced agents. Runtime behavior is reactive: file creation, deletion, or edits in the user recipe root trigger validation and tool-set refresh, with invalid recipes surfaced as diagnostics rather than silently ignored.
 
-```bash
-cp ~/.pi/agent/tools.json ~/.pi/agent/actors-tools.json
+Inspect the discovered registry with:
+
+```text
+inspect target=recipes view=status
+inspect target=recipes view=summary verbose=true
 ```
 
-No automatic rewrite is performed so operators can decide when to retire old config files.
+The summary reports active, shadowed, invalid, disabled, and diagnostic entries so operators can answer why a tool is present, hidden, broken, or disabled.
 
 ## Registering Tools
 
 `register_tool` is the interactive API for listing, creating, updating, or deleting persistent tools. Call it without arguments to list registered tools.
 
 ```text
-register_tool name=transcribe_groq \
-  description="Transcribe audio files using Groq Whisper API" \
-  template="~/.pi/agent/skills/groq-stt/scripts/transcribe.mjs {file} {lang=ru} {model=whisper-large-v3-turbo}"
+register_tool name=transcribe_audio \
+  description="Transcribe an audio file" \
+  template="~/bin/transcribe {file:path} {lang=ru} {model:string}"
 ```
 
 ```text
 register_tool name=call_subagent \
   description="Run pi as a non-interactive sub-agent" \
-  template="pi -p --model {model=openai-codex/gpt-5.5} --no-tools {prompt}"
+  template="pi -p --model {model} --no-tools {prompt}" args="prompt:string,model:string"
 ```
 
 Use `update=true` to overwrite an existing tool. Omit `template` and co-located recipe fields during update to keep the previous execution binding.
@@ -47,31 +57,30 @@ Use `update=true` to overwrite an existing tool. Omit `template` and co-located
 ]
 ```
 
-For reusable actor workflows, register a small tool whose `template` points to an actor recipe instead of embedding the launch graph in the tool itself:
+For reusable actor workflows, register a small tool whose `template` points to an existing actor recipe instead of embedding the launch graph in the tool itself:
 
 ```text
 register_tool name=docs_review \
   description="Start an async docs review actor" \
-  template="docs-review.json" \
-  args="scope:path,model:string=openai-codex/gpt-5.5"
+  template="docs-review" \
+  args="scope:path,model:string"
 ```
 
-This stores the recipe path in the registry as `template`. If `~/.pi/agent/recipes/docs-review.json` contains `async: true`, calling the tool starts a detached actor run and returns metadata immediately. If `async` is omitted or false, the same recipe runs foreground and returns normal tool output.
+This writes or updates `~/.pi/agent/recipes/docs_review.json` with `tool: true` and a recipe-reference template. If the referenced recipe contains `async: true`, calling the tool starts a detached actor run and returns metadata immediately. If `async` is omitted or false, the same recipe runs foreground and returns normal tool output.
 
-When co-location is clearer than a separate file, the registry entry may include recipe fields directly beside tool metadata:
+When co-location is clearer than a separate file, `register_tool` writes the recipe fields directly into the user recipe file:
 
 ```json
 {
-  "review_docs": {
-    "description": "Start an async docs review",
-    "name": "review-docs",
-    "async": true,
-    "template": "pi -p --model openai-codex/gpt-5.5 --tools read,bash \"Review {scope}\""
-  }
+  "description": "Start an async docs review",
+  "tool": true,
+  "async": true,
+  "args": ["scope:path", "model:string"],
+  "template": "pi -p --model {model} --tools read,bash \"Review {scope}\""
 }
 ```
 
-This is still not a cycle: `name` names the saved definition when it differs from the tool key, `async: true` selects detached run mode, and `template` remains the executable body. Co-located recipe entries must not define `tool`.
+This is still not a cycle: the filename is the saved definition id, `async: true` selects detached run mode, and `template` remains the executable body.
 
 Delete a tool with `template=null`:
 
@@ -81,23 +90,22 @@ register_tool name=call_subagent template=null
 
 ## Stored Shape
 
-Tool names come from the top-level registry keys. Tool entries define `template`; it may be an inline command template, a template recipe JSON path/name, or the body of a co-located template recipe when `async` or entry-local `name` is present. Template entries keep `template` last, matching the command-template readability rule. The commands above persist entries like this:
+Tool names come from recipe filenames in `~/.pi/agent/recipes`. Recipe files define `template`; it may be an inline command template, a command-template sequence, or an async recipe body. Template entries keep `template` last, matching the command-template readability rule. The commands above persist recipe files like this:
 
 ```json
 {
-  "transcribe_groq": {
-    "description": "Transcribe audio files using Groq Whisper API",
-    "template": "~/.pi/agent/skills/groq-stt/scripts/transcribe.mjs {file} {lang=ru} {model=whisper-large-v3-turbo}"
-  },
-  "call_subagent": {
-    "description": "Run pi as a non-interactive sub-agent",
-    "template": "pi -p --model {model=openai-codex/gpt-5.5} --no-tools {prompt}"
-  },
-  "docs_review": {
-    "description": "Start an async docs review actor",
-    "args": ["scope:path", "model:string=openai-codex/gpt-5.5"],
-    "template": "docs-review.json"
-  }
+  "description": "Transcribe an audio file",
+  "tool": true,
+  "template": "~/bin/transcribe {file:path} {lang=ru} {model:string}"
+}
+```
+
+```json
+{
+  "description": "Run pi as a non-interactive sub-agent",
+  "tool": true,
+  "args": ["prompt:string", "model:string"],
+  "template": "pi -p --model {model} --no-tools {prompt}"
 }
 ```
 
@@ -106,7 +114,7 @@ Tool names come from the top-level registry keys. Tool entries define `template`
 When `args` is omitted, `pi-actors` derives tool parameters from placeholders in `template`:
 
 ```text
-template="~/bin/transcribe {file} {lang=ru} {model=whisper-large-v3-turbo}"
+template="~/bin/transcribe {file:path} {lang=ru} {model:string}"
 ```
 
 The optional `args` field is an explicit placeholder declaration, matching the command-template standard. Untyped declarations remain valid:

package/index.ts

@@ -40,6 +40,8 @@ const RESERVED_TOOL_NAMES = new Set([
 export default function toolRegistryExtension(pi: ExtensionAPI) {
   let runsAnimationInterval: NodeJS.Timeout | undefined;
   let runsNotifyTimeout: NodeJS.Timeout | undefined;
+  let recipeReloadTimeout: NodeJS.Timeout | undefined;
+  let recipeRootWatcher: FSWatcher | undefined;
   let stateRootWatcher: FSWatcher | undefined;
   const runDirWatchers = new Map<string, FSWatcher>();
   const observedRuns = new Map<string, Observability.RunObservedStatus>();
@@ -147,23 +149,54 @@ export default function toolRegistryExtension(pi: ExtensionAPI) {
       watchRunDir(ctx, `${RUN_STATE_ROOT}/${entry.name}`);
     }
   }
+  const closeRecipeWatcher = (): void => {
+    recipeRootWatcher?.close();
+    recipeRootWatcher = undefined;
+    if (recipeReloadTimeout) clearTimeout(recipeReloadTimeout);
+    recipeReloadTimeout = undefined;
+  };
+  const scheduleRecipeReload = (ctx: ExtensionContext): void => {
+    if (recipeReloadTimeout) clearTimeout(recipeReloadTimeout);
+    recipeReloadTimeout = setTimeout(() => {
+      runtime.loadTools(ctx);
+      ctx.ui.notify("Recipe tools refreshed from ~/.pi/agent/recipes", "info");
+    }, 150);
+    recipeReloadTimeout.unref?.();
+  };
+  const watchRecipeRoot = (ctx: ExtensionContext): void => {
+    const recipeRoot = Paths.getRecipeRoot();
+    if (recipeRootWatcher || !existsSync(recipeRoot)) return;
+    try {
+      recipeRootWatcher = watch(recipeRoot, () => scheduleRecipeReload(ctx));
+      recipeRootWatcher.on("error", () => {
+        recipeRootWatcher?.close();
+        recipeRootWatcher = undefined;
+      });
+    } catch {
+      // Watching is best-effort; restarting the session reloads recipe tools.
+    }
+  };
   const actorToolDefinitions = new Map<string, any>();
   const runtime = Runtime.createAutoToolsRuntime({
     configPath: CONFIG_PATH,
     exec: CommandTemplates.execCommandTemplate,
+    getActiveTools: () => pi.getActiveTools(),
     getAllTools: () => pi.getAllTools(),
     registerTool: (definition) => {
       actorToolDefinitions.set(definition.name, definition);
       pi.registerTool(definition);
     },
     reservedToolNames: RESERVED_TOOL_NAMES,
+    setActiveTools: (toolNames) => pi.setActiveTools(toolNames),
   });
   pi.on("session_start", async (_event, ctx) => {
     await Temp.prepareExtensionTempDir(TEMP_DIR);
     runtime.loadTools(ctx);
     updateRunUi(ctx);
     closeRunWatchers();
+    closeRecipeWatcher();
     refreshRunWatchers(ctx);
+    watchRecipeRoot(ctx);
     if (runsAnimationInterval) clearInterval(runsAnimationInterval);
     runsAnimationInterval = setInterval(() => updateRunUi(ctx, false), 1000);
     runsAnimationInterval.unref?.();
@@ -172,6 +205,7 @@ export default function toolRegistryExtension(pi: ExtensionAPI) {
     if (runsAnimationInterval) clearInterval(runsAnimationInterval);
     runsAnimationInterval = undefined;
     closeRunWatchers();
+    closeRecipeWatcher();
   });
   pi.on("before_agent_start", async (event) => ({
     systemPrompt: `${event.systemPrompt}\n\n${Prompts.ONBOARDING_SYSTEM_PROMPT}`,

package/lib/actor-messages.ts

@@ -44,13 +44,15 @@ export function parseActorAddress(address: string): ActorAddress {
   const value = address.trim();
   if (value === "coordinator") return { kind: "coordinator" };
   const separator = value.indexOf(":");
-  if (separator < 0) throw new Error(`Actor address must include kind: ${address}`);
+  if (separator < 0)
+    throw new Error(`Actor address must include kind: ${address}`);
   const kind = value.slice(0, separator) as ActorAddressKind;
   const rest = value.slice(separator + 1);
   switch (kind) {
     case "branch": {
       const [run, branch, ...extra] = rest.split("/");
-      if (extra.length > 0) throw new Error(`Branch address has too many parts: ${address}`);
+      if (extra.length > 0)
+        throw new Error(`Branch address has too many parts: ${address}`);
       return {
         kind,
         value: assertToken(run || "", "branch run"),
@@ -74,14 +76,19 @@ export function formatActorAddress(address: ActorAddress): string {
   return `${address.kind}:${assertToken(address.value || "", `${address.kind} address`)}`;
 }
 
-function normalizeOptionalString(value: unknown, label: string): string | undefined {
+function normalizeOptionalString(
+  value: unknown,
+  label: string,
+): string | undefined {
   if (value === undefined || value === null) return undefined;
   if (typeof value !== "string") throw new Error(`${label} must be a string`);
   const normalized = value.trim();
   return normalized || undefined;
 }
 
-function normalizeMetadata(value: unknown): Record<string, unknown> | undefined {
+function normalizeMetadata(
+  value: unknown,
+): Record<string, unknown> | undefined {
   if (value === undefined || value === null) return undefined;
   if (typeof value !== "object" || Array.isArray(value)) {
     throw new Error("message metadata must be an object");
@@ -113,8 +120,14 @@ export function normalizeActorMessage(input: unknown): ActorMessage {
       ? { correlation_id: String(record.correlation_id) }
       : {}),
     ...(from ? { from: formatActorAddress(parseActorAddress(from)) } : {}),
-    ...(record.metadata !== undefined ? { metadata: normalizeMetadata(record.metadata) } : {}),
-    ...(record.reply_to !== undefined ? { reply_to: String(record.reply_to) } : {}),
-    ...(record.summary !== undefined ? { summary: String(record.summary) } : {}),
+    ...(record.metadata !== undefined
+      ? { metadata: normalizeMetadata(record.metadata) }
+      : {}),
+    ...(record.reply_to !== undefined
+      ? { reply_to: String(record.reply_to) }
+      : {}),
+    ...(record.summary !== undefined
+      ? { summary: String(record.summary) }
+      : {}),
   };
 }