@llblab/pi-actors 0.31.0 → 0.33.0

package/AGENTS.md

@@ -20,7 +20,7 @@ Pi host
   -> index.ts composition root
      -> lib/tools.ts / prompts.ts        public tool + injected prompt surface
      -> lib/runtime.ts / registry.ts     active user recipe tools
-     -> lib/recipe-*.ts                  packaged/user/candidate recipe discovery
+     -> lib/recipe-*.ts                  packaged/user/draft recipe discovery
      -> lib/async-runs.ts                spawn lifecycle and run state
      -> lib/actor-rooms.ts               room, roster, mailbox, communication log
      -> scripts/*.mjs                    thin process entrypoints
@@ -45,8 +45,8 @@ Pi host
 
 ## Repo Surfaces
 
-- `/scripts/*.mjs`: Stable executable shims for detached/helper processes.
-- `/lib/*.ts`: Compiled domain and script-entrypoint logic. Keep `scripts/*.mjs` lightweight and move substantive behavior into named domain modules so `dist/lib` is the JS-only runtime surface. This intentionally grows a standard library: script-born behavior should gain a clear domain name when reuse is plausible. Exception: self-contained application/build scripts with no expected second consumer, such as `music-player.mjs` or `build-dist.mjs`, may remain standalone `.mjs` files.
+- `/scripts/*.mjs`: Stable executables for detached/helper processes. Keep script-only release/build/glue behavior standalone when it has no plausible second consumer.
+- `/lib/*.ts`: Compiled domains and shared script-entrypoint logic. Move substantive script behavior into named domain modules only when reuse, tests, packaged JS-only execution, or clear ownership justifies it. Do not create a lib domain solely to keep a tiny script shim thin.
 - `/recipes/*.json`: Packaged standard recipe library. Keep recipes optional, composable, policy-light, and caller-configurable.
 - `/skills/actors/SKILL.md`: Dense practical reference for operating pi-actors itself.
 - `/skills/swarm/SKILL.md`: Bundled methodology skill for multi-agent standards, strategies, and portable examples.
@@ -61,6 +61,8 @@ Pi host
 - Prefer explicit operator action over silent user-config rewrites.
 - Keep published documentation portable: use `~`, `<repo>`, or relative paths instead of machine-local absolute paths.
 - Preserve runtime output discipline because tool output flows directly into agent context.
+- Optimize every actor-facing surface for signal over volume: prefer compact state-backed hints and fewer concepts over broad explanatory prose or speculative guidance.
+- Until a stable release greater than `1.x.x`, favor context compression over compatibility shims: do not preserve legacy actor-facing names, aliases, fields, env vars, paths, or docs solely for backward compatibility when a clearer current term exists. Remove compatibility layers in the same slice that renames a concept, and record the break in `CHANGELOG.md`.
 - Keep the project lens local-first and cybernetic: agents wrap durable local capabilities as actors, then use semantic tools and messages instead of repeatedly reconstructing shell commands.
 - Design recipes as agent-callable tools: make prompts, scopes, paths, models, and policy knobs public args/defaults when the caller should decide them at invocation time.
 - Decompose oversized bullets into sublists or hierarchy; long flat list items are a context-smell.
@@ -80,6 +82,7 @@ Pi host
 ## Public Actor Model
 
 - Preserve the public verbs: `spawn`, `message`, `inspect`.
+- Keep the model-facing concept ladder minimal: core is run actors, typed messages, intentional inspection, artifacts, and recipe/tool memory; group messaging, roster, branches, sessions, and diagnostics are advanced surfaces.
 - Prefer one typed actor-message envelope for upward, downward, lateral, parent/branch, and branch/parent messages.
 - Prefer actor addresses and inspect views over exposing FIFO, outbox, or status mechanics as public concepts.
 - Keep route and semantic type separate: delivery behavior comes from `to`, while `type` describes intent.
@@ -116,6 +119,7 @@ Pi host
 ## State, IO, And Safety
 
 - Tool stdout and temp state must stay bounded and local.
+- Feedback hints must be evidence-backed, bounded, and action-shaped; prefer `next_actions` pointing to existing verbs over prose, and avoid hints when no concrete next step is justified.
 - Keep tail truncation, full-output temp files, failure formatting, and centralized limits intact.
 - Published docs must not include machine-local absolute paths.
 - Any view scanning run directories must apply coordinator/session ownership filters before exposing summaries or previews.

package/BACKLOG.md

@@ -47,25 +47,12 @@ No open hotfix items.
 - File length alone is not a domain-split trigger: ~1000-line cohesive domain files are acceptable when ownership is clear.
 - Consider splitting only when a file crosses roughly 2000 lines, mixes real ownership zones, or hides a clearer domain boundary.
 - Prefer semantic compression before file splitting: fewer public nouns, consistent outcomes, compact diagnostics, and domain-owned constants/helpers.
+- Preserve signal/noise balance: feedback should be state-backed, compact, and action-shaped; do not add advisory prose just because a surface exists.
 
 ## Minor Backlog
 
 The backlog is intentionally pruned to the 20% of work most likely to deliver 80% of value for `pi-actors` as a local actor kernel. Bias toward consolidation, smaller public surface area, and reliability over new feature breadth.
 
-### M-14 Session Mismatch Follow-through
-
-- Priority: Medium.
-- Status: Planned.
-- Goal: Extend 0.27 structured session diagnostics consistently across room, branch, run, coordinator, and session workflows.
-- Why now: M-12 established the shape; dogfood should now make every ownership denial equally actionable without relaxing ownership gates.
-- Direction:
-  - Audit all session mismatch errors for consistent `reason`, owner/current session fields, and inspect-session hints.
-  - Keep read/write ownership policy unchanged.
-  - Update docs with session mismatch examples and recovery inspection paths.
-- Acceptance:
-  - Room, branch, run, coordinator, and session denials share the same compact/verbose shape.
-  - Tests cover representative inspect and message paths.
-
 ### M-15 Worker Stale-Claim Dogfood
 
 - Priority: Medium.
@@ -80,20 +67,6 @@ The backlog is intentionally pruned to the 20% of work most likely to deliver 80
   - Stale claims are reproducible and visible in worker status.
   - Tests cover stale-claim counting without adding scheduler/broker policy.
 
-### M-23 Tool Boundary Type Tightening
-
-- Priority: Low.
-- Status: Planned.
-- Goal: Remove avoidable `any` at the Pi/tool boundary where a narrow local type can express the real contract without broad rewiring.
-- Why now: `index.ts` still keeps runtime tool definitions in a `Map<string, any>`; this is small but visible in the composition root.
-- Direction:
-  - Add or reuse a narrow exported tool-definition type from the Pi adapter or tools domain.
-  - Keep SDK details behind `lib/pi.ts`.
-  - Do not introduce a broad type-modeling pass across every schema helper.
-- Acceptance:
-  - `index.ts` no longer uses `Map<string, any>` for actor tool definitions.
-  - TypeScript validation still passes without weakening public tool schemas.
-
 ### M-17 Message Delivery Outcome Contract
 
 - Priority: High.
@@ -111,37 +84,23 @@ The backlog is intentionally pruned to the 20% of work most likely to deliver 80
   - Room messages distinguish timeline append success from forwarded branch-targeted copies.
   - Tests cover at least run, branch, room, coordinator, and ownership-denied outcomes.
 
-### M-18 Candidate Recipe Promotion UX
+### M-18 Draft Recipe Promotion UX
 
 - Priority: High.
 - Status: Planned.
-- Goal: Make successful ad hoc actor patterns easy to promote manually from candidate memory into active user recipe memory.
-- Why now: Candidate recipes under `~/.pi/agent/recipes/candidates` are replayable but intentionally not active tools; the two-stage memory model now needs an explicit operator-gated promotion path.
+- Goal: Make successful ad hoc actor patterns easy to promote manually from draft memory into active user recipe memory.
+- Why now: Draft recipes under `~/.pi/agent/recipes/drafts` are replayable but intentionally not active tools, and the two-stage memory model needs an explicit operator-gated promotion path.
 - Direction:
-  - List candidate recipes with source run, timestamp, fingerprint, description/template preview, and validation status.
-  - Promote a selected candidate to `~/.pi/agent/recipes/<name>.json` only through an explicit action or explicit tool argument.
+  - List draft recipes with source run, timestamp, fingerprint, description/template preview, and validation status.
+  - Promote a selected draft to `~/.pi/agent/recipes/<name>.json` only through an explicit action or explicit tool argument.
   - Run recipe validation/doctor before writing and expose collision/shadowing diagnostics.
-  - Preserve candidate files unless deletion is explicitly requested.
+  - Preserve draft files unless deletion is explicitly requested.
   - Prefer extending existing registry/tool surfaces over adding a new public noun.
 - Acceptance:
-  - Candidate recipes remain non-tools until promotion.
+  - Draft recipes remain non-tools until promotion.
   - Promotion writes atomically and never auto-promotes.
-  - Tests cover valid promotion, invalid candidate, name collision, and packaged-recipe shadowing.
-  - Docs explain candidate memory vs active tool memory in one compact section.
-
-### M-24 Registry Path Naming Cleanup
-
-- Priority: Low.
-- Status: Planned.
-- Goal: Reduce legacy-storage naming noise without changing the persistent file path.
-- Why now: `legacy-tool-registry.json` is still a compatibility storage path, but helper names and tests should make clear that the stable path is retained intentionally.
-- Direction:
-  - Prefer neutral helper/test wording such as registry path or retained registry storage path.
-  - Keep the on-disk filename unchanged unless a separate migration is justified.
-  - Do not reintroduce legacy migration code.
-- Acceptance:
-  - Path helpers and tests no longer imply an unfinished migration.
-  - Existing registry storage compatibility remains unchanged.
+  - Tests cover valid promotion, invalid draft, name collision, and packaged-recipe shadowing.
+  - Docs explain draft memory vs active tool memory in one compact section.
 
 ### M-19 Recipe Doctor Risk Labels v2
 
@@ -166,10 +125,10 @@ The backlog is intentionally pruned to the 20% of work most likely to deliver 80
 - Priority: Medium.
 - Status: Planned.
 - Goal: Add one compact operator triage view that answers what needs attention right now without performing repairs.
-- Why now: Runtime status, recipe doctor, candidates, stale claims, session mismatches, failed runs, and other-session counts are currently separate bounded surfaces.
+- Why now: Runtime status, recipe doctor, drafts, stale claims, session mismatches, failed runs, and other-session counts are currently separate bounded surfaces.
 - Direction:
   - Add `inspect target=tool:pi-actors view=triage` or an equivalent existing inspect surface.
-  - Summarize runtime version/mode, active runs, other-session runs, invalid or blocking recipes, high-risk recipes, candidate recipes, stale worker claims, recent failed runs, attention messages, and suggested next inspect actions.
+  - Summarize runtime version/mode, active runs, other-session runs, invalid or blocking recipes, high-risk recipes, draft recipes, stale worker claims, recent failed runs, attention messages, and suggested next inspect actions.
   - Keep every warning tied to a next inspect/action hint.
   - Do not auto-repair, auto-prune, relax ownership, or hide detailed source-of-truth views.
 - Acceptance:
@@ -226,7 +185,7 @@ These are valid ideas but not current focus. Reintroduce only with concrete evid
 ## Suggested Milestone Order
 
 ```text
-Next milestone: M-14 Session Mismatch Follow-through.
-Then: M-15 Worker Stale-Claim Dogfood → M-17 Message Delivery Outcome Contract → M-18 Candidate Recipe Promotion UX.
+Next milestone: M-15 Worker Stale-Claim Dogfood.
+Then: M-17 Message Delivery Outcome Contract → M-18 Draft Recipe Promotion UX.
 Small cleanup lane: M-23 Tool Boundary Type Tightening → M-24 Registry Path Naming Cleanup.
 ```

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## Unreleased
 
+## 0.33.0: Signal-First Compatibility Pruning
+
+- `[Breaking]` Removed pre-1.x compatibility shims for draft recipe terminology: draft captures now live under `~/.pi/agent/recipes/drafts`, recipe inspection no longer emits `candidates`, spawn details no longer emit `candidate_recipe`, and shadow diagnostics use `blocked_fallback` instead of `blocked_candidate`.
+- `[Context]` Documented the pre-stable policy that context compression wins over compatibility aliases until after a stable release greater than `1.x.x`; rename slices should remove legacy actor-facing names, fields, env vars, paths, and docs instead of carrying shims.
+- `[Breaking]` Renamed retained registry storage from `legacy-tool-registry.json` to `tool-registry.json`, removing the stale compatibility noun from runtime path helpers and tests.
+- `[Types]` Added a narrow actor tool-definition type and removed the remaining `Map<string, any>` from the composition root without expanding SDK type exposure.
+- `[Scripts]` Collapsed the conformance runner back into a standalone script and removed its one-off lib domain, documenting that script-only glue should stay self-contained unless reuse or packaged runtime constraints justify a domain.
+
+## 0.32.0: Actor Surface Minimization
+
+- `[Context]` Added durable signal/noise guidance for actor-facing surfaces: keep the model-facing concept ladder minimal, make feedback hints state-backed and action-shaped, and avoid speculative advisory prose.
+- `[Backlog]` Added critical concept-surface compression and actor feedback-loop strengthening tracks to guide the next minimization-focused development cycle.
+- `[Concepts]` Compressed model-facing language by presenting captured inline-spawn recipes as drafts, treating `room:<run>` as advanced group messaging plus roster, demoting coordinator/session/debug views from golden-path guidance, and keeping compatibility names/paths as storage details rather than core onboarding nouns.
+- `[Feedback]` Added bounded next-action hints to recipe registry/doctor inspection, artifact inspection, delivery-fallback message results, and terminal run follow-ups so state-backed surfaces point back to `inspect`, `message`, `spawn`, or draft promotion without polling or auto-repair.
+- `[Sessions]` Normalized session-directed message ownership failures onto the same structured `reason=session_mismatch`, owner/current session, and inspect-session hint shape used by run, branch, room, and coordinator ownership denials.
+
 ## 0.31.0: Agent Adoption Ergonomics
 
 - `[Adoption]` Added a compact actor-mode trigger rule to the injected prompt, actors skill, README, and async-run docs so models prefer `spawn → message → inspect` for long-lived, stateful, follow-up, artifact, service, fanout, and resumable work while keeping short foreground checks as ordinary tools.

package/README.md

@@ -66,16 +66,21 @@ The npm package is dist-first for JavaScript-only runtimes: default Pi metadata
 
 ## Address Surface
 
-Actors and coordination endpoints are addressed with compact route strings:
+Core actor addresses stay small:
 
 ```text
-run:<id>               one detached actor run
-branch:<run>/<branch>  branch-local actor endpoint
-room:<run>             shared run-local task room
-coordinator            launching coordinator attention path
+run:<id>      one detached actor run
+tool:<name>   executable registered tool actor
+```
+
+Advanced coordination/debug addresses are available when a recipe or workflow needs them:
+
+```text
+branch:<run>/<branch>  branch-local worker endpoint
+room:<run>             group-message timeline plus roster for one run
+coordinator            compatibility alias for the current session coordination path
 session:               current session actor surface
-session:all            cross-session inventory surface
-tool:<name>            executable registered tool
+session:all            cross-session inventory surface for diagnostics
 ```
 
 Actor messages use one envelope shape:
@@ -140,9 +145,9 @@ message to=run:docs_review type=control.continue body=continue
 message to=run:docs_review type=control.kill body=stop
 ```
 
-## Actor Rooms
+## Group Messaging And Roster
 
-Every spawned run can have a shared room at `room:<run>`. A room is not a broker and not a chat app. It is a run-local coordination surface: append-only timeline, compact roster, member discovery, and previews.
+Every spawned run can have advanced group messaging at `room:<run>`. Treat this as a run-local timeline plus roster for coordinated actors, not as a core chat/broker concept.
 
 Actors can join, post, leave, and discover peers:
 
@@ -155,7 +160,7 @@ message \
   body='{"role":"reviewer","caps":["security-review"],"claim":"Review auth boundary risks"}'
 ```
 
-Inspect the room intentionally:
+Inspect group messages and roster intentionally:
 
 ```text
 inspect target=room:review view=status
@@ -165,7 +170,7 @@ inspect target=room:review view=contacts
 inspect target=room:review view=messages
 ```
 
-Room posts require a same-run sender, so unrelated runs do not pollute the roster. Direct messages and room messages use the same envelope; only the address changes. Direct `branch:<run>/<branch>` messages are private: they are forwarded through the parent run mailbox and recorded in the recipient branch inbox for worker protocols that consume queued branch work. For selected-recipient multicast, send to `room:<run>` with `metadata.recipients` set to same-run `branch:<run>/<branch>` addresses; this keeps one room transcript entry while forwarding branch-targeted copies.
+Group posts require a same-run sender, so unrelated runs do not pollute the roster. Direct messages and group messages use the same envelope; only the address changes. Direct `branch:<run>/<branch>` messages are private: they are forwarded through the parent run mailbox and recorded in the recipient branch inbox for worker protocols that consume queued branch work. For selected-recipient multicast, send to `room:<run>` with `metadata.recipients` set to same-run `branch:<run>/<branch>` addresses; this keeps one visible transcript entry while forwarding branch-targeted copies.
 
 ## Actor Inspector
 

package/dist/lib/observability.js

@@ -721,19 +721,30 @@ function formatRecipePersistenceSuggestion(transition) {
     }
     return `\nAgent note: this actor was spawned directly and completed successfully. If this pattern fits this machine's recurring workflow, ask the operator whether to save it as a durable recipe/tool under ~/.pi/agent/recipes with register_tool. Do not auto-save without confirmation.`;
 }
+function formatTransitionNextActions(transition) {
+    const actions = [
+        `inspect target=run:${transition.run} view=status`,
+        transition.to === "done" && Object.keys(transition.artifacts ?? {}).length > 0
+            ? `inspect target=run:${transition.run} view=artifacts`
+            : `inspect target=run:${transition.run} view=tail`,
+        `inspect target=run:${transition.run} view=messages`,
+    ].filter(Boolean);
+    return `\nNext actions: ${actions.join(" | ")}`;
+}
 export function formatRunTransitionMessage(transition) {
     const artifacts = formatNamedArtifacts(transition.artifacts);
     const runFiles = formatRunFileList(getRunArtifacts(transition));
     const persistenceSuggestion = formatRecipePersistenceSuggestion(transition);
+    const nextActions = formatTransitionNextActions(transition);
     if (transition.to === "done")
-        return `Run ${transition.run} completed successfully.${artifacts}${runFiles}\nUse inspect target=run:${transition.run} view=status or view=tail if the result needs inspection.${persistenceSuggestion}`;
+        return `Run ${transition.run} completed successfully.${artifacts}${runFiles}${nextActions}${persistenceSuggestion}`;
     if (transition.to === "failed")
-        return `Run ${transition.run} failed.${artifacts}${runFiles}\nUse inspect target=run:${transition.run} view=status or view=tail for details.`;
+        return `Run ${transition.run} failed.${artifacts}${runFiles}${nextActions}`;
     if (transition.to === "cancelled")
-        return `Run ${transition.run} was cancelled. Use inspect target=run:${transition.run} view=status or view=tail if analysis is needed.`;
+        return `Run ${transition.run} was cancelled.${nextActions}`;
     if (transition.to === "killed")
-        return `Run ${transition.run} was force-killed. Use inspect target=run:${transition.run} view=status or view=tail if analysis is needed.`;
+        return `Run ${transition.run} was force-killed.${nextActions}`;
     if (transition.to === "exited")
-        return `Run ${transition.run} exited before writing a result. Use inspect target=run:${transition.run} view=status or view=tail if analysis is needed.`;
-    return `Run ${transition.run} finished with status ${transition.to}. Use inspect target=run:${transition.run} view=status or view=tail if analysis is needed.`;
+        return `Run ${transition.run} exited before writing a result.${nextActions}`;
+    return `Run ${transition.run} finished with status ${transition.to}.${nextActions}`;
 }

package/dist/lib/paths.d.ts

@@ -17,5 +17,5 @@ export declare const EXTENSION_RUNTIME_PATHS: ExtensionRuntimePaths;
 export declare function getExtensionSkillsDir(extensionUrl: string): string;
 export declare function getExistingExtensionSkillPaths(extensionUrl: string): string[];
 export declare function getRecipeRoot(agentDir?: string): string;
-export declare function getRecipeCandidateRoot(agentDir?: string): string;
+export declare function getRecipeDraftRoot(agentDir?: string): string;
 export declare function getPackagedRecipeRoot(): string;

package/dist/lib/paths.js

@@ -13,7 +13,7 @@ export function getAgentDir(env = process.env) {
         : join(homedir(), ".pi", "agent");
 }
 export function getConfigPath(agentDir = getAgentDir()) {
-    return join(agentDir, "legacy-tool-registry.json");
+    return join(agentDir, "tool-registry.json");
 }
 export function getExtensionTmpDir(agentDir = getAgentDir(), extensionName = "pi-actors") {
     return join(agentDir, "tmp", extensionName);
@@ -39,8 +39,8 @@ export function getExistingExtensionSkillPaths(extensionUrl) {
 export function getRecipeRoot(agentDir = getAgentDir()) {
     return join(agentDir, "recipes");
 }
-export function getRecipeCandidateRoot(agentDir = getAgentDir()) {
-    return join(getRecipeRoot(agentDir), "candidates");
+export function getRecipeDraftRoot(agentDir = getAgentDir()) {
+    return join(getRecipeRoot(agentDir), "drafts");
 }
 export function getPackagedRecipeRoot() {
     const here = dirname(fileURLToPath(import.meta.url));

package/dist/lib/recipe-discovery.d.ts

@@ -47,6 +47,6 @@ export declare function discoverRecipeSources(sources: RecipeDiscoverySource[]):
 export declare function discoverRecipes(roots: string[]): RecipeDiscoveryResult;
 export declare function createRecipeIntegrityManifest(result: RecipeDiscoveryResult): RecipeIntegrityManifestEntry[];
 export declare function getShadowedLaunchDiagnostic(result: RecipeDiscoveryResult, id: string): Record<string, unknown> | undefined;
-export declare function listCandidateRecipes(root: string): Array<Record<string, unknown>>;
+export declare function listDraftRecipes(root: string): Array<Record<string, unknown>>;
 export declare function summarizeDiscovery(result: RecipeDiscoveryResult): Record<string, unknown>;
 export declare function toRegisteredTool(entry: DiscoveredRecipe): RegisteredTool | undefined;

package/dist/lib/recipe-discovery.js

@@ -324,16 +324,16 @@ function diagnosticDetails(result) {
 }
 function remediationForEntry(entry, activePath) {
     const riskyDiagnostics = entry.diagnostics.filter((message) => diagnosticSeverity(message) === "warning");
-    const blockedCandidate = entry.shadows[0];
+    const blockedFallback = entry.shadows[0];
     if (entry.invalid) {
         return {
             id: entry.id,
-            kind: blockedCandidate ? "blocking_invalid" : "invalid",
+            kind: blockedFallback ? "blocking_invalid" : "invalid",
             severity: "error",
             path: entry.path,
-            ...(blockedCandidate ? { blocked_candidate: blockedCandidate } : {}),
-            reason: blockedCandidate
-                ? "invalid higher-priority recipe blocks a lower-priority candidate"
+            ...(blockedFallback ? { blocked_fallback: blockedFallback } : {}),
+            reason: blockedFallback
+                ? "invalid higher-priority recipe blocks a lower-priority fallback"
                 : "recipe is invalid and cannot be exposed as a tool",
             action: "fix recipe syntax/config, or disable/delete/archive it to restore fallback",
         };
@@ -341,12 +341,12 @@ function remediationForEntry(entry, activePath) {
     if (entry.disabled && entry.active) {
         return {
             id: entry.id,
-            kind: blockedCandidate ? "blocking_disabled" : "disabled",
+            kind: blockedFallback ? "blocking_disabled" : "disabled",
             severity: "warning",
             path: entry.path,
-            ...(blockedCandidate ? { blocked_candidate: blockedCandidate } : {}),
-            reason: blockedCandidate
-                ? "disabled higher-priority recipe intentionally blocks a lower-priority candidate"
+            ...(blockedFallback ? { blocked_fallback: blockedFallback } : {}),
+            reason: blockedFallback
+                ? "disabled higher-priority recipe intentionally blocks a lower-priority fallback"
                 : "recipe is disabled and not exposed as a tool",
             action: "keep disabled intentionally, re-enable, or delete/archive the file",
         };
@@ -420,12 +420,12 @@ export function getShadowedLaunchDiagnostic(result, id) {
         return undefined;
     return {
         active_path: active.path,
-        blocked_candidate: active.shadows[0],
+        blocked_fallback: active.shadows[0],
         hint: "inspect_recipes_doctor",
         reason: active.invalid ? "shadowed_invalid" : "shadowed_disabled",
     };
 }
-export function listCandidateRecipes(root) {
+export function listDraftRecipes(root) {
     return listRecipeFiles(root).map((path) => {
         const id = RecipeReferences.getRecipeIdFromPath(path);
         const config = RecipeReferences.readRawRecipeConfig(path);

package/dist/lib/tools.d.ts

@@ -8,6 +8,11 @@ import * as Execution from "./execution.ts";
 import * as Registry from "./registry.ts";
 export type RegisterToolInput = Registry.RegisterToolInput;
 export type RegisterToolRuntimeDeps<TContext> = Registry.RegisterToolRuntimeDeps<TContext>;
+export interface ActorToolDefinition {
+    name: string;
+    execute?: (...args: never[]) => unknown;
+    [key: string]: unknown;
+}
 export interface CoreActorToolDefinitionDeps<TContext extends AsyncRunToolContext> {
     configPath: string;
     getActiveTools: () => string[];
@@ -43,6 +48,6 @@ export interface ActorMessageToolDeps<TContext = unknown> {
     getTool?: (name: string) => any | undefined;
 }
 export declare function createActorMessageToolDefinition<TContext = unknown>(deps?: ActorMessageToolDeps<TContext>): any;
-export declare function createCoreActorToolDefinitions<TContext extends AsyncRunToolContext>(deps: CoreActorToolDefinitionDeps<TContext>): any[];
+export declare function createCoreActorToolDefinitions<TContext extends AsyncRunToolContext>(deps: CoreActorToolDefinitionDeps<TContext>): ActorToolDefinition[];
 export declare function createRuntimeToolDefinition(cfg: RegisteredTool, exec: Execution.RegisteredToolExec): any;
 export {};