peachsim 0.1.920 → 0.1.922

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}`)

package/cli/commands/maestro.ts

@@ -55,10 +55,10 @@ function printHelp() {
 peach maestro — author and run Maestro YAML flows against peach
 
 usage:
-  peach maestro                         # discover .maestro/ or maestro/ in cwd, run all
+  peach maestro                         # discover .maestro/ or maestro/ workspace
   peach maestro test <flow-or-dir>      # mirrors "maestro test"
   peach maestro load <flow>             # load flow into runner without running (--dry-run)
-  peach maestro test .maestro/          # every *.yaml / *.yml in a directory
+  peach maestro test .maestro/          # workspace globs, root flows by default
   peach maestro generate "<goal>"       # generate, run, and upload a Maestro flow
   peach maestro start|keep|end          # author a flow from live CLI actions
   peach maestro validate <flow>         # validate a Maestro YAML file
@@ -78,8 +78,9 @@ options:
                          JUNIT, NOOP also accepted (case-insensitive)
   --output <file>        junit report path (needs --format junit)
   --test-output-dir <dir>
-                         per-flow screenshots, commands.json, and logs/maestro.log
-                         (config key testOutputDir:; CLI wins over config)
+                         per-flow screenshots, commands.json, and logs; stores
+                         result JSON here (config key testOutputDir:; CLI wins;
+                         default result dir is --out or /tmp/peach-recordings)
   --debug-output <dir>   write a session maestro.log there
   --flatten-debug-output accepted; peach output is already flat
   --test-suite-name <n>  junit testsuite name (default "Test Suite")
@@ -434,7 +435,14 @@ export async function runMaestro(
       console.error(`  error: no flows in ${target} match the requested tags`)
       return 1
     }
-    console.error(`  error: no *.yaml or *.yml files found in ${target}`)
+    console.error(`  error: no selected *.yaml or *.yml flows in ${target}`)
+    console.error(
+      '  Maestro selects root flows by default. Pass the folder containing your flows,',
+    )
+    console.error('  or add config.yaml with flows: ["flows/**"] to select nested flows.')
+    console.error(
+      '  Keep shared subflows outside the selected globs; runFlow can still load them.',
+    )
     return 1
   }
 
@@ -446,6 +454,30 @@ export async function runMaestro(
     : workspaceConfig.testOutputDir && workspaceConfigPath
       ? path.resolve(path.dirname(workspaceConfigPath), workspaceConfig.testOutputDir)
       : null
+  const outIndex = forwardArgs.indexOf('--out')
+  const resultOutputRoot =
+    testOutputRoot ??
+    path.resolve(cwd, outIndex >= 0 ? forwardArgs[outIndex + 1] : '/tmp/peach-recordings')
+  let wroteResultFiles = false
+  const writeResultFiles = (
+    kind: 'preview' | 'test',
+    flowIndex: number,
+    payload: Record<string, unknown>,
+  ): boolean => {
+    try {
+      fs.mkdirSync(resultOutputRoot, { recursive: true })
+      for (const name of cloudTestResultFileNames(kind, flowIndex, files.length)) {
+        fs.writeFileSync(path.join(resultOutputRoot, name), JSON.stringify(payload))
+        wroteResultFiles = true
+      }
+      return true
+    } catch (err) {
+      console.error(
+        `  error: could not write Maestro results in ${resultOutputRoot}: ${err instanceof Error ? err.message : String(err)}`,
+      )
+      return false
+    }
+  }
 
   console.log(`
   peach maestro — ${files.length} flow${files.length === 1 ? '' : 's'}
@@ -569,10 +601,9 @@ export async function runMaestro(
     }
 
     const upload = getLastFlowPreviewUploadResult()
-    // only --preview uploads, so only it leaves receipts in the working
-    // directory. they are the per-flow manifest: written with null ids when
-    // the upload failed, so the flow never disappears from the collected
-    // entries.
+    // only --preview uploads, so only it leaves preview receipts. they are the
+    // per-flow manifest: written with null ids when the upload failed, so the
+    // flow never disappears from the collected entries.
     if (args.includes('--preview')) {
       const uploaded = Boolean(upload?.shareId || upload?.previewUrl)
       const previewPayload = {
@@ -591,11 +622,10 @@ export async function runMaestro(
                   : `recording upload failed: ${getLastFlowPreviewUploadError() ?? 'no preview returned'}`,
               ).body.split('\n')[0],
       }
-      try {
-        for (const name of cloudTestResultFileNames('preview', flowIndex, files.length)) {
-          fs.writeFileSync(path.join(cwd, name), JSON.stringify(previewPayload))
-        }
-      } catch {}
+      if (!writeResultFiles('preview', flowIndex, previewPayload)) {
+        exit = 1
+        worstExit = 1
+      }
       if (!uploaded) {
         console.error('  error: required hosted recording upload failed')
         if (exit === 0) exit = 1
@@ -620,16 +650,6 @@ export async function runMaestro(
       })
       if (run) {
         console.log(`  run: ${run.id}${run.traceUrl ? ` · replay: ${run.traceUrl}` : ''}`)
-        try {
-          fs.writeFileSync(
-            path.join(cwd, 'test-result.json'),
-            JSON.stringify({
-              runId: run.id,
-              previewUrl: run.previewUrl,
-              traceUrl: run.traceUrl,
-            }),
-          )
-        } catch {}
       } else if (process.env.PEACH_REQUIRE_REGISTRATION === 'true') {
         console.error('  error: required hosted run registration failed')
         if (exit === 0) exit = 1
@@ -643,11 +663,10 @@ export async function runMaestro(
         previewUrl: run?.previewUrl ?? null,
         traceUrl: run?.traceUrl ?? null,
       }
-      try {
-        for (const name of cloudTestResultFileNames('test', flowIndex, files.length)) {
-          fs.writeFileSync(path.join(cwd, name), JSON.stringify(testPayload))
-        }
-      } catch {}
+      if (!writeResultFiles('test', flowIndex, testPayload)) {
+        exit = 1
+        worstExit = 1
+      }
     }
     // artifact, upload, and registration failures above flip the local exit
     // after the result was pushed; the report below must see the final one.
@@ -710,6 +729,9 @@ export async function runMaestro(
       if (worstExit === 0) worstExit = 1
     }
   }
+  if (wroteResultFiles) {
+    console.log(`  results: ${path.relative(cwd, resultOutputRoot) || resultOutputRoot}`)
+  }
 
   return worstExit
 }