@llblab/pi-actors 0.17.0 → 0.18.0

package/lib/recipe-discovery.ts

@@ -4,11 +4,13 @@
  * Owns filename identity discovery across prioritized recipe roots
  */
 
-import { existsSync, readdirSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { join } from "node:path";
 
 import type { RegisteredTool } from "./config.ts";
 import type { TemplateRecipeConfig } from "./recipe-references.ts";
+import * as CommandTemplates from "./command-templates.ts";
 import * as RecipeReferences from "./recipe-references.ts";
 import * as Schema from "./schema.ts";
 
@@ -28,6 +30,19 @@ export interface DiscoveredRecipe {
   shadows: string[];
 }
 
+export interface RecipeIntegrityManifestEntry {
+  id: string;
+  path: string;
+  root: string;
+  sha256: string;
+  size: number;
+  tool: boolean;
+  active: boolean;
+  invalid: boolean;
+  disabled: boolean;
+  shadowed: boolean;
+}
+
 export interface RecipeDiscoveryResult {
   active: Map<string, DiscoveredRecipe>;
   entries: DiscoveredRecipe[];
@@ -80,6 +95,16 @@ function listRecipeFiles(root: string): string[] {
     .sort();
 }
 
+function getRecipeConfigDiagnostics(
+  file: string,
+  config: TemplateRecipeConfig | undefined,
+): string[] {
+  if (!config) return [`Invalid recipe: ${file}`];
+  return CommandTemplates.getCommandTemplateWarnings(
+    typeof config.template === "string" ? config.template : { template: config.template },
+  ).map((warning) => `Recipe ${file}: ${warning}`);
+}
+
 function readDiscoveredRecipe(
   root: string,
   file: string,
@@ -102,9 +127,9 @@ function readDiscoveredRecipe(
       shadowed: false,
       invalid,
       disabled,
-      tool: (config?.tool ?? defaultTool) === true && !disabled && !invalid,
+      tool: defaultTool && !disabled && !invalid,
       mutableUsage,
-      diagnostics: invalid ? [`Invalid recipe: ${file}`] : [],
+      diagnostics: getRecipeConfigDiagnostics(file, config),
       shadows: [],
     };
   } catch (error) {
@@ -144,6 +169,36 @@ function filesForSource(
     : [];
 }
 
+function getRecipeRootDiagnostics(sources: RecipeDiscoverySource[]): string[] {
+  const diagnostics: string[] = [];
+  const roots = new Set(
+    sources
+      .map((source) => source.root)
+      .filter((root): root is string => typeof root === "string"),
+  );
+  for (const root of roots) {
+    try {
+      if (!existsSync(root)) continue;
+      const stat = statSync(root);
+      if ((stat.mode & 0o002) !== 0) {
+        diagnostics.push(
+          `Recipe root is world-writable; review permissions: ${root}`,
+        );
+      }
+      if ((stat.mode & 0o020) !== 0) {
+        diagnostics.push(
+          `Recipe root is group-writable; review ownership and permissions: ${root}`,
+        );
+      }
+    } catch (error) {
+      diagnostics.push(
+        `Failed to inspect recipe root ${root}: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+  return diagnostics;
+}
+
 export function discoverRecipeSources(
   sources: RecipeDiscoverySource[],
 ): RecipeDiscoveryResult {
@@ -160,7 +215,7 @@ export function discoverRecipeSources(
   }
 
   const active = new Map<string, DiscoveredRecipe>();
-  const diagnostics: string[] = [];
+  const diagnostics: string[] = getRecipeRootDiagnostics(sources);
   for (const [id, bucket] of byId) {
     bucket.sort(
       (a, b) => a.priority - b.priority || a.path.localeCompare(b.path),
@@ -231,7 +286,7 @@ function cleanupRecommendation(entry: DiscoveredRecipe): Record<string, unknown>
       id: entry.id,
       path: entry.path,
       reason: "active user tool has no recorded launches",
-      actions: ["keep as tool", "set tool false", "delete", "archive"],
+      actions: ["keep as tool", "move out of tool root", "delete", "archive"],
     };
   }
   if (entry.mutableUsage && !entry.tool) {
@@ -239,7 +294,7 @@ function cleanupRecommendation(entry: DiscoveredRecipe): Record<string, unknown>
       id: entry.id,
       path: entry.path,
       reason: "user recipe is a component, not an active tool",
-      actions: ["keep component", "enable tool", "merge", "delete", "archive"],
+      actions: ["keep component", "move into tool root", "merge", "delete", "archive"],
     };
   }
   if (entry.shadows.length > 0) {
@@ -253,6 +308,30 @@ function cleanupRecommendation(entry: DiscoveredRecipe): Record<string, unknown>
   return undefined;
 }
 
+export function createRecipeIntegrityManifest(
+  result: RecipeDiscoveryResult,
+): RecipeIntegrityManifestEntry[] {
+  return result.entries
+    .map((entry) => {
+      const bytes = readFileSync(entry.path);
+      return {
+        active: entry.active,
+        disabled: entry.disabled,
+        id: entry.id,
+        invalid: entry.invalid,
+        path: entry.path,
+        root: entry.root,
+        sha256: createHash("sha256").update(bytes).digest("hex"),
+        shadowed: entry.shadowed,
+        size: bytes.byteLength,
+        tool: entry.tool,
+      };
+    })
+    .sort(
+      (a, b) => a.id.localeCompare(b.id) || a.path.localeCompare(b.path),
+    );
+}
+
 function recommendationForEntry(
   entry: DiscoveredRecipe,
   activePath: string | undefined,
@@ -298,6 +377,7 @@ export function summarizeDiscovery(result: RecipeDiscoveryResult): Record<string
       .sort((a, b) => a.id.localeCompare(b.id)),
     recommendations,
     diagnostics: result.diagnostics,
+    integrity_manifest: createRecipeIntegrityManifest(result),
   };
 }
 

package/lib/recipe-migration.ts

@@ -35,9 +35,7 @@ function recipePathForTool(recipeRoot: string, name: string): string {
 
 function toRecipeConfig(tool: Config.RegisteredTool): TemplateRecipeConfig {
   return {
-    name: tool.name,
     description: tool.description,
-    tool: true,
     ...(tool.recipe?.async !== undefined ? { async: tool.recipe.async } : {}),
     ...(tool.recipe?.state_dir ? { state_dir: tool.recipe.state_dir } : {}),
     ...(tool.storedArgs ? { args: tool.storedArgs } : {}),

package/lib/recipe-references.ts

@@ -4,7 +4,7 @@
  * Owns detection, loading, and recipe-layer expansion for template recipe files
  */
 
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, dirname, resolve } from "node:path";
 
@@ -15,6 +15,9 @@ import type {
 import * as CommandTemplates from "./command-templates.ts";
 import * as Paths from "./paths.ts";
 
+const MAX_RECIPE_FILE_BYTES = 1024 * 1024;
+const MAX_RECIPE_IMPORT_DEPTH = 32;
+
 export interface TemplateRecipeImportBinding {
   from?: string;
   defaults?: Record<string, unknown>;
@@ -31,7 +34,6 @@ export interface TemplateRecipeMailbox {
 export interface TemplateRecipeDefinition {
   name?: string;
   description?: string;
-  tool?: boolean;
   disabled?: boolean;
   imports?: Record<string, TemplateRecipeImport>;
   template: CommandTemplateValue;
@@ -45,6 +47,7 @@ export interface TemplateRecipeDefinition {
   output?: string;
   artifacts?: Record<string, string>;
   mailbox?: TemplateRecipeMailbox;
+  retire_when?: "children_terminal";
   retry?: number | string;
   failure?: CommandTemplates.CommandTemplateFailureScope;
   recover?: CommandTemplateValue;
@@ -88,6 +91,28 @@ export function resolveRecipePath(
   );
 }
 
+function isBareRecipeName(value: string): boolean {
+  const trimmed = value.trim();
+  return Boolean(trimmed) && !trimmed.includes("/") && !trimmed.startsWith("~") && !trimmed.includes("{");
+}
+
+function recipeNameFile(value: string): string {
+  const trimmed = value.trim();
+  return trimmed.endsWith(".json") ? trimmed : `${trimmed}.json`;
+}
+
+function resolveRecipeImportPath(value: string, currentRecipeRoot: string): string {
+  if (!isBareRecipeName(value)) return resolveRecipePath(value, currentRecipeRoot);
+  const file = recipeNameFile(value);
+  const roots = [
+    Paths.getRecipeRoot(),
+    currentRecipeRoot,
+    Paths.getPackagedRecipeRoot(),
+  ];
+  const candidates = [...new Set(roots.map((root) => resolve(root, file)))];
+  return candidates.find((candidate) => existsSync(candidate)) ?? candidates[0];
+}
+
 export function getRecipePath(
   value: unknown,
   recipeRoot = Paths.getRecipeRoot(),
@@ -197,6 +222,12 @@ function readRawRecipeConfig(
   path: string,
 ): Record<string, unknown> | undefined {
   if (!existsSync(path)) return undefined;
+  const size = statSync(path).size;
+  if (size > MAX_RECIPE_FILE_BYTES) {
+    throw new Error(
+      `Recipe file exceeds size limit ${MAX_RECIPE_FILE_BYTES} bytes: ${path}`,
+    );
+  }
   try {
     const raw = JSON.parse(readFileSync(path, "utf8")) as Record<
       string,
@@ -471,11 +502,16 @@ export function readResolvedRecipeConfig(
   if (stack.includes(path)) {
     throw new Error(`Cyclic recipe import: ${[...stack, path].join(" -> ")}`);
   }
+  if (stack.length >= MAX_RECIPE_IMPORT_DEPTH) {
+    throw new Error(
+      `Recipe import depth exceeds limit ${MAX_RECIPE_IMPORT_DEPTH}: ${[...stack, path].join(" -> ")}`,
+    );
+  }
   const raw = readRawRecipeConfig(path);
   if (!raw || !Object.hasOwn(raw, "template")) return undefined;
   const imports: Record<string, ImportedRecipe> = {};
   for (const [alias, binding] of Object.entries(getRecipeImports(raw))) {
-    const importPath = resolveRecipePath(getImportFrom(binding), dirname(path));
+    const importPath = resolveRecipeImportPath(getImportFrom(binding), dirname(path));
     const config = readResolvedRecipeConfig(importPath, [...stack, path]);
     if (!config) throw new Error(`Recipe import not found: ${alias}`);
     const bindingDefaults =
@@ -499,17 +535,11 @@ export function readResolvedRecipeConfig(
   if (!template) return undefined;
   const expandedTemplate = expandImportNodes(template, imports);
   return {
-    name:
-      typeof substituted.name === "string"
-        ? substituted.name
-        : getRecipeIdFromPath(path),
+    name: getRecipeIdFromPath(path),
     ...(typeof substituted.description === "string" &&
     substituted.description.trim()
       ? { description: substituted.description.trim() }
       : {}),
-    ...(typeof substituted.tool === "boolean"
-      ? { tool: substituted.tool }
-      : {}),
     ...(typeof substituted.disabled === "boolean"
       ? { disabled: substituted.disabled }
       : {}),
@@ -582,6 +612,9 @@ export function readResolvedRecipeConfig(
           },
         }
       : {}),
+    ...(substituted.retire_when === "children_terminal"
+      ? { retire_when: "children_terminal" as const }
+      : {}),
     ...(typeof substituted.retry === "number" ||
     typeof substituted.retry === "string"
       ? { retry: substituted.retry }

package/lib/temp.ts

@@ -4,10 +4,11 @@
  * Owns pi-agent tmp directory preparation and stale-entry cleanup
  */
 
-import { mkdir, readdir, rm, stat } from "node:fs/promises";
+import { mkdir, readdir, readFile, rm, stat } from "node:fs/promises";
 import { join } from "node:path";
 
 export const DEFAULT_TEMP_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+export const DEFAULT_RUN_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
 
 export async function cleanupStaleTempEntries(
   tempDir: string,
@@ -37,10 +38,62 @@ export async function cleanupStaleTempEntries(
   return removed;
 }
 
+function isPidAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function isRunEntryAlive(path: string): Promise<boolean> {
+  try {
+    const raw = await readFile(join(path, "run.json"), "utf8");
+    const meta = JSON.parse(raw) as Record<string, unknown>;
+    const pid = Number(meta.pid || 0);
+    return pid > 0 && isPidAlive(pid);
+  } catch {
+    return false;
+  }
+}
+
+export async function cleanupStaleRunEntries(
+  runsDir: string,
+  maxAgeMs = DEFAULT_RUN_MAX_AGE_MS,
+  now = Date.now(),
+): Promise<number> {
+  let entries: Array<{ name: string; isDirectory(): boolean }>;
+  let removed = 0;
+  try {
+    entries = await readdir(runsDir, { withFileTypes: true });
+  } catch {
+    return 0;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const path = join(runsDir, entry.name);
+    try {
+      const info = await stat(path);
+      const timestamp = Math.min(info.birthtimeMs || info.mtimeMs, info.mtimeMs);
+      if (now - timestamp <= maxAgeMs) continue;
+      if (await isRunEntryAlive(path)) continue;
+      await rm(path, { force: true, recursive: true });
+      removed += 1;
+    } catch {
+      // Ignore temp cleanup races.
+    }
+  }
+  return removed;
+}
+
 export async function prepareExtensionTempDir(
   tempDir: string,
   maxAgeMs = DEFAULT_TEMP_MAX_AGE_MS,
+  runMaxAgeMs = DEFAULT_RUN_MAX_AGE_MS,
 ): Promise<number> {
   await mkdir(tempDir, { recursive: true });
-  return cleanupStaleTempEntries(tempDir, maxAgeMs);
+  const removedTemp = await cleanupStaleTempEntries(tempDir, maxAgeMs);
+  const removedRuns = await cleanupStaleRunEntries(join(tempDir, "runs"), runMaxAgeMs);
+  return removedTemp + removedRuns;
 }

package/lib/tools.ts

@@ -164,6 +164,7 @@ function compactAsyncRunStatus(value: unknown): string {
   ];
   if (status.tool) tokens.push(`tool=${String(status.tool)}`);
   if (status.recipe) tokens.push(`recipe=${String(status.recipe)}`);
+  if (status.retire_when) tokens.push(`retire_when=${String(status.retire_when)}`);
   if (Number(status.pid) > 0) tokens.push(`pid=${Number(status.pid)}`);
   if (progress.phase && progress.phase !== status.status)
     tokens.push(`phase=${String(progress.phase)}`);
@@ -286,6 +287,25 @@ function compactCommunicationSnapshot(
   return `\nself=${snapshot.self} root=${snapshot.root} rooms=${snapshot.rooms.length} updated_at=${snapshot.updated_at}`;
 }
 
+function compactBranchInbox(messages: Array<Record<string, unknown>>): string {
+  if (messages.length === 0) return "\n(no branch inbox 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.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")}`;
+}
+
 function compactActorFiles(status: Record<string, unknown>): string {
   const run = String(status.run ?? "<unknown>");
   const artifacts = asRecord(status.artifacts);
@@ -311,10 +331,15 @@ function compactSessionRuns(
 ): string {
   if (runs.length === 0) return `\nsession=${session} runs=0`;
   return `\nsession=${session} runs=${runs.length}\n${runs
-    .map(
-      (run) =>
-        `run=${String(run.run ?? "")} status=${String(run.status ?? "")}${run.recipe ? ` recipe=${String(run.recipe)}` : ""}`,
-    )
+    .map((run) => {
+      const tokens = [
+        `run=${String(run.run ?? "")}`,
+        `status=${String(run.status ?? "")}`,
+      ];
+      if (run.recipe) tokens.push(`recipe=${String(run.recipe)}`);
+      if (run.retire_when) tokens.push(`retire_when=${String(run.retire_when)}`);
+      return tokens.join(" ");
+    })
     .join("\n")}`;
 }
 
@@ -474,6 +499,29 @@ function assertMessageSenderBelongsToRun(
   }
 }
 
+function getRoomMulticastRecipients(
+  message: ActorMessages.ActorMessage,
+  run: string,
+): string[] {
+  const raw = message.metadata?.recipients;
+  if (raw === undefined) return [];
+  if (!Array.isArray(raw)) {
+    throw new Error("room multicast metadata.recipients must be an array.");
+  }
+  return raw.map((recipient) => {
+    if (typeof recipient !== "string") {
+      throw new Error("room multicast recipients must be actor addresses.");
+    }
+    const parsed = ActorMessages.parseActorAddress(recipient);
+    if (parsed.kind !== "branch" || parsed.value !== run) {
+      throw new Error(
+        `room multicast recipient must be branch:${run}/<branch>; got ${recipient}.`,
+      );
+    }
+    return ActorMessages.formatActorAddress(parsed);
+  });
+}
+
 export function createSpawnToolDefinition<
   TContext extends AsyncRunToolContext,
 >(): any {
@@ -534,7 +582,9 @@ export function createSpawnToolDefinition<
           run_id: runId,
           state_dir:
             typeof input.state_dir === "string" ? input.state_dir : undefined,
-          template: input.template as AsyncRuns.AsyncRunStartParams["template"],
+          ...(input.template !== undefined
+            ? { template: input.template as AsyncRuns.AsyncRunStartParams["template"] }
+            : {}),
           values: asRecord(input.values),
           ...(input.artifacts &&
           typeof input.artifacts === "object" &&
@@ -840,11 +890,34 @@ export function createInspectToolDefinition<TContext = unknown>(
         }
         throw new Error("inspect room:<run> supports view=status, view=messages, view=previews, view=roster, or view=contacts.");
       }
-      const runId = address.kind === "run" ? address.value : undefined;
+      const runId = address.kind === "run" || address.kind === "branch" ? address.value : undefined;
       if (!runId)
         throw new Error(
-          "inspect target must be run:<id>, coordinator, session:<id>, or tool:<name>.",
+          "inspect target must be run:<id>, branch:<run>/<branch>, coordinator, session:<id>, or tool:<name>.",
         );
+      if (address.kind === "branch") {
+        if (view !== "mailbox") throw new Error("inspect branch:<run>/<branch> supports view=mailbox.");
+        const status = assertRunAccessibleToContext(runId, ctx);
+        const messages = ActorRooms.readBranchInboxMessages(
+          String(status.state_dir ?? ""),
+          runId,
+          target,
+          Number(input.lines || 40),
+        );
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: maybeJsonText(
+                messages,
+                input.verbose === true,
+                compactBranchInbox(messages.map((message) => ({ ...message }))),
+              ),
+            },
+          ],
+          details: { messages },
+        };
+      }
       switch (view) {
         case "status": {
           const status = assertRunAccessibleToContext(runId, ctx);
@@ -945,7 +1018,7 @@ export function createInspectToolDefinition<TContext = unknown>(
         }
         default:
           throw new Error(
-            "inspect view must be one of: status, tail, messages, artifacts, files, mailbox, communication.",
+            "inspect view must be one of: status, tail, messages, artifacts, files, mailbox, communication; branch targets support mailbox.",
           );
       }
     },
@@ -1055,17 +1128,32 @@ export function createActorMessageToolDefinition<TContext = unknown>(
             }
           }
           ActorRooms.writeCommunicationSnapshot(stateDir, runId);
+          ActorRooms.appendBranchInboxMessage(stateDir, runId, message.to, message);
         }
         result = AsyncRuns.sendRunMessage(
           address.value,
           JSON.stringify(message),
         );
       } else if (address.kind === "room" && address.value && address.room) {
-        assertMessageSenderBelongsToRun(message, address.value, `room:${address.value}`);
-        const status = assertRunExistsForActorMessage(address.value);
+        const runId = address.value;
+        assertMessageSenderBelongsToRun(message, runId, `room:${runId}`);
+        const status = assertRunExistsForActorMessage(runId);
         const stateDir = String(status.state_dir ?? "");
         if (!stateDir) throw new Error(`${message.to} has no run state directory.`);
-        result = { ...ActorRooms.appendRoomMessage(stateDir, address.room, message) };
+        const recipients = getRoomMulticastRecipients(message, runId);
+        const roomResult = ActorRooms.appendRoomMessage(stateDir, address.room, message);
+        const multicast = recipients.map((recipient) =>
+          AsyncRuns.sendRunMessage(
+            runId,
+            JSON.stringify({ ...message, to: recipient }),
+          ),
+        );
+        result = {
+          ...roomResult,
+          ...(multicast.length > 0
+            ? { multicast: recipients, multicast_count: multicast.length }
+            : {}),
+        };
       } else if (address.kind === "tool" && address.value) {
         const tool = deps.getTool?.(address.value);
         if (!tool || typeof tool.execute !== "function") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-actors",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "private": false,
   "description": "Actor runtime and orchestrator for agent-managed local processes",
   "keywords": [

package/recipes/coordinator-locker.json

@@ -1,5 +1,4 @@
 {
-  "name": "coordinator-locker",
   "async": true,
   "args": [
     "repo:path",

package/recipes/lens-swarm.json

@@ -1,5 +1,4 @@
 {
-  "name": "lens-swarm",
   "description": "General-purpose multi-lens review swarm. Launches independent reviewers by lens, then verifies, merges, judges, and normalizes the result.",
   "async": true,
   "imports": {

package/recipes/music-player.json

@@ -1,5 +1,4 @@
 {
-  "name": "music-player",
   "async": true,
   "args": [
     "repo:path",

package/recipes/pipeline-architect-coordinator.json

@@ -1,5 +1,4 @@
 {
-  "name": "pipeline-architect-coordinator",
   "async": true,
   "imports": {
     "reviewer": "subagent-review.json",

package/recipes/pipeline-artifact-bundle.json

@@ -1,5 +1,4 @@
 {
-  "name": "pipeline-artifact-bundle",
   "async": true,
   "imports": {
     "artifactWrite": "pipeline-artifact-write.json",

package/recipes/pipeline-artifact-report.json

@@ -1,5 +1,4 @@
 {
-  "name": "pipeline-artifact-report",
   "async": true,
   "imports": {
     "normalizer": "subagent-normalize.json",

package/recipes/pipeline-artifact-write.json

@@ -1,5 +1,4 @@
 {
-  "name": "pipeline-artifact-write",
   "async": true,
   "imports": {
     "normalizer": "subagent-normalize.json",

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

@@ -1,5 +1,4 @@
 {
-  "name": "pipeline-async-run-ops",
   "async": true,
   "imports": {
     "snapshot": "utility-run-ops-snapshot.json",

package/recipes/pipeline-checkpoint-continuation.json

@@ -1,5 +1,4 @@
 {
-  "name": "pipeline-checkpoint-continuation",
   "async": true,
   "imports": {
     "checkpoint": "subagent-checkpoint.json",

package/recipes/pipeline-development-tasking.json

@@ -1,5 +1,4 @@
 {
-  "name": "pipeline-development-tasking",
   "async": true,
   "imports": {
     "planner": "subagent-plan.json",

package/recipes/pipeline-docs-maintenance.json

@@ -1,5 +1,4 @@
 {
-  "name": "pipeline-docs-maintenance",
   "async": true,
   "imports": {
     "docs_index": "utility-markdown-index.json",

package/recipes/pipeline-media-library.json

@@ -1,5 +1,4 @@
 {
-  "name": "pipeline-media-library",
   "async": true,
   "imports": {
     "playlist": "utility-playlist-build.json",

package/recipes/pipeline-quorum-review.json

@@ -1,5 +1,4 @@
 {
-  "name": "pipeline-quorum-review",
   "async": true,
   "imports": {
     "quorum": "subagent-quorum.json",

package/recipes/pipeline-release-readiness.json

@@ -1,5 +1,4 @@
 {
-  "name": "pipeline-release-readiness",
   "async": true,
   "imports": {
     "changelog": "utility-changelog-section.json",

package/recipes/pipeline-release-summary.json

@@ -1,5 +1,4 @@
 {
-  "name": "pipeline-release-summary",
   "async": true,
   "imports": {
     "changelog": "utility-changelog-section.json",

package/recipes/pipeline-repo-health.json

@@ -1,5 +1,4 @@
 {
-  "name": "pipeline-repo-health",
   "async": true,
   "imports": {
     "git_status": "utility-git-status.json",

package/recipes/pipeline-research-synthesis.json

@@ -1,5 +1,4 @@
 {
-  "name": "pipeline-research-synthesis",
   "async": true,
   "imports": {
     "planner": "subagent-plan.json",