@pikku/core 0.12.69 → 0.12.71

package/dist/types/core.types.d.ts

@@ -12,6 +12,7 @@ import type { PikkuScheduledTask } from '../wirings/scheduler/scheduler.types.js
 import type { PikkuQueue, QueueService } from '../wirings/queue/queue.types.js';
 import type { PikkuCLI } from '../wirings/cli/cli.types.js';
 import type { PikkuWorkflowWire, PikkuScenarioWire, WorkflowService, WorkflowServiceConfig, WorkflowStepWire } from '../wirings/workflow/workflow.types.js';
+import type { PikkuBrowserWire, PikkuScenarioStepWire } from '../wirings/workflow/scenario-step.types.js';
 import type { PikkuGraphWire } from '../wirings/workflow/graph/workflow-graph.types.js';
 import type { PikkuTrigger } from '../wirings/trigger/trigger.types.js';
 import type { PikkuGateway } from '../wirings/gateway/gateway.types.js';
@@ -19,7 +20,7 @@ import type { SchedulerService } from '../services/scheduler-service.js';
 import type { DeploymentService } from '../services/deployment-service.js';
 import type { AIStorageService } from '../services/ai-storage-service.js';
 import type { ContentService } from '../services/content-service.js';
-import type { ScenarioActors } from '../services/scenario-actors-service.js';
+import type { ScenarioActorOf, ScenarioActors } from '../services/scenario-actors-service.js';
 import type { AIAgentRunnerService } from '../services/ai-agent-runner-service.js';
 import type { AIEmbeddingService } from '../services/ai-embedding-service.js';
 import type { AIRunStateService } from '../services/ai-run-state-service.js';
@@ -85,6 +86,22 @@ export type FunctionRuntimeMeta = {
     scopes?: string[];
     expose?: boolean;
     remote?: boolean;
+    /**
+     * A step RPC: a name dispatched by a scenario run and refused everywhere
+     * else. It sits alongside `expose` (public) and `remote` as a kind of RPC
+     * rather than a separate concept — a step is invoked by name exactly as an
+     * RPC is, which is why a run records the step function in its `rpcName`.
+     * What makes it its own kind is that it is never network-callable: a step
+     * may drive a browser or assert against fixtures.
+     */
+    scenarioStep?: boolean;
+    /**
+     * The function behind a `pikkuScenario(...)` — a scenario's own body, as
+     * opposed to the steps it calls. Marked for the same reason as
+     * `scenarioStep`: a scenario is only ever run by `pikku scenario run`, so it
+     * has to be held back from the app bootstrap and from every deployed unit.
+     */
+    scenario?: boolean;
     mcp?: boolean;
     readonly?: boolean;
     deploy?: 'serverless' | 'server' | 'auto';
@@ -95,6 +112,10 @@ export type FunctionRuntimeMeta = {
     workflowRetries?: number;
     /** Timeout when this function is used as a workflow step (e.g. '30s', '5m'). */
     workflowTimeout?: string;
+    /** Scenario steps only: this step drives a browser, so the runner must provision one and an actor is mandatory. */
+    scenarioStepBrowser?: boolean;
+    /** Scenario steps only: the prose a reporter renders, with `{placeholders}` filled from the step's recorded input. */
+    scenarioStepTemplate?: string;
     version?: number;
     approvalRequired?: boolean;
     approvalDescription?: string;
@@ -306,7 +327,7 @@ export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
 /**
  * Represents different forms of wire within Pikku and the outside world.
  */
-export type PikkuWire<In = unknown, Out = unknown, HasInitialSession extends boolean = false, UserSession extends CoreUserSession = CoreUserSession, TypedRPC extends PikkuRPC = PikkuRPC, IsChannel extends true | null = null, MCPTools extends string | never = never, TypedWorkflow extends PikkuWorkflowWire | never = PikkuWorkflowWire, TriggerOutput = unknown, TypedScenario extends PikkuScenarioWire | never = PikkuScenarioWire> = {
+export type PikkuWire<In = unknown, Out = unknown, HasInitialSession extends boolean = false, UserSession extends CoreUserSession = CoreUserSession, TypedRPC extends PikkuRPC = PikkuRPC, IsChannel extends true | null = null, MCPTools extends string | never = never, TypedWorkflow extends PikkuWorkflowWire | never = PikkuWorkflowWire, TriggerOutput = unknown, TypedScenario extends PikkuScenarioWire | never = PikkuScenarioWire, TypedActors extends ScenarioActors = ScenarioActors> = {
     /** Always present — lazily initialised on first access for every function invocation */
     rpc: TypedRPC;
 } & Partial<{
@@ -326,7 +347,11 @@ export type PikkuWire<In = unknown, Out = unknown, HasInitialSession extends boo
     cli: PikkuCLI;
     workflow: TypedWorkflow;
     scenario: TypedScenario;
-    actors: ScenarioActors;
+    actors: TypedActors;
+    /** Present on every scenario step invocation */
+    scenarioStep: PikkuScenarioStepWire<ScenarioActorOf<TypedActors>>;
+    /** Present only when the runner provisioned a browser for this step */
+    browser: PikkuBrowserWire;
     workflowStep: WorkflowStepWire;
     graph: PikkuGraphWire;
     trigger: PikkuTrigger<TriggerOutput>;

package/dist/types/state.types.d.ts

@@ -9,7 +9,7 @@ import type { CoreAIAgent, AIAgentMeta } from '../wirings/ai-agent/ai-agent.type
 import type { CoreGateway, GatewaysMeta } from '../wirings/gateway/gateway.types.js';
 import type { CoreQueueWorker, QueueWorkersMeta } from '../wirings/queue/queue.types.js';
 import type { CoreScheduledTask, ScheduledTasksMeta } from '../wirings/scheduler/scheduler.types.js';
-import type { CoreWorkflow, WorkflowsRuntimeMeta } from '../wirings/workflow/workflow.types.js';
+import type { CoreWorkflow, CoreFeature, WorkflowsRuntimeMeta } from '../wirings/workflow/workflow.types.js';
 import type { CoreTrigger, CoreTriggerSource, TriggerMeta, TriggerSourceMeta } from '../wirings/trigger/trigger.types.js';
 import type { FunctionsMeta, CorePikkuMiddleware, CorePikkuMiddlewareGroup, CreateConfig, CreateSingletonServices, CreateWireServices, CoreConfig, CoreSingletonServices, CoreServices, CoreUserSession } from './core.types.js';
 import type { CorePikkuChannelMiddleware } from '../wirings/channel/channel.types.js';
@@ -77,6 +77,8 @@ export interface PikkuPackageState {
     };
     workflows: {
         registrations: Map<string, CoreWorkflow>;
+        /** Scenario groups declared with `pikkuFeature`, keyed by export name. */
+        features: Map<string, CoreFeature>;
         meta: WorkflowsRuntimeMeta;
     };
     trigger: {

package/dist/wirings/actor-flow/actor-flow.types.d.ts

@@ -20,7 +20,7 @@ export interface ConverseOptions<TAgentName extends string = string> {
     evaluate: string;
     /** How the actor answers the agent's tool-approval requests. Default `'in-persona'`. */
     approvals?: ActorFlowApprovalPolicy;
-    /** Model the persona uses for its own turns/decisions. Falls back to the actor service default. */
+    /** Model the actor uses for its own turns/decisions. Falls back to the actor service default. */
     model?: string;
     /** Hard cap on conversation turns before forcing evaluation. Default 12. */
     maxTurns?: number;

package/dist/wirings/actor-flow/index.d.ts

@@ -8,4 +8,4 @@
  * over HTTP.
  */
 export type { ActorFlowApprovalPolicy, ActorFlowVerdict, ConverseOptions, TargetAgentReply, TargetPendingApproval, TargetAgentDriver, } from './actor-flow.types.js';
-export { runConversation, type RunConversationParams, type PersonaLLM, } from './run-conversation.js';
+export { runConversation, type RunConversationParams, type ActorLLM, } from './run-conversation.js';

package/dist/wirings/actor-flow/run-conversation.d.ts

@@ -1,20 +1,20 @@
 import type { ActorFlowApprovalPolicy, ActorFlowVerdict, TargetAgentDriver } from './actor-flow.types.js';
 import type { ScenarioActorConfig } from '../../services/scenario-actors-service.js';
 import type { AIAgentRunnerParams, AIAgentStepResult } from '../../services/ai-agent-runner-service.js';
-/** The LLM call the persona uses for its own turns/decisions/evaluation. */
-export type PersonaLLM = (params: AIAgentRunnerParams) => Promise<AIAgentStepResult>;
+/** The LLM call the actor uses for its own turns/decisions/evaluation. */
+export type ActorLLM = (params: AIAgentRunnerParams) => Promise<AIAgentStepResult>;
 export interface RunConversationParams {
-    /** Persona config (personality/jobTitle/name) that shapes how the actor talks. */
-    persona: ScenarioActorConfig;
-    /** Stable persona name (for transcript labelling). */
-    personaName: string;
+    /** The actor's own config (personality/jobTitle/name), which shapes how it talks. */
+    actor: ScenarioActorConfig;
+    /** Stable actor name (for transcript labelling). */
+    actorName: string;
     /** What the actor is trying to get the target agent to accomplish. */
     task: string;
     /** Natural-language success criterion the actor evaluates at the end. */
     evaluate: string;
     /** How the actor answers the target agent's tool-approval requests. */
     approvals?: ActorFlowApprovalPolicy;
-    /** Model the persona uses for its own turns/decisions. */
+    /** Model the actor uses for its own turns/decisions. */
     model: string;
     /** Hard cap on conversation turns. Default 12. */
     maxTurns?: number;
@@ -22,13 +22,13 @@ export interface RunConversationParams {
     maxApprovalRounds?: number;
     /** Transport that drives the target agent (HTTP in production). */
     target: TargetAgentDriver;
-    /** The persona's own LLM. */
-    llm: PersonaLLM;
+    /** The actor's own LLM. */
+    llm: ActorLLM;
     /** Display name of the target agent (transcript labelling). */
     agentName: string;
 }
 /**
- * Run a conversation: an LLM-driven persona holds a real multi-turn exchange
+ * Run a conversation: an LLM-driven actor holds a real multi-turn exchange
  * with a target agent (driven via the injected transport), answers the target's
  * tool-approval requests in-persona, then evaluates whether the task was met.
  * Deterministic checks are the caller's responsibility.

package/dist/wirings/actor-flow/run-conversation.js

@@ -1,5 +1,5 @@
-/** One turn the persona takes: the message to send and whether it's finished. */
-const PERSONA_TURN_SCHEMA = {
+/** One turn the actor takes: the message to send and whether it's finished. */
+const ACTOR_TURN_SCHEMA = {
     type: 'object',
     properties: {
         message: { type: 'string' },
@@ -7,7 +7,7 @@ const PERSONA_TURN_SCHEMA = {
     },
     required: ['message', 'done'],
 };
-/** The persona's approve/deny decision for each pending tool request. */
+/** The actor's approve/deny decision for each pending tool request. */
 const APPROVAL_DECISION_SCHEMA = {
     type: 'object',
     properties: {
@@ -26,7 +26,7 @@ const APPROVAL_DECISION_SCHEMA = {
     },
     required: ['decisions'],
 };
-/** The persona's final verdict on whether the task was accomplished. */
+/** The actor's final verdict on whether the task was accomplished. */
 const EVALUATION_SCHEMA = {
     type: 'object',
     properties: {
@@ -60,13 +60,13 @@ function readObject(result) {
     }
     return null;
 }
-function personaInstructions(persona, task) {
+function actorInstructions(actor, task) {
     return [
         `You are role-playing a real user interacting with an AI assistant. Stay in character at all times — you are the user, not the assistant.`,
-        persona.name ? `Your name is ${persona.name}.` : '',
-        persona.jobTitle ? `Your role: ${persona.jobTitle}.` : '',
-        persona.personality
-            ? `Your personality and communication style: ${persona.personality}. Match this tone, vocabulary, and level of detail exactly.`
+        actor.name ? `Your name is ${actor.name}.` : '',
+        actor.jobTitle ? `Your role: ${actor.jobTitle}.` : '',
+        actor.personality
+            ? `Your personality and communication style: ${actor.personality}. Match this tone, vocabulary, and level of detail exactly.`
             : '',
         `Your goal in this conversation: ${task}.`,
         `Send one message at a time. Set "done" to true only once your goal is clearly accomplished, or clearly impossible.`,
@@ -74,7 +74,7 @@ function personaInstructions(persona, task) {
         .filter(Boolean)
         .join('\n');
 }
-/** Route the target agent's pending tool approvals through the persona. */
+/** Route the target agent's pending tool approvals through the actor. */
 async function decideApprovals(params, instructions, pending) {
     const policy = params.approvals ?? 'in-persona';
     if (policy === 'always') {
@@ -88,7 +88,7 @@ async function decideApprovals(params, instructions, pending) {
         .join('\n');
     const result = await params.llm({
         model: params.model,
-        instructions: `${instructions}\nThe assistant is asking permission to run tools on your behalf. Decide whether YOU, as this persona, would allow each one.`,
+        instructions: `${instructions}\nThe assistant is asking permission to run tools on your behalf. Decide whether YOU, as this actor, would allow each one.`,
         messages: [
             msg('user', `The assistant wants to run these tools:\n${summary}\nApprove or deny each toolCallId.`),
         ],
@@ -104,7 +104,7 @@ async function decideApprovals(params, instructions, pending) {
         return { toolCallId: p.toolCallId, approved: match?.approved ?? false };
     });
 }
-/** Drive the target to a non-suspended reply, routing approvals to the persona. */
+/** Drive the target to a non-suspended reply, routing approvals to the actor. */
 async function converseWithTarget(params, instructions, message) {
     const maxRounds = params.maxApprovalRounds ?? DEFAULT_MAX_APPROVAL_ROUNDS;
     let reply = await params.target.run(message);
@@ -122,40 +122,40 @@ async function converseWithTarget(params, instructions, message) {
     return reply;
 }
 /**
- * Run a conversation: an LLM-driven persona holds a real multi-turn exchange
+ * Run a conversation: an LLM-driven actor holds a real multi-turn exchange
  * with a target agent (driven via the injected transport), answers the target's
  * tool-approval requests in-persona, then evaluates whether the task was met.
  * Deterministic checks are the caller's responsibility.
  */
 export async function runConversation(params) {
     const maxTurns = params.maxTurns ?? DEFAULT_MAX_TURNS;
-    const instructions = personaInstructions(params.persona, params.task);
-    // Seed a kickoff so the very first persona turn has a non-empty message list
-    // (providers reject an empty prompt). It's an instruction TO the persona, so
+    const instructions = actorInstructions(params.actor, params.task);
+    // Seed a kickoff so the very first actor turn has a non-empty message list
+    // (providers reject an empty prompt). It's an instruction TO the actor, so
     // it never appears in the transcript.
-    const personaMessages = [
+    const actorMessages = [
         msg('user', 'Begin the conversation now — send your first message to the assistant to work towards your goal.'),
     ];
     const transcript = [];
     for (let turn = 0; turn < maxTurns; turn++) {
-        const personaResult = await params.llm({
+        const actorResult = await params.llm({
             model: params.model,
             instructions,
-            messages: personaMessages,
+            messages: actorMessages,
             tools: [],
             maxSteps: 1,
             toolChoice: 'none',
-            outputSchema: PERSONA_TURN_SCHEMA,
+            outputSchema: ACTOR_TURN_SCHEMA,
         });
-        const turnData = readObject(personaResult);
-        const personaMessage = turnData?.message?.trim();
-        if (!personaMessage) {
+        const turnData = readObject(actorResult);
+        const actorMessage = turnData?.message?.trim();
+        if (!actorMessage) {
             break;
         }
-        personaMessages.push(msg('assistant', personaMessage));
-        transcript.push(`${params.personaName}: ${personaMessage}`);
-        const reply = await converseWithTarget(params, instructions, personaMessage);
-        personaMessages.push(msg('user', reply.text ?? ''));
+        actorMessages.push(msg('assistant', actorMessage));
+        transcript.push(`${params.actorName}: ${actorMessage}`);
+        const reply = await converseWithTarget(params, instructions, actorMessage);
+        actorMessages.push(msg('user', reply.text ?? ''));
         transcript.push(`${params.agentName}: ${reply.text ?? ''}`);
         if (turnData?.done) {
             break;

package/dist/wirings/ai-agent/ai-agent-agui.js

@@ -256,14 +256,6 @@ export function wrapChannelWithAGUI(inner, options) {
                     });
                     break;
                 }
-                case 'workflow-created': {
-                    send({
-                        type: 'CUSTOM',
-                        name: 'pikku:workflow-created',
-                        value: { workflowName: event.workflowName, graph: event.graph },
-                    });
-                    break;
-                }
                 case 'agent-call': {
                     send({
                         type: 'CUSTOM',

package/dist/wirings/ai-agent/ai-agent-prepare.js

@@ -312,8 +312,7 @@ export function createScopedChannel(parent, agentName, session) {
                 event.type === 'tool-call' ||
                 event.type === 'tool-result' ||
                 event.type === 'usage' ||
-                event.type === 'error' ||
-                event.type === 'workflow-created') {
+                event.type === 'error') {
                 parent.send({ ...event, agent: agentName, session });
             }
             else {

package/dist/wirings/ai-agent/ai-agent.types.d.ts

@@ -346,12 +346,6 @@ export type AIStreamEvent = {
     type: 'audio-done';
     agent?: string;
     session?: string;
-} | {
-    type: 'workflow-created';
-    workflowName: string;
-    graph: any;
-    agent?: string;
-    session?: string;
 } | {
     type: 'data';
     name: string;

package/dist/wirings/cli/command-parser.js

@@ -150,8 +150,18 @@ export function parseCLIArguments(args, programName, allMeta) {
         const arg = args[currentIndex];
         if (arg.startsWith('--')) {
             // Long option (--from-plan → fromPlan)
+            const negatedKey = arg.startsWith('--no-')
+                ? toCamelCase(arg.slice(5))
+                : undefined;
             const equalIndex = arg.indexOf('=');
-            if (equalIndex > 0) {
+            if (negatedKey &&
+                typeof availableOptions[negatedKey]?.default === 'boolean') {
+                // --no-<flag> turns a boolean option off. Only options that declare a
+                // boolean default can be negated, so a literal `--no-something` option
+                // name still parses as itself.
+                optionArgs[negatedKey] = false;
+            }
+            else if (equalIndex > 0) {
                 // --option=value format
                 const key = toCamelCase(arg.slice(2, equalIndex));
                 const optionDef = availableOptions[key];

package/dist/wirings/rpc/rpc-runner.js

@@ -129,7 +129,7 @@ export class ContextAwareRPCService {
         if (!functionMeta) {
             throw new RPCNotFoundError(funcName);
         }
-        if (!functionMeta.expose) {
+        if (!functionMeta.expose || functionMeta.scenarioStep) {
             throw new RPCNotFoundError(funcName);
         }
         return await this.rpc(funcName, data);

package/dist/wirings/workflow/dsl/workflow-dsl.types.d.ts

@@ -5,6 +5,7 @@
 import type { StandardSchemaV1 } from '@standard-schema/spec';
 import type { WorkflowRun } from '../workflow.types.js';
 import type { ScenarioActor } from '../../../services/scenario-actors-service.js';
+import type { ScenarioStepOptions, ScenarioStepPhase } from '../scenario-step.types.js';
 /**
  * Workflow step options
  */
@@ -60,6 +61,13 @@ export type WorkflowWireDoRPC = <TOutput = any, TInput = any>(stepName: string,
  * Type signature for workflow.do() inline form - used by inspector
  */
 export type WorkflowWireDoInline = <T>(stepName: string, fn: () => Promise<T> | T, options?: WorkflowStepOptions) => Promise<T>;
+/**
+ * Type signature for scenario.step/given/when/then - used by inspector.
+ *
+ * Deliberately mirrors WorkflowWireDoRPC's shape: the target is a string, not
+ * an imported symbol, so the extractor reads it as a literal.
+ */
+export type ScenarioStepInvocation = <TOutput = any, TInput = any>(stepName: string, stepFunc: string, data?: TInput, options?: ScenarioStepOptions) => Promise<TOutput>;
 /**
  * Type signature for workflow.sleep() - used by inspector
  */
@@ -172,6 +180,33 @@ export interface RpcStepMeta {
     /** True for workflow.expectEventually polling steps */
     expectEventually?: boolean;
 }
+/**
+ * Scenario step metadata — a call to `scenario.step/given/when/then`.
+ *
+ * Distinct from RpcStepMeta on purpose: a step runs locally through
+ * runPikkuFunc and must never be treated as dispatchable on the queue/replay
+ * path, nor registered as a callable RPC (a browser-driving step must not be
+ * network-invocable).
+ */
+export interface ScenarioStepMeta {
+    type: 'scenarioStep';
+    /** Cache key (first argument), ordinal-suffixed by the engine when repeated */
+    stepName: string;
+    /** Registered name of the step function being run */
+    stepFunc: string;
+    /** Which keyword the reporter prefixes — given/when/then, or none for `step` */
+    phase: ScenarioStepPhase;
+    /** Output variable name (if assigned) */
+    outputVar?: string;
+    /** Input source mappings, or 'passthrough' when entire data is passed */
+    inputs?: Record<string, InputSource> | 'passthrough';
+    /** Step options */
+    options?: WorkflowStepOptions;
+    /** Scenario actor name this step runs as ({ actor: actors.x }) */
+    actor?: string;
+    /** Mirrors the step function's `browser: true` declaration */
+    browser?: boolean;
+}
 /**
  * Simple condition expression (leaf node)
  */
@@ -214,7 +249,7 @@ export interface BranchStepMeta {
 export interface ParallelGroupStepMeta {
     type: 'parallel';
     /** Child steps to execute in parallel */
-    children: RpcStepMeta[];
+    children: Array<RpcStepMeta | ScenarioStepMeta>;
 }
 /**
  * Fanout step metadata (parallel or sequential iteration)
@@ -234,7 +269,7 @@ export interface FanoutStepMeta {
     /** Execution mode */
     mode: 'parallel' | 'sequential';
     /** Steps to execute inline per iteration, in order */
-    body: Array<RpcStepMeta | SleepStepMeta | SuspendStepMeta>;
+    body: Array<RpcStepMeta | SleepStepMeta | SuspendStepMeta | ScenarioStepMeta>;
     /** Time between iterations (sequential mode only) */
     timeBetween?: string;
 }
@@ -385,7 +420,7 @@ export interface ArrayPredicateStepMeta {
 /**
  * Workflow step metadata (extracted by inspector)
  */
-export type WorkflowStepMeta = RpcStepMeta | BranchStepMeta | ParallelGroupStepMeta | FanoutStepMeta | ReturnStepMeta | InlineStepMeta | SleepStepMeta | CancelStepMeta | SuspendStepMeta | ApprovalStepMeta | SwitchStepMeta | FilterStepMeta | ArrayPredicateStepMeta | SetStepMeta;
+export type WorkflowStepMeta = RpcStepMeta | ScenarioStepMeta | BranchStepMeta | ParallelGroupStepMeta | FanoutStepMeta | ReturnStepMeta | InlineStepMeta | SleepStepMeta | CancelStepMeta | SuspendStepMeta | ApprovalStepMeta | SwitchStepMeta | FilterStepMeta | ArrayPredicateStepMeta | SetStepMeta;
 /**
  * Workflow step wire context for RPC functions
  * Provides step-level metadata including retry attempt tracking
@@ -448,5 +483,19 @@ export interface PikkuScenarioWire extends PikkuWorkflowWire {
     expectError: <TInput = any>(stepName: string, rpcName: string, data: TInput, options?: WorkflowExpectErrorOptions) => Promise<string>;
     /** Stub-assertion step: asserts `service.method` was called on the target server */
     expectService: (stepName: string, serviceMethod: string, options?: WorkflowExpectServiceOptions) => Promise<void>;
+    /**
+     * Run a registered scenario step. Shaped exactly like `do`'s RPC form —
+     * `(stepName, target, data, options)` — so the inspector reads the target as
+     * a string literal rather than resolving an imported symbol.
+     *
+     * The generated `TypedScenario` narrows these over `FlattenedScenarioStepMap`.
+     */
+    step(stepName: string, stepFunc: string, data?: any, options?: ScenarioStepOptions): Promise<any>;
+    /** `step` with a "Given" prefix in the rendered prose */
+    given(stepName: string, stepFunc: string, data?: any, options?: ScenarioStepOptions): Promise<any>;
+    /** `step` with a "When" prefix in the rendered prose */
+    when(stepName: string, stepFunc: string, data?: any, options?: ScenarioStepOptions): Promise<any>;
+    /** `step` with a "Then" prefix in the rendered prose */
+    then(stepName: string, stepFunc: string, data?: any, options?: ScenarioStepOptions): Promise<any>;
     runScheduledTask: (name: string) => Promise<unknown>;
 }

package/dist/wirings/workflow/feature.d.ts

@@ -0,0 +1,28 @@
+import type { CoreFeature, CoreWorkflow, FeaturePlanEntry } from './workflow.types.js';
+/**
+ * Register a feature under the name it is exported as. Called from generated
+ * wiring, the same way `addWorkflow` is.
+ */
+export declare const addFeature: (featureId: string, feature: CoreFeature, packageName?: string | null) => void;
+/**
+ * Resolve every feature's scenario references back to the names their
+ * scenarios are registered under.
+ *
+ * Matching is by **object identity**: `pikkuScenario` returns its config
+ * verbatim and `addWorkflow` registers that same object, so a feature holding
+ * the imported identifier holds the very object that was registered. Nothing
+ * is matched by shape, by name, or by any other guess — which is also why a
+ * scenario built inline inside a feature (and therefore never registered)
+ * comes back as unresolved rather than silently running as something else.
+ *
+ * Entries are returned in declaration order, features in registration order.
+ * A scenario's effective tags are its own plus the containing feature's, so
+ * `--tags credential` selects through the feature.
+ */
+export declare const resolveFeatureScenarios: (features: Map<string, CoreFeature>, registrations: Map<string, CoreWorkflow>) => {
+    entries: FeaturePlanEntry[];
+    unresolved: Array<{
+        featureId: string;
+        index: number;
+    }>;
+};

package/dist/wirings/workflow/feature.js

@@ -0,0 +1,57 @@
+import { pikkuState } from '../../pikku-state.js';
+/**
+ * Register a feature under the name it is exported as. Called from generated
+ * wiring, the same way `addWorkflow` is.
+ */
+export const addFeature = (featureId, feature, packageName = null) => {
+    pikkuState(packageName, 'workflows', 'features').set(featureId, feature);
+};
+/**
+ * Resolve every feature's scenario references back to the names their
+ * scenarios are registered under.
+ *
+ * Matching is by **object identity**: `pikkuScenario` returns its config
+ * verbatim and `addWorkflow` registers that same object, so a feature holding
+ * the imported identifier holds the very object that was registered. Nothing
+ * is matched by shape, by name, or by any other guess — which is also why a
+ * scenario built inline inside a feature (and therefore never registered)
+ * comes back as unresolved rather than silently running as something else.
+ *
+ * Entries are returned in declaration order, features in registration order.
+ * A scenario's effective tags are its own plus the containing feature's, so
+ * `--tags credential` selects through the feature.
+ */
+export const resolveFeatureScenarios = (features, registrations) => {
+    const nameByConfig = new Map();
+    for (const [name, registration] of registrations) {
+        nameByConfig.set(registration.func, name);
+    }
+    const entries = [];
+    const unresolved = [];
+    for (const [featureId, feature] of features) {
+        const scenarios = feature.scenarios ?? [];
+        for (let index = 0; index < scenarios.length; index++) {
+            const entry = scenarios[index];
+            const paired = typeof entry === 'object' && entry !== null && 'scenario' in entry;
+            const config = paired ? entry.scenario : entry;
+            const scenarioName = nameByConfig.get(config);
+            if (!scenarioName) {
+                unresolved.push({ featureId, index });
+                continue;
+            }
+            entries.push({
+                featureId,
+                featureName: feature.name ?? featureId,
+                scenarioName,
+                data: paired ? entry.data : undefined,
+                tags: [
+                    ...new Set([
+                        ...(registrations.get(scenarioName)?.func?.tags ?? []),
+                        ...(feature.tags ?? []),
+                    ]),
+                ],
+            });
+        }
+    }
+    return { entries, unresolved };
+};

package/dist/wirings/workflow/graph/graph-runner.js

@@ -399,8 +399,9 @@ export async function continueGraph(workflowService, runId, graphName, overrideM
         }
         return;
     }
-    const run = await workflowService.getRun(runId);
-    const triggerInput = run?.input;
+    // The same run read a few lines up: nothing between here and there writes it,
+    // and `input` is fixed at creation anyway.
+    const triggerInput = currentRun?.input;
     for (const fire of plan.toFire) {
         const node = nodes[fire.logical];
         if (!node?.rpcName)

package/dist/wirings/workflow/graph/graph-validation.d.ts

@@ -1,3 +1 @@
-export declare function computeEntryNodeIds(nodes: Record<string, any>): string[];
-export declare function validateWorkflowWiring(nodes: Record<string, any>, toolNames: string[]): string[];
 export declare function generateMermaidDiagram(workflowName: string, nodes: Record<string, any>, entryNodeIds: string[]): string;