peachsim 0.1.921 → 0.1.923

package/README.md

@@ -519,12 +519,17 @@ Maestro is Peach's single YAML test surface. Point it at your existing
 `.maestro/` directory, generate a test, or author one from live actions:
 
 ```sh
-peach maestro                      # discover .maestro/ and run all flows
+peach maestro                      # discover .maestro/ workspace
 peach maestro test .maestro/       # explicit
 peach maestro generate "verify login"
 peach maestro --list-compat        # see the verb support matrix
 ```
 
+Directory discovery selects root YAML flows by default, as Maestro does.
+For nested suites, pass their folder, such as `.maestro/flows`, or add
+`config.yaml` with `flows: ["flows/**"]`. Keep shared subflows outside those
+globs; `runFlow` can still load them.
+
 Tap settling compares consecutive full-screen pixels within Maestro's iOS
 three-second budget, while also draining screen transitions, native motion and
 image loads. Periodic caret paints do not require a continuous stillness window,
@@ -567,14 +572,15 @@ therefore prove that they are painting without weakening the boot-card guard.
     withFrame: true
 ```
 
-For plan-driven app-store exports, use `peach screenshot appstore`:
+For plan-driven app-store exports, use `peach screenshot appstore`. The CLI
+provisions its browser dependency. Paths resolve relative to the plan file:
 
 ```yaml
 app: 8081
 device: iphone-16
 
 capture:
-  flow: .maestro/capture-app-store-screenshots.yaml
+  flow: ../.maestro/capture-app-store-screenshots.yaml
   mode: raw+framed
 
 compose:
@@ -602,8 +608,8 @@ instead of prepending `--screenshots <rawDir>`:
 
 ```yaml
 capture:
-  flow: .maestro/capture-app-store-screenshots.yaml
-  from: ./apps/app-store-screenshots/public/screenshots/apple/iphone/en
+  flow: ../.maestro/capture-app-store-screenshots.yaml
+  from: ../apps/app-store-screenshots/public/screenshots/apple/iphone/en
   pathMode: flow
 ```
 

package/cli/commands/cpu-profile.ts

@@ -407,6 +407,31 @@ export async function runCpuProfile(
   args: string[],
   opts: ProfileOptions,
 ): Promise<number> {
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(`
+peach perf cpu — capture CPU profiles for the page and every worker
+
+usage:
+  peach perf cpu [options]
+
+options:
+  --cdp-port <number>             Chrome debugging port (default: PEACH_CDP_PORT or 9222)
+  --match <substring>             page URL filter (default: /rn/)
+  --duration <seconds>            capture duration (default: 5)
+  --sample-interval <ms>          CPU sampling interval (default: 0.1)
+  --output, -o <path>             profile path (default: /tmp/peach.cpuprofile)
+  --interaction-barrier          wait for a workload's measured interaction
+  --interaction-barrier-timeout <seconds>  barrier deadline (default: 90)
+
+examples:
+  peach open 8081 --new --driver playwright --cdp-port 9222
+  peach perf cpu --cdp-port 9222 --match 8081 --duration 5
+
+Writes a page profile, worker profiles, and a manifest alongside the output.
+`)
+    return 0
+  }
+
   const duration = Number(valueOf(args, '--duration') ?? '5')
   if (!Number.isFinite(duration) || duration <= 0) {
     console.error('  --duration must be a positive number (seconds)')

package/cli/commands/flow.ts

@@ -11,6 +11,7 @@ import { applyPeachConfigToUrl, type PeachConfig } from '../../src/config'
 import { printBridgeFailureDiagnostics } from '../bridge-diagnostics'
 import {
   SootSimBridgeFlowRunner,
+  type MaestroStep,
   type SootSimFlowProfileResult,
   type SootSimFlowTraceStep,
 } from '../bridge-flow-runner'
@@ -217,7 +218,10 @@ export async function runFlowPlayback(
   // beforeSteps runs once the flow is on its target and about to run its first
   // step. opening a frontmatter `app:` navigates the sim, which wipes in-page
   // state, so a caller capturing the run itself (film) starts here.
-  hooks: { beforeSteps?: () => Promise<void> } = {},
+  hooks: {
+    beforeSteps?: () => Promise<void>
+    runSteps?: (driver: SootSimBridgeFlowRunner, steps: MaestroStep[]) => Promise<void>
+  } = {},
 ): Promise<number> {
   lastPreviewUploadResult = null
   lastPreviewUploadError = null
@@ -782,7 +786,8 @@ flow extension:
       }
     }
     await hooks.beforeSteps?.()
-    await driver.runFlow(steps, { skipPlan: dryRun })
+    if (hooks.runSteps) await hooks.runSteps(driver, steps)
+    else await driver.runFlow(steps, { skipPlan: dryRun })
     if (profile) {
       profileResult = await driver.stopProfile()
     }

package/cli/commands/maestro-generate.ts

@@ -1,26 +1,25 @@
 // plain-language Maestro authoring for `peach maestro generate`.
 
-import { mkdtempSync, writeFileSync } from 'fs'
+import { mkdtempSync, readFileSync, writeFileSync } from 'node:fs'
 import { tmpdir } from 'os'
 import { join } from 'path'
 import yaml from 'yaml'
 import { isRecord } from '../../src/is-record'
 import { authHeaderValue, resolveCliAuth } from '../auth'
 import { registerRun, stepSummaryFromTrace } from '../run-registry'
-import { createBridgeFromParsed, parseBridgeCliArgs } from '../ws-bridge'
 import {
   findUnexpectedFlowArgs,
   FLOW_ARG_VALUE_FLAGS,
-  FLOW_BRIDGE_ARG_OPTIONS,
   getLastFlowPreviewUploadResult,
   getLastFlowTraceSteps,
   runFlowPlayback,
   type UnexpectedFlowArg,
 } from './flow'
-import { inspectDescribe } from './inspect/core'
 import { resolveDefaultUploadOrigin } from './upload'
+import type { MaestroStep, SootSimBridgeFlowRunner } from '../bridge-flow-runner'
 
 const DEFAULT_TEST_MODEL = process.env.PEACH_TEST_MODEL || 'deepseek-v4-flash'
+const MAX_GENERATION_STEPS = 30
 const DESCRIBE_CONTEXT_LIMIT = 18_000
 const LLM_TIMEOUT_MS = 180_000
 
@@ -37,12 +36,8 @@ function flagValueAny(args: string[], names: string[]): string | undefined {
   return undefined
 }
 
-// generate is a front-end for runFlowPlayback: it inspects the sim, asks the
-// model for a flow, then hands the argv down. these are the only flags it reads
-// itself; everything else belongs to the runner and is forwarded verbatim. this
-// file used to keep its own allowlist of what to forward, which silently
-// dropped --proof, --record, --profile, --screenshots, --out and --base-url
-// while `maestro test` honoured all six.
+// generation runs inside playback's target and recording lifecycle. only these
+// flags belong to generation; the runner receives every other flag verbatim.
 const GENERATE_VALUE_FLAGS = ['--origin', '--preview-origin', '--public-origin']
 
 const VALUE_FLAGS = new Set([...GENERATE_VALUE_FLAGS, ...FLOW_ARG_VALUE_FLAGS])
@@ -61,50 +56,15 @@ export function findPrompt(args: string[]): { prompt: string; index: number } |
   return null
 }
 
-function stripPromptForBridge(args: string[], promptIndex: number): string[] {
-  return args.filter((_, index) => index !== promptIndex)
-}
-
-async function describeCurrentSim(args: string[], promptIndex: number): Promise<string> {
-  const bridgeArgs = stripPromptForBridge(args, promptIndex)
-  const parsedBridgeArgs = parseBridgeCliArgs(bridgeArgs, {
-    stripBooleanFlags: FLOW_BRIDGE_ARG_OPTIONS.stripBooleanFlags,
-    stripValueFlags: [
-      ...GENERATE_VALUE_FLAGS,
-      ...FLOW_BRIDGE_ARG_OPTIONS.stripValueFlags,
-    ],
-  })
-  const bridge = createBridgeFromParsed(parsedBridgeArgs)
-  try {
-    const describe = await inspectDescribe(bridge, {
-      describe: true,
-      verbose: false,
-      filter: '',
-      compact: true,
-      hideXy: true,
-    })
-    const parts = [
-      typeof describe.nodeCount === 'number' ? `nodes: ${describe.nodeCount}` : '',
-      describe.tree || '',
-    ].filter(Boolean)
-    const text = parts.join('\n')
-    return text.length > DESCRIBE_CONTEXT_LIMIT
-      ? text.slice(0, DESCRIBE_CONTEXT_LIMIT) + '\n[tree truncated]'
-      : text
-  } finally {
-    bridge.close()
-  }
-}
-
-const RNX_TEST_SYSTEM_PROMPT = `
-You write Maestro-compatible peach YAML flows from a user's plain-language test goal.
+const PEACH_TEST_SYSTEM_PROMPT = `
+You author a Maestro-compatible peach flow one step at a time on a running simulator.
 Return only JSON, no markdown, with this exact shape:
-{"summary":"short human-readable result goal","steps":[{"waitFor":{"text":"...","timeout":10000}}]}
+{"summary":"short result goal","step":{"tapOn":{"id":"observed-id"}},"done":false}
 
-Use only these flow commands:
+Use only these commands, one per response:
 - waitFor: { "text"?: string, "id"?: string, "timeout"?: number }
-- assertVisible: string or { "text"?: string, "id"?: string }
-- assertNotVisible: string or { "text"?: string, "id"?: string }
+- assertVisible: string or { "text"?: string, "id"?: string, "index"?: number }
+- assertNotVisible: string or { "text"?: string, "id"?: string, "index"?: number }
 - tapOn: string or { "text"?: string, "id"?: string, "index"?: number }
 - inputText: string
 - pressKey: string
@@ -113,26 +73,38 @@ Use only these flow commands:
 - waitForAnimationToEnd: true
 - takeScreenshot: "label"
 
-Prefer ids/testIDs from the tree. Prefer visible text when no id exists.
-Do not invent app-specific data that is not visible. Keep the flow short.
-End with an assertion or wait that proves the user's goal.
+Every selector must use an exact id or text from the current observed elements.
+Prefer ids. Accessible labels are text selectors. Use index for repeated labels.
+Only assertNotVisible may refer to an element observed on an earlier screen.
+Never guess selectors for the next screen. After each step the simulator is inspected again.
+Use existing visible app data; do not invent credentials or test data.
+Set done:true only with a final assertion that proves the user's goal, or step:null
+when the preceding assertion already proved it. Keep the flow short.
 `.trim()
 
-function buildPromptRequest(prompt: string, describe: string): string {
+function buildPromptRequest(
+  prompt: string,
+  describe: string,
+  steps: MaestroStep[],
+): string {
   return `
 User goal:
 ${prompt}
 
-Current peach visible tree:
-${describe || '[no tree available]'}
+Successfully executed steps:
+${yaml.stringify(steps)}
+
+Current peach observed selectors (id, text and role):
+${describe}
 
-Generate the shortest replayable flow that verifies the goal from this current state.
+Choose only the next step, using a selector from these observations.
 `.trim()
 }
 
 async function generateFlowJson(args: {
   prompt: string
   describe: string
+  steps: MaestroStep[]
   origin: string
   authHeader: string
 }): Promise<string> {
@@ -145,16 +117,16 @@ async function generateFlowJson(args: {
     body: JSON.stringify({
       modelId: DEFAULT_TEST_MODEL,
       context: {
-        systemPrompt: RNX_TEST_SYSTEM_PROMPT,
+        systemPrompt: PEACH_TEST_SYSTEM_PROMPT,
         messages: [
           {
             role: 'user',
-            content: buildPromptRequest(args.prompt, args.describe),
+            content: buildPromptRequest(args.prompt, args.describe, args.steps),
             timestamp: Date.now(),
           },
         ],
       },
-      options: { maxTokens: 1800, temperature: 0.2 },
+      options: { maxTokens: 600, temperature: 0.2 },
       threadId: null,
     }),
     signal: AbortSignal.timeout(LLM_TIMEOUT_MS),
@@ -173,15 +145,14 @@ async function generateFlowJson(args: {
   const handleLine = (line: string) => {
     const trimmed = line.trim()
     if (!trimmed) return
-    const event = JSON.parse(trimmed) as {
-      type?: string
-      delta?: string
-      errorMessage?: string
-    }
-    if (event.type === 'text_delta' && event.delta) {
+    const event: unknown = JSON.parse(trimmed)
+    if (!isRecord(event)) throw new Error('llm returned an invalid stream event')
+    if (event.type === 'text_delta' && typeof event.delta === 'string') {
       deltas.push(event.delta)
     } else if (event.type === 'error') {
-      throw new Error(event.errorMessage || 'llm error')
+      throw new Error(
+        typeof event.errorMessage === 'string' ? event.errorMessage : 'llm error',
+      )
     }
   }
 
@@ -199,7 +170,7 @@ async function generateFlowJson(args: {
   if (buffer.trim()) handleLine(buffer)
 
   const text = deltas.join('').trim()
-  if (!text) throw new Error('llm returned an empty test flow')
+  if (!text) throw new Error('llm returned an empty next step')
   return text
 }
 
@@ -211,26 +182,217 @@ function extractJson(text: string): unknown {
   return JSON.parse(candidate)
 }
 
-function parseGeneratedFlow(text: string): {
-  summary: string
-  steps: Record<string, unknown>[]
-  yamlText: string
-} {
-  const parsed = extractJson(text)
-  if (!isRecord(parsed)) throw new Error('llm did not return a JSON object')
-  const summary =
-    typeof parsed.summary === 'string' && parsed.summary.trim()
-      ? parsed.summary.trim().slice(0, 500)
-      : 'peach generated test'
-  const rawSteps = parsed.steps
-  if (!Array.isArray(rawSteps) || rawSteps.length === 0) {
-    throw new Error('llm returned no flow steps')
+interface GeneratedObservation {
+  testID?: string
+  text?: string
+  label?: string
+  role?: string
+}
+
+type ObservedSelector = { id?: string; text?: string; index?: number }
+
+function parseObservedSelector(
+  value: unknown,
+  elements: GeneratedObservation[],
+  allowTimeout = false,
+): ObservedSelector & { timeout?: number } {
+  const raw = typeof value === 'string' ? { text: value } : value
+  if (!isRecord(raw)) throw new Error('generated selector must name observed text or id')
+  const allowed = allowTimeout ? ['id', 'text', 'timeout'] : ['id', 'text', 'index']
+  const unsupported = Object.keys(raw).filter((key) => !allowed.includes(key))
+  if (unsupported.length > 0) {
+    throw new Error(
+      `generated selector contains unsupported fields: ${unsupported.join(', ')}; use observed id or text`,
+    )
+  }
+  const id = raw.id
+  const text = raw.text
+  if (
+    (id !== undefined && typeof id !== 'string') ||
+    (text !== undefined && typeof text !== 'string') ||
+    (!id && !text)
+  )
+    throw new Error('generated selector must name observed text or id')
+  const matches = elements.filter(
+    (node) =>
+      (id === undefined || node.testID === id) &&
+      (text === undefined || node.text === text || node.label === text),
+  )
+  if (matches.length === 0) {
+    throw new Error(`generated selector was never observed: ${JSON.stringify(raw)}`)
+  }
+  const selector: ObservedSelector & { timeout?: number } = {}
+  // id selectors are regexes in Maestro, so quote the observed literal id.
+  if (typeof id === 'string') selector.id = id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  if (typeof text === 'string') selector.text = text
+  if (raw.index !== undefined) {
+    if (
+      typeof raw.index !== 'number' ||
+      !Number.isInteger(raw.index) ||
+      raw.index < 0 ||
+      raw.index >= matches.length
+    ) {
+      throw new Error('generated selector index is outside observed elements')
+    }
+    selector.index = raw.index
+  }
+  if (raw.timeout !== undefined) {
+    if (
+      typeof raw.timeout !== 'number' ||
+      !Number.isFinite(raw.timeout) ||
+      raw.timeout <= 0
+    ) {
+      throw new Error('generated wait timeout must be positive')
+    }
+    selector.timeout = raw.timeout
+  }
+  return selector
+}
+
+function parseGeneratedStep(
+  value: unknown,
+  current: GeneratedObservation[],
+  observed: GeneratedObservation[],
+): MaestroStep {
+  if (!isRecord(value) || Object.keys(value).length !== 1) {
+    throw new Error('llm must return exactly one flow command')
+  }
+  const [command] = Object.keys(value)
+  const target = value[command]
+  switch (command) {
+    case 'tapOn':
+      return { tapOn: parseObservedSelector(target, current) }
+    case 'assertVisible':
+      return { assertVisible: parseObservedSelector(target, current) }
+    case 'assertNotVisible':
+      return { assertNotVisible: parseObservedSelector(target, observed) }
+    case 'waitFor':
+      return { waitFor: parseObservedSelector(target, current, true) }
+    case 'inputText':
+    case 'pressKey':
+    case 'takeScreenshot':
+      if (typeof target !== 'string') throw new Error(`${command} requires a string`)
+      return { [command]: target }
+    case 'hideKeyboard':
+    case 'waitForAnimationToEnd':
+      if (target !== true) throw new Error(`${command} requires true`)
+      return { [command]: true }
+    case 'swipe': {
+      if (
+        !isRecord(target) ||
+        Object.keys(target).some((key) => !['direction', 'duration'].includes(key))
+      ) {
+        throw new Error('generated swipe requires a direction and optional duration')
+      }
+      const direction = target.direction
+      if (
+        typeof direction !== 'string' ||
+        !['UP', 'DOWN', 'LEFT', 'RIGHT'].includes(direction)
+      ) {
+        throw new Error('generated swipe direction is invalid')
+      }
+      const duration = target.duration
+      if (
+        duration !== undefined &&
+        (typeof duration !== 'number' || !Number.isFinite(duration) || duration <= 0)
+      ) {
+        throw new Error('generated swipe duration must be positive')
+      }
+      return {
+        swipe: { direction, ...(typeof duration === 'number' ? { duration } : {}) },
+      }
+    }
+    default:
+      throw new Error(`unsupported generated flow command: ${command}`)
   }
-  const steps = rawSteps.map((step, index) => {
-    if (!isRecord(step)) throw new Error(`flow step ${index + 1} is not an object`)
-    return step
-  })
-  return { summary, steps, yamlText: yaml.stringify(steps) }
+}
+
+// every proposal is checked against a new tree before execution or persistence.
+// transport and execution failures leave the last grounded step in the flow file.
+export async function generateObservedFlow(options: {
+  driver: Pick<SootSimBridgeFlowRunner, 'bridge' | 'simId' | 'runStep' | 'planFlow'>
+  prompt: string
+  origin: string
+  authHeader: string
+  flowPath: string
+  steps: MaestroStep[]
+}): Promise<string> {
+  const { driver, steps, flowPath } = options
+  steps.length = 0
+  const observed: GeneratedObservation[] = []
+  let summary = 'peach generated test'
+  for (let index = 0; index < MAX_GENERATION_STEPS; index++) {
+    // listInspectable is the visible snapshot behind describe. read testID
+    // directly: the semantic tree also aliases nativeID as testID, while a
+    // Maestro id selector only matches the real testID.
+    const result: unknown = await driver.bridge.send({
+      type: 'call',
+      simId: driver.simId,
+      path: '__sootsimTest.listInspectable',
+      args: [{}],
+    })
+    if (!Array.isArray(result))
+      throw new Error('simulator returned no valid observed elements')
+    const current: GeneratedObservation[] = result.map((node: unknown) => {
+      if (!isRecord(node))
+        throw new Error('simulator returned an invalid observed element')
+      const entry: GeneratedObservation = {}
+      const fields = {
+        testID: node.testID,
+        text: node.text,
+        label: node.accessibilityLabel ?? node.label,
+        role: node.role,
+      }
+      for (const key of [
+        'testID',
+        'text',
+        'label',
+        'role',
+      ] satisfies (keyof GeneratedObservation)[]) {
+        const value = fields[key]
+        if (value !== undefined && value !== null && typeof value !== 'string') {
+          throw new Error(`simulator returned an invalid observed ${key}`)
+        }
+        if (typeof value === 'string' && value) entry[key] = value
+      }
+      return entry
+    })
+    observed.push(...current)
+    const catalog: string[] = []
+    let contextSize = 2
+    for (const { testID, text, label, role } of current) {
+      const item = JSON.stringify({ id: testID, text: label ?? text, role })
+      if (contextSize + item.length + 1 > DESCRIBE_CONTEXT_LIMIT) break
+      catalog.push(item)
+      contextSize += item.length + 1
+    }
+    const describe = `[${catalog.join(',')}]`
+    const proposal = extractJson(await generateFlowJson({ ...options, describe }))
+    if (!isRecord(proposal) || typeof proposal.done !== 'boolean') {
+      throw new Error('llm must return a next step and a done boolean')
+    }
+    if (typeof proposal.summary === 'string' && proposal.summary.trim()) {
+      summary = proposal.summary.trim().slice(0, 500)
+    }
+    if (proposal.step === null && proposal.done) {
+      const last = steps.at(-1)
+      if (!last?.assertVisible && !last?.assertNotVisible)
+        throw new Error('generated flow finished without a goal assertion')
+      return summary
+    }
+    const step = parseGeneratedStep(proposal.step, current, observed)
+    if (proposal.done && !step.assertVisible && !step.assertNotVisible) {
+      throw new Error('generated flow must finish with a goal assertion')
+    }
+    steps.push(step)
+    writeFileSync(flowPath, yaml.stringify(steps))
+    await driver.planFlow(steps)
+    await driver.runStep(step, index)
+    if (proposal.done) return summary
+  }
+  throw new Error(
+    `generation exceeded ${MAX_GENERATION_STEPS} steps before proving the goal`,
+  )
 }
 
 export function buildFlowArgs(
@@ -323,19 +485,45 @@ export async function runMaestroGenerate(args: string[]): Promise<number> {
   const origin = await resolveDefaultUploadOrigin(
     flagValueAny(args, ['--origin', '--preview-origin']),
   )
-  console.log('  inspecting current sim…')
-  const describe = await describeCurrentSim(args, promptIndex)
-  console.log('  generating Maestro flow…')
-  const generated = await generateFlowJson({ prompt, describe, origin, authHeader })
-  const flow = parseGeneratedFlow(generated)
   const tempDir = mkdtempSync(join(tmpdir(), 'peach-maestro-generate-'))
   const flowPath = join(tempDir, 'flow.yaml')
-  writeFileSync(flowPath, flow.yamlText)
+  // the runner establishes the target, cold preview state, and recording first.
+  // this placeholder is replaced before any authored step executes.
+  writeFileSync(flowPath, yaml.stringify([{ waitForAnimationToEnd: true }]))
   console.log(`  flow: ${flowPath}`)
+  console.log('  generating Maestro flow from live observations…')
 
   const startedAt = Date.now()
+  let summary = 'peach generated test'
+  let generationError: string | null = null
   const flowArgs = buildFlowArgs(args, promptIndex, flowPath, origin)
-  const exitCode = await runFlowPlayback(flowArgs)
+  let exitCode: number
+  try {
+    exitCode = await runFlowPlayback(flowArgs, {
+      runSteps: async (driver, steps) => {
+        writeFileSync(flowPath, '[]\n')
+        try {
+          summary = await generateObservedFlow({
+            driver,
+            steps,
+            prompt,
+            origin,
+            authHeader,
+            flowPath,
+          })
+        } catch (error) {
+          generationError = error instanceof Error ? error.message : String(error)
+          throw error
+        }
+      },
+    })
+  } catch (error) {
+    console.error(
+      `  generation failed: ${error instanceof Error ? error.message : String(error)}`,
+    )
+    console.error(`  partial flow: ${flowPath}`)
+    return 1
+  }
   const upload = getLastFlowPreviewUploadResult()
   const traceSteps = getLastFlowTraceSteps()
   const failedStep = traceSteps.find((step) => step.status === 'failure')
@@ -344,19 +532,25 @@ export async function runMaestroGenerate(args: string[]): Promise<number> {
     origin,
     kind: 'maestro',
     prompt,
-    summary: flow.summary,
+    summary,
     status,
     failureMessage:
-      status === 'failed' ? (failedStep?.error ?? 'flow playback failed') : null,
+      status === 'failed'
+        ? (generationError ?? failedStep?.error ?? 'flow playback failed')
+        : null,
     previewShareId: upload?.shareId ?? null,
     owner: flagValue(args, '--owner') ?? null,
     repo: flagValue(args, '--repo') ?? null,
     durationMs: Date.now() - startedAt,
-    flowYamlSizeBytes: Buffer.byteLength(flow.yamlText, 'utf8'),
+    flowYamlSizeBytes: Buffer.byteLength(readFileSync(flowPath, 'utf8'), 'utf8'),
     ...stepSummaryFromTrace(traceSteps),
     auth: cliAuth,
   })
 
+  if (exitCode !== 0)
+    console.error(
+      `  partial flow: ${flowPath}${generationError ? ` (${generationError})` : ''}`,
+    )
   console.log(`\n  result: ${status}`)
   if (run) console.log(`  run: ${run.id}`)
   if (upload?.previewUrl) console.log(`  preview: ${upload.previewUrl}`)