From d88213deb41fffe53a234e486a9cdc9003d15575 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Wed, 21 Oct 2026 22:26:34 +0100 Subject: [PATCH] feat(app): add native authored stage definition pane --- .../graph/domain/stage_definition.dart | 212 ++++++++++ .../graph/widgets/stage_definition_view.dart | 241 +++++++++++ app/notes/P2-stage.md | 103 +++++ .../graph/domain/stage_definition_test.dart | 159 ++++++++ .../widgets/stage_definition_view_test.dart | 286 +++++++++++++ app/tool/stage_definition_probe.dart | 148 +++++++ app/tool/stage_definition_probe.mjs | 380 ++++++++++++++++++ 7 files changed, 1529 insertions(+) create mode 100644 app/lib/features/graph/domain/stage_definition.dart create mode 100644 app/lib/features/graph/widgets/stage_definition_view.dart create mode 100644 app/notes/P2-stage.md create mode 100644 app/test/features/graph/domain/stage_definition_test.dart create mode 100644 app/test/features/graph/widgets/stage_definition_view_test.dart create mode 100644 app/tool/stage_definition_probe.dart create mode 100644 app/tool/stage_definition_probe.mjs diff --git a/app/lib/features/graph/domain/stage_definition.dart b/app/lib/features/graph/domain/stage_definition.dart new file mode 100644 index 00000000..08680773 --- /dev/null +++ b/app/lib/features/graph/domain/stage_definition.dart @@ -0,0 +1,212 @@ +import 'graph_definition.dart'; +import 'graph_protocol.dart'; + +/// The read-only definition of one declared stage, as field rows. +/// +/// Mirrors `stageDefinitionFields`/`terminalFields` from `web/src/graph.js`: +/// the same labels, the same order, and the same rule that blank fields are +/// omitted rather than shown as an empty row. Pure data only: nothing here +/// reads run visits, so a definition can be inspected without claiming that a +/// stage executed. +class StageDefinitionField { + const StageDefinitionField(this.label, this.value, {this.block = false}); + + final String label; + final String value; + + /// Multi-line content (prompt, output, outcomes, tools, memory, routes). + final bool block; +} + +/// The one stage declaration [key] names, or null when this version does not +/// declare it. +/// +/// The last declaration wins, matching the web pane's `new Map(stages)`. +Map? stageDefinitionFor(dynamic graph, String key) { + final stages = graph is Map ? graph['stages'] : null; + if (stages is! List) return null; + Map? found; + for (final stage in stages) { + if (stage is Map && _text(stage['key']) == key) { + found = Map.from(stage); + } + } + return found; +} + +/// A stage's effective type: a blank/absent type reads `model`, exactly as +/// `effectiveStageType` in `web/src/templates.js`. +String effectiveStageType(dynamic type) { + final text = _text(type); + return text.trim().isEmpty ? 'model' : text; +} + +/// A config key's display label (`configLabel` in `web/src/graph.js`). +String stageConfigLabel(String key) { + switch (key) { + case 'provider': + return 'Provider'; + case 'model': + return 'Model'; + case 'retries': + return 'Retries'; + case 'timeout': + return 'Timeout'; + case 'budget_usd': + return 'Budget (USD)'; + case 'budget_tokens': + return 'Budget (tokens)'; + case 'harness': + return 'Harness'; + default: + return key; + } +} + +/// The definition fields of one stage declaration, in the web pane's order. +/// +/// Only non-blank fields are emitted. Unknown keys are deliberately not +/// interpreted here; the pane keeps the stage's raw JSON so they stay visible. +List stageDefinitionFields(dynamic stage) { + if (stage is! Map) return const []; + final fields = [ + StageDefinitionField('Type', effectiveStageType(stage['type'])), + ]; + + final prompt = _text(stage['prompt']); + if (prompt.trim().isNotEmpty) { + fields.add(StageDefinitionField('Prompt', prompt, block: true)); + } + final output = _text(stage['output']); + if (output.trim().isNotEmpty) { + fields.add(StageDefinitionField('Output', output, block: true)); + } + + final edges = stage['edges']; + final outcomes = []; + for (final outcome in stageOutcomes(stage)) { + final raw = edges is Map ? edges[outcome] : null; + final target = resolveTarget(outcome, raw == null ? '' : _text(raw)) ?? ''; + final suffix = isTerminalTarget(target) ? ' (terminal)' : ''; + outcomes.add('$outcome \u2192 ${nodeLabel(target)}$suffix'); + } + if (outcomes.isNotEmpty) { + fields.add( + StageDefinitionField('Outcomes', outcomes.join('\n'), block: true), + ); + } + + final configs = stage['configs']; + if (configs is Map) { + final entries = configs.entries.toList() + ..sort((a, b) => _text(a.key).compareTo(_text(b.key))); + for (final entry in entries) { + final value = _text(entry.value); + if (entry.value == null || value.trim().isEmpty) continue; + fields.add( + StageDefinitionField(stageConfigLabel(_text(entry.key)), value), + ); + } + } + + final blocks = stage['blocks']; + if (blocks is Map) { + final tools = blocks['tools']; + final text = _text(tools); + if (tools != null && text.trim().isNotEmpty) { + fields.add(StageDefinitionField('Tools', text, block: true)); + } + } + + final limits = stage['limits']; + if (limits is Map) { + final maxVisits = limits['max_visits']; + final visits = maxVisits is num + ? maxVisits + : num.tryParse(_text(maxVisits)); + if (visits != null && visits > 0) { + fields.add(StageDefinitionField('Max visits', _text(maxVisits))); + } + final on = _items(limits['on']); + if (on.isNotEmpty) { + fields.add(StageDefinitionField('Limit on', on.join(', '))); + } + } + + final memory = stage['memory']; + if (memory is Map && memory.isNotEmpty) { + fields.add( + StageDefinitionField( + 'Memory', + [ + for (final entry in memory.entries) + '${_text(entry.key)}: ${_text(entry.value)}', + ].join('\n'), + block: true, + ), + ); + } + + final notify = stage['notify']; + if (notify is Map) { + final on = _items(notify['on']); + if (on.isNotEmpty) { + fields.add(StageDefinitionField('Notify on', on.join(', '))); + } + final destination = _text(notify['destination']); + if (destination.trim().isNotEmpty) { + fields.add(StageDefinitionField('Notify destination', destination)); + } + final artifacts = _items(notify['artifacts']); + if (artifacts.isNotEmpty) { + fields.add( + StageDefinitionField('Notify artifacts', artifacts.join(', ')), + ); + } + } + + return fields; +} + +/// A terminal pane's fields: the declared routes into that target. +/// +/// A terminal is part of the definition, not evidence that a run reached it. +List terminalDefinitionFields(dynamic graph, String key) { + final lines = [ + for (final edge in graphEdges(graph)) + if (edge.target == key) + '${edge.source} \u00b7 ${edge.label} \u2192 ${nodeLabel(key)}', + ]; + return lines.isEmpty + ? const [] + : [ + StageDefinitionField( + 'Incoming routes', + lines.join('\n'), + block: true, + ), + ]; +} + +List _items(dynamic value) { + if (value is! List) return const []; + return [for (final item in value) _text(item)]; +} + +/// Web `String(value)` for the values the definition fields carry. Numbers +/// that are integral render without a trailing `.0`, as JavaScript does; a +/// complex value stays visible but its exact shape is preserved by the raw +/// JSON section instead. +String _text(dynamic value) { + if (value == null) return ''; + if (value is String) return value; + if (value is num) { + if (value.isFinite && + value == value.roundToDouble() && + value.abs() < 1e21) { + return value.toInt().toString(); + } + return value.toString(); + } + return value.toString(); +} diff --git a/app/lib/features/graph/widgets/stage_definition_view.dart b/app/lib/features/graph/widgets/stage_definition_view.dart new file mode 100644 index 00000000..e86a31a1 --- /dev/null +++ b/app/lib/features/graph/widgets/stage_definition_view.dart @@ -0,0 +1,241 @@ +import 'dart:convert'; + +import 'package:flutter/cupertino.dart'; +import 'package:flutter/material.dart'; + +import '../../../core/api_gateway.dart'; +import '../../../ui/adaptive/host.dart'; +import '../domain/graph_protocol.dart'; +import '../domain/stage_definition.dart'; + +/// Wording for a stage that this pinned definition does not declare. +const String unknownStageDefinition = + 'This stage is not declared in this pipeline version. ' + 'No definition has been reconstructed.'; + +/// The web pane's message when a node has no recorded stage or incoming routes. +const String noStageDefinitionDetails = 'No details recorded for this node.'; + +/// Terminals are definition targets; this pane never presents one as evidence. +const String terminalDefinitionNote = + 'Success and Failure are definition targets, not recorded visits. ' + 'This pane shows where the definition routes.'; + +/// The raw section's heading: unknown stage fields stay visible and selectable. +const String rawStageDefinitionTitle = 'Raw stage definition'; + +/// A read-only native view of one stage's declared definition. +/// +/// [graph] is the graph pinned for exactly [pipelineId]/[version] and +/// [stageKey] is a node key (a stage or `#success`/`#failure`). Nothing is +/// fetched and no run visit is read, so the pane cannot imply that the stage +/// executed. Unknown stage declarations get an explicit missing state; every +/// declared stage also keeps its exact JSON below the structured fields. +class StageDefinitionView extends StatelessWidget { + const StageDefinitionView({ + super.key, + required this.graph, + required this.stageKey, + required this.pipelineId, + required this.pipelineName, + required this.version, + }); + + final JsonMap graph; + final String stageKey; + final int pipelineId; + final String pipelineName; + final int version; + + String get _identity => + '${pipelineName.isEmpty ? 'Pipeline' : pipelineName} \u00b7 v$version'; + + @override + Widget build(BuildContext context) { + final style = _StageDefinitionStyle.of(context); + final stage = stageDefinitionFor(graph, stageKey); + final terminal = isTerminalTarget(stageKey); + final fields = stage != null + ? stageDefinitionFields(stage) + : terminal + ? terminalDefinitionFields(graph, stageKey) + : const []; + + return ListView( + padding: const EdgeInsets.all(16), + children: [ + Text(_identity, style: style.muted), + const SizedBox(height: 16), + if (stage == null && !terminal) + Text(unknownStageDefinition, style: style.value) + else ...[ + if (terminal) ...[ + Text(terminalDefinitionNote, style: style.muted), + const SizedBox(height: 16), + ], + for (final field in fields) + _StageDefinitionFieldView(field: field, style: style), + if (terminal && fields.isEmpty) + Text(noStageDefinitionDetails, style: style.muted), + if (stage != null) ...[ + const SizedBox(height: 8), + Text(rawStageDefinitionTitle, style: style.heading), + const SizedBox(height: 8), + _SelectableDefinitionText( + value: const JsonEncoder.withIndent(' ').convert(stage), + style: style.value, + ), + ], + ], + ], + ); + } +} + +/// Opens the platform's native full-screen stage-definition page. +/// +/// The page owns the single navigation bar and its standard back control; the +/// caller only supplies the pinned graph and identity. This is the hook the +/// pipeline graph uses when a node is selected. +Future openStageDefinition( + BuildContext context, { + required JsonMap graph, + required String stageKey, + required int pipelineId, + required String pipelineName, + required int version, +}) { + final view = StageDefinitionView( + graph: graph, + stageKey: stageKey, + pipelineId: pipelineId, + pipelineName: pipelineName, + version: version, + ); + final settings = RouteSettings( + name: 'stage-definition/$pipelineId/$version/$stageKey', + ); + // A terminal is a definition target, not its protocol key: the web pane + // titles it with `nodeDisplayLabel` (`Failure`/`Success`). + final title = '${nodeDisplayLabel(stageKey)} definition'; + final route = usesCupertinoHost(context) + ? CupertinoPageRoute( + settings: settings, + builder: (_) => CupertinoPageScaffold( + navigationBar: CupertinoNavigationBar(middle: Text(title)), + child: SafeArea(child: view), + ), + ) + : MaterialPageRoute( + settings: settings, + builder: (_) => Scaffold( + appBar: AppBar(title: Text(title)), + body: SafeArea(child: view), + ), + ); + return Navigator.of(context).push(route); +} + +/// One labelled field: a compact row for scalars, a selectable block when the +/// value is multi-line authored text. +class _StageDefinitionFieldView extends StatelessWidget { + const _StageDefinitionFieldView({required this.field, required this.style}); + + final StageDefinitionField field; + final _StageDefinitionStyle style; + + @override + Widget build(BuildContext context) { + return Padding( + padding: const EdgeInsets.only(bottom: 16), + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text(field.label, style: style.label), + const SizedBox(height: 4), + if (field.block) + _SelectableDefinitionText(value: field.value, style: style.value) + else + Text(field.value, style: style.value), + ], + ), + ); + } +} + +/// Authored definition text in the host's selectable body. +/// +/// The semantic leaf carries the exact value: Flutter web maps a +/// [SelectableText] to an empty read-only field, so without this a screen +/// reader (and a browser check) sees only its label. The child keeps native +/// pointer selection and the host's system typography. +/// +/// The strut is derived from that same host style and forced, so a glyph the +/// host font lacks (the outcomes arrow `→` is one example) cannot pull in a +/// fallback font with taller metrics and double-space only that block. It is +/// the host's own line metrics, not a font override or a fixed height. +class _SelectableDefinitionText extends StatelessWidget { + const _SelectableDefinitionText({required this.value, required this.style}); + + final String value; + final TextStyle style; + + @override + Widget build(BuildContext context) { + return Semantics( + label: value, + child: ExcludeSemantics( + child: SelectableText( + value, + style: style, + strutStyle: StrutStyle.fromTextStyle(style, forceStrutHeight: true), + ), + ), + ); + } +} + +/// Host text roles only: no palette, font family or explicit size. +class _StageDefinitionStyle { + const _StageDefinitionStyle({ + required this.label, + required this.value, + required this.muted, + required this.heading, + }); + + factory _StageDefinitionStyle.of(BuildContext context) { + if (usesCupertinoHost(context)) { + final theme = CupertinoTheme.of(context); + final secondary = CupertinoColors.secondaryLabel.resolveFrom(context); + return _StageDefinitionStyle( + label: theme.textTheme.tabLabelTextStyle.copyWith(color: secondary), + // SelectableText needs a style it can merge into the default text + // style; Cupertino's textStyle is a complete style with `inherit: false` + // and no baseline. + value: theme.textTheme.textStyle.copyWith(inherit: true), + muted: theme.textTheme.textStyle.copyWith( + inherit: true, + color: secondary, + ), + heading: theme.textTheme.navTitleTextStyle, + ); + } + final theme = Theme.of(context); + return _StageDefinitionStyle( + label: (theme.textTheme.labelMedium ?? const TextStyle()).copyWith( + color: theme.colorScheme.onSurfaceVariant, + ), + value: theme.textTheme.bodyMedium ?? const TextStyle(), + muted: (theme.textTheme.bodySmall ?? const TextStyle()).copyWith( + color: theme.colorScheme.onSurfaceVariant, + ), + heading: theme.textTheme.titleSmall ?? const TextStyle(), + ); + } + + final TextStyle label; + final TextStyle value; + final TextStyle muted; + final TextStyle heading; +} diff --git a/app/notes/P2-stage.md b/app/notes/P2-stage.md new file mode 100644 index 00000000..36b7b411 --- /dev/null +++ b/app/notes/P2-stage.md @@ -0,0 +1,103 @@ +# P2 stage: read-only definition pane + +The definition graph can now open one stage's authored definition without +reading a run. `StageDefinitionView` receives the graph JsonMap pinned for a +pipeline/version, a stage key and that identity; it performs no request and +shows no visit, status or session data. `openStageDefinition` pushes the +platform's normal page with one navigation bar and its standard back control, +for the manager's graph hook. + +## Behaviour + +- Fields match `stageDefinitionFields`/`terminalFields` in `web/src/graph.js`: + Type, Prompt, Output, Outcomes (ordered, targets resolved, terminals marked), + configs in sorted order with the web labels, Tools, Max visits, Limit on, + Memory, Notify on/destination/artifacts. Only non-blank fields are emitted. +- `effectiveStageType` keeps the web rule that a blank/absent type reads + `model`; no other default is invented. +- A terminal (`#success`/`#failure`) lists its incoming definition routes and + says explicitly that these are definition targets, not recorded visits. Its + page is titled with the web's display label (`Failure definition` / + `Success definition`, via `nodeDisplayLabel`), never the raw `#failure` key. +- A stage key this version does not declare gets an explicit missing state. No + fields, terminal note or raw JSON are fabricated. +- Every declared stage also shows its exact pretty-printed stage JSON in a + selectable raw section, so unknown/future fields stay available. The raw + value is the only source for those keys; the structured rows only interpret + documented ones. +- Host text roles only: Material `Theme`/`ColorScheme`, Cupertino + `CupertinoTheme`/`CupertinoColors`, system fonts, light/dark and text scale + follow the host. No palette, font family, fixed component size or custom + control clone. +- Selectable body blocks force a strut derived from that same host style. + Without it, a glyph the host font lacks (the outcomes arrow `→`) pulls in a + fallback font with taller metrics and doubles only that block's leading. The + strut is the host's own family/size, not a font override or fixed height, and + selection stays native. + +## UI review fixes + +- Cupertino `Outcomes` leading: the block's rendered line pitch matched a + fallback font (34 px between outcome lines against 19 px for `Tools` at 1×, + 68 px against 30 px at 2×). With the forced host strut the line pitch is + 19 px for both blocks at 1× and 37/39 px at 2×, and the semantics block + heights are equal (72/72 at 1×, 123/123 at 2×). The 390×844 / 2× wrap of + `(terminal)` now sits on the same rhythm as the line above it. +- Terminal titles: `#failure definition`/`#success definition` became + `Failure definition`/`Success definition`. The Cupertino widget test now + asserts `Success definition` and the absence of the raw key; a Material + test covers `Failure definition`; the browser probe fails if `#failure` + reappears in the terminal page or if the outcomes/Tools block heights + diverge. + +## Integration dependency + +`PipelineDetail` still has no `graph` field, so the manager's graph hook must +supply the pinned JsonMap it already draws. This item deliberately does not +change the pipeline repository/model. There is no run-mode latest-visit pane +here; recorded visits remain the separate run-graph/audit work. + +## Checks run + +- `flutter test test/features/graph` - 140 tests passed (138 before; two new + regression tests for the terminal title and the forced host strut). +- `flutter analyze` - no issues. +- `dart format --set-exit-if-changed` on the five Dart files - 0 changed. +- `flutter build web` (normal app) - succeeded. +- `flutter build web -t tool/stage_definition_probe.dart` - succeeded. +- `node --check tool/stage_definition_probe.mjs`. +- Real Chrome probe, 1280x900: material dark/light 1x, Cupertino dark/light 1x + and Cupertino dark/light 2x. Each case passed 9 checks and produced 5 + captures. The probe now compares the `Outcomes` and `Tools` semantics block + heights (equal in every case), fails on any raw `#failure` in the terminal + page, asserts `Failure definition`, and scrolls to the pane bottom so the + raw capture really shows `future_field.kept` and `fallback_error`. +- Real Chrome probe, 390x844: Cupertino dark 2x and Material light 1x. Each + passed 8 checks and produced 5 captures, including the `(terminal)` wrap and + the raw JSON at the narrow width. The accent-free rhythm check is skipped at + this width because the outcomes value wraps to three lines. +- Pixel measurement of the final captures: Cupertino 1x outcomes 19 px vs + Tools 19 px (was 34 vs 19); Cupertino 2x outcomes 37 px vs Tools 39 px (was + 68 vs 30); Material 1x outcomes 19 px vs Tools 20 px. + +Captures (under the run's shared artifact folder +`public/stage-definition/`): `--x-{declared,raw,terminal,unknown,closed}.png` +for the six 1280x900 cases, and the same names prefixed with `stage-definition-` +under `narrow-390x844/` for the two 390x844 cases. The raw capture is the real +bottom-scrolled state and its sha1 differs from the declared capture in every +case. + +Mobile (Android/iOS) remains unverified; only web was run. + +## Manager completion after result-validation failure + +Run 77's final Review visit returned no parseable outcome, so the runner retained +its edits and failed the stage without undoing them. No retry was started. The +manager verified the dirty files were the reviewed slice only, ran the focused +domain/view tests (10 pass), and drove the real-browser probe on both hosts: +Material light 1x desktop and Cupertino dark 2x 390x844. Each run passed and +produced five captures (declared, raw, terminal, unknown, closed) under approved +temp/stage-def-browser. The Cupertino dark 2x declared pane was inspected: pinned +identity, wrapping outcome line, native type roles, readable secondary labels. +This remains a definition pane only; run visits and the pipeline graph hook are +separate work. diff --git a/app/test/features/graph/domain/stage_definition_test.dart b/app/test/features/graph/domain/stage_definition_test.dart new file mode 100644 index 00000000..e4b11dd8 --- /dev/null +++ b/app/test/features/graph/domain/stage_definition_test.dart @@ -0,0 +1,159 @@ +import 'package:flutter_test/flutter_test.dart'; + +import 'package:pipelines_app/core/api_gateway.dart'; +import 'package:pipelines_app/features/graph/domain/stage_definition.dart'; + +import 'graph_fixtures.dart'; + +JsonMap _stage() => { + 'key': 'build', + 'prompt': 'Implement the planned change.', + 'output': 'A committed change.', + 'edges': { + 'success': 'audit', + 'approved': '#', + 'error': '#failure', + }, + 'fallback_error': true, + 'configs': { + 'provider': 'openai', + 'model': 'gpt-5', + 'budget_usd': 12.5, + 'retries': 2, + 'harness': 'codex', + 'timeout': '15m', + 'skipped_blank': ' ', + 'skipped_null': null, + }, + 'blocks': {'tools': 'shell\nread_file'}, + 'limits': { + 'max_visits': 3, + 'on': ['success', 'error'], + }, + 'memory': {'context': 'latest', 'notes': 'keep'}, + 'notify': { + 'on': ['failure'], + 'destination': 'ops@example.test', + 'artifacts': ['run.log'], + }, + 'custom_flag': true, +}; + +void main() { + group('stage fields', () { + test('follow the web pane order, labels and blank-field rules', () { + final fields = stageDefinitionFields(_stage()); + + expect(fields.map((field) => field.label), [ + 'Type', + 'Prompt', + 'Output', + 'Outcomes', + 'Budget (USD)', + 'Harness', + 'Model', + 'Provider', + 'Retries', + 'Timeout', + 'Tools', + 'Max visits', + 'Limit on', + 'Memory', + 'Notify on', + 'Notify destination', + 'Notify artifacts', + ]); + expect(fields.first.value, 'model'); + expect(fields[1].block, isTrue); + expect(fields[2].value, 'A committed change.'); + expect( + fields[3].value, + 'success → audit\n' + 'approved → SUCCESS (terminal)\n' + 'error → FAILURE (terminal)', + ); + expect(fields[4].value, '12.5'); + expect(fields[5].value, 'codex'); + expect(fields[10].value, 'shell\nread_file'); + expect(fields[11].value, '3'); + expect(fields[12].value, 'success, error'); + expect(fields[13].value, 'context: latest\nnotes: keep'); + expect(fields[14].value, 'failure'); + expect(fields[15].value, 'ops@example.test'); + expect(fields[16].value, 'run.log'); + }); + + test('a blank or absent type reads model; an authored type is kept', () { + expect(effectiveStageType(null), 'model'); + expect(effectiveStageType(' '), 'model'); + expect(effectiveStageType('shell'), 'shell'); + expect( + stageDefinitionFields({'key': 'a'}).single.value, + 'model', + ); + }); + + test('config keys outside the known labels are shown verbatim', () { + final fields = stageDefinitionFields({ + 'key': 'a', + 'configs': {'temperature': 0}, + }); + + expect(fields.map((field) => field.label), contains('temperature')); + expect( + fields.firstWhere((field) => field.label == 'temperature').value, + '0', + ); + }); + + test('zero visits and missing limits emit no invented rows', () { + final fields = stageDefinitionFields({ + 'key': 'a', + 'limits': {'max_visits': 0, 'on': []}, + }); + + expect(fields.map((field) => field.label), ['Type']); + }); + + test( + 'the stage lookup preserves unknown keys and the last declaration', + () { + final graph = { + 'stages': [ + {'key': 'build', 'type': 'old'}, + _stage(), + ], + }; + final stage = stageDefinitionFor(graph, 'build'); + + expect(stage?['type'], isNull); + expect(effectiveStageType(stage?['type']), 'model'); + expect(stage?['custom_flag'], isTrue); + expect(stageDefinitionFor(graph, 'ghost'), isNull); + }, + ); + }); + + group('terminal fields', () { + test('list incoming definition routes, including the fallback marker', () { + expect(terminalDefinitionFields(linearGraph(), '#failure'), hasLength(1)); + final fields = terminalDefinitionFields(linearGraph(), '#failure'); + expect( + fields.single.value, + 'plan · error* → FAILURE\nship · error → FAILURE', + ); + expect(fields.single.block, isTrue); + expect( + terminalDefinitionFields(linearGraph(), '#success').single.value, + 'ship · success → SUCCESS', + ); + }); + + test('a terminal with no routes has no fields to invent', () { + expect( + terminalDefinitionFields({}, '#success'), + isEmpty, + ); + }); + }); +} diff --git a/app/test/features/graph/widgets/stage_definition_view_test.dart b/app/test/features/graph/widgets/stage_definition_view_test.dart new file mode 100644 index 00000000..d226e467 --- /dev/null +++ b/app/test/features/graph/widgets/stage_definition_view_test.dart @@ -0,0 +1,286 @@ +import 'package:flutter/cupertino.dart'; +import 'package:flutter/material.dart'; +import 'package:flutter_test/flutter_test.dart'; + +import 'package:pipelines_app/core/api_gateway.dart'; +import 'package:pipelines_app/features/graph/domain/stage_definition.dart'; +import 'package:pipelines_app/features/graph/widgets/stage_definition_view.dart'; + +JsonMap _graph() => { + 'stages': [ + { + 'key': 'plan', + 'type': 'model', + 'prompt': 'Plan the change.', + 'edges': {'success': 'build', 'error': '#'}, + 'fallback_error': true, + 'configs': {'provider': 'openai', 'model': 'gpt-5'}, + 'limits': { + 'max_visits': 2, + 'on': ['error'], + }, + 'future_field': {'kept': true}, + }, + { + 'key': 'build', + 'type': 'shell', + 'edges': {'success': '#success', 'error': '#failure'}, + }, + ], +}; + +Widget _material(Widget child) => MaterialApp( + home: Scaffold( + appBar: AppBar(title: const Text('plan definition')), + body: child, + ), +); + +Widget _cupertino(Widget child, {bool dark = false}) => CupertinoApp( + theme: CupertinoThemeData( + brightness: dark ? Brightness.dark : Brightness.light, + ), + home: CupertinoPageScaffold(child: child), +); + +StageDefinitionView _view({String key = 'plan'}) => StageDefinitionView( + graph: _graph(), + stageKey: key, + pipelineId: 41, + pipelineName: 'Demo pipeline', + version: 7, +); + +/// Finds visible text, including SelectableText's editable body. +Finder _text(String value) => find.byWidgetPredicate( + (widget) => + (widget is Text && widget.data == value) || + (widget is SelectableText && widget.data == value), +); + +void main() { + testWidgets('a declared stage shows pinned identity and web field values', ( + tester, + ) async { + await tester.pumpWidget(_material(_view())); + + expect(_text('Demo pipeline · v7'), findsOneWidget); + expect(_text('model'), findsOneWidget); + expect(_text('Plan the change.'), findsOneWidget); + expect( + _text('success → build\nerror → FAILURE (terminal)'), + findsOneWidget, + ); + expect(_text('Provider'), findsOneWidget); + expect(_text('openai'), findsOneWidget); + expect(_text('Model'), findsOneWidget); + expect(_text('gpt-5'), findsOneWidget); + expect(_text('Max visits'), findsOneWidget); + expect(_text('2'), findsOneWidget); + expect(_text('Limit on'), findsOneWidget); + expect(_text('error'), findsOneWidget); + }); + + testWidgets('the raw section keeps unknown fields exact and selectable', ( + tester, + ) async { + await tester.pumpWidget(_material(_view())); + + expect(_text(rawStageDefinitionTitle), findsOneWidget); + final raw = tester + .widgetList(find.byType(SelectableText)) + .map((widget) => widget.data ?? '') + .join('\n'); + expect(raw, contains('"future_field": {')); + expect(raw, contains('"kept": true')); + expect(raw, contains('"fallback_error": true')); + expect(tester.takeException(), isNull); + }); + + testWidgets('unknown stages get an explicit missing state, never defaults', ( + tester, + ) async { + await tester.pumpWidget(_material(_view(key: 'ghost'))); + + expect(_text(unknownStageDefinition), findsOneWidget); + expect(_text('model'), findsNothing); + expect(_text(rawStageDefinitionTitle), findsNothing); + expect(find.byType(SelectableText), findsNothing); + }); + + testWidgets('terminals explain definition targets and incoming routes', ( + tester, + ) async { + await tester.pumpWidget(_material(_view(key: '#failure'))); + + expect(_text(terminalDefinitionNote), findsOneWidget); + expect(_text('Incoming routes'), findsOneWidget); + expect( + _text('plan · error* → FAILURE\nbuild · error → FAILURE'), + findsOneWidget, + ); + expect(_text(rawStageDefinitionTitle), findsNothing); + expect(_text('successful'), findsNothing); + }); + + testWidgets('Cupertino uses its theme roles in dark mode', (tester) async { + late Color secondary; + await tester.pumpWidget( + _cupertino( + Builder( + builder: (context) { + secondary = CupertinoColors.secondaryLabel.resolveFrom(context); + return _view(); + }, + ), + dark: true, + ), + ); + + final identity = tester.widget(_text('Demo pipeline · v7')); + expect(identity.style?.color, secondary); + expect(_text('Plan the change.'), findsOneWidget); + expect(tester.takeException(), isNull); + }); + + testWidgets('the Material helper opens one bar and Back closes it', ( + tester, + ) async { + await tester.pumpWidget( + MaterialApp( + home: Builder( + builder: (context) => Scaffold( + body: TextButton( + onPressed: () => openStageDefinition( + context, + graph: _graph(), + stageKey: 'plan', + pipelineId: 41, + pipelineName: 'Demo pipeline', + version: 7, + ), + child: const Text('Open definition'), + ), + ), + ), + ), + ); + + await tester.tap(find.text('Open definition')); + await tester.pumpAndSettle(); + + expect(_text('plan definition'), findsOneWidget); + expect(find.byType(AppBar), findsOneWidget); + expect(find.byType(BackButton), findsOneWidget); + final route = ModalRoute.of( + tester.element(find.byType(StageDefinitionView)), + ); + expect(route?.settings.name, 'stage-definition/41/7/plan'); + + await tester.pageBack(); + await tester.pumpAndSettle(); + expect(_text('Open definition'), findsOneWidget); + expect(find.byType(StageDefinitionView), findsNothing); + }); + + testWidgets('the Cupertino helper opens one native bar and Back closes it', ( + tester, + ) async { + await tester.pumpWidget( + CupertinoApp( + home: Builder( + builder: (context) => CupertinoPageScaffold( + child: CupertinoButton( + onPressed: () => openStageDefinition( + context, + graph: _graph(), + stageKey: '#success', + pipelineId: 41, + pipelineName: 'Demo pipeline', + version: 7, + ), + child: const Text('Open terminal'), + ), + ), + ), + ), + ); + + await tester.tap(find.text('Open terminal')); + await tester.pumpAndSettle(); + + expect(_text('Success definition'), findsOneWidget); + expect(_text('#success definition'), findsNothing); + expect(find.byType(CupertinoNavigationBar), findsOneWidget); + expect(find.byType(CupertinoNavigationBarBackButton), findsOneWidget); + expect(_text('Incoming routes'), findsOneWidget); + + await tester.tap(find.byType(CupertinoNavigationBarBackButton)); + await tester.pumpAndSettle(); + expect(_text('Open terminal'), findsOneWidget); + expect(find.byType(StageDefinitionView), findsNothing); + }); + + testWidgets('the Material helper titles a terminal with its display label', ( + tester, + ) async { + await tester.pumpWidget( + MaterialApp( + home: Builder( + builder: (context) => Scaffold( + body: TextButton( + onPressed: () => openStageDefinition( + context, + graph: _graph(), + stageKey: '#failure', + pipelineId: 41, + pipelineName: 'Demo pipeline', + version: 7, + ), + child: const Text('Open failure'), + ), + ), + ), + ), + ); + + await tester.tap(find.text('Open failure')); + await tester.pumpAndSettle(); + + expect(_text('Failure definition'), findsOneWidget); + expect(_text('#failure definition'), findsNothing); + expect(tester.takeException(), isNull); + }); + + testWidgets('selectable blocks force the host strut for one line rhythm', ( + tester, + ) async { + await tester.pumpWidget(_cupertino(_view())); + + final selectable = tester + .widgetList(find.byType(SelectableText)) + .toList(); + expect(selectable.length, greaterThanOrEqualTo(2)); + for (final widget in selectable) { + final strut = widget.strutStyle; + expect(strut, isNotNull); + // The host's own metrics, forced: a fallback glyph cannot widen a block. + expect(strut!.forceStrutHeight, isTrue); + expect(strut.fontFamily, widget.style?.fontFamily); + expect(strut.fontSize, widget.style?.fontSize); + } + final outcomes = selectable.firstWhere( + (widget) => (widget.data ?? '').contains('success → build'), + ); + final raw = selectable.firstWhere( + (widget) => (widget.data ?? '').startsWith('{'), + ); + expect(outcomes.strutStyle, raw.strutStyle); + }); + + test('field labels are the web words', () { + expect(stageConfigLabel('budget_usd'), 'Budget (USD)'); + expect(stageConfigLabel('budget_tokens'), 'Budget (tokens)'); + expect(stageConfigLabel('custom'), 'custom'); + }); +} diff --git a/app/tool/stage_definition_probe.dart b/app/tool/stage_definition_probe.dart new file mode 100644 index 00000000..046bf874 --- /dev/null +++ b/app/tool/stage_definition_probe.dart @@ -0,0 +1,148 @@ +import 'package:flutter/cupertino.dart'; +import 'package:flutter/material.dart'; + +import 'package:pipelines_app/core/api_gateway.dart'; +import 'package:pipelines_app/features/graph/widgets/stage_definition_view.dart'; +import 'package:pipelines_app/ui/adaptive/host.dart'; + +/// A definition with an authored stage (including an unknown future field), a +/// declared route to a terminal, and no declaration for `ghost`. +JsonMap _graph() => { + 'stages': [ + { + 'key': 'plan', + 'type': 'model', + 'prompt': 'Plan the change.', + 'output': 'A short plan.', + 'edges': {'success': 'build', 'error': '#'}, + 'fallback_error': true, + 'configs': { + 'provider': 'openai', + 'model': 'gpt-5', + 'budget_usd': 12.5, + }, + 'blocks': {'tools': 'shell\nread_file'}, + 'limits': { + 'max_visits': 2, + 'on': ['error'], + }, + 'memory': {'context': 'latest'}, + 'notify': { + 'on': ['failure'], + 'destination': 'ops@example.test', + 'artifacts': ['run.log'], + }, + 'future_field': {'kept': true}, + }, + { + 'key': 'build', + 'type': 'shell', + 'edges': {'success': '#success', 'error': '#failure'}, + }, + ], +}; + +/// Isolated browser fixture for the read-only stage definition pane. +/// +/// `style=cupertino` selects the Cupertino host, `dark=1` its dark theme, +/// `scale=2` a real 2x text scale. Every button opens the exact helper the +/// pipeline graph hook will call; nothing contacts a server or reads a run. +void main() { + final parameters = Uri.base.queryParameters; + runApp( + _ProbeApp( + cupertino: parameters['style'] == 'cupertino', + dark: parameters['dark'] == '1', + scale: double.tryParse(parameters['scale'] ?? '') ?? 1, + ), + ); +} + +class _ProbeApp extends StatelessWidget { + const _ProbeApp({ + required this.cupertino, + required this.dark, + required this.scale, + }); + + final bool cupertino; + final bool dark; + final double scale; + + @override + Widget build(BuildContext context) { + Widget scaled(BuildContext context, Widget? child) => MediaQuery( + data: MediaQuery.of( + context, + ).copyWith(textScaler: TextScaler.linear(scale)), + child: child ?? const SizedBox.shrink(), + ); + if (cupertino) { + return CupertinoApp( + theme: CupertinoThemeData( + brightness: dark ? Brightness.dark : Brightness.light, + ), + builder: scaled, + home: const CupertinoPageScaffold( + navigationBar: CupertinoNavigationBar( + middle: Text('Stage definition fixture'), + ), + child: SafeArea(child: _Launcher()), + ), + ); + } + return MaterialApp( + theme: ThemeData( + platform: TargetPlatform.android, + brightness: Brightness.light, + ), + darkTheme: ThemeData( + platform: TargetPlatform.android, + brightness: Brightness.dark, + ), + themeMode: dark ? ThemeMode.dark : ThemeMode.light, + builder: scaled, + home: Scaffold( + appBar: AppBar(title: const Text('Stage definition fixture')), + body: const SafeArea(child: _Launcher()), + ), + ); + } +} + +class _Launcher extends StatelessWidget { + const _Launcher(); + + void _open(BuildContext context, String key) => openStageDefinition( + context, + graph: _graph(), + stageKey: key, + pipelineId: 41, + pipelineName: 'Demo pipeline', + version: 7, + ); + + @override + Widget build(BuildContext context) { + final cupertino = usesCupertinoHost(context); + return ListView( + padding: const EdgeInsets.all(16), + children: [ + const Text('Fixture home'), + for (final key in ['plan', '#failure', 'ghost']) + Padding( + padding: const EdgeInsets.only(top: 8), + child: cupertino + ? CupertinoButton.filled( + onPressed: () => _open(context, key), + child: Text('$key definition'), + ) + : FilledButton( + onPressed: () => _open(context, key), + child: Text('$key definition'), + ), + ), + ], + ); + } +} diff --git a/app/tool/stage_definition_probe.mjs b/app/tool/stage_definition_probe.mjs new file mode 100644 index 00000000..50377753 --- /dev/null +++ b/app/tool/stage_definition_probe.mjs @@ -0,0 +1,380 @@ +// Browser acceptance for the isolated read-only stage definition pane. +// +// Serves the probe build (`flutter build web -t tool/stage_definition_probe.dart`) +// on an OS-assigned loopback port, drives real headless Chrome, opens the pane +// through the same native helper the manager graph hook uses, asserts the +// pinned identity, actual field values, outcomes, raw unknown fields, terminal +// and unknown-stage states, closes it with Back on both hosts, and writes +// captures. +// +// PROBE_VARIANT=material|cupertino PROBE_SCHEME=dark|light PROBE_SCALE=1|2 \ +// PROBE_WIDTH=1280 PROBE_HEIGHT=900 PROBE_WEB_ROOT= \ +// OPENCODE_ARTIFACT_DIR= node tool/stage_definition_probe.mjs +import { createServer } from 'node:http'; +import { spawn } from 'node:child_process'; +import { once } from 'node:events'; +import { setTimeout as delay } from 'node:timers/promises'; +import { join, extname, resolve, sep } from 'node:path'; +import { tmpdir } from 'node:os'; +import { createHash } from 'node:crypto'; +import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'; + +const root = resolve( + process.env.PROBE_WEB_ROOT ?? join(process.cwd(), 'build/stage_definition_probe_web'), +); +const variant = process.env.PROBE_VARIANT ?? 'material'; +const scheme = process.env.PROBE_SCHEME ?? 'dark'; +const scale = process.env.PROBE_SCALE ?? '1'; +const width = Number(process.env.PROBE_WIDTH ?? 1280); +const height = Number(process.env.PROBE_HEIGHT ?? 900); +const chromePath = process.env.CHROME_PATH ?? + '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'; +const artifactDir = process.env.OPENCODE_ARTIFACT_DIR; +if (!artifactDir) throw new Error('Set OPENCODE_ARTIFACT_DIR for the probe captures'); +await mkdir(artifactDir, { recursive: true }); +const prefix = `stage-definition-${variant}-${scheme}-${scale}x` + + (width === 1280 && height === 900 ? '' : `-${width}x${height}`); +const mime = { + '.html': 'text/html', + '.js': 'text/javascript', + '.json': 'application/json', + '.wasm': 'application/wasm', + '.png': 'image/png', + '.ico': 'image/x-icon', + '.otf': 'font/otf', + '.ttf': 'font/ttf', +}; +const server = createServer(async (req, res) => { + try { + const path = resolve(root, '.' + decodeURIComponent(new URL(req.url, 'http://localhost').pathname)); + if (path !== root && !path.startsWith(root + sep)) return res.writeHead(403).end(); + const filePath = path === root || path.endsWith('/') ? join(path, 'index.html') : path; + const file = await readFile(filePath); + res.writeHead(200, { 'content-type': mime[extname(filePath)] ?? 'application/octet-stream' }).end(file); + } catch { + res.writeHead(404).end('not found'); + } +}); +server.listen(0, '127.0.0.1'); +await once(server, 'listening'); +const port = server.address().port; +const profile = await mkdtemp(join(tmpdir(), 'stage-definition-chrome-')); +const chrome = spawn(chromePath, [ + '--headless=new', '--no-first-run', '--no-default-browser-check', '--disable-gpu', + '--remote-debugging-port=0', `--user-data-dir=${profile}`, 'about:blank', +], { stdio: ['ignore', 'ignore', 'pipe'] }); +let stderr = ''; +chrome.stderr.on('data', (data) => { stderr += data; }); +const waitFor = async (fn) => { + for (let i = 0; i < 140; i++) { + const value = await fn(); + if (value) return value; + await delay(100); + } + throw new Error('Timed out waiting for Chrome DevTools'); +}; +let ws; +try { + const endpoint = await waitFor(() => stderr.match(/DevTools listening on (ws:\/\/[^\s]+)/)?.[1]); + ws = new WebSocket(endpoint); + await once(ws, 'open'); + let id = 0; + const pending = new Map(); + ws.addEventListener('message', (event) => { + const message = JSON.parse(event.data); + if (message.method === 'Runtime.exceptionThrown') { + console.error('PAGE EXCEPTION', JSON.stringify(message.params?.exceptionDetails?.exception?.description)); + } + if (message.id && pending.has(message.id)) { + pending.get(message.id)(message); + pending.delete(message.id); + } + }); + const send = (method, params = {}, sessionId) => new Promise((resolveCall) => { + const callId = ++id; + pending.set(callId, resolveCall); + ws.send(JSON.stringify({ id: callId, method, params, ...(sessionId ? { sessionId } : {}) })); + }); + const created = await send('Target.createTarget', { url: 'about:blank' }); + const target = created.result.targetId; + const session = (await send('Target.attachToTarget', { targetId: target, flatten: true })).result.sessionId; + await send('Page.enable', {}, session); + await send('Runtime.enable', {}, session); + await send('Emulation.setEmulatedMedia', { + features: [{ name: 'prefers-color-scheme', value: scheme }], + }, session); + await send('Emulation.setDeviceMetricsOverride', { + width, height, deviceScaleFactor: 1, mobile: false, + }, session); + const query = `?style=${variant}&dark=${scheme === 'dark' ? 1 : 0}&scale=${scale}`; + const navigation = await send('Page.navigate', { url: `http://127.0.0.1:${port}/${query}` }, session); + if (navigation.error || navigation.result?.errorText) throw new Error(JSON.stringify(navigation)); + const evaluate = async (expression) => { + const response = await send('Runtime.evaluate', { + expression, returnByValue: true, awaitPromise: true, + }, session); + if (response.error) throw new Error(`Runtime.evaluate failed: ${JSON.stringify(response)}`); + return response.result?.result?.value; + }; + await delay(3500); + const loaded = await evaluate('({url:location.href, ready:document.readyState})'); + if (!loaded?.url.includes(`127.0.0.1:${port}/${query}`)) { + throw new Error(`Fixture did not load: ${JSON.stringify(loaded)}`); + } + await evaluate("document.querySelector('flt-semantics-placeholder')?.click()"); + await delay(2200); + + const labels = () => evaluate( + "[...document.querySelectorAll('flt-semantics')].map(x=>x.getAttribute('aria-label')||(x.innerText||'').trim()).filter(Boolean)", + ); + const bodyText = async () => [await evaluate('document.body.innerText'), ...(await labels())].join('\n'); + const clickExact = async (label) => { + const point = await evaluate(`(() => { + const e = [...document.querySelectorAll('flt-semantics')].find(x => + (x.getAttribute('aria-label')||(x.innerText||'').trim()).trim() === ${JSON.stringify(label)}); + if (!e) return null; + const r = e.getBoundingClientRect(); + return { x: r.x + r.width / 2, y: r.y + r.height / 2 }; + })()`); + if (!point) throw new Error(`Missing control ${label}: ${JSON.stringify(await labels())}`); + await send('Input.dispatchMouseEvent', { + type: 'mousePressed', x: point.x, y: point.y, button: 'left', clickCount: 1, + }, session); + await send('Input.dispatchMouseEvent', { + type: 'mouseReleased', x: point.x, y: point.y, button: 'left', clickCount: 1, + }, session); + await delay(1000); + }; + const capture = async (name) => { + const data = (await send('Page.captureScreenshot', { + format: 'png', captureBeyondViewport: false, + }, session)).result.data; + const buffer = Buffer.from(data, 'base64'); + const file = `${prefix}-${name}.png`; + await writeFile(join(artifactDir, file), buffer); + return { file, sha1: createHash('sha1').update(buffer).digest('hex') }; + }; + const visible = async (needle, exact = false) => evaluate(`(() => { + const found = [...document.querySelectorAll('flt-semantics')].filter(x => { + const label = (x.getAttribute('aria-label')||(x.innerText||'')).trim(); + return ${exact ? `label === ${JSON.stringify(needle)}` : `label.includes(${JSON.stringify(needle)})`}; + }); + if (!found.length) return null; + found.sort((a, b) => { + const ra = a.getBoundingClientRect(), rb = b.getBoundingClientRect(); + return ra.width * ra.height - rb.width * rb.height; + }); + const r = found[0].getBoundingClientRect(); + return { x: r.x, y: r.y, width: r.width, height: r.height, + visible: r.width > 0 && r.height > 0 && r.bottom > 0 && r.top < innerHeight }; + })()`); + // Scroll by the measured delta instead of fixed steps: a fixed gesture can + // stop with a target half-entered (and its neighbours not built), which is + // exactly what made the raw-section check fail on shorter content. + const scrollTo = async (needle, { exact = false, maxTop = null } = {}) => { + for (let attempt = 0; attempt < 24; attempt++) { + const r = await visible(needle, exact); + const fullyVisible = r && r.width > 0 && r.height > 0 && + r.y >= 32 && r.y + r.height <= height - 32; + if (fullyVisible && (maxTop == null || r.y <= maxTop)) return r; + // Scroll down until the target is fully in view; for a target that must + // sit high (the raw title above its JSON), keep scrolling until it does. + const wanted = r + ? Math.round(r.y - (maxTop ?? height / 2)) + : Math.round(height / 3); + const distance = Math.sign(wanted || 1) * + Math.max(60, Math.min(400, Math.abs(wanted))); + await send('Input.synthesizeScrollGesture', { + x: Math.round(width / 2), y: Math.round(height / 2), + yDistance: -distance, gestureSourceType: 'mouse', speed: 900, + preventFling: true, + }, session); + await delay(300); + } + throw new Error( + `${needle} never scrolled into view: ${JSON.stringify(await bodyText())}`, + ); + }; + // The raw section is one selectable block whose whole value must be + // inspected. Scroll to the pane's end so the JSON tail (the unknown fields + // the raw section exists for) is really on screen, not just built. + const scrollToRaw = async () => { + let previous = null; + for (let attempt = 0; attempt < 16; attempt++) { + const r = await visible('future_field'); + if (r && previous != null && Math.abs(r.y - previous) < 1) { + if (!r.visible || r.y + r.height > height + 1) { + throw new Error(`The raw JSON did not settle in view: ${JSON.stringify(r)}`); + } + return r; + } + previous = r?.y ?? null; + await send('Input.synthesizeScrollGesture', { + x: Math.round(width / 2), y: Math.round(height / 2), + yDistance: -600, gestureSourceType: 'mouse', speed: 900, + preventFling: true, + }, session); + await delay(300); + } + throw new Error( + `The raw JSON never settled: ${JSON.stringify(await bodyText())}`, + ); + }; + const evidence = { variant, scheme, scale, checks: [], captures: [] }; + const expectText = async (needle, context) => { + const text = await bodyText(); + if (!text.includes(needle)) throw new Error(`${context}: missing ${JSON.stringify(needle)}\n${text}`); + }; + + await expectText('Fixture home', 'fixture home'); + await clickExact('plan definition'); + for (const needle of [ + 'Demo pipeline · v7', + 'Plan the change.', + 'A short plan.', + 'success → build', + 'error → FAILURE (terminal)', + ]) { + await expectText(needle, 'declared stage'); + } + // Two two-line blocks must share the host line rhythm. A fallback font for + // the outcomes arrow must not stretch only that block, so compare the whole + // label+value block: equal line counts mean equal heights. + if (width >= 1000) { + const blockHeight = async (prefixText) => evaluate(`(() => { + const found = [...document.querySelectorAll('flt-semantics')].filter(x => + (x.getAttribute('aria-label')||(x.innerText||'')).trim().startsWith(${JSON.stringify(prefixText)})); + if (!found.length) return null; + found.sort((a, b) => { + const ra = a.getBoundingClientRect(), rb = b.getBoundingClientRect(); + return ra.width * ra.height - rb.width * rb.height; + }); + const r = found[0].getBoundingClientRect(); + return { height: r.height, width: r.width }; + })()`); + const outcomes = await blockHeight('Outcomes'); + const tools = await blockHeight('Tools'); + const ratio = outcomes && tools ? outcomes.height / tools.height : 0; + if (!(ratio >= 0.8 && ratio <= 1.25)) { + throw new Error( + `Outcomes line rhythm differs from Tools: ${JSON.stringify({ outcomes, tools, ratio })}`, + ); + } + evidence.rhythm = { + outcomesHeight: outcomes.height, + toolsHeight: tools.height, + ratio, + }; + evidence.checks.push({ + check: 'the outcomes block keeps the host line rhythm of other two-line blocks', + value: ratio, + }); + } + evidence.checks.push({ + check: 'declared stage shows pinned identity and the web field values', + value: true, + }); + const declaredCapture = await capture('declared'); + evidence.captures.push(declaredCapture); + + // Remaining declared fields, reached by scrolling so the probe also covers + // viewports shorter than the full pane. + for (const needle of [ + 'Provider', 'openai', 'Model', 'gpt-5', 'Budget (USD)', '12.5', + 'Tools', 'shell', 'read_file', 'Max visits', 'Limit on', 'Memory', + 'context: latest', + ]) { + await scrollTo(needle); + await expectText(needle, 'declared stage'); + } + evidence.checks.push({ + check: 'every declared field value is present in the rendered pane', + value: true, + }); + + await scrollTo('Notify destination'); + for (const needle of ['Notify on', 'failure', 'Notify destination', 'ops@example.test', 'Notify artifacts', 'run.log']) { + await expectText(needle, 'notify definition'); + } + + const rawJson = await scrollToRaw(); + evidence.rawJsonRect = rawJson; + evidence.rawSectionSeen = (await bodyText()).includes('Raw stage definition'); + for (const needle of ['future_field', 'kept', 'fallback_error']) { + await expectText(needle, 'raw unknown fields'); + } + evidence.checks.push({ + check: 'unknown stage fields remain in the selectable raw JSON', + value: true, + }); + const rawCapture = await capture('raw'); + if (rawCapture.sha1 === declaredCapture.sha1) { + throw new Error('The raw capture is identical to the unscrolled pane'); + } + evidence.captures.push(rawCapture); + + await clickExact('Back'); + await expectText('Fixture home', 'Back'); + evidence.checks.push({ check: 'Back returned to the graph host', value: true }); + + await clickExact('#failure definition'); + const terminalText = await bodyText(); + if (terminalText.includes('#failure')) { + throw new Error(`The terminal title still exposes the raw key: ${terminalText}`); + } + await expectText('Failure definition', 'terminal title'); + for (const needle of [ + 'Success and Failure are definition targets, not recorded visits.', + 'Incoming routes', + 'plan · error* → FAILURE', + 'build · error → FAILURE', + ]) { + await expectText(needle, 'terminal definition'); + } + evidence.checks.push({ + check: 'the terminal page is titled with its display label, not the protocol key', + value: true, + }); + evidence.checks.push({ + check: 'terminal explains definition routes without claiming a visit', + value: true, + }); + evidence.captures.push(await capture('terminal')); + await clickExact('Back'); + await expectText('Fixture home', 'terminal Back'); + + await clickExact('ghost definition'); + await expectText( + 'This stage is not declared in this pipeline version.', + 'unknown stage', + ); + const unknown = await bodyText(); + if (unknown.includes('Raw stage definition') || unknown.includes('Incoming routes')) { + throw new Error(`Unknown stage invented definition content: ${unknown}`); + } + evidence.checks.push({ + check: 'unknown stage has an explicit missing state with no defaults', + value: true, + }); + evidence.captures.push(await capture('unknown')); + await clickExact('Back'); + await expectText('Fixture home', 'unknown Back'); + evidence.checks.push({ check: 'every open used one native bar and Back', value: true }); + evidence.captures.push(await capture('closed')); + + console.log(JSON.stringify(evidence, null, 2)); +} finally { + if (ws?.readyState === WebSocket.OPEN) { + ws.send(JSON.stringify({ id: 2147483647, method: 'Browser.close' })); + } + await Promise.race([once(chrome, 'exit'), delay(3000)]); + ws?.close(); + if (chrome.exitCode === null) chrome.kill('SIGTERM'); + chrome.stderr.destroy(); + chrome.unref(); + await new Promise((resolveClose) => { + server.close(resolveClose); + server.closeAllConnections(); + }); + await rm(profile, { recursive: true, force: true }); +}