@pikku/core 0.12.72 → 0.12.74

package/src/wirings/virtual-user/virtual-user-rng.ts

@@ -0,0 +1,50 @@
+/**
+ * A seeded PRNG, so a run replays exactly.
+ *
+ * Reproducibility is the whole point: a virtual user that finds something has
+ * to be re-runnable into the same finding before it can be shrunk into a
+ * regression scenario. `Math.random` would make every finding a one-off story.
+ *
+ * mulberry32 — 32 bits of state, uniform enough for scheduling weights, and
+ * short enough to read.
+ */
+export const createRng = (seed: number) => {
+  let state = seed >>> 0
+  const next = () => {
+    state = (state + 0x6d2b79f5) >>> 0
+    let t = state
+    t = Math.imul(t ^ (t >>> 15), t | 1)
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61)
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296
+  }
+  return {
+    next,
+    /** True with probability `p`. */
+    chance: (p: number) => next() < p,
+    /** A uniform pick, or undefined for an empty list. */
+    pick: <T>(items: readonly T[]): T | undefined =>
+      items.length === 0 ? undefined : items[Math.floor(next() * items.length)],
+    /**
+     * A weighted pick over `[key, weight]` pairs. Zero-weight keys can never be
+     * drawn, which is how a disposition switches a move off entirely.
+     */
+    weighted: <K extends string>(
+      weights: Readonly<Record<K, number>>
+    ): K | undefined => {
+      const entries = (Object.entries(weights) as [K, number][]).filter(
+        ([, weight]) => weight > 0
+      )
+      const total = entries.reduce((sum, [, weight]) => sum + weight, 0)
+      if (total <= 0) return undefined
+      let roll = next() * total
+      for (const [key, weight] of entries) {
+        roll -= weight
+        if (roll <= 0) return key
+      }
+      return entries[entries.length - 1]?.[0]
+    },
+  }
+}
+
+/** The seeded generator the engine threads through a whole run. */
+export type VirtualUserRng = ReturnType<typeof createRng>

package/src/wirings/virtual-user/virtual-user-target.ts

@@ -0,0 +1,47 @@
+import type { ScenarioPersona } from '../../services/personas-service.js'
+import type { VirtualUserTarget } from './virtual-user.types.js'
+
+export interface PersonaTargetOptions {
+  /** Model the persona uses for its side of a conversation with an agent. */
+  model?: string
+  /** Agents this user may talk to. Omit to leave `talkTo` unavailable. */
+  agents?: readonly string[]
+}
+
+/**
+ * Drive a virtual user through a signed-in persona.
+ *
+ * This is the only place the engine meets the network. A persona already signs
+ * in as a real user over the app's own auth, keeps its cookies, re-logs-in when
+ * a session expires mid-run and reports a status as data rather than throwing —
+ * everything a user imitating a user needs, and none of it worth building twice.
+ *
+ * `invokeRaw` rather than `invoke` matters: to a virtual user a 403 is not an
+ * error, it is the system saying no, which is information it should be allowed
+ * to act on.
+ */
+export const personaVirtualUserTarget = (
+  persona: ScenarioPersona,
+  { model, agents }: PersonaTargetOptions = {}
+): VirtualUserTarget => ({
+  call: (rpcName, args) => persona.invokeRaw(rpcName, args),
+  talkTo: agents?.length
+    ? async (agent, task) => {
+        if (!agents.includes(agent)) {
+          return {
+            passed: false,
+            reasoning: `There is no assistant called '${agent}'.`,
+            transcript: [],
+          }
+        }
+        return persona.converse({
+          agent,
+          task,
+          // A user asking for something judges the answer by whether they got
+          // what they asked for. There is no separate criterion to hold it to.
+          evaluate: `The assistant did what was asked: ${task}`,
+          model,
+        })
+      }
+    : undefined,
+})

package/src/wirings/virtual-user/virtual-user.types.ts

@@ -0,0 +1,219 @@
+import type { ScenarioHttpResponse } from '../../services/personas-service.js'
+import type { ActorFlowVerdict } from '../actor-flow/actor-flow.types.js'
+
+/**
+ * How a virtual user behaves, mechanically. A disposition changes the loop, the
+ * input generation, the memory and the oracle — anything that only changes how
+ * the user *talks* is persona prose (`ResolvedPersona.personality`) and does
+ * not belong here.
+ *
+ * - `realistic` — schema-first, goal-directed, plausible values (default).
+ * - `careless` — repeats, abandons, double-submits, boundary values.
+ * - `newcomer` — starts with empty memory and must discover everything.
+ * - `stale` — seeded from an earlier run's ids, some no longer valid.
+ * - `auditor` — pursues no goal; reads one truth from several places and compares.
+ * - `adversarial` — probes authorization and tenancy; a 2xx can be the finding.
+ * - `accountable` — pursues its goals for real; the only one production allows.
+ *
+ * `accountable` sits opposite `adversarial` on an *intent* axis — bad faith
+ * against good faith — where `careless` and `thorough` are a *care* axis. It is
+ * the one disposition whose actions carry consequences: no oracle, no rollback,
+ * and every call attributed to the persona in the audit log like anyone else's.
+ */
+export type VirtualUserDisposition =
+  | 'realistic'
+  | 'careless'
+  | 'newcomer'
+  | 'stale'
+  | 'auditor'
+  | 'adversarial'
+  | 'accountable'
+
+/**
+ * The one disposition a production environment accepts.
+ *
+ * Every other disposition exists to find out what the product does wrong, which
+ * is not a thing to do to real customers' data. Named here so the declaration
+ * check and the sign-in check cannot drift apart.
+ */
+export const PRODUCTION_DISPOSITION: VirtualUserDisposition = 'accountable'
+
+/**
+ * Hard caps the engine enforces itself. Anything the engine cannot count —
+ * money above all — belongs in {@link RunVirtualUserParams.stop} instead.
+ */
+export interface VirtualUserBudget {
+  /** Model turns, including ones that produced no call. */
+  steps?: number
+  /** Non-read RPC calls. */
+  mutations?: number
+  /** Wall clock, as ms or a duration string (`'30m'`). */
+  duration?: number | string
+}
+
+/**
+ * The running count handed to {@link RunVirtualUserParams.stop}. Pikku collects
+ * it because only the engine sees every step; what it is *worth* is the app's,
+ * which is why no price or currency appears anywhere in core.
+ */
+export interface VirtualUserTally {
+  steps: number
+  calls: number
+  mutations: number
+  tokensIn: number
+  tokensOut: number
+  model: string
+  elapsedMs: number
+  findings: number
+}
+
+/**
+ * One RPC as the virtual user sees it before reading its schema: enough to
+ * choose from, not enough to call with. The whole catalogue goes in the prompt,
+ * so this stays deliberately compact — a project with 430 RPCs renders to
+ * roughly 8k tokens, which is cheaper than any retrieval step and hides nothing.
+ */
+export interface ApiCatalogueEntry {
+  name: string
+  /** Top-level input property names, for choosing between similar endpoints. */
+  inputKeys?: readonly string[]
+  /** Top-level output property names. */
+  outputKeys?: readonly string[]
+  description?: string
+  /**
+   * Whether the call only reads. `undefined` means nobody annotated it — which
+   * is not the same as safe, so the engine falls back to a name heuristic and
+   * reports how many entries it had to guess at.
+   */
+  readonly?: boolean
+  /** Declared by the app as needing a human's approval — denied by default. */
+  approvalRequired?: boolean
+  /**
+   * Scopes the session must hold to call this, all of them.
+   *
+   * Splits the catalogue in two: what a persona's roles entitle it to reach,
+   * and what they do not. Scopes rather than permission-function names because
+   * a scope is declared and checkable, whereas a permission is arbitrary code
+   * whose verdict nobody can predict without running it.
+   */
+  scopes?: readonly string[]
+  tags?: readonly string[]
+  /** JSON schema returned by `describe`, before the user may call. */
+  inputSchema?: Record<string, unknown>
+  outputSchema?: Record<string, unknown>
+}
+
+/**
+ * Where an intent comes from: a feature or scenario in the app's own words.
+ *
+ * Deliberately prose. The virtual user never receives the scenario's step graph
+ * — no rpc names, no `$ref` dataflow — because finding the API itself is the
+ * behaviour under test, and those graphs are a build-time artifact that no
+ * deployed stage carries.
+ */
+export interface IntentSource {
+  id: string
+  title: string
+  description?: string
+  /** Step prose, as a person would be told it. Never rpc names. */
+  steps?: readonly string[]
+  tags?: readonly string[]
+  /** Persona ids this intent is available to. Empty means everyone. */
+  personas?: readonly string[]
+}
+
+/** Why the engine flagged something. */
+export type VirtualUserFindingKind =
+  | 'server-error'
+  | 'transport-error'
+  | 'schema-violation'
+  | 'unexpected-success'
+  | 'custom'
+
+/** Something worth a human's attention, found while imitating a user. */
+export interface VirtualUserFinding {
+  kind: VirtualUserFindingKind
+  detail: string
+  rpcName?: string
+  status?: number
+  intentId?: string
+  /** Step index within the run, so the transcript can be replayed to here. */
+  step: number
+}
+
+/**
+ * The transport the virtual user acts through. HTTP in production (an
+ * `HttpPersona`), but the engine only sees this contract — which is what
+ * lets the whole loop be tested without a network.
+ */
+export interface VirtualUserTarget {
+  /** Invoke an RPC as this user, reporting the status as data rather than throwing. */
+  call(rpcName: string, args: unknown): Promise<ScenarioHttpResponse>
+  /** Converse with an AI agent in persona. Omitted by apps that have no agents. */
+  talkTo?(agent: string, task: string): Promise<ActorFlowVerdict>
+  /** Send a fixture file. Omitted by apps with no upload surface. */
+  upload?(file: string): Promise<ScenarioHttpResponse>
+}
+
+/** What the model chose to do this turn. */
+export type VirtualUserAction =
+  | { kind: 'describe'; rpcName: string }
+  | { kind: 'call'; rpcName: string; args?: unknown }
+  | { kind: 'talkTo'; agent: string; task: string }
+  | { kind: 'upload'; file: string }
+  | { kind: 'complete'; summary?: string }
+  | { kind: 'stuck'; reason?: string }
+
+/** How an intent ended, or that it has not. */
+export type IntentStatus =
+  | 'open'
+  | 'suspended'
+  | 'completed'
+  | 'abandoned'
+  | 'stuck'
+
+/** One intent's life within a run. */
+export interface IntentRecord {
+  id: string
+  sourceId: string
+  title: string
+  status: IntentStatus
+  /** Step indices at which this intent was the active one. */
+  steps: number[]
+  /** How many times it was put down and picked back up. */
+  suspensions: number
+  summary?: string
+}
+
+/** One turn: what the engine scheduled, what the model did, what came back. */
+export interface StepRecord {
+  index: number
+  intentId?: string
+  action: VirtualUserAction | { kind: 'invalid'; detail: string }
+  status?: number
+  ok?: boolean
+  /** Truncated response text, so a run record stays readable. */
+  response?: string
+  findingKinds?: VirtualUserFindingKind[]
+  tokensIn: number
+  tokensOut: number
+}
+
+/** Everything a run produced. Seeded, so it replays. */
+export interface VirtualUserRunResult {
+  seed: number
+  tally: VirtualUserTally
+  findings: VirtualUserFinding[]
+  intents: IntentRecord[]
+  steps: StepRecord[]
+  /** Ids and slugs the user saw, for seeding a later `stale` run. */
+  memory: Record<string, string>
+  /** Why the run ended. */
+  stoppedBy:
+    | 'no-intents'
+    | 'budget-steps'
+    | 'budget-mutations'
+    | 'budget-duration'
+    | 'stop-hook'
+    | 'exhausted'
+}

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

@@ -6,10 +6,11 @@
 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 { ScenarioPersona } from '../../../services/personas-service.js'
 import type {
   ScenarioStepOptions,
   ScenarioStepPhase,
+  ScenarioSurface,
 } from '../scenario-step.types.js'
 
 /**
@@ -35,7 +36,7 @@ export interface WorkflowStepOptions {
    * internally — so auth middleware and permissions are exercised end-to-end.
    * The step is recorded durably like any RPC step.
    */
-  actor?: ScenarioActor
+  actor?: ScenarioPersona
   // Future: timeout, failFast, priority
 }
 
@@ -221,8 +222,8 @@ export interface ScenarioStepMeta {
   options?: WorkflowStepOptions
   /** Scenario actor name this step runs as ({ actor: actors.x }) */
   actor?: string
-  /** Mirrors the step function's `browser: true` declaration */
-  browser?: boolean
+  /** Mirrors the surfaces the step function declares a binding for */
+  surfaces?: ScenarioSurface[]
 }
 
 /**

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

@@ -1,10 +1,6 @@
 import { pikkuState } from '../../../pikku-state.js'
 import { addFunction } from '../../../function/function-runner.js'
 
-/**
- * Add a workflow to the system
- * This is called by the generated workflow wirings
- */
 export const addWorkflow = (
   workflowName: string,
   workflowFunc: any,

package/src/wirings/workflow/feature.ts

@@ -5,10 +5,6 @@ import type {
   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 const addFeature = (
   featureId: string,
   feature: CoreFeature,
@@ -17,21 +13,6 @@ export const addFeature = (
   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: Map<string, CoreFeature>,
   registrations: Map<string, CoreWorkflow>

package/src/wirings/workflow/graph/graph-node.ts

@@ -4,82 +4,11 @@ import type {
   RefValue,
 } from './workflow-graph.types.js'
 
-/**
- * Standard RPC handler interface (matches generated FlattenedRPCMap entries)
- */
 export interface RPCHandler<I = any, O = any> {
   input: I
   output: O
 }
 
-/**
- * Compute output types for all nodes based on their func (RPC name)
- */
-export type NodeOutputMap<
-  Nodes extends Record<string, { func: string }>,
-  RPCMap extends Record<string, RPCHandler>,
-> = {
-  [K in keyof Nodes]: Nodes[K]['func'] extends keyof RPCMap
-    ? RPCMap[Nodes[K]['func']]['output']
-    : unknown
-}
-
-/**
- * Node definition with RPC name reference
- */
-export interface GraphNodeDef<
-  RPCMap extends Record<string, RPCHandler>,
-  NodeIds extends string = string,
-  NodeOutputs extends Record<string, any> = Record<string, any>,
-> {
-  /** RPC function name (must be a key in RPCMap) */
-  func: keyof RPCMap & string
-  /** Input mapping - reference outputs from other nodes with autocomplete */
-  input?: (
-    ref: <N extends keyof NodeOutputs & string>(
-      nodeId: N,
-      path: keyof NodeOutputs[N] & string
-    ) => RefValue
-  ) => Record<string, unknown>
-  /** Next node(s) to execute */
-  next?: NextConfig<NodeIds>
-  /** Error handling - node(s) to execute on error */
-  onError?: NodeIds | NodeIds[]
-  /** Maximum retry attempts allowed (excludes the initial attempt) */
-  retries?: number
-  /** Delay between retries — milliseconds, duration string, or 'exponential' */
-  retryDelay?: string | number
-}
-
-/**
- * Helper to create a type-safe graph definition with RPC autocomplete.
- * Pass node IDs as first type parameter for type-safe next/ref/output key completion.
- *
- * @example
- * ```typescript
- * // Import the typed graph from generated types
- * import { pikkuWorkflowGraph } from './.pikku/workflow/pikku-workflow-types.gen.js'
- *
- * export const myGraph = pikkuWorkflowGraph({
- *   name: 'myWorkflow',
- *   nodes: {
- *     entry: 'createUserProfile',  // autocompletes RPC names
- *     sendWelcome: 'sendEmail',
- *   },
- *   config: {
- *     entry: { next: 'sendWelcome' },
- *     sendWelcome: {
- *       input: (ref) => ({
- *         to: ref('entry', 'email'),  // 'entry' and 'email' both autocomplete
- *       }),
- *     },
- *   },
- * })
- * ```
- */
-/**
- * Type to compute output types for all nodes based on their func mapping
- */
 type ComputeNodeOutputs<
   FuncMap extends Record<string, string>,
   RPCMap extends Record<string, RPCHandler>,
@@ -89,9 +18,6 @@ type ComputeNodeOutputs<
     : unknown
 }
 
-/**
- * Type to compute input types for all nodes based on their func mapping
- */
 type ComputeNodeInputs<
   FuncMap extends Record<string, string>,
   RPCMap extends Record<string, RPCHandler>,
@@ -101,15 +27,8 @@ type ComputeNodeInputs<
     : unknown
 }
 
-/**
- * Typed ref value - carries the type of the referenced field as a phantom type.
- * At runtime this is just RefValue, but TypeScript tracks the type T.
- */
 export type TypedRef<T> = RefValue & { __phantomType?: T }
 
-/**
- * Map input type fields to allow TypedRef of matching type as an alternative
- */
 type InputWithRefs<T> = {
   [K in keyof T]: T[K] | TypedRef<T[K]>
 }
@@ -126,7 +45,6 @@ export function createGraph<RPCMap extends Record<string, RPCHandler>>() {
   > => {
     type NodeIds = Extract<keyof FuncMap, string>
 
-    // If no nodes provided, return just the funcMap converted to graph nodes
     if (!nodesOrBuilder) {
       const result: Record<string, GraphNodeConfig<string>> = {}
       for (const [nodeId, rpcName] of Object.entries(funcMap)) {
@@ -159,9 +77,6 @@ export function createGraph<RPCMap extends Record<string, RPCHandler>>() {
   }
 }
 
-/**
- * Type helper for node configuration map
- */
 type GraphNodeConfigMap<
   FuncMap extends Record<string, string>,
   RPCMap extends Record<string, RPCHandler>,
@@ -180,57 +95,6 @@ type GraphNodeConfigMap<
     onError?: Extract<keyof FuncMap, string> | Extract<keyof FuncMap, string>[]
     retries?: number
     retryDelay?: string | number
-    /** Free-text node documentation. Non-semantic — excluded from graphHash. */
     notes?: string
   }
 }
-
-/**
- * Untyped graph for use without RPC map.
- * Pass node IDs as type parameter for type-safe next/ref, or omit for untyped usage.
- *
- * @example
- * ```typescript
- * // Typed usage - next and ref are type-checked
- * graph<'entry' | 'sendWelcome'>({
- *   entry: { func: 'createUserProfile', next: 'sendWelcome' },
- *   sendWelcome: { func: 'sendEmail', input: (ref) => ({ to: ref('entry', 'email') }) },
- * })
- *
- * // Untyped usage - no type checking on next/ref
- * graph({
- *   entry: { func: 'createUserProfile', next: 'sendWelcome' },
- *   sendWelcome: { func: 'sendEmail' },
- * })
- * ```
- */
-export function graph<NodeIds extends string = string>(
-  nodes: Record<
-    NodeIds,
-    {
-      func: string
-      next?: NextConfig<NodeIds>
-      input?: (
-        ref: (nodeId: NodeIds, path: string) => RefValue
-      ) => Record<string, unknown>
-      onError?: NodeIds | NodeIds[]
-      retries?: number
-      retryDelay?: string | number
-    }
-  >
-): Record<NodeIds, GraphNodeConfig<NodeIds>> {
-  const result: Record<string, GraphNodeConfig<string>> = {}
-
-  for (const [nodeId, def] of Object.entries(nodes) as [string, any][]) {
-    result[nodeId] = {
-      func: def.func,
-      input: def.input as any,
-      next: def.next,
-      onError: def.onError,
-      retries: def.retries,
-      retryDelay: def.retryDelay,
-    }
-  }
-
-  return result as Record<NodeIds, GraphNodeConfig<NodeIds>>
-}

package/src/wirings/workflow/graph/graph-runner.test.ts

@@ -258,8 +258,6 @@ describe('graph-runner bugs', () => {
       },
     } as any)
 
-    // start → a, where a loops back through b once, then exits to c:
-    //   start → a --retry--> b → a --done--> c
     const meta: WorkflowRuntimeMeta = {
       name: 'testCyclicGraph',
       pikkuFuncId: 'testCyclicGraph',
@@ -274,11 +272,16 @@ describe('graph-runner bugs', () => {
       },
     }
 
-    const runId = await ws.createRun('testCyclicGraph', {}, false, 'cyclic-hash', {
-      type: 'test',
-    })
+    const runId = await ws.createRun(
+      'testCyclicGraph',
+      {},
+      false,
+      'cyclic-hash',
+      {
+        type: 'test',
+      }
+    )
 
-    // Succeed a queued step (taking an optional branch), then advance the graph.
     const advance = async (stepName: string, branch?: string) => {
       const step = await ws.getStepState(runId, stepName)
       await ws.setStepRunning(step.stepId)
@@ -287,15 +290,13 @@ describe('graph-runner bugs', () => {
       await continueGraph(ws, runId, 'testCyclicGraph', meta)
     }
 
-    await continueGraph(ws, runId, 'testCyclicGraph', meta) // fire entry
+    await continueGraph(ws, runId, 'testCyclicGraph', meta)
     await advance('start')
-    await advance('a', 'retry') // a → b (b reaches a, but first visit ⇒ bare 'b')
-    await advance('b') // b → a revisit ⇒ a#1
-    await advance('a#1', 'done') // a#1 → c (forward edge, terminal)
+    await advance('a', 'retry')
+    await advance('b')
+    await advance('a#1', 'done')
     await advance('c')
 
-    // Each step records the predecessor it was reached from; the cyclic
-    // revisit is a fresh ordinal instance (a#1) with its own provenance.
     assert.deepEqual(queued, [
       { stepName: 'start', fromStepName: undefined },
       { stepName: 'a', fromStepName: 'start' },
@@ -307,7 +308,6 @@ describe('graph-runner bugs', () => {
     const run = await ws.getRun(runId)
     assert.equal(run?.status, 'completed')
 
-    // Reconstruct the walked path purely from the fromStepName chain.
     const instances = await ws.getStepInstances(runId)
     const from = new Map(instances.map((i) => [i.stepName, i.fromStepName]))
     const path: string[] = []
@@ -419,7 +419,6 @@ describe('graph-runner bugs', () => {
   test('inline graph revisits a cyclic node and records the walked path via fromStepName', async () => {
     const ws = new InMemoryWorkflowService()
 
-    // attempt loops back to itself via `again` until it converges to `done`.
     const mockRpcService = {
       rpcWithWire: async (rpcName: string, _data: any, wire: any) => {
         if (rpcName === 'cyclicBegin') return { attempts: 3 }
@@ -464,7 +463,6 @@ describe('graph-runner bugs', () => {
     const run = await ws.getRun(runId)
     assert.equal(run?.status, 'completed')
 
-    // The self-cycle produced three ordinal instances of `attempt`.
     const instances = await ws.getStepInstances(runId)
     const names = instances.map((i) => i.stepName).sort()
     assert.ok(
@@ -474,8 +472,6 @@ describe('graph-runner bugs', () => {
       `expected attempt/attempt#1/attempt#2, got ${JSON.stringify(names)}`
     )
 
-    // Walk the fromStepName chain back from the terminal node — inline now
-    // records provenance identical to the queued path.
     const from = new Map(instances.map((i) => [i.stepName, i.fromStepName]))
     const path: string[] = []
     let cursor: string | undefined = 'finish'
@@ -483,7 +479,13 @@ describe('graph-runner bugs', () => {
       path.unshift(cursor)
       cursor = from.get(cursor) ?? undefined
     }
-    assert.deepEqual(path, ['begin', 'attempt', 'attempt#1', 'attempt#2', 'finish'])
+    assert.deepEqual(path, [
+      'begin',
+      'attempt',
+      'attempt#1',
+      'attempt#2',
+      'finish',
+    ])
 
     delete metaState['testInlineCyclic']
   })
@@ -647,7 +649,6 @@ describe('graph-runner bugs', () => {
       },
     }
 
-    // Set up queue service to verify nothing is queued
     let queued = false
     pikkuState(null, 'package', 'singletonServices', {
       queueService: {