@llblab/pi-actors 0.45.0 → 0.46.0

package/AGENTS.md

@@ -36,14 +36,15 @@ Pi host
      -> lib/observability.ts          terminal + Trace-attention observation
      -> lib/inspector*.ts             owner-filtered actor-instance inspection
      -> scripts/*.mjs                 process/service entrypoints
-     -> recipes/*.json                packaged Recipe library
+     -> skills/*/recipes/*            Skill-owned Recipe components
      -> skills/* + docs/*             agent and human guidance
 ```
 
-`index.ts` wires Pi ports and must not own domain behavior. Keep the local TypeScript import graph acyclic.
+`index.ts` wires Pi ports and must not own domain behavior. Keep the local TypeScript import graph acyclic. For architecture-affecting work, load and follow `.agents/skills/domain-dag/SKILL.md`; its validator is local agent tooling, not an npm, CI, or release gate.
 
 ## Key Domains
 
+- `extension-runtime.ts`: low-level Pi session lifecycle, tool adaptation, and runtime service composition behind the thin `index.ts` event-registration root.
 - `command-templates.ts`: portable synchronous execution graph.
 - `recipes-references.ts`, `recipes-discovery.ts`, `recipe-control.ts`: Recipe resolution, imports, shadowing, and Control declarations.
 - `async-runs.ts`: lifecycle facade.
@@ -57,17 +58,20 @@ Pi host
 - `observability.ts`, `run-ui-runtime.ts`: Trace attention, terminal reconciliation, and Pi follow-up delivery.
 - automatic draft/tool review domains: structurally redacted model review, journaled mutation, lineage, recovery, and explicit retry/reset safety.
 
-Scripts remain self-contained when no non-script consumer justifies a TypeScript domain. Command-template script leaves infer `.js`/`.mjs` in order through Node, Bun, or `deno run` and `.sh` through Bash without shell evaluation. Helper-backed packaged Recipes self-locate their installed package root while explicit caller values remain authoritative. Recipes stay optional, composable, policy-light, and caller-configurable.
+The bundled Skill Recipe dependency DAG is `artifacts → actors, swarm`, `media → artifacts`, and `project-work → actors, artifacts, swarm`; `actors`, `swarm`, and `recipe-memory` have no cross-Skill Recipe dependencies.
+
+Scripts remain self-contained when no non-script consumer justifies a TypeScript domain. Command-template script leaves infer `.js`/`.mjs` in order through Node, Bun, or `deno run` and `.sh` through Bash without shell evaluation. Helper-backed Skill Recipes self-locate through runtime-owned `{skill_dir}`. Recipes stay optional, composable, policy-light, and caller-configurable.
 
 ## Operating Principles
 
 ### Recipe
 
+- Skill Recipe identity is `<active Skill name>/<Recipe filename stem>`; Recipe files have no top-level `name`. `SKILL.md` `name` is Pi host metadata matching the Skill directory, not a second pi-actors identity field.
 - Recipe files may define args/defaults, imports, artifacts, command-template flags, and `control`.
 - Declare actor-local actions only when a long-lived process implements them.
 - Actions are lowercase, unique, and cannot use runtime-reserved lifecycle names.
 - Removed communication-plane metadata fails explicitly; never translate it.
-- User Recipes shadow packaged definitions; invalid shadowing blocks fallback.
+- User Recipes are discovered only from the persistent user registry; Skill Recipes are exact components outside tool discovery. Explicit entry paths resolve from invocation `cwd`; relative imports resolve from their importing file.
 - Files over 1 MiB, import depth over 32, and import cycles fail closed.
 
 ### Trace
@@ -137,8 +141,8 @@ When a deferred Run result gates the next step, wait for its terminal follow-up.
 - Keep published text portable: use `~`, `<repo>`, or relative paths.
 - Update `skills/actors/SKILL.md` when durable operating mechanics change.
 - Keep `skills/swarm/SKILL.md` focused on multi-agent methodology rather than kernel internals.
-- Recipe `description` is optional because discovery supplies stable fallback tool copy; packaged Recipe QA must report zero diagnostics and zero release-blocking warnings without component boilerplate.
-- Before release run build, full tests, preservation tests, Recipe QA, Domain DAG validation, ABCd context validation, line-count gates, and release gates.
+- Recipe `description` is optional. Skill Recipe QA recursively validates direct filesystem-owned components and capability semantics with zero diagnostics or warnings; it does not enforce aesthetics or architecture policy.
+- Before release run the normal product validation and dependency audit. Use the project-local Domain DAG Skill during architecture-affecting development, not as publication automation.
 - `.github/workflows/release.yml` owns the immutable sequence reusable validation → npm Trusted Publisher publication/verification → GitHub Release convergence; follow [docs/releasing.md](docs/releasing.md).
 - Keep npm publication tokenless: use the exact npm Trusted Publisher binding and job-scoped OIDC permission, never a long-lived npm token or token fallback.
 - Until a stable version beyond `1.x`, prefer clean breaking simplification over compatibility aliases or renamed legacy abstractions.

package/CHANGELOG.md

@@ -1,6 +1,19 @@
 # Changelog
 
-> Each release keeps at most 8 outcome records of at most 512 characters.
+## 0.46.0: Skill-Owned Capability Packs
+
+- `Breaking Recipe Grammar`: File-backed identity now comes only from the filename; top-level Recipe `name`, nested Skill identities, JSON/Markdown stem collisions, bare references, and the old `std:` / `skill:` prefixes fail with migration guidance. Composition accepts exact `<active-skill>/<stem>` references or explicit `.json` / `.md` paths, with entry paths based at invocation cwd and relative imports based at their owning Recipe.
+- `Skill-Owned Distribution`: All 58 bundled components move from the root Recipe library into six flat Pi Skills—Actors, Artifacts, Media, Project Work, Recipe Memory, and Swarm—with 67 explicit imports and an acyclic cross-Skill graph. Root and `dist` Recipe libraries, package-root discovery, fallback/shadowing, wrapper installation, and obsolete root capability helpers are removed; Skill components never auto-register as tools.
+- `Scoped Resolution and Provenance`: Immutable active-Skill contexts are session-scoped and captured per Run. Recipe inspection distinguishes user registry capabilities, active Skill components, and explicit files while recording entry/import roles, filename stems, logical identities, Skill ownership, and alias ancestry without exposing private `source_file`, `{skill_dir}`, or `{recipe_dir}` values to model/Inspector surfaces.
+- `Capability Safety`: Automatic review resolves exact package-owned `recipe-memory/*` components so user files cannot redirect reviewers. Helpers self-locate through runtime-owned `{skill_dir}`; Control, Trace, lifecycle fencing, review transactions, and the public `spawn`, `message`, `inspect`, `register_tool` plus Recipe/Trace/Control view contracts remain unchanged.
+- `Validation and Architecture`: Recursive Skill QA validates direct identity, parse/import semantics, origins, Control, portable paths, and helper targets in source and installed packages. The custom release-gate and executable-style policy scanners are removed; CI runs product validation plus dependency audit, while a non-packaged project-local Domain DAG Skill supports architecture work without becoming a release gate.
+- `Dogfood and Migration`: Source and installed tests execute repository health, release readiness, quorum review, artifact bundle, media player, and package-owned draft review through qualified Skill references, plus relative/absolute file imports and all breaking failures. Migrate `std:foo` to `owning-skill/foo`, `skill:foo/bar` to `foo/bar`, root Recipes to their owning Skill filename, and delete Recipe `name` fields.
+
+## 0.45.1: Entrypoint and Release Policy
+
+- `Architecture`: Keeps `index.ts` as a thin Pi event-registration and composition root while moving session lifecycle, runtime service composition, Skill discovery, and tool adaptation into the acyclic `extension-runtime.ts` domain.
+- `Release Policy`: Raises the fixed shipped-source ceiling to 32,000 lines and rejects blank lines inside executable JavaScript/TypeScript blocks across the complete source and test tree while exempting structural declarations.
+- `Package Metadata`: Moves the package image to the new raw-content endpoint to restore cross-origin loading.
 
 ## 0.45.0: Skill Recipe Standard Library
 

package/README.md

@@ -1,6 +1,8 @@
 # pi-actors
 
-Local Run kernel and persistent tool registry for [Pi](https://github.com/badlogic/pi-mono).
+![pi-actors banner](https://raw.githubusercontent.com/llblab/pi-actors/main/banner.jpg)
+
+Local Run kernel and persistent tool registry for [Pi](https://github.com/earendil-works/pi).
 
 ```text
 Recipe --spawn--> Run
@@ -21,17 +23,18 @@ For local development:
 pi install /path/to/pi-actors
 ```
 
-The package contributes the extension, packaged Recipes, and the `actors` and `swarm` skills.
+The package contributes the extension and six capability-owning Skills for actors, artifacts, media, project work, Recipe memory, and swarm orchestration.
 
 ## Public Tools
 
 ### `spawn`
 
-Create a Run from a packaged/local Recipe or an inline command template:
+Create a Run from an active-Skill Recipe, an explicit Recipe file, or an inline command template:
 
 ```text
 spawn template="sleep 30" as=run:demo
-spawn recipe=pipeline-repo-health values={"repo":"/work/project","model":"provider/model"}
+spawn recipe=project-work/repo-health values={"repo":"/work/project","model":"provider/model"}
+spawn recipe=media/player values={"source":"/music"} as=run:player
 spawn template="make test" as=run:test
 ```
 
@@ -97,13 +100,25 @@ Example controlled Recipe:
   "async": true,
   "control": ["pause", "resume", "stop"],
   "artifacts": { "state": "{state_dir}/player-state.json" },
-  "template": "{repo}/scripts/player.mjs --state-dir {state_dir}"
+  "template": "{skill_dir}/scripts/player.mjs --state-dir {state_dir}"
 }
 ```
 
 Ordinary one-shot Recipes should omit `control`. Recipe imports compose definitions inside one Run; they do not create peer actors.
 
-File-backed Recipes receive immutable `{recipe_dir}`; Recipes under a Pi-active Skill also receive `{skill_dir}`. Use `std:<recipe>` for an exact packaged component and `skill:<skill>/<recipe-path>` for an exact active-Skill component. Skill Recipes are namespaced reusable components and do not become tools automatically.
+```json
+{
+  "imports": {
+    "report": "artifacts/report",
+    "review": "swarm/quorum-review"
+  },
+  "template": [{ "name": "report" }, { "name": "review" }]
+}
+```
+
+Skill Recipe identity is `<active Skill name>/<Recipe filename stem>`. Recipe files have no top-level `name`; the filename is identity. `SKILL.md` `name` remains Pi host metadata and matches the Skill directory—pi-actors adds no second Skill identity field.
+
+References have two classes: exact active-Skill identities such as `project-work/repo-health`, and explicit `.json` / `.md` paths. Entry file paths resolve from invocation `cwd`; relative imports resolve from the importing Recipe's directory; absolute paths remain exact. File-backed Recipes receive immutable `{recipe_dir}` and Skill Recipes also receive `{skill_dir}`. Skill components never become tools automatically.
 
 String command-template leaves execute directly without shell interpretation. Use template arrays for sequencing or an explicit trusted shell/script when shell semantics matter.
 
@@ -173,15 +188,16 @@ Open the owner-filtered TUI:
 
 It presents actor instances through Recipe, Trace, and Control tabs, with source filtering, detail navigation, refresh, and generation-fenced Run kill.
 
-## Packaged Recipes
+## Skill Recipes
 
 Useful entry points include:
 
-- `pipeline-repo-health`
-- `pipeline-quorum-review`
-- `pipeline-artifact-bundle`
-- `music-player` — controlled playback service
-- `resource-locker` — optional controlled resource-lock service
+- `project-work/repo-health`
+- `project-work/release-readiness`
+- `swarm/quorum-review`
+- `artifacts/bundle`
+- `media/player` — controlled playback service
+- `actors/resource-locker` — optional controlled resource-lock service
 
 Validate Recipes with:
 

package/dist/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/dist/index.d.ts

@@ -1,8 +1,7 @@
 /**
  * pi-actors — actor runtime and persistent local tool registry for pi.
  * Zones: composition root, pi agent, actor runtime
- *
- * Wraps command templates as callable pi tools, stores durable user tools as recipe files, and exposes actor orchestration across reloads and sessions.
+ * Owns extension composition and Pi event registration, not domain behavior.
  */
 import * as Pi from "./lib/pi.ts";
 export default function toolRegistryExtension(pi: Pi.ExtensionAPI): void;

package/dist/index.js

@@ -1,117 +1,17 @@
 /**
  * pi-actors — actor runtime and persistent local tool registry for pi.
  * Zones: composition root, pi agent, actor runtime
- *
- * Wraps command templates as callable pi tools, stores durable user tools as recipe files, and exposes actor orchestration across reloads and sessions.
+ * Owns extension composition and Pi event registration, not domain behavior.
  */
-import * as AutomaticReviewRuntime from "./lib/automatic-review-runtime.js";
-import * as CommandTemplates from "./lib/command-templates.js";
+import * as ExtensionRuntime from "./lib/extension-runtime.js";
 import * as InspectorCommand from "./lib/inspector-command.js";
-import * as Paths from "./lib/paths.js";
-import * as Pi from "./lib/pi.js";
-import * as Prompts from "./lib/prompts.js";
-import * as RecipesReferences from "./lib/recipes-references.js";
-import * as RunUiRuntime from "./lib/run-ui-runtime.js";
-import * as Runtime from "./lib/runtime.js";
-import * as Temp from "./lib/temp.js";
-import * as Tools from "./lib/tools.js";
-import * as ToolsResponse from "./lib/tools-response.js";
 export default function toolRegistryExtension(pi) {
-    let activeRunContext;
-    const getRunOwnerId = Pi.getSessionId;
-    const automaticReview = AutomaticReviewRuntime.createAutomaticReviewRuntime({
-        getActiveContext: () => activeRunContext,
-        getRunOwnerId,
-        getThinkingLevel: () => pi.getThinkingLevel(),
-    });
-    const runUiRuntime = RunUiRuntime.createRunUiRuntime({
-        getActiveContext: () => activeRunContext,
-        getRunOwnerId,
-        onRunEvent: automaticReview.schedule,
-        pi,
-    });
-    const actorToolDefinitions = new Map();
-    const withCurrentThinkingContext = (definition) => {
-        if (typeof definition.execute !== "function")
-            return definition;
-        const execute = definition.execute;
-        return {
-            ...definition,
-            execute: async (...args) => {
-                const nextArgs = [...args];
-                const ctx = nextArgs[4];
-                if (ctx && typeof ctx === "object") {
-                    nextArgs[4] = {
-                        ...ctx,
-                        getThinkingLevel: () => pi.getThinkingLevel(),
-                    };
-                }
-                try {
-                    return ToolsResponse.spaceToolResult(await execute(...nextArgs));
-                }
-                catch (error) {
-                    throw ToolsResponse.spaceToolError(error);
-                }
-            },
-        };
-    };
-    const runtime = Runtime.createAutoToolsRuntime({
-        configPath: Paths.EXTENSION_RUNTIME_PATHS.configPath,
-        exec: CommandTemplates.execCommandTemplate,
-        getActiveTools: () => pi.getActiveTools(),
-        registerTool: (definition) => {
-            const wrapped = withCurrentThinkingContext(definition);
-            actorToolDefinitions.set(wrapped.name, wrapped);
-            pi.registerTool(wrapped);
-        },
-        reservedToolNames: Tools.RESERVED_TOOL_NAMES,
-        setActiveTools: (toolNames) => pi.setActiveTools(toolNames),
-    });
-    const recipeReload = Runtime.createRecipeToolReloadWatcher(runtime);
-    pi.on("resources_discover", async () => {
-        const skillPaths = Paths.getExistingExtensionSkillPaths(import.meta.url);
-        if (skillPaths.length === 0)
-            return;
-        return { skillPaths };
-    });
-    pi.on("session_start", async (_event, ctx) => {
-        // Clear the pre-overlay widget after hot reloads from older pi-actors builds.
-        ctx.ui.setWidget("zz-pi-actors-comms", undefined);
-        activeRunContext = ctx;
-        runUiRuntime.close();
-        automaticReview.close();
-        recipeReload.close();
-        await Temp.prepareExtensionTempDir(Paths.EXTENSION_RUNTIME_PATHS.tempDir);
-        if (activeRunContext !== ctx)
-            return;
-        automaticReview.start(ctx);
-        runtime.loadTools(ctx);
-        runUiRuntime.start(ctx);
-        recipeReload.watch(ctx);
-    });
-    pi.on("agent_end", async (_event, ctx) => {
-        if (activeRunContext === ctx)
-            automaticReview.schedule();
-    });
-    pi.on("session_shutdown", async (event, ctx) => {
-        activeRunContext = undefined;
-        automaticReview.close();
-        recipeReload.close();
-        runUiRuntime.shutdown(event.reason, ctx);
-    });
-    InspectorCommand.registerActorInspectorCommand(pi, getRunOwnerId);
-    pi.on("before_agent_start", async (event) => {
-        RecipesReferences.setActiveSkillRecipeSources(event.systemPromptOptions.skills ?? []);
-        return {
-            systemPrompt: `${event.systemPrompt}\n\n${Prompts.ONBOARDING_SYSTEM_PROMPT}`,
-        };
-    });
-    Pi.registerToolDefinitions(pi, Tools.createCoreActorToolDefinitions({
-        configPath: Paths.EXTENSION_RUNTIME_PATHS.configPath,
-        getActiveTools: () => pi.getActiveTools(),
-        getRuntimeTool: (name) => Tools.resolveActiveRuntimeTool(name, runtime.getTools(), (activeName) => actorToolDefinitions.get(activeName)),
-        handleRuntimeControl: automaticReview.handleControl,
-        registryRuntime: runtime,
-        setActiveTools: (toolNames) => pi.setActiveTools(toolNames),
-    }).map(withCurrentThinkingContext));
+    const runtime = ExtensionRuntime.createActorExtensionRuntime(pi);
+    pi.on("resources_discover", async () => runtime.discoverResources(import.meta.url));
+    pi.on("session_start", async (_event, ctx) => runtime.onSessionStart(ctx));
+    pi.on("agent_end", async (_event, ctx) => runtime.onAgentEnd(ctx));
+    pi.on("session_shutdown", async (event, ctx) => runtime.onSessionShutdown(event.reason, ctx));
+    pi.on("before_agent_start", async (event, ctx) => runtime.beforeAgentStart(event.systemPrompt, event.systemPromptOptions.skills ?? [], ctx));
+    InspectorCommand.registerActorInspectorCommand(pi, runtime.getRunOwnerId);
+    runtime.registerCoreTools();
 }

package/dist/lib/async-runs.d.ts

@@ -98,7 +98,10 @@ export interface AsyncRunMeta {
 export { safeRunId } from "./runs-identity.ts";
 export { resolveArtifactManifest } from "./runs-artifacts.ts";
 export type { RunArtifactDeclaration, RunArtifactManifestEntry, } from "./runs-artifacts.ts";
-export declare function startRun(params: AsyncRunStartParams, cwd: string): AsyncRunMeta;
+export interface AsyncRunStartOptions {
+    skillContext?: RecipesReferences.ActiveSkillRecipeContext;
+}
+export declare function startRun(params: AsyncRunStartParams, cwd: string, options?: AsyncRunStartOptions): AsyncRunMeta;
 export declare function getRunStatus(runOrDir: string): Record<string, unknown>;
 export type { RunStateIndexEntry } from "./runs-index.ts";
 export declare function listRunStateDirs(stateRoot?: string): string[];

package/dist/lib/async-runs.js

@@ -105,10 +105,11 @@ function resolveStateDir(params, run) {
 function assertNoActiveRunState(stateDir) {
     RunsStart.assertNoActiveRunState(stateDir, readJson, RUNNER_PATH);
 }
-function resolveRecipeFile(file) {
-    return (RecipesReferences.resolveRecipeReferencePath(file, Paths.getRecipeRoot()) ??
-        RecipesReferences.getRecipePath(file, Paths.getRecipeRoot()) ??
-        RecipesReferences.resolveRecipePath(file, Paths.getRecipeRoot()));
+function resolveRecipeFile(file, cwd, options) {
+    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}`);
 }
 function isMutableUsageRecipeFile(file) {
     const userRoot = resolve(DEFAULT_RECIPE_ROOT);
@@ -116,12 +117,13 @@ function isMutableUsageRecipeFile(file) {
     const relation = relative(userRoot, resolved);
     return relation !== "" && !relation.startsWith("..") && !isAbsolute(relation);
 }
-function readRecipeFile(file) {
-    const path = resolveRecipeFile(file);
+function readRecipeFile(file, cwd, options) {
+    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}`);
@@ -141,10 +143,10 @@ function getRunIdFromFile(file) {
     const name = basename(file, extname(file));
     return name || undefined;
 }
-function resolveStartParams(params) {
+function resolveStartParams(params, cwd, options) {
     if (!params.file)
         return params;
-    const fileParams = readRecipeFile(params.file);
+    const fileParams = readRecipeFile(params.file, cwd, options);
     return {
         ...fileParams,
         ...params,
@@ -239,23 +241,13 @@ function acquireStateStartLock(stateDir, options = {}) {
 function prepareStateDirForStart(stateDir) {
     RunsStart.prepareStateDirForStart(stateDir, readJson, RUNNER_PATH);
 }
-export function startRun(params, cwd) {
-    const startParams = resolveStartParams(params);
+export function startRun(params, cwd, options = {}) {
+    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)
-        : 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)
+        ? resolveRecipeFile(startParams.file, cwd, options)
         : undefined;
     const argSpec = Schema.parseToolArgDeclarationList(startParams.args ?? []);
     if (argSpec.error)
@@ -268,7 +260,6 @@ export function startRun(params, cwd) {
     const values = Schema.normalizeRuntimeValues({
         ...argSpec.defaults,
         ...(startParams.defaults || {}),
-        ...(packagedRepo ? { repo: packagedRepo } : {}),
         ...(startParams.values || {}),
         run_id: run,
         state_dir: stateDir,
@@ -306,7 +297,15 @@ export function startRun(params, cwd) {
         const includeActorRecipeContext = startParams.actor_context !== false &&
             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",
+                }
+                : record)
             : undefined;
         if (recipeFile &&
             isMutableUsageRecipeFile(recipeFile) &&

package/dist/lib/automatic-review-runtime.d.ts

@@ -4,6 +4,7 @@
  * Owns automatic-review lifecycle wiring without owning review decisions or filesystem transactions.
  */
 import type * as Pi from "./pi.ts";
+import * as RecipesReferences from "./recipes-references.ts";
 export interface AutomaticReviewRuntime {
     close(): void;
     handleControl(action: string, input: unknown): Record<string, unknown>;
@@ -15,4 +16,5 @@ export interface AutomaticReviewRuntimeDeps {
     getRunOwnerId(ctx: Pi.ExtensionContext): string;
     getThinkingLevel(): unknown;
 }
+export declare const PACKAGE_RECIPE_MEMORY_CONTEXT: RecipesReferences.ActiveSkillRecipeContext;
 export declare function createAutomaticReviewRuntime(deps: AutomaticReviewRuntimeDeps): AutomaticReviewRuntime;

package/dist/lib/automatic-review-runtime.js

@@ -3,13 +3,20 @@
  * Zones: session-bound review schedulers, silent reviewer launch adapters, review controls
  * 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.js";
 import * as DraftSleep from "./draft-sleep.js";
 import * as ModelContext from "./model-context.js";
 import * as Paths from "./paths.js";
+import * as RecipesReferences from "./recipes-references.js";
 import * as ReviewControl from "./review-control.js";
 import * as ToolReviewScheduler from "./tool-review-scheduler.js";
+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) {
     let draftScheduler;
     let toolScheduler;
@@ -56,14 +63,14 @@ export function createAutomaticReviewRuntime(deps) {
                         throw new Error("Draft review session changed before launch.");
                     }
                     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),
                         policy_values: policyValues(ctx),
                         run_id: DraftSleep.draftSleepRunId(batch.batchId),
                         values: { input_path: batch.reviewerInputPath },
-                    }, ctx.cwd);
+                    }, ctx.cwd, { skillContext: PACKAGE_RECIPE_MEMORY_CONTEXT });
                 },
                 process: (state) => DraftSleep.processDraftSleepReview(state, {
                     getRunStatus: AsyncRuns.getRunStatus,
@@ -77,14 +84,14 @@ export function createAutomaticReviewRuntime(deps) {
                         throw new Error("Tool review session changed before launch.");
                     }
                     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),
                         policy_values: policyValues(ctx),
                         run_id: ToolReviewScheduler.toolReviewRunId(batch.reviewId),
                         values: { input_path: batch.reviewerInputPath },
-                    }, ctx.cwd);
+                    }, ctx.cwd, { skillContext: PACKAGE_RECIPE_MEMORY_CONTEXT });
                 },
                 process: (state) => ToolReviewScheduler.processToolReviewResult(state, {
                     getRunStatus: AsyncRuns.getRunStatus,

package/dist/lib/draft-sleep.js

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

package/dist/lib/extension-runtime.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Pi actor extension runtime coordinator.
+ * Zones: extension session lifecycle, host tool adaptation, runtime service composition
+ * Owns low-level Pi lifecycle effects and tool wrapping without owning event registration.
+ */
+import * as Pi from "./pi.ts";
+import * as RecipesReferences from "./recipes-references.ts";
+export interface ActorExtensionRuntime {
+    beforeAgentStart(systemPrompt: string, skills: RecipesReferences.ActiveSkillRecipeSource[], ctx: Pi.ExtensionContext): {
+        systemPrompt: string;
+    };
+    discoverResources(metaUrl: string): {
+        skillPaths: string[];
+    } | undefined;
+    getRunOwnerId(ctx: Pi.ExtensionContext): string;
+    onAgentEnd(ctx: Pi.ExtensionContext): void;
+    onSessionShutdown(reason: string, ctx: Pi.ExtensionContext): void;
+    onSessionStart(ctx: Pi.ExtensionContext): Promise<void>;
+    registerCoreTools(): void;
+}
+export declare function createActorExtensionRuntime(pi: Pi.ExtensionAPI): ActorExtensionRuntime;

package/dist/lib/extension-runtime.js

@@ -0,0 +1,122 @@
+/**
+ * Pi actor extension runtime coordinator.
+ * Zones: extension session lifecycle, host tool adaptation, runtime service composition
+ * Owns low-level Pi lifecycle effects and tool wrapping without owning event registration.
+ */
+import * as AutomaticReviewRuntime from "./automatic-review-runtime.js";
+import * as CommandTemplates from "./command-templates.js";
+import * as Paths from "./paths.js";
+import * as Pi from "./pi.js";
+import * as Prompts from "./prompts.js";
+import * as RecipesReferences from "./recipes-references.js";
+import * as RunUiRuntime from "./run-ui-runtime.js";
+import * as Runtime from "./runtime.js";
+import * as Temp from "./temp.js";
+import * as Tools from "./tools.js";
+import * as ToolsResponse from "./tools-response.js";
+export function createActorExtensionRuntime(pi) {
+    let activeRunContext;
+    const skillContextsBySession = new Map();
+    const getRunOwnerId = Pi.getSessionId;
+    const getSkillContext = (ctx) => skillContextsBySession.get(getRunOwnerId(ctx)) ??
+        RecipesReferences.EMPTY_ACTIVE_SKILL_RECIPE_CONTEXT;
+    const automaticReview = AutomaticReviewRuntime.createAutomaticReviewRuntime({
+        getActiveContext: () => activeRunContext,
+        getRunOwnerId,
+        getThinkingLevel: () => pi.getThinkingLevel(),
+    });
+    const runUiRuntime = RunUiRuntime.createRunUiRuntime({
+        getActiveContext: () => activeRunContext,
+        getRunOwnerId,
+        onRunEvent: automaticReview.schedule,
+        pi,
+    });
+    const actorToolDefinitions = new Map();
+    const withCurrentThinkingContext = (definition) => {
+        if (typeof definition.execute !== "function")
+            return definition;
+        const execute = definition.execute;
+        return {
+            ...definition,
+            execute: async (...args) => {
+                const nextArgs = [...args];
+                const ctx = nextArgs[4];
+                if (ctx && typeof ctx === "object") {
+                    nextArgs[4] = {
+                        ...ctx,
+                        activeSkillRecipeContext: getSkillContext(ctx),
+                        getThinkingLevel: () => pi.getThinkingLevel(),
+                    };
+                }
+                try {
+                    return ToolsResponse.spaceToolResult(await execute(...nextArgs));
+                }
+                catch (error) {
+                    throw ToolsResponse.spaceToolError(error);
+                }
+            },
+        };
+    };
+    const runtime = Runtime.createAutoToolsRuntime({
+        configPath: Paths.EXTENSION_RUNTIME_PATHS.configPath,
+        exec: CommandTemplates.execCommandTemplate,
+        getActiveTools: () => pi.getActiveTools(),
+        registerTool: (definition) => {
+            const wrapped = withCurrentThinkingContext(definition);
+            actorToolDefinitions.set(wrapped.name, wrapped);
+            pi.registerTool(wrapped);
+        },
+        reservedToolNames: Tools.RESERVED_TOOL_NAMES,
+        setActiveTools: (toolNames) => pi.setActiveTools(toolNames),
+    });
+    const recipeReload = Runtime.createRecipeToolReloadWatcher(runtime);
+    return {
+        beforeAgentStart(systemPrompt, skills, ctx) {
+            skillContextsBySession.set(getRunOwnerId(ctx), RecipesReferences.createActiveSkillRecipeContext(skills));
+            return {
+                systemPrompt: `${systemPrompt}\n\n${Prompts.ONBOARDING_SYSTEM_PROMPT}`,
+            };
+        },
+        discoverResources(metaUrl) {
+            const skillPaths = Paths.getExistingExtensionSkillPaths(metaUrl);
+            return skillPaths.length > 0 ? { skillPaths } : undefined;
+        },
+        getRunOwnerId,
+        onAgentEnd(ctx) {
+            if (activeRunContext === ctx)
+                automaticReview.schedule();
+        },
+        onSessionShutdown(reason, ctx) {
+            skillContextsBySession.delete(getRunOwnerId(ctx));
+            activeRunContext = undefined;
+            automaticReview.close();
+            recipeReload.close();
+            runUiRuntime.shutdown(reason, ctx);
+        },
+        async onSessionStart(ctx) {
+            skillContextsBySession.set(getRunOwnerId(ctx), RecipesReferences.EMPTY_ACTIVE_SKILL_RECIPE_CONTEXT);
+            ctx.ui.setWidget("zz-pi-actors-comms", undefined);
+            activeRunContext = ctx;
+            runUiRuntime.close();
+            automaticReview.close();
+            recipeReload.close();
+            await Temp.prepareExtensionTempDir(Paths.EXTENSION_RUNTIME_PATHS.tempDir);
+            if (activeRunContext !== ctx)
+                return;
+            automaticReview.start(ctx);
+            runtime.loadTools(ctx);
+            runUiRuntime.start(ctx);
+            recipeReload.watch(ctx);
+        },
+        registerCoreTools() {
+            Pi.registerToolDefinitions(pi, Tools.createCoreActorToolDefinitions({
+                configPath: Paths.EXTENSION_RUNTIME_PATHS.configPath,
+                getActiveTools: () => pi.getActiveTools(),
+                getRuntimeTool: (name) => Tools.resolveActiveRuntimeTool(name, runtime.getTools(), (activeName) => actorToolDefinitions.get(activeName)),
+                handleRuntimeControl: automaticReview.handleControl,
+                registryRuntime: runtime,
+                setActiveTools: (toolNames) => pi.setActiveTools(toolNames),
+            }).map(withCurrentThinkingContext));
+        },
+    };
+}