@pikku/core 0.12.50 → 0.12.52

package/src/types/core.types.ts

@@ -29,7 +29,7 @@ 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 { UserFlowActors } from '../services/user-flow-actors-service.js'
+import type { ScenarioActors } from '../services/scenario-actors-service.js'
 import type { AIAgentRunnerService } from '../services/ai-agent-runner-service.js'
 import type { AIRunStateService } from '../services/ai-run-state-service.js'
 import type { AgentRunService } from '../wirings/ai-agent/ai-agent.types.js'
@@ -244,7 +244,7 @@ export type CoreConfig<Config extends Record<string, unknown> = {}> = {
 export interface CoreUserSession {
   userId?: string
   orgId?: string
-  /** True when the session belongs to a synthetic user-flow actor — lets audits/analytics address synthetic traffic */
+  /** True when the session belongs to a synthetic scenario actor — lets audits/analytics address synthetic traffic */
   actor?: boolean
 }
 
@@ -339,8 +339,8 @@ export type PikkuWire<
   queue: PikkuQueue
   cli: PikkuCLI
   workflow: TypedWorkflow
-  /** User-flow actor registry (user-flow runs only) — pass into workflow.do as `{ actor: actors.x }` */
-  actors: UserFlowActors
+  /** Scenario actor registry (scenario runs only) — pass into workflow.do as `{ actor: actors.x }` */
+  actors: ScenarioActors
   workflowStep: WorkflowStepWire
   graph: PikkuGraphWire
   trigger: PikkuTrigger<TriggerOutput>
@@ -609,6 +609,55 @@ export type CommonWireMeta = {
   permissions?: PermissionMetadata[]
 }
 
+/**
+ * Dependency security audit artifact — the shape of `.pikku/audit.json` written
+ * by `pikku audit`. Canonical home for the type shared by the CLI (writer), the
+ * console addon (reader), and the console UI (renderer).
+ */
+export type SecuritySeverity = 'critical' | 'high' | 'moderate' | 'low' | 'info'
+export type SecurityUpdateLevel = 'major' | 'minor' | 'patch' | 'unknown'
+
+export interface SecurityAuditIssue {
+  package: string
+  severity: SecuritySeverity
+  title: string
+  advisoryId: string
+  url: string
+  vulnerableVersions: string
+  cwe: string[]
+  cvssScore: number | null
+  recommendedVersion: string | null
+}
+
+export interface SecurityAuditUpdate {
+  package: string
+  current: string
+  latest: string
+  level: SecurityUpdateLevel
+}
+
+export interface SecurityAuditSummary {
+  totalIssues: number
+  critical: number
+  high: number
+  moderate: number
+  low: number
+  totalUpdates: number
+  major: number
+  minor: number
+  patch: number
+}
+
+export interface SecurityAuditReport {
+  schemaVersion: number
+  tool: string
+  generatedAt: string
+  note?: string
+  issues: SecurityAuditIssue[]
+  updates: SecurityAuditUpdate[]
+  summary: SecurityAuditSummary
+}
+
 /**
  * Serialized error for storage
  */

package/src/wirings/actor-flow/actor-flow.types.ts

@@ -0,0 +1,73 @@
+/**
+ * How an actor agent answers the target agent's tool-approval requests during
+ * a conversation.
+ * - `'in-persona'` — the actor agent decides as the persona would (default).
+ * - `'always'` — approve every request (stress the happy path).
+ * - `'never'` — deny every request (exercise refusal handling).
+ */
+export type ActorFlowApprovalPolicy = 'in-persona' | 'always' | 'never'
+
+/**
+ * Options for `actor.converse(...)` — a dynamic conversation an actor holds
+ * with a target Pikku AI agent, in the actor's own persona. `TAgentName` is
+ * bound to the generated union of agent names in a typed project.
+ */
+export interface ConverseOptions<TAgentName extends string = string> {
+  /** Target Pikku AI agent name to converse with. */
+  agent: TAgentName
+  /** What the actor is trying to get the agent to accomplish. */
+  task: string
+  /** Natural-language success criterion the actor evaluates at the end. */
+  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?: string
+  /** Hard cap on conversation turns before forcing evaluation. Default 12. */
+  maxTurns?: number
+}
+
+/**
+ * The verdict a conversation produces: the persona's LLM self-evaluation of
+ * whether the task was met. Deterministic checks are the caller's job — they
+ * already hold the actor and can `actor.invoke(...)` afterwards.
+ */
+export interface ActorFlowVerdict {
+  /** Whether the actor judged the task accomplished. */
+  passed: boolean
+  /** The actor's reasoning for its verdict. */
+  reasoning: string
+  /** The conversation transcript, for debugging/reporting. */
+  transcript: string[]
+}
+
+/** A pending tool-approval request surfaced by the target agent. */
+export interface TargetPendingApproval {
+  toolCallId: string
+  toolName: string
+  args: unknown
+  reason?: string
+}
+
+/** A normalized reply from the target agent, independent of transport. */
+export interface TargetAgentReply {
+  text: string
+  runId: string
+  status?: 'completed' | 'suspended'
+  pendingApprovals?: TargetPendingApproval[]
+}
+
+/**
+ * Drives the target agent. In production this is HTTP-backed (the actor's
+ * `agentRun` / `agentApprove` calls as the signed-in actor); the conversation
+ * engine only sees this transport-agnostic contract.
+ */
+export interface TargetAgentDriver {
+  /** Send a message, starting or continuing the target agent's run. */
+  run(message: string): Promise<TargetAgentReply>
+  /** Answer the target agent's pending approvals and continue its run. */
+  approve(
+    runId: string,
+    decisions: { toolCallId: string; approved: boolean }[]
+  ): Promise<TargetAgentReply>
+}

package/src/wirings/actor-flow/index.ts

@@ -0,0 +1,22 @@
+/**
+ * Actor flow module exports.
+ *
+ * An actor holds a dynamic conversation with a target Pikku AI agent via
+ * `actor.converse(...)` — playing its own persona, approving the agent's tool
+ * requests in-persona, and evaluating whether the task was accomplished. The
+ * conversation engine here is transport-agnostic; the actor drives the target
+ * 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'

package/src/wirings/actor-flow/run-conversation.test.ts

@@ -0,0 +1,176 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { runConversation, type PersonaLLM } from './run-conversation.js'
+import type {
+  TargetAgentDriver,
+  TargetAgentReply,
+  ActorFlowApprovalPolicy,
+} from './actor-flow.types.js'
+import type { AIAgentStepResult } from '../../services/ai-agent-runner-service.js'
+
+const stepResult = (object: unknown): AIAgentStepResult => ({
+  text: '',
+  object,
+  toolCalls: [],
+  toolResults: [],
+  usage: { inputTokens: 0, outputTokens: 0 },
+  finishReason: 'stop',
+})
+
+/** A persona LLM scripted by the outputSchema it's asked for. */
+const scriptedLLM = (script: {
+  turns: Array<{ message: string; done: boolean }>
+  decisions: Array<{ toolCallId: string; approved: boolean }>
+  evaluation: { passed: boolean; reasoning: string }
+}): { llm: PersonaLLM; calls: string[] } => {
+  let turn = 0
+  const calls: string[] = []
+  const llm: PersonaLLM = async (params) => {
+    const props =
+      (params.outputSchema as { properties?: Record<string, unknown> })
+        ?.properties ?? {}
+    if ('message' in props) {
+      // Providers reject an empty prompt — every persona turn must carry messages.
+      assert.ok(
+        params.messages.length > 0,
+        'persona turn requested with empty messages'
+      )
+      const t = script.turns[turn] ?? script.turns[script.turns.length - 1]
+      turn++
+      calls.push('turn')
+      return stepResult(t)
+    }
+    if ('decisions' in props) {
+      calls.push('approval')
+      return stepResult({ decisions: script.decisions })
+    }
+    if ('passed' in props) {
+      calls.push('eval')
+      return stepResult(script.evaluation)
+    }
+    throw new Error('unexpected schema')
+  }
+  return { llm, calls }
+}
+
+/** A target that suspends once for approval, then completes. */
+const suspendingTarget = (): {
+  target: TargetAgentDriver
+  approvedWith: Array<{ toolCallId: string; approved: boolean }[]>
+} => {
+  let runs = 0
+  const approvedWith: Array<{ toolCallId: string; approved: boolean }[]> = []
+  const target: TargetAgentDriver = {
+    run: async (): Promise<TargetAgentReply> => {
+      runs++
+      if (runs === 1) {
+        return {
+          text: 'Let me do that.',
+          runId: 'run-1',
+          status: 'suspended',
+          pendingApprovals: [
+            { toolCallId: 'tc1', toolName: 'createTodo', args: { title: 'x' } },
+          ],
+        }
+      }
+      return { text: 'All set.', runId: `run-${runs}`, status: 'completed' }
+    },
+    approve: async (runId, decisions): Promise<TargetAgentReply> => {
+      approvedWith.push(decisions)
+      return { text: 'Created it.', runId, status: 'completed' }
+    },
+  }
+  return { target, approvedWith }
+}
+
+/** A target that never completes — always re-suspends for the same approval. */
+const alwaysSuspendingTarget = (): {
+  target: TargetAgentDriver
+  approveCalls: () => number
+} => {
+  let approveCalls = 0
+  const suspended: TargetAgentReply = {
+    text: 'working on it',
+    runId: 'run-stuck',
+    status: 'suspended',
+    pendingApprovals: [
+      { toolCallId: 'tc1', toolName: 'createTodo', args: { title: 'x' } },
+    ],
+  }
+  const target: TargetAgentDriver = {
+    run: async () => suspended,
+    approve: async () => {
+      approveCalls++
+      return suspended
+    },
+  }
+  return { target, approveCalls: () => approveCalls }
+}
+
+const base = {
+  persona: { email: 'pm@example.com', name: 'Priya', personality: 'concise' },
+  personaName: 'Priya',
+  agentName: 'todoBot',
+  task: 'Get a todo created',
+  evaluate: 'A todo now exists',
+  model: 'test/test-model',
+}
+
+describe('runConversation', () => {
+  test('drives turns, approves in-persona, evaluates', async () => {
+    const { llm, calls } = scriptedLLM({
+      turns: [
+        { message: 'please make a todo', done: false },
+        { message: 'thanks', done: true },
+      ],
+      decisions: [{ toolCallId: 'tc1', approved: true }],
+      evaluation: { passed: true, reasoning: 'todo created' },
+    })
+    const { target, approvedWith } = suspendingTarget()
+
+    const verdict = await runConversation({ ...base, llm, target })
+
+    assert.equal(verdict.passed, true)
+    assert.match(verdict.reasoning, /todo/i)
+    assert.ok(verdict.transcript.length >= 2)
+    assert.deepEqual(approvedWith, [[{ toolCallId: 'tc1', approved: true }]])
+    assert.ok(calls.includes('approval'))
+    assert.ok(calls.includes('eval'))
+  })
+
+  test("approvals policy 'never' denies without asking the persona", async () => {
+    const { llm, calls } = scriptedLLM({
+      turns: [{ message: 'make a todo', done: true }],
+      decisions: [{ toolCallId: 'tc1', approved: true }],
+      evaluation: { passed: false, reasoning: 'blocked' },
+    })
+    const { target, approvedWith } = suspendingTarget()
+
+    const verdict = await runConversation({
+      ...base,
+      approvals: 'never' as ActorFlowApprovalPolicy,
+      llm,
+      target,
+    })
+
+    assert.deepEqual(approvedWith, [[{ toolCallId: 'tc1', approved: false }]])
+    assert.ok(!calls.includes('approval'))
+    assert.equal(verdict.passed, false)
+  })
+
+  test('caps the approval loop when the target never stops suspending', async () => {
+    const { llm } = scriptedLLM({
+      turns: [{ message: 'please make a todo', done: false }],
+      decisions: [{ toolCallId: 'tc1', approved: true }],
+      evaluation: { passed: false, reasoning: 'never got there' },
+    })
+    const { target, approveCalls } = alwaysSuspendingTarget()
+
+    await assert.rejects(
+      runConversation({ ...base, approvals: 'always', maxApprovalRounds: 3, llm, target }),
+      /approval rounds/
+    )
+    assert.equal(approveCalls(), 3)
+  })
+})

package/src/wirings/actor-flow/run-conversation.ts

@@ -0,0 +1,285 @@
+import type {
+  ActorFlowApprovalPolicy,
+  ActorFlowVerdict,
+  TargetAgentDriver,
+  TargetPendingApproval,
+} from './actor-flow.types.js'
+import type { ScenarioActorConfig } from '../../services/scenario-actors-service.js'
+import type { AIMessage } from '../ai-agent/ai-agent.types.js'
+import type {
+  AIAgentRunnerParams,
+  AIAgentStepResult,
+} from '../../services/ai-agent-runner-service.js'
+
+/** One turn the persona takes: the message to send and whether it's finished. */
+const PERSONA_TURN_SCHEMA = {
+  type: 'object',
+  properties: {
+    message: { type: 'string' },
+    done: { type: 'boolean' },
+  },
+  required: ['message', 'done'],
+} as const
+
+/** The persona's approve/deny decision for each pending tool request. */
+const APPROVAL_DECISION_SCHEMA = {
+  type: 'object',
+  properties: {
+    decisions: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          toolCallId: { type: 'string' },
+          approved: { type: 'boolean' },
+          reason: { type: 'string' },
+        },
+        required: ['toolCallId', 'approved'],
+      },
+    },
+  },
+  required: ['decisions'],
+} as const
+
+/** The persona's final verdict on whether the task was accomplished. */
+const EVALUATION_SCHEMA = {
+  type: 'object',
+  properties: {
+    passed: { type: 'boolean' },
+    reasoning: { type: 'string' },
+  },
+  required: ['passed', 'reasoning'],
+} as const
+
+const DEFAULT_MAX_TURNS = 12
+
+const DEFAULT_MAX_APPROVAL_ROUNDS = 16
+
+/** The LLM call the persona uses for its own turns/decisions/evaluation. */
+export type PersonaLLM = (
+  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
+  /** 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: string
+  /** Hard cap on conversation turns. Default 12. */
+  maxTurns?: number
+  /** Hard cap on tool-approval rounds within a single target turn. Default 16. */
+  maxApprovalRounds?: number
+  /** Transport that drives the target agent (HTTP in production). */
+  target: TargetAgentDriver
+  /** The persona's own LLM. */
+  llm: PersonaLLM
+  /** Display name of the target agent (transcript labelling). */
+  agentName: string
+}
+
+function msg(role: AIMessage['role'], content: string): AIMessage {
+  return {
+    id: globalThis.crypto.randomUUID(),
+    role,
+    content,
+    createdAt: new Date(),
+  }
+}
+
+/** Read a structured `run` result, falling back to parsing JSON from text. */
+function readObject<T>(result: { object?: unknown; text?: string }): T | null {
+  if (result.object && typeof result.object === 'object') {
+    return result.object as T
+  }
+  if (result.text) {
+    try {
+      return JSON.parse(result.text) as T
+    } catch {
+      return null
+    }
+  }
+  return null
+}
+
+function personaInstructions(
+  persona: ScenarioActorConfig,
+  task: string
+): string {
+  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.`
+      : '',
+    `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.`,
+  ]
+    .filter(Boolean)
+    .join('\n')
+}
+
+/** Route the target agent's pending tool approvals through the persona. */
+async function decideApprovals(
+  params: RunConversationParams,
+  instructions: string,
+  pending: TargetPendingApproval[]
+): Promise<{ toolCallId: string; approved: boolean }[]> {
+  const policy = params.approvals ?? 'in-persona'
+  if (policy === 'always') {
+    return pending.map((p) => ({ toolCallId: p.toolCallId, approved: true }))
+  }
+  if (policy === 'never') {
+    return pending.map((p) => ({ toolCallId: p.toolCallId, approved: false }))
+  }
+
+  const summary = pending
+    .map(
+      (p) =>
+        `- toolCallId "${p.toolCallId}": ${p.toolName}(${JSON.stringify(p.args)})${p.reason ? ` — ${p.reason}` : ''}`
+    )
+    .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.`,
+    messages: [
+      msg(
+        'user',
+        `The assistant wants to run these tools:\n${summary}\nApprove or deny each toolCallId.`
+      ),
+    ],
+    tools: [],
+    maxSteps: 1,
+    toolChoice: 'none',
+    outputSchema: APPROVAL_DECISION_SCHEMA as unknown as Record<
+      string,
+      unknown
+    >,
+  })
+
+  const decided =
+    readObject<{
+      decisions?: { toolCallId: string; approved: boolean }[]
+    }>(result)?.decisions ?? []
+
+  // Every pending call must get a decision; a missing one defaults to denied.
+  return pending.map((p) => {
+    const match = decided.find((d) => d.toolCallId === p.toolCallId)
+    return { toolCallId: p.toolCallId, approved: match?.approved ?? false }
+  })
+}
+
+/** Drive the target to a non-suspended reply, routing approvals to the persona. */
+async function converseWithTarget(
+  params: RunConversationParams,
+  instructions: string,
+  message: string
+) {
+  const maxRounds = params.maxApprovalRounds ?? DEFAULT_MAX_APPROVAL_ROUNDS
+  let reply = await params.target.run(message)
+  let rounds = 0
+  while (
+    reply.status === 'suspended' &&
+    reply.pendingApprovals &&
+    reply.pendingApprovals.length > 0
+  ) {
+    if (rounds >= maxRounds) {
+      throw new Error(
+        `Target agent "${params.agentName}" stayed suspended after ${maxRounds} approval rounds (runId ${reply.runId}); aborting to avoid an unbounded approve loop.`
+      )
+    }
+    rounds++
+    const decisions = await decideApprovals(
+      params,
+      instructions,
+      reply.pendingApprovals
+    )
+    reply = await params.target.approve(reply.runId, decisions)
+  }
+  return reply
+}
+
+/**
+ * Run a conversation: an LLM-driven persona 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: RunConversationParams
+): Promise<ActorFlowVerdict> {
+  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
+  // it never appears in the transcript.
+  const personaMessages: AIMessage[] = [
+    msg(
+      'user',
+      'Begin the conversation now — send your first message to the assistant to work towards your goal.'
+    ),
+  ]
+  const transcript: string[] = []
+
+  for (let turn = 0; turn < maxTurns; turn++) {
+    const personaResult = await params.llm({
+      model: params.model,
+      instructions,
+      messages: personaMessages,
+      tools: [],
+      maxSteps: 1,
+      toolChoice: 'none',
+      outputSchema: PERSONA_TURN_SCHEMA as unknown as Record<string, unknown>,
+    })
+
+    const turnData = readObject<{ message: string; done: boolean }>(
+      personaResult
+    )
+    const personaMessage = turnData?.message?.trim()
+    if (!personaMessage) {
+      break
+    }
+
+    personaMessages.push(msg('assistant', personaMessage))
+    transcript.push(`${params.personaName}: ${personaMessage}`)
+
+    const reply = await converseWithTarget(params, instructions, personaMessage)
+    personaMessages.push(msg('user', reply.text ?? ''))
+    transcript.push(`${params.agentName}: ${reply.text ?? ''}`)
+
+    if (turnData?.done) {
+      break
+    }
+  }
+
+  const evalResult = await params.llm({
+    model: params.model,
+    instructions: `${instructions}\nThe conversation has ended. Judge honestly whether your goal was accomplished.`,
+    messages: [
+      msg(
+        'user',
+        `Here is the full conversation:\n\n${transcript.join('\n')}\n\nSuccess criterion: ${params.evaluate}\n\nWas it met?`
+      ),
+    ],
+    tools: [],
+    maxSteps: 1,
+    toolChoice: 'none',
+    outputSchema: EVALUATION_SCHEMA as unknown as Record<string, unknown>,
+  })
+
+  const verdict = readObject<{ passed: boolean; reasoning: string }>(evalResult)
+  return {
+    passed: verdict?.passed ?? false,
+    reasoning: verdict?.reasoning ?? 'No evaluation produced.',
+    transcript,
+  }
+}

package/src/wirings/http/http.types.ts

@@ -226,6 +226,7 @@ export type HTTPFunctionMetaInputTypes = {
 export type HTTPWiringMeta = CommonWireMeta & {
   route: string
   method: HTTPMethod
+  refTarget?: string
   params?: string[]
   query?: string[]
   inputTypes?: HTTPFunctionMetaInputTypes

package/src/wirings/workflow/dsl/workflow-dsl.types.ts

@@ -4,7 +4,7 @@
  */
 
 import type { WorkflowRun } from '../workflow.types.js'
-import type { UserFlowActor } from '../../../services/user-flow-actors-service.js'
+import type { ScenarioActor } from '../../../services/scenario-actors-service.js'
 
 /**
  * Workflow step options
@@ -17,18 +17,18 @@ export interface WorkflowStepOptions {
   /** Delay between retry attempts (e.g., '1s', '2s', '2min') */
   retryDelay?: string | number
   /**
-   * Run this step as an actor (user flows). The RPC is sent through the
+   * Run this step as an actor (scenarios). The RPC is sent through the
    * actor's authenticated client over the REAL transport — never dispatched
    * internally — so auth middleware and permissions are exercised end-to-end.
    * The step is recorded durably like any RPC step.
    */
-  actor?: UserFlowActor
+  actor?: ScenarioActor
   // Future: timeout, failFast, priority
 }
 
 /**
  * Options for workflow.expectEventually() — a durable polling step used by
- * user flows to await async effects (a notification landing, a job finishing).
+ * scenarios to await async effects (a notification landing, a job finishing).
  */
 export interface WorkflowExpectEventuallyOptions extends WorkflowStepOptions {
   /** Give up after this long (e.g. '30s'). Default '30s'. */
@@ -109,7 +109,7 @@ export interface RpcStepMeta {
   inputs?: Record<string, InputSource> | 'passthrough'
   /** Step options */
   options?: WorkflowStepOptions
-  /** User-flow actor name this step runs as ({ actor: actors.x }) */
+  /** Scenario actor name this step runs as ({ actor: actors.x }) */
   actor?: string
   /** True for workflow.expectEventually polling steps */
   expectEventually?: boolean
@@ -370,7 +370,7 @@ export interface PikkuWorkflowWire {
   do: WorkflowWireDoRPC & WorkflowWireDoInline
 
   /**
-   * Durable polling step (user flows): invoke `rpcName` (as an actor when
+   * Durable polling step (scenarios): invoke `rpcName` (as an actor when
    * `options.as` is set) until `predicate` passes or `options.within` elapses.
    */
   expectEventually: <TOutput = any, TInput = any>(