docs(automation): declare the stranded-row carve-out on sys_automation_run's node_id and variables_json

The durable row's own declarations now agree with their writer: on the one
terminal-row class that carries a consumed suspension, node_id is the PAUSED
node (the Runs surface titles and highlights the row with it), and
variables_json is either the restorable snapshot or the store's drop notice,
which is not one. Same carve-out pattern node_type's description already
carried. The changeset names the visible Runs-surface change. Source-only.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01XpTx2tbq3pZRYAdoGt6E6Y

Author: claude

.changeset/stranded-run-status-stamp.md

@@ -37,8 +37,13 @@ repairs to how `restoreConsumedSuspension` finds a stranded run's snapshot:
   object store read that column back as the snapshot's node, so a restore
   from the row (after a restart, or on another replica) re-armed the run at
   the failed node and the next resume skipped it while reporting the run
-  completed. The throwing node stays where the Runs surface reads it: the
-  row's step log and `error`.
+  completed. The throwing node stays in the row's step log and `error`.
+  Visible on the Runs surface: `sys_automation_run`'s row title and highlight
+  set are built from `node_id` (`titleFormat '{flow_name} · {node_id}'`), so a
+  stranded run's row now names the PAUSED node — the one an operator can
+  re-arm — where it named the node that threw; ordinary completed / failed
+  rows are unchanged. The `node_id` and `variables_json` field descriptions
+  carry this carve-out, the way `node_type`'s already did.
 - The verb reads the durable row and its own per-process journal as two
   witnesses of one strand instead of trusting either alone. The hot copy is
   preferred when both describe the same pause (it is the verbatim object the

packages/services/service-automation/src/sys-automation-run.object.ts

@@ -113,11 +113,20 @@ export const SysAutomationRun = ObjectSchema.create({
 
     flow_version: Field.number({ label: 'Flow Version', required: false, group: 'Identity' }),
 
+    // [#13937] The stranded-class carve-out in this description mirrors
+    // `node_type`'s below, for the same reason: the restore verb re-arms the
+    // pause from this column (`ObjectStoreSuspendedRunStore` rebuilds the
+    // consumed snapshot's node from it — there is no other column), so on that
+    // one terminal-row class the writer (`AutomationEngine.recordLog`) puts
+    // the PAUSED node here, not the last step. This column is also what the
+    // Runs surface titles and highlights a row with (`titleFormat` /
+    // `highlightFields` above), so the carve-out is visible there too, by
+    // design: the row names the pause an operator can re-arm.
     node_id: Field.text({
       label: 'Node',
       required: false,
       maxLength: 255,
-      description: 'For a suspended run, the node it is paused at (resume continues from its out-edges); for a terminal run, the last node reached.',
+      description: 'For a suspended run, the node it is paused at (resume continues from its out-edges); for a terminal run, the last node reached — except the one class of terminal row that carries a consumed suspension (a run whose resume consumed its pause and then failed downstream, answered `status: \'stranded\'`), which keeps the PAUSED node so a restore re-arms the pause rather than the node that threw. On that row the last node reached is the final entry of steps_json and the failure is in error; the Runs surface titles the row with this column, so a stranded run reads as its pause node there.',
       group: 'State',
     }),
 
@@ -235,11 +244,16 @@ export const SysAutomationRun = ObjectSchema.create({
 
     // [#13909] The presence-discriminator named in this description lives in
     // ObjectStoreSuspendedRunStore.deserializeConsumedSuspension — one writer,
-    // one reader, this column is the key for both.
+    // one reader, this column is the key for both. [#13937] The same column
+    // carries the store's drop notice when the snapshot was over its row
+    // budget (`$consumedSuspensionDropped`, read back as
+    // `RunRecord.consumedSuspensionDropped`), so "present" now has two shapes
+    // and only one of them is a restorable snapshot — stated in the
+    // description rather than left to the reader of the column.
     variables_json: Field.textarea({
       label: 'Variables',
       required: false,
-      description: 'JSON snapshot of the flow variable map at suspend time. On a terminal row its PRESENCE is the discriminator: nothing but the consumed-suspension path writes it there, so variables_json present on a completed/failed row ⇔ the row carries a restorable suspension — the store\'s deserializer keys off exactly this.',
+      description: 'JSON snapshot of the flow variable map at suspend time. On a terminal row its PRESENCE is the discriminator: nothing but the consumed-suspension path writes it there, so variables_json present on a completed/failed row ⇔ the row\'s run had a pause that its resume consumed before a downstream node failed — the store\'s deserializer keys off exactly this. Two shapes on such a row: the snapshot itself (a restorable suspension), or a one-key notice `{"$consumedSuspensionDropped": …}` recording that the snapshot existed and was NOT persisted (over the store\'s row budget) — the notice is not a restorable snapshot; such a run can be restored only by the process that stranded it, while it runs.',
       group: 'State',
     }),