fix flutter runs foundation parity gaps

This commit is contained in:
2026-10-21 13:34:56 +01:00
parent 7dd21b08c6
commit 1515ebee99
9 changed files with 1229 additions and 96 deletions
@@ -0,0 +1,105 @@
import '../../../core/api_gateway.dart';
import '../domain/run_models.dart';
/// Protocol failure kept separate from transport errors; server error envelopes
/// are otherwise propagated unchanged by [ApiGateway].
class RunsRepositoryException implements Exception {
const RunsRepositoryException(this.message);
final String message;
@override
String toString() => message;
}
/// Run protocol requests over the application's shared gateway.
class RunsRepository {
RunsRepository(this._gateway);
final ApiGateway _gateway;
Future<RunListResult> listRuns() async {
final reply = await _gateway.call('list_runs');
final runs = reply['runs'];
return RunListResult(
runs is List
? runs
.whereType<Map>()
.map((r) => Map<String, dynamic>.from(r))
.toList()
: const [],
reply['usage'] is Map
? Map<String, dynamic>.from(reply['usage'] as Map)
: null,
);
}
Future<JsonMap> getRun(num id) async =>
_required(await _gateway.call('get_run', {'run_id': id}), 'run_detail');
Future<JsonMap> cancelRun(num id) async => _required(
await _gateway.call('cancel_run', {'run_id': id}),
'run_detail',
);
Future<JsonMap> retryRun(
num id, {
required String requestKey,
String? mode,
}) async {
final fields = <String, dynamic>{'run_id': id, 'request_key': requestKey};
if (mode == 'restart') fields['retry_mode'] = mode;
return _required(await _gateway.call('retry_run', fields), 'run_detail');
}
Future<JsonMap> decideRun(
num id, {
String? stage,
required String option,
String feedback = '',
}) async {
final selected = option.trim();
if (selected.isEmpty) {
throw const RunsRepositoryException(
'Choose an option before continuing.',
);
}
final fields = <String, dynamic>{'run_id': id, 'option': selected};
if (stage != null && stage.trim().isNotEmpty) fields['stage'] = stage;
if (feedback.trim().isNotEmpty) fields['feedback'] = feedback.trim();
return _required(await _gateway.call('decide_run', fields), 'run_detail');
}
Future<JsonMap> setRunTitle(num id, String title) async => _required(
await _gateway.call('set_run_title', {'run_id': id, 'title': title}),
'run_detail',
);
Future<JsonMap> startRun({
required num pipelineId,
required num version,
required String prompt,
required String workspace,
required String requestKey,
String title = '',
String outputFormat = '',
String notifyMode = 'auto',
}) async {
final fields = <String, dynamic>{
'pipeline_id': pipelineId,
'version': version,
'request_key': requestKey,
'workspace': workspace.trim(),
'input': {'prompt': prompt},
};
if (title.trim().isNotEmpty) fields['title'] = title.trim();
if (outputFormat.isNotEmpty) fields['output_format'] = outputFormat;
final mode = notifyMode.trim().toLowerCase();
if (mode == 'on' || mode == 'off') fields['notify_mode'] = mode;
return _required(await _gateway.call('run_pipeline', fields), 'run_detail');
}
JsonMap _required(JsonMap reply, String key) {
final value = reply[key];
if (value is! Map) {
throw RunsRepositoryException('The server returned no $key.');
}
return Map<String, dynamic>.from(value);
}
}
@@ -0,0 +1,110 @@
import '../../../core/api_gateway.dart';
import 'run_models.dart';
class PendingDecision {
const PendingDecision({
required this.runId,
required this.runLabel,
required this.stageKey,
required this.instructions,
required this.options,
});
final num runId;
final String runLabel;
final String stageKey;
final String instructions;
final List<DecisionOption> options;
}
JsonMap? lastWaitingStep(List<dynamic> steps) {
for (final value in steps.reversed) {
if (value is Map && value['status'] == 'waiting') {
return Map<String, dynamic>.from(value);
}
}
return null;
}
String waitingPrompt(dynamic output) =>
output is Map && output['prompt'] is String
? output['prompt'] as String
: '';
List<String> waitingOptions(dynamic output) {
final options = output is Map ? output['options'] : null;
if (options is! List) return const [];
return options
.whereType<String>()
.where((entry) => entry.trim().isNotEmpty)
.toList();
}
List<String> humanOptions(dynamic edges) {
if (edges is! Map) return const [];
return edges.keys.map((key) => '$key').where((key) => key != 'error').toList()
..sort();
}
PendingDecision? pendingDecision(JsonMap? run) {
if (run == null ||
run['status'] != 'waiting' ||
_positive(run['export_pending_sequence'])) {
return null;
}
final steps = run['steps'] is List ? run['steps'] as List : const [];
final step = lastWaitingStep(steps);
final stage = _string(step?['stage']).trim().isNotEmpty
? _string(step?['stage'])
: _string(run['current_stage']);
if (stage.trim().isEmpty) return null;
JsonMap? declaration;
final graph = run['graph'];
final graphStages = graph is Map ? graph['stages'] : null;
if (graphStages is List) {
for (final value in graphStages.whereType<Map>()) {
if (value['key'] == stage) {
declaration = Map<String, dynamic>.from(value);
break;
}
}
}
if (declaration?['type'] != null && declaration!['type'] != 'human') {
return null;
}
final edges = declaration?['edges'];
final options = waitingOptions(step?['output']);
final keys = options.isNotEmpty ? options : humanOptions(edges);
if (keys.isEmpty) return null;
final instructions = waitingPrompt(step?['output']).trim().isNotEmpty
? waitingPrompt(step?['output'])
: _string(declaration?['prompt']);
return PendingDecision(
runId: run['id'] is num ? run['id'] as num : 0,
runLabel: runIdentity(run['title'], run['name']).label,
stageKey: stage,
instructions: instructions,
options: keys
.map(
(key) => DecisionOption(
key,
target: _targetLabel(key, edges is Map ? edges[key] : null),
),
)
.toList(),
);
}
String _targetLabel(String option, dynamic target) {
if (target == null || '$target'.trim().isEmpty) return '';
final resolved = target == '#'
? (option == 'error' ? '#failure' : '#success')
: '$target';
return switch (resolved) {
'#success' => 'SUCCESS',
'#failure' => 'FAILURE',
_ => resolved,
};
}
bool _positive(dynamic value) => value is num && value > 0;
String _string(dynamic value) => value == null ? '' : '$value';
+222 -20
View File
@@ -1,24 +1,226 @@
import '../../../core/api_gateway.dart';
const _terminal = {'succeeded','failed','canceled','interrupted'};
int _rank(dynamic s) => s == 'queued' ? 0 : {'running','waiting'}.contains(s) ? 1 : _terminal.contains(s) ? 2 : -1;
int _stepRank(dynamic s) => {'running','waiting'}.contains(s) ? 1 : {'completed','failed','canceled','interrupted'}.contains(s) ? 2 : -1;
bool _stale(dynamic a, dynamic b, int Function(dynamic) rank) => '${b ?? ''}'.trim().isNotEmpty && rank(a) >= 0 && rank(b) >= 0 && (rank(b) < rank(a) || (rank(a) == 2 && rank(b) == 2 && a != b));
String _advance(dynamic a, dynamic b, int Function(dynamic) rank) => '${b ?? ''}'.trim().isEmpty || rank(b) < rank(a) || (rank(a) == 2 && rank(b) == 2) ? '${a ?? ''}' : '${b ?? ''}';
({List<JsonMap> runs, bool needsResync}) foldRunEvent(List<JsonMap> runs, JsonMap frame) {
final id = frame['run_id']; if (id is! num || id <= 0) return (runs:runs, needsResync:false);
final i = runs.indexWhere((r) => r['id'] == id);
if (i < 0) { final pid=frame['pipeline_id']; final name=frame['name']; if (pid is! num || '${name ?? ''}'.trim().isEmpty) return (runs:runs, needsResync:true);
return (runs:[{'id':id,'pipeline_id':pid,'name':name,'title':frame['title'],'version':frame['version'] ?? 0,'status':frame['status'] ?? '', 'executing':true,'completed_steps':frame['completed_steps'] ?? 0,'created_at':frame['created_at'] ?? '', 'finished_at':frame['finished_at'] ?? '', 'resource_wait':frame['resource_wait']}, ...runs], needsResync:false); }
final current=runs[i]; if (_stale(current['status'],frame['status'],_rank) && frame['resource_wait_set'] != true) return (runs:runs, needsResync:false);
final status=frame['resource_wait_set']==true && frame['status']=='queued' && !_terminal.contains(current['status']) ? 'queued' : _advance(current['status'],frame['status'],_rank);
final updated=<String,dynamic>{...current,'status':status,'executing':status=='queued'||status=='running','completed_steps':(((current['completed_steps'] as num?)??0).toInt()).clamp(((frame['completed_steps'] as num?)??0).toInt(),0x7fffffff),'resource_wait':_terminal.contains(status)?null:frame['resource_wait_set']==true?frame['resource_wait']:current['resource_wait']};
for(final k in ['outcome','current_stage','finished_at','created_at']) { if ('${frame[k]??''}'.trim().isNotEmpty) updated[k]=frame[k]; }
final next=[...runs]; next[i]=updated; return (runs:next,needsResync:false);
import 'run_step_evidence.dart';
const terminalRunStatuses = {'succeeded', 'failed', 'canceled', 'interrupted'};
bool isTerminalRunStatus(dynamic status) =>
terminalRunStatuses.contains(_word(status));
bool isWaitingRunStatus(dynamic status) => _word(status) == 'waiting';
int runLifecycleRank(dynamic status) => switch (_word(status)) {
'queued' => 0,
'running' || 'waiting' => 1,
'succeeded' || 'failed' || 'canceled' || 'interrupted' => 2,
_ => -1,
};
int stepLifecycleRank(dynamic status) => switch (_word(status)) {
'running' || 'waiting' => 1,
'completed' || 'failed' || 'canceled' || 'interrupted' => 2,
_ => -1,
};
bool _stale(dynamic current, dynamic incoming, int Function(dynamic) rank) {
if (_word(incoming).isEmpty) return false;
final oldRank = rank(current);
final newRank = rank(incoming);
return oldRank >= 0 &&
newRank >= 0 &&
(newRank < oldRank ||
(oldRank == 2 && newRank == 2 && incoming != current));
}
bool runDetailNeedsFullSync(JsonMap f) => _terminal.contains(f['status']) || f['status']=='waiting' || f['cancel_requested']==true || f['cleanup_unconfirmed']==true || f['step']?['status']=='waiting' || _stepRank(f['step']?['status'])==2;
String _advance(dynamic current, dynamic incoming, int Function(dynamic) rank) {
if (_word(incoming).isEmpty || incoming == current) return '${current ?? ''}';
final oldRank = rank(current);
final newRank = rank(incoming);
if (oldRank < 0) return '$incoming';
if (newRank < 0 || (oldRank == 2 && newRank == 2) || newRank < oldRank) {
return '${current ?? ''}';
}
return '$incoming';
}
bool executingFor(dynamic status, bool current) => switch (_word(status)) {
'queued' || 'running' => true,
'waiting' || 'succeeded' || 'failed' || 'canceled' || 'interrupted' => false,
_ => current,
};
bool _blank(dynamic value) => '${value ?? ''}'.trim().isEmpty;
JsonMap _scheduleOrigin(JsonMap current, JsonMap frame) {
final oldId = _positiveInt(current['schedule_id']);
final newId = _positiveInt(frame['schedule_id']);
final known =
current.containsKey('scheduled') ||
frame.containsKey('scheduled') ||
oldId > 0 ||
newId > 0;
if (!known) return {};
final id = oldId > 0 ? oldId : newId;
final nameConflict = oldId > 0 && newId > 0 && oldId != newId;
final name =
'${current['schedule_name'] ?? (nameConflict ? '' : frame['schedule_name'] ?? '')}';
return {
'scheduled':
current['scheduled'] == true || frame['scheduled'] == true || id > 0,
if (id > 0) 'schedule_id': id,
if (name.isNotEmpty) 'schedule_name': name,
};
}
int _positiveInt(dynamic value) =>
value is num && value > 0 ? value.toInt() : 0;
JsonMap _mergeRunFields(JsonMap current, JsonMap frame) {
if (_stale(current['status'], frame['status'], runLifecycleRank) &&
frame['resource_wait_set'] != true) {
return current;
}
final beforeStatus = '${current['status'] ?? ''}';
final status =
frame['resource_wait_set'] == true &&
frame['status'] == 'queued' &&
!isTerminalRunStatus(beforeStatus)
? 'queued'
: _advance(beforeStatus, frame['status'], runLifecycleRank);
final merged = <String, dynamic>{
...current,
..._scheduleOrigin(current, frame),
'status': status,
'executing': executingFor(status, current['executing'] == true),
'completed_steps': _maxInt(
current['completed_steps'],
frame['completed_steps'],
),
'resource_wait': isTerminalRunStatus(status)
? null
: frame['resource_wait_set'] == true
? frame['resource_wait']
: current['resource_wait'],
'notify_mode': _blank(frame['notify_mode'])
? current['notify_mode'] ?? 'auto'
: frame['notify_mode'],
'cancel_requested':
current['cancel_requested'] == true ||
frame['cancel_requested'] == true,
'cleanup_unconfirmed':
current['cleanup_unconfirmed'] == true ||
frame['cleanup_unconfirmed'] == true,
};
for (final key in ['outcome', 'current_stage', 'created_at', 'finished_at']) {
if (!_blank(frame[key])) merged[key] = frame[key];
}
final oldExport = _positiveInt(current['export_pending_sequence']);
if (oldExport > 0 || frame.containsKey('export_pending_sequence')) {
merged['export_pending_sequence'] = _blank(frame['status'])
? oldExport
: status == 'waiting'
? _positiveInt(frame['export_pending_sequence'])
: 0;
}
if (current['steps'] is! List) {
final evidence = mergeGraphEvidence(
current['graph_evidence'] as JsonMap?,
frame,
);
if (evidence != null) merged['graph_evidence'] = evidence;
}
return merged;
}
int _maxInt(dynamic a, dynamic b) =>
(a is num ? a.toInt() : 0).clamp(b is num ? b.toInt() : 0, 0x7fffffff);
/// A summary row can be built from a sufficiently identified push; otherwise
/// the caller must resync from the server's authoritative list.
JsonMap? newRunSummaryFromFrame(JsonMap frame) {
final id = frame['run_id'];
final pipelineId = frame['pipeline_id'];
if (id is! num ||
id <= 0 ||
pipelineId is! num ||
pipelineId <= 0 ||
_blank(frame['name'])) {
return null;
}
final row = <String, dynamic>{
'id': id,
'pipeline_id': pipelineId,
'name': frame['name'],
'title': _blank(frame['title']) ? null : frame['title'],
'version': frame['version'] ?? 0,
'notify_mode': frame['notify_mode'] ?? 'auto',
'status': frame['status'] ?? '',
'executing': executingFor(frame['status'], true),
'completed_steps': _maxInt(0, frame['completed_steps']),
'created_at': frame['created_at'] ?? '',
'finished_at': frame['finished_at'] ?? '',
'outcome': frame['outcome'] ?? '',
'current_stage': frame['current_stage'] ?? '',
'resource_wait': frame['resource_wait'],
'cancel_requested': frame['cancel_requested'] == true,
'cleanup_unconfirmed': frame['cleanup_unconfirmed'] == true,
};
row.addAll(_scheduleOrigin({}, frame));
final sequence = _positiveInt(frame['export_pending_sequence']);
if (sequence > 0) row['export_pending_sequence'] = sequence;
final evidence = mergeGraphEvidence(null, frame);
if (evidence != null) row['graph_evidence'] = evidence;
return row;
}
({List<JsonMap> runs, bool needsResync}) foldRunEvent(
List<JsonMap> runs,
JsonMap frame,
) {
final id = frame['run_id'];
if (id is! num || id <= 0) return (runs: runs, needsResync: false);
final index = runs.indexWhere((run) => run['id'] == id);
if (index < 0) {
final row = newRunSummaryFromFrame(frame);
return row == null
? (runs: runs, needsResync: true)
: (runs: [row, ...runs], needsResync: false);
}
final updated = _mergeRunFields(runs[index], frame);
if (identical(updated, runs[index])) return (runs: runs, needsResync: false);
final next = [...runs];
next[index] = updated;
return (runs: next, needsResync: false);
}
JsonMap? foldRunEventDetail(JsonMap? detail, JsonMap frame) {
if(detail==null || detail['id']!=frame['run_id'] || (_stale(detail['status'],frame['status'],_rank)&&frame['resource_wait_set']!=true)) return detail;
final folded=foldRunEvent([detail],frame).runs.single; final delta=frame['step'];
if(delta is Map) { final steps=List<JsonMap>.from(detail['steps']??[]); final i=steps.indexWhere((s)=>s['sequence']==delta['sequence']); if(i<0){steps.add(Map<String,dynamic>.from(delta));steps.sort((a,b)=>((a['sequence'] as num?)??0).compareTo((b['sequence'] as num?)??0));} else if(!_stale(steps[i]['status'],delta['status'],_stepRank)){steps[i]={...steps[i],...Map<String,dynamic>.from(delta)};} folded['steps']=steps; }
return folded;
if (detail == null || detail['id'] != frame['run_id']) return detail;
if (_stale(detail['status'], frame['status'], runLifecycleRank) &&
frame['resource_wait_set'] != true) {
return detail;
}
final merged = _mergeRunFields(detail, frame);
final steps = frame['step'] is Map
? upsertRunStep(
detail['steps'] is List
? (detail['steps'] as List)
.whereType<Map>()
.map((s) => Map<String, dynamic>.from(s))
.toList()
: [],
Map<String, dynamic>.from(frame['step'] as Map),
)
: detail['steps'] ?? [];
return {...merged, 'steps': steps};
}
bool runDetailNeedsFullSync(JsonMap frame) {
final step = frame['step'];
final stepStatus = step is Map ? step['status'] : null;
return isTerminalRunStatus(frame['status']) ||
isWaitingRunStatus(frame['status']) ||
frame['cancel_requested'] == true ||
frame['cleanup_unconfirmed'] == true ||
isWaitingRunStatus(stepStatus) ||
stepLifecycleRank(stepStatus) == 2;
}
String _word(dynamic value) => '${value ?? ''}'.trim().toLowerCase();
+203 -19
View File
@@ -1,33 +1,217 @@
import '../../../core/api_gateway.dart';
const runStates = ['queued', 'running', 'waiting', 'succeeded', 'failed', 'canceled', 'interrupted'];
const runStates = [
'queued',
'running',
'waiting',
'succeeded',
'failed',
'canceled',
'interrupted',
];
({String label, String? pipeline}) runIdentity(dynamic title, dynamic name) {
final stored = '${title ?? ''}'.trim();
return (label: stored.isNotEmpty ? stored : '${name ?? ''}', pipeline: stored.isNotEmpty ? '${name ?? ''}' : null);
return (
label: stored.isNotEmpty ? stored : '${name ?? ''}',
pipeline: stored.isNotEmpty ? '${name ?? ''}' : null,
);
}
String runStateOf(dynamic status) => switch ('${status ?? ''}'.trim().toLowerCase()) {
'queued' || 'running' || 'waiting' || 'active' || 'blocked' || 'skipped' => '${status ?? ''}'.trim().toLowerCase(),
'succeeded' || 'success' || 'completed' || 'done' => 'succeeded',
'failed' || 'error' => 'failed', 'canceled' || 'cancelled' => 'canceled', 'interrupted' => 'interrupted', _ => 'unknown',
};
List<JsonMap> filterRuns(List<JsonMap> runs, {Set<String> statuses = const {}, int? pipelineId}) => runs.where((r) => (statuses.isEmpty || statuses.contains(runStateOf(r['status']))) && (pipelineId == null || r['pipeline_id'] == pipelineId)).toList();
String runStateOf(dynamic status) =>
switch ('${status ?? ''}'.trim().toLowerCase()) {
'queued' ||
'running' ||
'waiting' ||
'active' ||
'blocked' ||
'skipped' => '${status ?? ''}'.trim().toLowerCase(),
'succeeded' || 'success' || 'completed' || 'done' => 'succeeded',
'failed' || 'error' => 'failed',
'canceled' || 'cancelled' => 'canceled',
'interrupted' => 'interrupted',
_ => 'unknown',
};
List<JsonMap> filterRuns(
List<JsonMap> runs, {
Set<String> statuses = const {},
int? pipelineId,
String timeRange = 'any_time',
String scheduled = 'any',
DateTime? today,
}) => runs.where((run) {
if (statuses.isNotEmpty && !statuses.contains(runStateOf(run['status']))) {
return false;
}
if (pipelineId != null && run['pipeline_id'] != pipelineId) {
return false;
}
if (scheduled == 'scheduled' && !_isScheduled(run)) {
return false;
}
if (scheduled == 'unscheduled' &&
(run['scheduled'] != false || _isScheduled(run))) {
return false;
}
if (timeRange == 'any_time' || timeRange.isEmpty) {
return true;
}
final created = DateTime.tryParse('${run['created_at'] ?? ''}')?.toLocal();
if (created == null) {
return false;
}
final now = today ?? DateTime.now();
final start = DateTime(now.year, now.month, now.day);
final date = DateTime(created.year, created.month, created.day);
if (date.isAfter(start)) {
return false;
}
final days = switch (timeRange) {
'today' => 0,
'last_7_days' => 6,
'last_30_days' => 29,
_ => null,
};
return days == null || !date.isBefore(start.subtract(Duration(days: days)));
}).toList();
bool _isScheduled(JsonMap run) =>
run['scheduled'] == true ||
(run['schedule_id'] is num && (run['schedule_id'] as num) > 0);
String runStatusLabel(JsonMap run) {
final status = '${run['status'] ?? ''}';
if (!{'queued', 'running', 'waiting'}.contains(status)) {
return status.isEmpty ? 'unknown' : status;
}
if (run['cleanup_unconfirmed'] == true) {
return 'Cleanup unconfirmed — workspace reserved';
}
if (run['cancel_requested'] == true) {
return 'Stopping — waiting for execution to stop';
}
if (status == 'waiting' &&
(run['export_pending_sequence'] as num? ?? 0) > 0) {
return 'Waiting for session export';
}
return status;
}
List<JsonMap> sortRuns(List<JsonMap> runs, {String sort = 'newest_first'}) {
int time(dynamic x) => DateTime.tryParse('${x ?? ''}')?.millisecondsSinceEpoch ?? -0x7fffffffffffffff;
final result = [...runs];
result.sort((a,b) {
final c = switch (sort) { 'oldest_first' => time(a['created_at']).compareTo(time(b['created_at'])), 'pipeline_name' => '${a['name'] ?? ''}'.toLowerCase().compareTo('${b['name'] ?? ''}'.toLowerCase()), 'status' => '${a['status'] ?? ''}'.compareTo('${b['status'] ?? ''}'), _ => time(b['created_at']).compareTo(time(a['created_at'])) };
return c == 0 ? ((b['id'] as num?) ?? 0).compareTo((a['id'] as num?) ?? 0) : c;
int? instant(dynamic value) =>
DateTime.tryParse('${value ?? ''}')?.millisecondsSinceEpoch;
int? duration(JsonMap run) {
final from = instant(run['created_at']);
final to = instant(run['finished_at']);
if (from == null || to == null || to < from) return null;
return (to - from) ~/ 1000;
}
int cmp<T extends Comparable<Object>>(T a, T b) => a.compareTo(b);
result.sort((a, b) {
final at = instant(a['created_at']);
final bt = instant(b['created_at']);
int primary;
switch (sort) {
case 'oldest_first':
primary = cmp(at ?? 0x7fffffffffffffff, bt ?? 0x7fffffffffffffff);
break;
case 'longest_duration':
primary = cmp(duration(a) == null ? 1 : 0, duration(b) == null ? 1 : 0);
if (primary == 0) primary = cmp(duration(b) ?? -1, duration(a) ?? -1);
if (primary == 0) {
primary = cmp(bt ?? -0x7fffffffffffffff, at ?? -0x7fffffffffffffff);
}
break;
case 'shortest_duration':
primary = cmp(duration(a) == null ? 1 : 0, duration(b) == null ? 1 : 0);
if (primary == 0) {
primary = cmp(
duration(a) ?? 0x7fffffffffffffff,
duration(b) ?? 0x7fffffffffffffff,
);
}
if (primary == 0) {
primary = cmp(bt ?? -0x7fffffffffffffff, at ?? -0x7fffffffffffffff);
}
break;
case 'pipeline_name':
primary = '${a['name'] ?? ''}'.toLowerCase().compareTo(
'${b['name'] ?? ''}'.toLowerCase(),
);
if (primary == 0) {
primary = cmp(bt ?? -0x7fffffffffffffff, at ?? -0x7fffffffffffffff);
}
break;
case 'status':
primary = '${a['status'] ?? ''}'.toLowerCase().compareTo(
'${b['status'] ?? ''}'.toLowerCase(),
);
if (primary == 0) {
primary = cmp(bt ?? -0x7fffffffffffffff, at ?? -0x7fffffffffffffff);
}
break;
default:
primary = cmp(bt ?? -0x7fffffffffffffff, at ?? -0x7fffffffffffffff);
}
return primary == 0
? ((b['id'] as num?) ?? 0).compareTo((a['id'] as num?) ?? 0)
: primary;
});
return result;
}
/// Null usage means unsupported/unavailable, not zero.
class RunListResult { const RunListResult(this.runs, this.usage); final List<JsonMap> runs; final JsonMap? usage; }
class DecisionOption { const DecisionOption(this.key, {this.target = ''}); final String key; final String target; }
class DecisionDraft { const DecisionDraft({this.selected, this.feedback = ''}); final String? selected; final String feedback; bool get canSubmit => selected != null && selected!.trim().isNotEmpty; }
class RunListResult {
const RunListResult(this.runs, this.usage);
final List<JsonMap> runs;
final JsonMap? usage;
}
class DecisionOption {
const DecisionOption(this.key, {this.target = ''});
final String key;
final String target;
}
class DecisionDraft {
const DecisionDraft({this.selected, this.feedback = ''});
final String? selected;
final String feedback;
bool get canSubmit => selected != null && selected!.trim().isNotEmpty;
DecisionDraft select(String option) =>
DecisionDraft(selected: option, feedback: feedback);
DecisionDraft withFeedback(String value) =>
DecisionDraft(selected: selected, feedback: value);
}
String attentionKey(num runId, String kind) => '$runId:$kind';
List<JsonMap> orderAttention(List<JsonMap> runs, {Set<String> dismissed = const {}}) {
final result = runs.where((r) => ['waiting','failed'].contains(r['status']) && !dismissed.contains(attentionKey(r['id'] as num, r['status'] == 'waiting' ? 'Decision' : 'Failed'))).toList();
int at(JsonMap r) => DateTime.tryParse('${r['finished_at'] ?? r['created_at'] ?? ''}')?.millisecondsSinceEpoch ?? 0;
result.sort((a,b) { final rank = (a['status'] == 'waiting' ? 0 : 1).compareTo(b['status'] == 'waiting' ? 0 : 1); if (rank != 0) return rank; final date = at(b).compareTo(at(a)); return date != 0 ? date : (b['id'] as num).compareTo(a['id'] as num); });
List<JsonMap> orderAttention(
List<JsonMap> runs, {
Set<String> dismissed = const {},
}) {
final result = runs.where((run) {
final waiting = run['status'] == 'waiting';
if (waiting && (run['export_pending_sequence'] as num? ?? 0) > 0) {
return false;
}
final kind = waiting ? 'Decision' : 'Failed';
return (waiting || run['status'] == 'failed') &&
!dismissed.contains(attentionKey(run['id'] as num, kind));
}).toList();
String recency(JsonMap run) => '${run['finished_at'] ?? ''}'.trim().isNotEmpty
? '${run['finished_at']}'
: '${run['created_at'] ?? ''}';
result.sort((a, b) {
final rank = (a['status'] == 'waiting' ? 0 : 1).compareTo(
b['status'] == 'waiting' ? 0 : 1,
);
if (rank != 0) return rank;
final date = recency(b).compareTo(recency(a));
return date != 0 ? date : (b['id'] as num).compareTo(a['id'] as num);
});
return result;
}
@@ -0,0 +1,142 @@
import '../../../core/api_gateway.dart';
/// Merge a visit by sequence without allowing stale status or blank sparse
/// deltas to erase evidence already held by the detail cache.
List<JsonMap> upsertRunStep(List<JsonMap> steps, JsonMap delta) {
final sequence = delta['sequence'] is num
? (delta['sequence'] as num).toInt()
: 0;
final index = steps.indexWhere((step) => step['sequence'] == sequence);
if (index < 0) {
final result = [...steps, _stepFields({}, delta, sequence)];
result.sort(
(a, b) => ((a['sequence'] as num?) ?? 0).compareTo(
(b['sequence'] as num?) ?? 0,
),
);
return result;
}
final old = steps[index];
final incomingStatus = '${delta['status'] ?? ''}';
final oldStatus = '${old['status'] ?? ''}';
if (_stale(oldStatus, incomingStatus)) return steps;
final merged = _stepFields(old, delta, sequence);
if (_same(old, merged)) return steps;
final result = [...steps];
result[index] = merged;
return result;
}
JsonMap _stepFields(JsonMap old, JsonMap delta, int sequence) {
final oldStatus = '${old['status'] ?? ''}';
final incoming = '${delta['status'] ?? ''}';
return {
...old,
'sequence': sequence,
for (final key in ['stage', 'outcome', 'target', 'diagnostic'])
key: _blank(delta[key]) ? old[key] ?? '' : delta[key],
'status': _advance(oldStatus, incoming),
};
}
bool _stale(String old, String incoming) {
if (_blank(incoming)) return false;
final before = _rank(old);
final after = _rank(incoming);
return before >= 0 &&
after >= 0 &&
(after < before || (before == 2 && after == 2 && old != incoming));
}
String _advance(String old, String incoming) {
if (_blank(incoming)) return old;
final before = _rank(old);
final after = _rank(incoming);
if (before < 0 || (after >= 0 && after > before && before < 2)) {
return incoming;
}
if (before < 2 && after == before) return incoming;
return old;
}
int _rank(String status) => switch (status.trim().toLowerCase()) {
'running' || 'waiting' => 1,
'completed' || 'failed' || 'canceled' || 'interrupted' => 2,
_ => -1,
};
bool _same(JsonMap a, JsonMap b) =>
a.length == b.length && a.entries.every((e) => b[e.key] == e.value);
/// Compact graph evidence is intentionally allowlisted. It retains latest
/// visit-by-stage and distinct outcome routes, not arbitrary frame diagnostics.
JsonMap? mergeGraphEvidence(JsonMap? current, JsonMap frame) {
final incomingEvidence = frame['graph_evidence'];
final graphVisits = frame['graph_visits'];
final step = frame['step'];
if (incomingEvidence is! Map && graphVisits is! List && step is! Map) {
return current;
}
var visits = <JsonMap>[];
final oldVisits = current?['visits'];
if (oldVisits is List) {
visits = oldVisits
.whereType<Map>()
.map((v) => Map<String, dynamic>.from(v))
.toList();
}
final additions = <dynamic>[];
if (incomingEvidence is Map && incomingEvidence['visits'] is List) {
additions.addAll(incomingEvidence['visits'] as List);
}
if (graphVisits is List) additions.addAll(graphVisits);
if (step is Map) additions.add(step);
for (final item in additions.whereType<Map>()) {
final delta = Map<String, dynamic>.from(item);
visits = upsertRunStep(visits, {
'sequence': delta['sequence'],
'stage': delta['stage'],
'status': delta['status'],
'outcome': delta['outcome'],
'target': delta['target'],
});
}
final latestByStage = <String, int>{};
final routeSequence = <String, int>{};
for (final visit in visits) {
final sequence = (visit['sequence'] as num?)?.toInt() ?? 0;
final stage = '${visit['stage'] ?? ''}';
latestByStage[stage] = sequence;
if (!_blank(visit['outcome']) && !_blank(visit['target'])) {
routeSequence['$stage\u0000${visit['outcome']}\u0000${visit['target']}'] =
sequence;
}
}
visits = visits
.where((visit) {
final sequence = (visit['sequence'] as num?)?.toInt() ?? 0;
final stage = '${visit['stage'] ?? ''}';
final route = '$stage\u0000${visit['outcome']}\u0000${visit['target']}';
return latestByStage[stage] == sequence ||
routeSequence[route] == sequence;
})
.map(
(visit) => <String, dynamic>{
for (final key in [
'sequence',
'stage',
'status',
'outcome',
'target',
])
key: visit[key],
},
)
.toList();
final complete =
current?['complete'] == true ||
(incomingEvidence is Map && incomingEvidence['complete'] == true);
return {'complete': complete, 'visits': visits};
}
bool _blank(dynamic value) => '${value ?? ''}'.trim().isEmpty;
+18 -8
View File
@@ -1,12 +1,22 @@
# F3 run foundation
Public API: `run_models.dart` provides run identity/state/filter/sort helpers,
`RunListResult`, decision draft/option values, and attention ordering/identity.
`run_events.dart` provides monotonic list/detail event folds and
`runDetailNeedsFullSync`. `data/runs_repository.dart` provides `RunsRepository`
for list/get/cancel/retry/decide/title/start calls through the shared gateway.
status wording, `RunListResult`, decision draft/option values, and attention
ordering/identity. `run_decisions.dart` resolves recorded human options and
prompt evidence with graph fallback. `run_events.dart` and
`run_step_evidence.dart` provide monotonic list/detail folds, immutable schedule
origin, graph evidence, and `runDetailNeedsFullSync`. `data/runs_repository.dart`
provides list/get/cancel/retry/decide/title/start calls through the shared gateway.
Focused tests cover stale lifecycle deltas, explicit resource-wait clearing,
unknown usage versus zero, decision refusal, attention identity/order, and exact
retry/start fields. This is a nonvisual foundation; browser UI captures were not
applicable. Mobile targets are unverified.
Focused tests cover stale and terminal lifecycle deltas, resource-wait clearing,
sparse step preservation, sticky cancel/cleanup flags, schedule provenance,
export gating, pending-decision evidence, list/detail agreement, filters/sorts,
exact request fields and server refusals. The repository file is deliberately
tracked despite the repository's `data/` ignore rule. This is a nonvisual
foundation; browser UI captures were not applicable. Mobile targets are
unverified.
This is not total web parity: date filtering uses Dart local-time conversion
rather than web's explicit IANA-zone/locale helpers; the complete attention
dismissal/persistence surface, retry key generation, and repository methods for
export repair/request-key reconciliation are not included in this foundation.
@@ -0,0 +1,87 @@
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/core/api_gateway.dart';
import 'package:pipelines_app/features/runs/domain/run_decisions.dart';
import 'package:pipelines_app/features/runs/domain/run_events.dart';
import 'package:pipelines_app/features/runs/domain/run_models.dart';
void main() {
test(
'scheduled origin is immutable and export pending blocks attention/decision',
() {
final rows = <JsonMap>[
{
'id': 5,
'status': 'waiting',
'scheduled': true,
'schedule_id': 12,
'schedule_name': 'Nightly',
},
];
final changed = foldRunEvent(rows, {
'run_id': 5,
'status': 'waiting',
'scheduled': false,
'schedule_id': 99,
'schedule_name': 'Other',
'export_pending_sequence': 4,
});
expect(changed.runs.single['schedule_id'], 12);
expect(changed.runs.single['schedule_name'], 'Nightly');
expect(changed.runs.single['scheduled'], true);
expect(orderAttention(changed.runs), isEmpty);
expect(
pendingDecision({
...changed.runs.single,
'current_stage': 'human',
'steps': [],
}),
isNull,
);
},
);
test(
'pending decision uses recorded options then graph fallback and target labels',
() {
final run = <String, dynamic>{
'id': 7,
'status': 'waiting',
'current_stage': 'human',
'name': 'Build',
'graph': {
'stages': [
{
'key': 'human',
'type': 'human',
'prompt': 'Graph prompt',
'edges': {'go': '#', 'error': '#', 'skip': 'finish'},
},
],
},
'steps': [
{
'sequence': 1,
'status': 'waiting',
'stage': 'human',
'output': {
'prompt': 'Recorded prompt',
'options': ['go'],
},
},
],
};
final decision = pendingDecision(run)!;
expect(decision.instructions, 'Recorded prompt');
expect(decision.options.map((option) => option.key), ['go']);
expect(decision.options.single.target, 'SUCCESS');
final fallback = pendingDecision({
...run,
'steps': [
{'status': 'waiting', 'stage': 'human', 'output': {}},
],
})!;
expect(fallback.instructions, 'Graph prompt');
expect(fallback.options.map((option) => option.key), ['go', 'skip']);
},
);
}
+179 -49
View File
@@ -1,59 +1,189 @@
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/core/api_gateway.dart';
import 'package:pipelines_app/features/runs/data/runs_repository.dart';
import 'package:pipelines_app/features/runs/domain/run_events.dart';
import 'package:pipelines_app/features/runs/domain/run_models.dart';
class FakeGateway implements ApiGateway {
String? type;
JsonMap fields = {};
JsonMap reply = {};
@override
Future<JsonMap> call(String type, [JsonMap fields = const {}]) async {
this.type = type;
this.fields = Map.of(fields);
return reply;
}
@override
Stream<JsonMap> get frames => const Stream.empty();
}
void main() {
test('filter/sort identities and unknown usage remain distinct', () {
expect(runIdentity(' Report ', 'Build').label, 'Report');
final rows = [{'id': 1, 'pipeline_id': 2, 'status': 'failed', 'created_at': '2024-01-01'}, {'id': 2, 'pipeline_id': 2, 'status': 'running', 'created_at': '2025-01-01'}];
expect(filterRuns(rows, statuses: {'failed'}).single['id'], 1);
expect(sortRuns(rows).first['id'], 2);
expect(RunListResult(const [], null).usage, isNull);
});
group('event fold', () {
test('terminal status and resource wait reset are monotonic', () {
final initial = <JsonMap>[
{
'id': 1,
'status': 'succeeded',
'executing': false,
'completed_steps': 4,
},
];
final reset = foldRunEvent(initial, {
'run_id': 1,
'status': 'queued',
'resource_wait_set': true,
'resource_wait': null,
});
expect(reset.runs.single['status'], 'succeeded');
expect(reset.runs.single['executing'], false);
final competing = foldRunEvent(initial, {
'run_id': 1,
'status': 'failed',
'resource_wait_set': true,
});
expect(competing.runs.single['status'], 'succeeded');
expect(competing.runs.single['resource_wait'], isNull);
});
test('fold is monotonic and explicit resource wait clearing is honored', () {
final rows = <JsonMap>[{'id': 1, 'status': 'running', 'completed_steps': 3, 'resource_wait': {'resource': 'gpu'}}];
final stale = foldRunEvent(rows, {'run_id': 1, 'status': 'queued', 'completed_steps': 1});
expect(stale.runs.single['status'], 'running');
final cleared = foldRunEvent(rows, {'run_id': 1, 'status': 'queued', 'resource_wait_set': true, 'resource_wait': null});
expect(cleared.runs.single['status'], 'queued');
expect(cleared.runs.single['resource_wait'], isNull);
expect(cleared.runs.single['completed_steps'], 3);
expect(runDetailNeedsFullSync({'status': 'waiting'}), isTrue);
});
test(
'resource wait reset advances only nonterminal rows, even on stale status',
() {
final rows = <JsonMap>[
{
'id': 2,
'status': 'running',
'executing': true,
'resource_wait': {'resource': 'gpu'},
'completed_steps': 3,
},
];
final result = foldRunEvent(rows, {
'run_id': 2,
'status': 'queued',
'resource_wait_set': true,
'resource_wait': null,
'completed_steps': 1,
});
expect(result.runs.single['status'], 'queued');
expect(result.runs.single['resource_wait'], isNull);
expect(result.runs.single['completed_steps'], 3);
},
);
test('decision guard and attention dismissal identity', () {
expect(const DecisionDraft().canSubmit, isFalse);
expect(const DecisionDraft(selected: ' continue ').canSubmit, isTrue);
expect(attentionKey(7, 'Decision'), '7:Decision');
final ordered = orderAttention([{'id': 8, 'status': 'failed'}, {'id': 7, 'status': 'waiting'}]);
expect(ordered.first['id'], 7);
});
test(
'new waiting and terminal rows are not executing; identity-less frame resyncs',
() {
for (final status in ['waiting', 'succeeded']) {
final result = foldRunEvent([], {
'run_id': 8,
'pipeline_id': 4,
'name': 'Build',
'status': status,
});
expect(result.runs.single['executing'], false);
}
expect(
foldRunEvent([], {'run_id': 9, 'status': 'running'}).needsResync,
isTrue,
);
},
);
test('repository emits exact action envelopes and requires idempotency key', () async {
final gateway = FakeGateway()..reply = {'run_detail': {'id': 3}};
final repo = RunsRepository(gateway);
await repo.retryRun(3, requestKey: 'retry-1');
expect(gateway.type, 'retry_run');
expect(gateway.fields, {'run_id': 3, 'request_key': 'retry-1'});
await repo.startRun(pipelineId: 4, version: 2, prompt: 'hello', workspace: ' /work ', requestKey: 'start-2');
expect(gateway.fields, {'pipeline_id': 4, 'version': 2, 'request_key': 'start-2', 'workspace': '/work', 'input': {'prompt': 'hello'}});
await expectLater(repo.decideRun(3, option: ' '), throwsA(isA<RunsRepositoryException>()));
test(
'blank sparse step fields preserve graph evidence and terminal visit',
() {
final detail = <String, dynamic>{
'id': 1,
'status': 'running',
'steps': [
{
'sequence': 2,
'stage': 'review',
'status': 'completed',
'outcome': 'approve',
'target': 'publish',
'diagnostic': 'kept',
},
],
};
final next = foldRunEventDetail(detail, {
'run_id': 1,
'status': 'running',
'step': {
'sequence': 2,
'stage': '',
'status': 'running',
'outcome': ' ',
'target': '',
'diagnostic': '',
},
})!;
final step = (next['steps'] as List).single as JsonMap;
expect(step, containsPair('stage', 'review'));
expect(step, containsPair('status', 'completed'));
expect(step, containsPair('outcome', 'approve'));
expect(step, containsPair('target', 'publish'));
expect(step, containsPair('diagnostic', 'kept'));
},
);
test(
'cancel and cleanup flags stick; resource wait can clear; terminal clears it',
() {
final rows = <JsonMap>[
{
'id': 3,
'status': 'running',
'resource_wait': {'resource': 'gpu'},
},
];
final first = foldRunEvent(rows, {
'run_id': 3,
'status': 'running',
'cancel_requested': true,
'cleanup_unconfirmed': true,
});
final second = foldRunEvent(first.runs, {
'run_id': 3,
'status': 'running',
'cancel_requested': false,
'cleanup_unconfirmed': false,
'resource_wait_set': true,
'resource_wait': null,
});
expect(second.runs.single['cancel_requested'], true);
expect(second.runs.single['cleanup_unconfirmed'], true);
expect(second.runs.single['resource_wait'], isNull);
final terminal = foldRunEvent(second.runs, {
'run_id': 3,
'status': 'failed',
});
expect(terminal.runs.single['resource_wait'], isNull);
},
);
test(
'full sync triggers and list/detail folds agree across stale and current frames',
() {
expect(runDetailNeedsFullSync({'status': 'waiting'}), true);
expect(
runDetailNeedsFullSync({
'status': 'running',
'step': {'status': 'completed'},
}),
true,
);
final summary = <JsonMap>[
{'id': 1, 'status': 'running', 'completed_steps': 1},
];
final frame = {
'run_id': 1,
'status': 'succeeded',
'completed_steps': 2,
'outcome': 'done',
};
final list = foldRunEvent(summary, frame).runs.single;
final detail = foldRunEventDetail({
'id': 1,
'status': 'running',
'completed_steps': 1,
'steps': [],
}, frame)!;
expect(list['status'], detail['status']);
expect(list['completed_steps'], detail['completed_steps']);
final old = foldRunEventDetail(detail, {
'run_id': 1,
'status': 'running',
'outcome': '',
})!;
expect(old['status'], 'succeeded');
expect(old['outcome'], 'done');
},
);
});
}
@@ -0,0 +1,163 @@
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/core/api_gateway.dart';
import 'package:pipelines_app/features/runs/data/runs_repository.dart';
import 'package:pipelines_app/features/runs/domain/run_models.dart';
class FakeGateway implements ApiGateway {
String? type;
JsonMap fields = {};
JsonMap reply = {};
Object? failure;
@override
Future<JsonMap> call(String type, [JsonMap fields = const {}]) async {
this.type = type;
this.fields = Map.of(fields);
if (failure case final error?) throw error;
return reply;
}
@override
Stream<JsonMap> get frames => const Stream.empty();
}
void main() {
test(
'run models match identity, filtering, sorting and null usage behavior',
() {
expect(runIdentity(' Report ', 'Build').label, 'Report');
final rows = <JsonMap>[
{
'id': 1,
'pipeline_id': 2,
'status': 'failed',
'created_at': '2024-01-01T00:00:00Z',
'finished_at': '2024-01-01T00:00:10Z',
},
{
'id': 2,
'pipeline_id': 2,
'status': 'running',
'created_at': '2025-01-01T00:00:00Z',
},
];
expect(filterRuns(rows, statuses: {'failed'}).single['id'], 1);
expect(sortRuns(rows).first['id'], 2);
expect(sortRuns(rows, sort: 'shortest_duration').first['id'], 1);
final scheduled = [
{
'id': 3,
'scheduled': true,
'schedule_id': 9,
'created_at': '2025-03-10T12:00:00Z',
},
{'id': 4, 'scheduled': false, 'created_at': '2025-03-10T12:00:00Z'},
{'id': 5, 'created_at': '2025-03-10T12:00:00Z'},
];
expect(
filterRuns(scheduled, scheduled: 'scheduled').map((run) => run['id']),
[3],
);
expect(
filterRuns(
scheduled,
scheduled: 'unscheduled',
timeRange: 'today',
today: DateTime(2025, 3, 10),
).map((run) => run['id']),
[4],
);
expect(
runStatusLabel({'status': 'waiting', 'export_pending_sequence': 2}),
'Waiting for session export',
);
expect(RunListResult(const [], null).usage, isNull);
},
);
test('repository sends exact action and launch requests', () async {
final gateway = FakeGateway()
..reply = {
'run_detail': {'id': 3},
};
final repo = RunsRepository(gateway);
gateway.reply = {
'runs': [
{'id': 1, 'status': 'running'},
],
'usage': {'active': 1},
};
final listed = await repo.listRuns();
expect(gateway.type, 'list_runs');
expect(gateway.fields, isEmpty);
expect(listed.runs.single['id'], 1);
expect(listed.usage, {'active': 1});
gateway.reply = {
'run_detail': {'id': 3},
};
await repo.retryRun(3, requestKey: 'retry-1');
expect(gateway.type, 'retry_run');
expect(gateway.fields, {'run_id': 3, 'request_key': 'retry-1'});
await repo.retryRun(3, requestKey: 'retry-2', mode: 'restart');
expect(gateway.fields, {
'run_id': 3,
'request_key': 'retry-2',
'retry_mode': 'restart',
});
await repo.decideRun(3, stage: 'human', option: ' go ', feedback: ' yes ');
expect(gateway.fields, {
'run_id': 3,
'stage': 'human',
'option': 'go',
'feedback': 'yes',
});
await repo.cancelRun(3);
expect(gateway.type, 'cancel_run');
expect(gateway.fields, {'run_id': 3});
await repo.setRunTitle(3, 'New');
expect(gateway.type, 'set_run_title');
expect(gateway.fields, {'run_id': 3, 'title': 'New'});
await repo.startRun(
pipelineId: 4,
version: 2,
prompt: 'hello',
workspace: ' /work ',
requestKey: 'start-2',
title: ' Job ',
notifyMode: 'off',
outputFormat: 'json',
);
expect(gateway.type, 'run_pipeline');
expect(gateway.fields, {
'pipeline_id': 4,
'version': 2,
'request_key': 'start-2',
'workspace': '/work',
'input': {'prompt': 'hello'},
'title': 'Job',
'notify_mode': 'off',
'output_format': 'json',
});
});
test(
'repository propagates server refusals and rejects missing detail',
() async {
final gateway = FakeGateway()..reply = {};
final repo = RunsRepository(gateway);
await expectLater(
repo.getRun(3),
throwsA(isA<RunsRepositoryException>()),
);
await expectLater(
repo.decideRun(3, option: ' '),
throwsA(isA<RunsRepositoryException>()),
);
gateway.failure = const RunsRepositoryException('server refused');
await expectLater(
repo.cancelRun(3),
throwsA(predicate((error) => '$error' == 'server refused')),
);
},
);
}