@llblab/pi-actors 0.45.1 → 0.46.0

package/dist/{recipes/pipeline-quorum-review.json → skills/swarm/recipes/quorum-review.json}

@@ -1,10 +1,10 @@
 {
   "async": true,
   "imports": {
-    "subagent": "subagent-prompt.json",
-    "merger": "subagent-merge.json",
-    "judge": "subagent-judge.json",
-    "normalizer": "subagent-normalize.json"
+    "subagent": "swarm/subagent-prompt",
+    "merger": "swarm/subagent-merge",
+    "judge": "swarm/subagent-judge",
+    "normalizer": "swarm/subagent-normalize"
   },
   "args": [
     "prompt:string",

package/{recipes/pipeline-research-synthesis.json → dist/skills/swarm/recipes/research-synthesis.json}

@@ -1,12 +1,12 @@
 {
   "async": true,
   "imports": {
-    "planner": "subagent-plan.json",
-    "evidence": "subagent-evidence-map.json",
-    "contradictions": "subagent-contradiction-map.json",
-    "verifier": "subagent-verify.json",
-    "merger": "subagent-merge.json",
-    "normalizer": "subagent-normalize.json"
+    "planner": "swarm/subagent-plan",
+    "evidence": "swarm/subagent-evidence-map",
+    "contradictions": "swarm/subagent-contradiction-map",
+    "verifier": "swarm/subagent-verify",
+    "merger": "swarm/subagent-merge",
+    "normalizer": "swarm/subagent-normalize"
   },
   "args": [
     "question:string",

package/{recipes/pipeline-review-readiness.json → dist/skills/swarm/recipes/review-readiness.json}

@@ -1,7 +1,7 @@
 {
   "async": true,
   "imports": {
-    "coordinator": "subagent-review-coordinator.json"
+    "coordinator": "swarm/subagent-review-coordinator"
   },
   "args": [
     "scope:string",

package/{recipes/subagents-prompts.json → dist/skills/swarm/recipes/subagent-prompts.json}

@@ -1,7 +1,7 @@
 {
   "async": true,
   "imports": {
-    "subagent": "subagent-prompt.json"
+    "subagent": "swarm/subagent-prompt"
   },
   "args": [
     "prompts:array",

package/{recipes → dist/skills/swarm/recipes}/subagent-quorum.json

@@ -1,7 +1,7 @@
 {
   "async": true,
   "imports": {
-    "subagent": "subagent-prompt.json"
+    "subagent": "swarm/subagent-prompt"
   },
   "args": [
     "prompt:string",

package/dist/{recipes → skills/swarm/recipes}/subagent-review-coordinator.json

@@ -1,12 +1,12 @@
 {
   "async": true,
   "imports": {
-    "preflight": "subagent-preflight.json",
-    "reviewer": "subagent-review.json",
-    "verifier": "subagent-verify.json",
-    "merger": "subagent-merge.json",
-    "judge": "subagent-judge.json",
-    "normalizer": "subagent-normalize.json"
+    "preflight": "swarm/subagent-preflight",
+    "reviewer": "swarm/subagent-review",
+    "verifier": "swarm/subagent-verify",
+    "merger": "swarm/subagent-merge",
+    "judge": "swarm/subagent-judge",
+    "normalizer": "swarm/subagent-normalize"
   },
   "args": [
     "scope:string",

package/docs/actor-inspector.md

@@ -12,13 +12,14 @@ The Inspector follows the kernel directly. It shows Runs owned by the current Pi
 
 Shows captured execution provenance:
 
-- Recipe name and source path;
+- file-derived Recipe stem and logical reference;
+- source kind (`user_registry_capability`, `active_skill_component`, or `explicit_file_recipe`) and Skill identity when owned;
 - resolved template and values;
-- imports/context records;
+- root/import roles plus alias ancestry;
 - declared artifacts and actor-local actions;
 - model/thinking policy and launch source.
 
-Captured Recipe evidence belongs to the Run generation and does not change when an active Recipe file later changes. Non-empty object values render as indented brace-delimited property lists rather than flattened inline strings.
+Captured Recipe evidence belongs to the Run generation and does not change when an active Recipe file later changes. Skill components display logical identities such as `artifacts/report`; private physical `source_file`, `skill_dir`, and `recipe_dir` stay out of Inspector and model-facing views. Non-empty object values render as indented brace-delimited property lists rather than flattened inline strings.
 
 ## Trace
 

package/docs/async-runs.md

@@ -123,8 +123,8 @@ Archive and prune apply only to terminal Runs and enforce path containment. Rete
 
 Packaged controlled services demonstrate the endpoint protocol:
 
-- `music-player` consumes playback Controls and emits playback Trace;
-- `resource-locker` consumes queue/lease actions, emits lock Trace, and atomically retains at most 512 valid journal records within 1 MiB.
+- `media/player` consumes playback Controls and emits playback Trace;
+- `actors/resource-locker` consumes queue/lease actions, emits lock Trace, and atomically retains at most 512 valid journal records within 1 MiB.
 
 Shared archive/prune evidence similarly retains at most 256 valid records within 1 MiB under its canonical lock. The obsolete advisory `wake.jsonl` notifier was removed; filesystem watchers and bounded reconciliation observe authoritative state directly.
 

package/docs/recipe-library.md

@@ -1,43 +1,43 @@
-# Packaged Recipe Library
+# Skill-Owned Recipe Components
 
-Packaged Recipes provide maintained execution graphs and service definitions. User Recipes with the same name shadow packaged definitions; invalid shadowing fails closed.
+Active Skills provide maintained execution graphs and service definitions. Skill Recipe identity is `<active Skill name>/<Recipe filename stem>`. Recipe files have no top-level `name`; `SKILL.md` `name` remains Pi host metadata matching the Skill directory, and pi-actors introduces no additional Skill identity field. Skill components are outside user Recipe discovery and never become tools merely because a Skill is active.
 
 ## Recommended Entry Points
 
 ### Repository and delivery
 
-- `pipeline-repo-health.json` — repository inspection and bounded health artifact.
-- `pipeline-docs-maintenance.json` — documentation analysis and artifact preparation.
-- `pipeline-release-readiness.json` — release checks and readiness artifact.
-- `pipeline-release-summary.json` — release-summary artifact.
-- `pipeline-development-tasking.json` — task-card and implementation planning pipeline.
+- `project-work/repo-health` — repository inspection and bounded health artifact.
+- `project-work/docs-maintenance` — documentation analysis and artifact preparation.
+- `project-work/release-readiness` — release checks and readiness artifact.
+- `project-work/release-summary` — release-summary artifact.
+- `swarm/development-tasking` — task-card and implementation planning pipeline.
 
 ### Review and synthesis
 
-- `pipeline-quorum-review.json` — parallel reviewers with quorum-oriented synthesis.
-- `pipeline-review-readiness.json` — review plus readiness stages.
-- `pipeline-research-synthesis.json` — evidence-oriented research synthesis.
-- `lens-swarm.json` — configurable repeated review lenses.
-- `subagent-review-coordinator.json` — lower-level review/verify/merge/judge composition.
+- `swarm/quorum-review` — parallel reviewers with quorum-oriented synthesis.
+- `swarm/review-readiness` — review plus readiness stages.
+- `swarm/research-synthesis` — evidence-oriented research synthesis.
+- `swarm/lens-review` — configurable repeated review lenses.
+- `swarm/subagent-review-coordinator` — lower-level review/verify/merge/judge composition.
 
 Callers should own model, thinking, concurrency, quorum, and mission policy. Review pipelines preflight provider/model availability before expensive fanout.
 
 ### Artifacts
 
-- `pipeline-artifact-report.json` — prepare one artifact body.
-- `pipeline-artifact-write.json` — prepare and deterministically write an artifact.
-- `pipeline-artifact-bundle.json` — optional validation, artifact write, manifest generation, and manifest write.
-- `utility-artifact-write.json` — deterministic create/overwrite/append helper.
-- `utility-artifact-manifest.json` — artifact manifest generation.
+- `artifacts/report` — prepare one artifact body.
+- `artifacts/write` — prepare and deterministically write an artifact.
+- `artifacts/bundle` — optional validation, artifact write, manifest generation, and manifest write.
+- `artifacts/file-write` — deterministic create/overwrite/append helper.
+- `artifacts/manifest` — artifact manifest generation.
 
 Artifact pipelines terminate in files/manifests and result evidence; they do not fabricate communication events.
 
 ### Controlled services
 
-- `music-player.json` — playback service with declared playback actions, `controls.jsonl`, generation-fenced endpoint readiness, state artifact, and playback Trace. Player selection is `player:enum(auto,mpv,afplay,ffplay,cvlc,play,wmp)=auto`.
-- `resource-locker.json` — optional queue/lease-lock service with explicit owner/resource input, lock Trace, and a 512-record/1 MiB atomically retained journal.
+- `media/player` — playback service with declared playback actions, `controls.jsonl`, generation-fenced endpoint readiness, state artifact, and playback Trace. Player selection is `player:enum(auto,mpv,afplay,ffplay,cvlc,play,wmp)=auto`.
+- `actors/resource-locker` — optional queue/lease-lock service with explicit owner/resource input, lock Trace, and a 512-record/1 MiB atomically retained journal.
 
-These are the packaged Recipes that declare actor-local Control. Ordinary one-shot Recipes omit it. Helper-backed packaged Recipes self-locate their installed package root when `repo` is omitted; an explicit caller value still wins for development or custom layouts.
+These Recipes declare actor-local Control. Ordinary one-shot Recipes omit it. Helper-backed Skill Recipes self-locate through runtime-owned `{skill_dir}`; callers do not pass package installation roots.
 
 ## Component Recipes
 
@@ -45,7 +45,7 @@ Subagent components provide reusable command-template cells for normalization, p
 
 Imports compose these definitions inside one parent Run. They are not independently addressable peers. Parent template flags control sequencing, parallelism, retries, failure scope, recovery, and repeated execution.
 
-Packaged components can be selected exactly as `std:<recipe-name>`. Recipes bundled under a Pi-active Skill are selected as `skill:<skill-name>/<recipe-path>` and receive runtime-owned `{skill_dir}` plus `{recipe_dir}`. Active Skill components are namespaced library entries, never automatic tools; expose one intentionally through a user Recipe wrapper when a direct tool is desired.
+Recipes bundled under a Pi-active Skill are selected as `<skill-name>/<recipe-stem>` and receive runtime-owned `{skill_dir}` plus `{recipe_dir}`. Explicit `.json` / `.md` paths select exact files: entry paths are based at invocation `cwd`, while relative imports are based at the importing Recipe's directory. Active Skill components are library entries, never automatic tools; expose one intentionally through a user Recipe wrapper when a direct tool is desired.
 
 ## Utility Recipes
 
@@ -70,7 +70,7 @@ Use utilities as imported cells or registered tools where their contract fits.
 
 ## Installation Safety
 
-Do not bulk-copy `recipes/*.json` into the user Recipe root. Internal `draft-review.json` and `tool-review.json` support fenced automatic review and must not become user-installed callable tools. Register or wrap only the specific public capability you intend to use.
+Do not bulk-copy bundled Recipes into the user Recipe root. Internal `recipe-memory/draft-review` and `recipe-memory/tool-review` components support fenced automatic review and must not become user-installed callable tools. Register or wrap only the specific public capability you intend to use.
 
 ## Validation
 
@@ -78,7 +78,7 @@ Do not bulk-copy `recipes/*.json` into the user Recipe root. Internal `draft-rev
 npm run recipes:qa
 ```
 
-Recipe QA validates syntax, imports, Control declarations, artifact paths, helper references, and platform documentation. Recipe descriptions are optional because discovery supplies stable fallback tool copy; internal component Recipes do not need boilerplate. The packaged baseline requires zero diagnostics and zero warnings, and any future warning is release-blocking with its concrete file and repair. Removed mailbox declarations fail with the migration diagnostic rather than receiving automatic conversion.
+Recipe QA recursively inventories direct Skill components and validates filesystem identity, syntax, imports, Control declarations, origin ownership, portable artifact paths, and `{skill_dir}` helper references. Nested files and JSON/Markdown stem collisions fail precisely. Recipe descriptions remain optional; QA requires zero capability diagnostics and zero warnings without enforcing style, documentation quotas, or architecture policy. Removed mailbox declarations fail with the migration diagnostic rather than receiving automatic conversion.
 
 ## Related
 

package/docs/releasing.md

@@ -1,6 +1,6 @@
 # Release Operations
 
-Stable releases use one immutable tag workflow. The workflow runs the complete reusable Ubuntu, macOS, Windows, and dependency-audit boundary before any publication, publishes and verifies the exact npm package through Trusted Publisher, then creates or converges the GitHub Release from the matching changelog section.
+Stable releases use one immutable tag workflow. The workflow runs normal product validation on Ubuntu, macOS, and Windows plus the dependency audit before any publication, publishes and verifies the exact npm package through Trusted Publisher, then creates or converges the GitHub Release from the matching changelog section. Architecture review uses the project-local Domain DAG Skill during architecture-affecting development; release automation does not run policy, line-count, source-style, or Domain DAG gates.
 
 ## One-time npm Trusted Publisher setup
 
@@ -19,7 +19,7 @@ Do not create `NPM_TOKEN`, `NODE_AUTH_TOKEN`, or another long-lived npm publish
 
 1. Merge the validated release tree through the repository's guarded `dev` to `main` flow.
 2. Create one immutable `v<package.version>` tag on the verified `main` commit.
-3. Let `.github/workflows/release.yml` invoke the complete reusable validation workflow.
+3. Let `.github/workflows/release.yml` invoke the reusable `npm run validate` and dependency-audit workflow.
 4. Let the publication job verify the tag commit, package manifests, and non-empty changelog section.
 5. Publish the exact public npm package through OIDC when the version does not exist.
 6. Verify npm version, `gitHead`, Pi extension/skill metadata, and packed runtime manifests.

package/docs/template-recipes.md

@@ -10,7 +10,7 @@ A Recipe stores a reusable command-template definition as JSON or Markdown.
   "description": "Create a repository health artifact",
   "args": ["repo:path", "artifact_path:path", "model:string"],
   "defaults": { "artifact_path": "{state_dir}/health.md" },
-  "imports": { "review": "subagent-review.json" },
+  "imports": { "review": "swarm/quorum-review" },
   "artifacts": { "report": "{artifact_path}" },
   "template": {
     "name": "review",
@@ -39,11 +39,13 @@ summarize {file}
 
 Fences marked `template`, `command-template`, `json`, or `recipe` can define execution. Frontmatter supports Recipe metadata and command-template flags.
 
+Skill Recipe identity is `<active Skill name>/<Recipe filename stem>`. Recipe files have no top-level `name`; both JSON and Markdown fail with migration guidance when that removed field is present. `SKILL.md` `name` remains Pi host metadata and matches the Skill directory; pi-actors introduces no additional Skill identity field. The `name` field on a command-template node still selects an imported alias and is not Recipe self-identity.
+
 ## Fields
 
 Common Recipe fields:
 
-- `name`, `description`, `disabled`;
+- `description`, `disabled`;
 - `args`, typed arg declarations, inline defaults, `defaults`, and composition `values`;
 - `imports` with optional binding defaults/values;
 - `template`;
@@ -58,25 +60,39 @@ Common Recipe fields:
 ```json
 {
   "imports": {
-    "review": "subagent-review.json",
-    "verify": {
-      "from": "subagent-verify.json",
+    "review": "swarm/quorum-review",
+    "report": {
+      "from": "../shared/report.md",
       "defaults": { "thinking": "medium" }
     }
   },
   "template": [
     { "name": "review", "values": { "input": "{input}" } },
-    { "name": "verify", "values": { "input": "Use prior output" } }
+    { "name": "report", "values": { "input": "Use prior output" } }
   ]
 }
 ```
 
 Imports are local definitions. Named nodes call imported templates inside the same execution graph and Run. Effective values follow `caller > node/import/Recipe values > defaults > inline arg default > missing-value error`, then the selected value is checked against its declared type or enum.
 
-Bare references preserve user → adjacent → packaged resolution. `std:<name>` selects a packaged Recipe exactly. `skill:<skill-name>/<recipe-path>` selects a component under the `recipes/` tree of a Skill currently active through Pi resource discovery. Skill Recipes never become tools merely by existing, and duplicate active Skill names fail as ambiguous rather than shadowing silently.
+Imports accept exactly `<skill>/<recipe>` or an explicit `.json` / `.md` file path. A Skill reference selects one direct filename stem under the exact Skill currently active through Pi resource discovery; duplicate active Skill identities and JSON/Markdown stem collisions fail closed. Explicit paths may be relative (`./local-review.json`, `../shared/report.md`) or absolute (`/absolute/path/to/recipe.json`). An entry file path resolves from invocation `cwd`; a relative import resolves from the importing Recipe's directory. No bare or ambient lookup remains.
 
 Direct delegation can use another Recipe as the entire template. The delegated Recipe remains the source of truth while the wrapper may narrow args/defaults or override selected lifecycle metadata.
 
+A launched Run captures each entry/import role, filename-derived stem, logical reference, Skill identity when owned, and import alias ancestry. Private physical source paths remain execution provenance; Inspector and child-agent context expose logical identities rather than machine-local Skill locations.
+
+## Migration from pre-0.46 references
+
+```text
+std:foo              -> owning-skill/foo
+skill:foo/bar        -> foo/bar
+root packaged foo    -> owning-skill/new-file-stem
+Recipe name field    -> delete; filename is identity
+nested skill path    -> flatten filename or use explicit file path
+```
+
+Removed `std:` and `skill:` forms fail with migration guidance; they are not aliases. Root packaged Recipes no longer exist. Flatten a maintained Skill component to a direct filename, or reference a nested/local file explicitly when it is intentionally outside the Skill component namespace.
+
 ## Control
 
 Only a process that consumes actor-local input declares actions:
@@ -85,7 +101,7 @@ Only a process that consumes actor-local input declares actions:
 {
   "async": true,
   "control": ["pause", "resume", "stop"],
-  "template": "{repo}/scripts/service.mjs --state-dir {state_dir}"
+  "template": "{skill_dir}/scripts/service.mjs --state-dir {state_dir}"
 }
 ```
 
@@ -110,7 +126,7 @@ Every file-backed Recipe receives immutable `{recipe_dir}`. A Recipe under an ac
 
 ## Context and Provenance
 
-File-backed Runs capture Recipe context records for the entry and imports, including qualified `std:` or `skill:` identity when applicable. The captured bundle explains composition identity and remains generation-local evidence. Runtime origin paths remain in local Run provenance but are omitted from model-facing launch values. It does not override the authored task prompt.
+File-backed Runs capture Recipe context records for the entry and imports. File identity is the filename stem; a direct Recipe under an active Skill has the logical identity `<skill>/<stem>`. The captured bundle explains composition identity and remains generation-local evidence. Runtime origin paths remain in local Run provenance but are omitted from model-facing launch values. It does not override the authored task prompt.
 
 Recipes that need a minimal child prompt may opt out of injected Recipe context through the documented `actor_context` launch option.
 
@@ -129,18 +145,18 @@ Defaults can inherit current Pi policy:
 
 Resolution fails before launch when required current policy is unavailable. The Run persists whether values were inherited or explicit.
 
-## Resolution and Shadowing
+## Resolution Context
 
-User Recipes under `~/.pi/agent/recipes` take priority over adjacent and packaged Recipes for compatible bare lookup. Exact `std:` and `skill:` references bypass that ambiguous space. The active Skill namespace converges from Pi's loaded Skill metadata on startup/reload; pi-actors does not scan ambient Skill roots independently. An invalid active file blocks fallback and reports both paths. Disabled Recipes cannot launch. Registry watchers converge after atomic changes without executing partial definitions.
+User Recipes under `~/.pi/agent/recipes` remain intentionally registered tools, not an ambient import namespace. Each session receives an immutable active-Skill resolution context from Pi's loaded Skill metadata; pi-actors does not scan ambient Skill roots independently or keep a process-global mutable namespace. A launch captures its resolved graph, so later Skill changes affect only future launches. An invalid or missing exact target fails without fallback. Disabled Recipes cannot launch. Registry watchers converge after atomic changes without executing partial definitions.
 
 ## Validation
 
 ```bash
-node scripts/validate-recipe.mjs recipes/example.json --qa
-node scripts/validate-recipe.mjs recipes --all --qa --summary
+node skills/actors/scripts/validate-recipe.mjs path/to/recipe.json --qa
+node skills/actors/scripts/validate-recipe.mjs skills --skills --qa --summary
 ```
 
-Validation checks JSON/Markdown compilation, imports, Control, artifacts, helper paths, and platform notes. Files exceed 1 MiB or import depth 32 fail closed.
+Skill validation recursively inventories every direct `<skill>/recipes/*.json|*.md` component, rejects nested files and duplicate stems, and checks filename identity, JSON/Markdown compilation, origins, imports, Control, artifacts, portable paths, helper targets, and platform notes. Files exceeding 1 MiB or import depth 32 fail closed.
 
 ## Related
 

package/docs/tool-registry.md

@@ -22,7 +22,7 @@ Promote an immutable captured draft only with its draft path and explicit target
 
 ## Resolution
 
-User Recipes take priority over packaged Recipes. Active invalid or disabled shadowing blocks fallback and reports both paths. Runtime reload watches the Recipe root and converges after atomic changes; stale watcher generations cannot replace current registration state.
+User Recipes are the only file-discovered tool source. Invalid or disabled user entries fail closed. Active Skill Recipes remain exact components outside tool discovery. Runtime reload watches the user Recipe root and converges after atomic changes; stale watcher generations cannot replace current registration state.
 
 Inspect registry state with:
 
@@ -61,7 +61,7 @@ Usage and lineage live in locked metadata ledgers rather than authored Recipe fi
 
 ## Wrapping Existing Recipes
 
-Prefer a small user-root wrapper that imports a maintained Recipe by exact `std:<recipe>` or `skill:<skill>/<recipe-path>` identity and delegates by alias. Skill Recipes remain components and are never exposed merely because their Skill is active. Do not duplicate executable templates, defaults, Control declarations, artifacts, or runtime-owned `{recipe_dir}`/`{skill_dir}`. Install only specific capabilities; internal automatic-review Recipes must not become user-callable tools.
+Prefer a small user-root wrapper that imports a maintained Recipe by exact `<skill>/<recipe>` identity and delegates by alias. Skill Recipes remain components and are never exposed merely because their Skill is active. Do not duplicate executable templates, defaults, Control declarations, artifacts, or runtime-owned `{recipe_dir}`/`{skill_dir}`. Install only specific capabilities; internal automatic-review Recipes must not become user-callable tools.
 
 ## Safety
 

package/fixtures/protocol/recipe-summary.json

@@ -1,6 +1,6 @@
 {
   "id": "music-player",
-  "path": "recipes/music-player.json",
+  "path": "skills/media/recipes/player.json",
   "location": "packaged",
   "active": true,
   "args": ["repo", "command", "source", "loop", "volume", "player", "state_dir"],

package/index.ts

@@ -18,10 +18,11 @@ export default function toolRegistryExtension(pi: Pi.ExtensionAPI) {
   pi.on("session_shutdown", async (event, ctx) =>
     runtime.onSessionShutdown(event.reason, ctx),
   );
-  pi.on("before_agent_start", async (event) =>
+  pi.on("before_agent_start", async (event, ctx) =>
     runtime.beforeAgentStart(
       event.systemPrompt,
       event.systemPromptOptions.skills ?? [],
+      ctx,
     ),
   );
   InspectorCommand.registerActorInspectorCommand(pi, runtime.getRunOwnerId);

package/lib/async-runs.ts

@@ -259,11 +259,23 @@ function assertNoActiveRunState(stateDir: string): void {
   RunsStart.assertNoActiveRunState(stateDir, readJson, RUNNER_PATH);
 }
 
-function resolveRecipeFile(file: string): string {
-  return (
-    RecipesReferences.resolveRecipeReferencePath(file, Paths.getRecipeRoot()) ??
-    RecipesReferences.getRecipePath(file, Paths.getRecipeRoot()) ??
-    RecipesReferences.resolveRecipePath(file, Paths.getRecipeRoot())
+export interface AsyncRunStartOptions {
+  skillContext?: RecipesReferences.ActiveSkillRecipeContext;
+}
+
+function resolveRecipeFile(
+  file: string,
+  cwd: string,
+  options: AsyncRunStartOptions,
+): string {
+  const path = RecipesReferences.resolveRecipeReferencePath(
+    file,
+    cwd,
+    options.skillContext,
+  );
+  if (path) return path;
+  throw new Error(
+    `Recipe reference not found. Use <skill>/<recipe> or an explicit .json/.md file path: ${file}`,
   );
 }
 
@@ -274,13 +286,18 @@ function isMutableUsageRecipeFile(file: string): boolean {
   return relation !== "" && !relation.startsWith("..") && !isAbsolute(relation);
 }
 
-function readRecipeFile(file: string): AsyncRunStartParams {
-  const path = resolveRecipeFile(file);
+function readRecipeFile(
+  file: string,
+  cwd: string,
+  options: AsyncRunStartOptions,
+): AsyncRunStartParams {
+  const path = resolveRecipeFile(file, cwd, options);
   const raw = RecipesReferences.readRawRecipeConfig(path);
   const includeActorRecipeContext =
     raw?.actor_context !== false && raw?.actor_context !== "off";
   const config = RecipesReferences.readResolvedRecipeConfig(path, [], {
     includeActorRecipeContext,
+    skillContext: options.skillContext,
   });
   if (!config) {
     throw new Error(`Template recipe must define template: ${path}`);
@@ -301,9 +318,13 @@ function getRunIdFromFile(file: string | undefined): string | undefined {
   return name || undefined;
 }
 
-function resolveStartParams(params: AsyncRunStartParams): AsyncRunStartParams {
+function resolveStartParams(
+  params: AsyncRunStartParams,
+  cwd: string,
+  options: AsyncRunStartOptions,
+): AsyncRunStartParams {
   if (!params.file) return params;
-  const fileParams = readRecipeFile(params.file);
+  const fileParams = readRecipeFile(params.file, cwd, options);
   return {
     ...fileParams,
     ...params,
@@ -468,25 +489,15 @@ function prepareStateDirForStart(stateDir: string): void {
 export function startRun(
   params: AsyncRunStartParams,
   cwd: string,
+  options: AsyncRunStartOptions = {},
 ): AsyncRunMeta {
-  const startParams = resolveStartParams(params);
+  const startParams = resolveStartParams(params, cwd, options);
   const resolved = resolveRunTemplate(startParams);
   const run = safeRunId(startParams.run_id);
   const stateDir = resolveStateDir(startParams, run);
   const recipeFile = startParams.file
-    ? resolveRecipeFile(startParams.file)
+    ? resolveRecipeFile(startParams.file, cwd, options)
     : undefined;
-  const packagedRecipeRoot = resolve(Paths.getPackagedRecipeRoot());
-  const recipeRelation = recipeFile
-    ? relative(packagedRecipeRoot, recipeFile)
-    : undefined;
-  const packagedRepo =
-    startParams.defaults?.repo === "~/.pi/agent/extensions/pi-actors" &&
-    recipeRelation &&
-    !recipeRelation.startsWith("..") &&
-    !isAbsolute(recipeRelation)
-      ? dirname(packagedRecipeRoot)
-      : undefined;
   const argSpec = Schema.parseToolArgDeclarationList(startParams.args ?? []);
   if (argSpec.error) throw new Error(argSpec.error);
   const declaredArgs = new Set(argSpec.args);
@@ -498,7 +509,6 @@ export function startRun(
     {
       ...argSpec.defaults,
       ...(startParams.defaults || {}),
-      ...(packagedRepo ? { repo: packagedRepo } : {}),
       ...(startParams.values || {}),
       run_id: run,
       state_dir: stateDir,
@@ -546,7 +556,20 @@ export function startRun(
       startParams.actor_context !== "off";
     const recipeContextRecords =
       recipeFile && includeActorRecipeContext
-        ? RecipesReferences.buildRecipeContextRecords(recipeFile)
+        ? RecipesReferences.buildRecipeContextRecords(
+            recipeFile,
+            options.skillContext,
+          ).map((record, index) =>
+            index === 0 &&
+            startParams.launch_source === "tool" &&
+            record.source_kind === "explicit_file_recipe"
+              ? {
+                  ...record,
+                  logical_reference: record.name,
+                  source_kind: "user_registry_capability" as const,
+                }
+              : record,
+          )
         : undefined;
     if (
       recipeFile &&

package/lib/automatic-review-runtime.ts

@@ -4,13 +4,14 @@
  * Owns automatic-review lifecycle wiring without owning review decisions or filesystem transactions.
  */
 
-import { join } from "node:path";
+import { fileURLToPath } from "node:url";
 
 import * as AsyncRuns from "./async-runs.ts";
 import * as DraftSleep from "./draft-sleep.ts";
 import * as ModelContext from "./model-context.ts";
 import * as Paths from "./paths.ts";
 import type * as Pi from "./pi.ts";
+import * as RecipesReferences from "./recipes-references.ts";
 import * as ReviewControl from "./review-control.ts";
 import * as ToolReviewScheduler from "./tool-review-scheduler.ts";
 
@@ -27,6 +28,16 @@ export interface AutomaticReviewRuntimeDeps {
   getThinkingLevel(): unknown;
 }
 
+export const PACKAGE_RECIPE_MEMORY_CONTEXT =
+  RecipesReferences.createActiveSkillRecipeContext([
+    {
+      name: "recipe-memory",
+      filePath: fileURLToPath(
+        new URL("../skills/recipe-memory/SKILL.md", import.meta.url),
+      ),
+    },
+  ]);
+
 export function createAutomaticReviewRuntime(
   deps: AutomaticReviewRuntimeDeps,
 ): AutomaticReviewRuntime {
@@ -88,7 +99,7 @@ export function createAutomaticReviewRuntime(
           }
           return AsyncRuns.startRun(
             {
-              file: join(Paths.getPackagedRecipeRoot(), "draft-review.json"),
+              file: "recipe-memory/draft-review",
               launch_source: "tool",
               notification_policy: "silent",
               ownerId: deps.getRunOwnerId(ctx),
@@ -97,6 +108,7 @@ export function createAutomaticReviewRuntime(
               values: { input_path: batch.reviewerInputPath },
             },
             ctx.cwd,
+            { skillContext: PACKAGE_RECIPE_MEMORY_CONTEXT },
           );
         },
         process: (state) =>
@@ -113,7 +125,7 @@ export function createAutomaticReviewRuntime(
           }
           return AsyncRuns.startRun(
             {
-              file: join(Paths.getPackagedRecipeRoot(), "tool-review.json"),
+              file: "recipe-memory/tool-review",
               launch_source: "tool",
               notification_policy: "silent",
               ownerId: deps.getRunOwnerId(ctx),
@@ -122,6 +134,7 @@ export function createAutomaticReviewRuntime(
               values: { input_path: batch.reviewerInputPath },
             },
             ctx.cwd,
+            { skillContext: PACKAGE_RECIPE_MEMORY_CONTEXT },
           );
         },
         process: (state) =>

package/lib/draft-sleep.ts

@@ -96,7 +96,6 @@ function readState(path: string): DraftSleepState | undefined {
 function defaultActiveTools(recipeRoot: string): DraftReviewActiveTool[] {
   const discovered = RecipesDiscovery.discoverRecipeSources([
     { root: recipeRoot, defaultTool: true, mutableUsage: true },
-    { root: Paths.getPackagedRecipeRoot() },
   ]);
   return [...discovered.active.values()]
     .filter((entry) => existsSync(entry.path))