Surface run-summary projection missing-run age on dw system:operator-metrics

Renders the workflow-v2 run-summary projection-lag age pair on the
operator-metrics CLI surface so HTTP-only operators can read "how long
has the worst-case run been without a run-summary projection?" — the
primary projection-lag age indicator on the run-summary path —
directly from `dw system:operator-metrics`.

`OperatorMetricsCommand::renderProjections()` is a new section that
emits two rows under "Projection lag":

Run-summary missing age:           <ms>
Oldest run-summary missing run at: <ISO-8601>

The renderer omits the entire section when the snapshot predates the
contract, so older alphas continue to render without a stray "Projection
lag" header. Existing repair-section "Oldest missing-task age" rendering
of `repair.{max_missing_run_age_ms,oldest_missing_run_started_at}`
remains unchanged — the new section reports projection lag, not the
repair-detector signal.

Pins `projections.run_summaries.oldest_missing_run_started_at` and
`projections.run_summaries.max_missing_run_age_ms` on
`schemas/output/operator-metrics.schema.json`, and adds
`test_operator_metrics_schema_pins_run_summary_missing_age_keys` plus
`test_operator_metrics_command_omits_run_summary_missing_age_when_snapshot_predates_contract`
to guard the schema declaration and the renderer fallback.

Author: durable-workflow-ops

schemas/output/operator-metrics.schema.json

@@ -145,6 +145,20 @@
             "task_dispatch_mode": { "type": ["string", "null"] }
           },
           "additionalProperties": true
+        },
+        "projections": {
+          "type": "object",
+          "properties": {
+            "run_summaries": {
+              "type": "object",
+              "properties": {
+                "oldest_missing_run_started_at": { "type": ["string", "null"] },
+                "max_missing_run_age_ms": { "type": ["integer", "null"] }
+              },
+              "additionalProperties": true
+            }
+          },
+          "additionalProperties": true
         }
       },
       "additionalProperties": true

src/Commands/SystemCommand/OperatorMetricsCommand.php

@@ -69,6 +69,7 @@ protected function execute(InputInterface $input, OutputInterface $output): int
         $this->renderTasks($output, $this->sectionArray($metrics, 'tasks'));
         $this->renderBacklog($output, $this->sectionArray($metrics, 'backlog'));
         $this->renderRepair($output, $this->sectionArray($metrics, 'repair'));
+        $this->renderProjections($output, $this->sectionArray($metrics, 'projections'));
         $this->renderWorkers($output, $this->sectionArray($metrics, 'workers'));
         $this->renderBackend($output, $this->sectionArray($metrics, 'backend'));
         $this->renderMatchingRole($output, $this->sectionArray($metrics, 'matching_role'));
@@ -221,6 +222,34 @@ private function renderRepair(OutputInterface $output, array $repair): void
         $output->writeln('');
     }
 
+    /**
+     * @param  array<string, mixed>  $projections
+     */
+    private function renderProjections(OutputInterface $output, array $projections): void
+    {
+        $runSummaries = is_array($projections['run_summaries'] ?? null) ? $projections['run_summaries'] : [];
+
+        if (! array_key_exists('max_missing_run_age_ms', $runSummaries)
+            && ! is_string($runSummaries['oldest_missing_run_started_at'] ?? null)) {
+            return;
+        }
+
+        $output->writeln('<info>Projection lag</info>');
+        if (array_key_exists('max_missing_run_age_ms', $runSummaries)) {
+            $output->writeln(sprintf(
+                '  Run-summary missing age: %d ms',
+                (int) ($runSummaries['max_missing_run_age_ms'] ?? 0),
+            ));
+        }
+        if (is_string($runSummaries['oldest_missing_run_started_at'] ?? null)) {
+            $output->writeln(sprintf(
+                '  Oldest run-summary missing run at: %s',
+                $runSummaries['oldest_missing_run_started_at'],
+            ));
+        }
+        $output->writeln('');
+    }
+
     /**
      * @param  array<string, mixed>  $workers
      */

tests/Commands/SystemCommandTest.php

@@ -539,6 +539,10 @@ public function test_operator_metrics_command_renders_rollout_safety_signals():
         self::assertStringContainsString('Oldest missing-task age: 125000 ms', $display);
         self::assertStringContainsString('Oldest missing run at:   2026-04-24T11:27:55Z', $display);
 
+        self::assertStringContainsString('Projection lag', $display);
+        self::assertStringContainsString('Run-summary missing age: 330000 ms', $display);
+        self::assertStringContainsString('Oldest run-summary missing run at: 2026-04-24T11:24:30Z', $display);
+
         self::assertStringContainsString('Required compatibility: build-2026.04.24', $display);
         self::assertStringContainsString('Active workers:         2 (2 queue scopes, 1 supporting required)', $display);
         self::assertStringNotContainsString(
@@ -788,6 +792,40 @@ public function test_operator_metrics_command_omits_dispatch_failed_age_when_sna
         self::assertStringContainsString('dispatch failed 2', $display);
     }
 
+    public function test_operator_metrics_schema_pins_run_summary_missing_age_keys(): void
+    {
+        $schema = json_decode(
+            (string) file_get_contents(__DIR__.'/../../schemas/output/operator-metrics.schema.json'),
+            true,
+            flags: JSON_THROW_ON_ERROR,
+        );
+
+        $runSummaries = $schema['properties']['operator_metrics']['properties']
+            ['projections']['properties']['run_summaries']['properties'];
+
+        self::assertSame(['string', 'null'], $runSummaries['oldest_missing_run_started_at']['type']);
+        self::assertSame(['integer', 'null'], $runSummaries['max_missing_run_age_ms']['type']);
+    }
+
+    public function test_operator_metrics_command_omits_run_summary_missing_age_when_snapshot_predates_contract(): void
+    {
+        $payload = self::operatorMetricsPayload();
+        unset($payload['operator_metrics']['projections']);
+
+        $command = new OperatorMetricsCommand();
+        $command->setServerClient(new SystemFakeClient($payload));
+
+        $tester = new CommandTester($command);
+        self::assertSame(Command::SUCCESS, $tester->execute([]));
+
+        $display = $tester->getDisplay();
+
+        self::assertStringNotContainsString('Projection lag', $display);
+        self::assertStringNotContainsString('Run-summary missing age', $display);
+        self::assertStringNotContainsString('Oldest run-summary missing run at', $display);
+        self::assertStringContainsString('Oldest missing-task age: 125000 ms', $display);
+    }
+
     public function test_operator_metrics_command_omits_activities_block_when_payload_lacks_it(): void
     {
         $payload = self::operatorMetricsPayload();
@@ -959,6 +997,12 @@ private static function operatorMetricsPayload(): array
                     'shape' => 'in_worker',
                     'task_dispatch_mode' => 'queue',
                 ],
+                'projections' => [
+                    'run_summaries' => [
+                        'oldest_missing_run_started_at' => '2026-04-24T11:24:30Z',
+                        'max_missing_run_age_ms' => 330000,
+                    ],
+                ],
             ],
         ];
     }