Derive Waterline list badges from actionability

Author: durable-workflow-ops

app/Support/ActionabilityContract.php

@@ -132,6 +132,8 @@ private static function runActionability(array $payload): array
             default => 'not_needed',
         };
 
+        $taskProblem = ($payload['task_problem'] ?? false) === true;
+
         return [
             'schema' => self::SCHEMA,
             'version' => self::VERSION,
@@ -140,9 +142,13 @@ private static function runActionability(array $payload): array
             'blocked_reason' => $blockedReason,
             'status_bucket' => $statusBucket,
             'closed_reason' => $closedReason,
-            'task_problem' => ($payload['task_problem'] ?? false) === true,
+            'task_problem' => $taskProblem,
             'diagnostic_only_evidence' => self::hasDiagnosticOnlyEvidence($payload),
             'actions' => self::runActions($payload, $repairState, $blockedReason),
+            'badges' => [
+                'repair' => self::repairBadge($repairState, $blockedReason),
+                'task_problem' => self::taskProblemBadge($taskProblem),
+            ],
         ];
     }
 
@@ -192,6 +198,63 @@ private static function repairBlockedReason(string $repairState, ?string $blocke
         };
     }
 
+    /**
+     * @return array{code: ?string, label: string, description: string, tone: string, badge_visible: bool, derived_from: string}
+     */
+    private static function repairBadge(string $repairState, ?string $blockedReason): array
+    {
+        $reason = self::repairBlockedReason($repairState, $blockedReason);
+
+        return [
+            'code' => $reason,
+            'label' => match ($reason) {
+                'unsupported_history' => 'Replay Blocked',
+                'selected_run_not_current' => 'Run Not Current',
+                'run_closed' => 'Run Closed',
+                'waiting_for_compatible_worker' => 'Compatibility Wait',
+                'repair_not_needed' => 'Repair Not Needed',
+                'repair_state_unknown' => 'Repair Unknown',
+                default => $repairState === 'repairable' ? 'Repairable' : 'Repair Blocked',
+            },
+            'description' => match ($reason) {
+                'unsupported_history' => 'Repair is blocked because only unsupported diagnostic history remains.',
+                'selected_run_not_current' => 'Repair is blocked because the selected run is not the current active run.',
+                'run_closed' => 'Repair is blocked because the run is already closed.',
+                'waiting_for_compatible_worker' => 'Repair is waiting for an active compatible worker.',
+                'repair_not_needed' => 'Repair is not needed for this run.',
+                'repair_state_unknown' => 'Waterline has not classified this run as repairable yet.',
+                default => $repairState === 'repairable'
+                    ? 'This run has an actionable durable repair source.'
+                    : 'Repair is currently blocked.',
+            },
+            'tone' => match ($reason) {
+                'unsupported_history', 'selected_run_not_current', 'run_closed' => 'dark',
+                'waiting_for_compatible_worker', 'repair_state_unknown' => 'warning',
+                'repair_not_needed' => 'secondary',
+                default => $repairState === 'repairable' ? 'success' : 'secondary',
+            },
+            'badge_visible' => $repairState === 'blocked',
+            'derived_from' => 'repair_state',
+        ];
+    }
+
+    /**
+     * @return array{code: ?string, label: string, description: string, tone: string, badge_visible: bool, derived_from: string}
+     */
+    private static function taskProblemBadge(bool $taskProblem): array
+    {
+        return [
+            'code' => $taskProblem ? 'task_problem' : null,
+            'label' => $taskProblem ? 'Task Problem' : 'No Task Problem',
+            'description' => $taskProblem
+                ? 'This run recorded workflow-task problems.'
+                : 'This run has not recorded workflow-task problems.',
+            'tone' => $taskProblem ? 'warning' : 'secondary',
+            'badge_visible' => $taskProblem,
+            'derived_from' => self::SCHEMA,
+        ];
+    }
+
     /**
      * @param array<string, mixed> $payload
      */

public/app.js

@@ -1,5 +1,5 @@
 {
-    "/app.js": "/app.js?id=bbec336332163e9c26b71b93398fbf3b",
+    "/app.js": "/app.js?id=b411ae7fdc166fb6effcde55a370168f",
     "/app-dark.css": "/app-dark.css?id=64d24ee96944ffdb4b26a9be1658c1e3",
     "/app.css": "/app.css?id=d525454610dfd3c5a581fc49676f8a37",
     "/img/favicon.png": "/img/favicon.png?id=7c006241b093796d6abfa3049df93a59",

public/mix-manifest.json

@@ -244,6 +244,12 @@
             },
 
             repairBlocked(flow) {
+                const badge = this.actionabilityBadge(flow, 'repair')
+
+                if (badge) {
+                    return badge
+                }
+
                 return flow && flow.repair_blocked
                     ? flow.repair_blocked
                     : null
@@ -278,11 +284,24 @@
             },
 
             taskProblem(flow) {
+                const badge = this.actionabilityBadge(flow, 'task_problem')
+
+                if (badge) {
+                    return badge
+                }
+
                 return flow && flow.task_problem_badge
                     ? flow.task_problem_badge
                     : null
             },
 
+            actionabilityBadge(flow, name) {
+                const actionability = flow && flow.actionability ? flow.actionability : null
+                const badges = actionability && actionability.badges ? actionability.badges : null
+
+                return badges && badges[name] ? badges[name] : null
+            },
+
             showCompatibilityEntryBadge(flow) {
                 return flow && flow.declared_entry_mode === 'compatibility'
             },

resources/js/screens/flows/flow-row.vue

@@ -951,8 +951,17 @@ public function testV2ListResponseItemsMatchTypedListItemContract(): void
         $this->assertFalse($item['actionability']['actions']['repair']['allowed']);
         $this->assertSame('unsupported_history', $item['actionability']['actions']['repair']['reason']);
         $this->assertSame('repair_state', $item['actionability']['actions']['repair']['derived_from']);
+        $this->assertSame('unsupported_history', $item['actionability']['badges']['repair']['code']);
+        $this->assertSame('Replay Blocked', $item['actionability']['badges']['repair']['label']);
+        $this->assertSame('dark', $item['actionability']['badges']['repair']['tone']);
+        $this->assertTrue($item['actionability']['badges']['repair']['badge_visible']);
+        $this->assertSame('repair_state', $item['actionability']['badges']['repair']['derived_from']);
         $this->assertTrue($item['task_problem']);
         $this->assertIsArray($item['task_problem_badge']);
+        $this->assertSame('task_problem', $item['actionability']['badges']['task_problem']['code']);
+        $this->assertSame('Task Problem', $item['actionability']['badges']['task_problem']['label']);
+        $this->assertTrue($item['actionability']['badges']['task_problem']['badge_visible']);
+        $this->assertSame('waterline.actionability', $item['actionability']['badges']['task_problem']['derived_from']);
         $this->assertSame('compatibility', $item['declared_entry_mode']);
         $this->assertSame('live_definition', $item['declared_contract_source']);
         $this->assertSame('no_required_marker', $item['compatibility_semantics']['state']);