Repository navigation
Conversation
…ecovery A storage-owner reconciliation of a started schema change on a graph with an applied policy names no actor. It fails on main with deployment_outcome_unknown and retains a fresh admission lock, although nothing ran.
…mission Reconciling an outstanding deployment as a storage owner with no actor failed when a started schema change or a deletion touched a graph with an applied policy: the engine refused the settlement for lack of an actor, the refusal was reported as deployment_outcome_unknown, and the attempt kept a new admission lock. Nothing had run. Recovery now checks this before it takes admission and refuses with policy_denied, naming --as. The documented recovery command and the skill say when --as is needed.
There was a problem hiding this comment.
🔍 Devin Review: 2 flags
Not posted on this PR by your GitHub settings — view them in Devin Review. (Configure)
ragnorc
left a comment
There was a problem hiding this comment.
Review of #1438 at 6f563d75
Recommendation: revise before merge. The change is correct for the case it names. But the same defect remains for a named recovery caller that the policy refuses. One small change closes the whole class (B1).
What the change does
A direct cluster apply --deployment-id … --writers-stopped with no --as, on a graph with an applied policy, used to take the admission lock and then fail inside the engine. The cluster reported deployment_outcome_unknown and kept the lock, although nothing ran. Now require_recovery_actor refuses this case with policy_denied before admission. So no lock is taken and nothing changes. The docs, the skill and a release note say when --as is necessary.
Impact: an operator who follows the documented recovery gets a true refusal and a usable remedy, not a false "unknown outcome" and a lock to remove by hand.
Blocking
B1. The fix covers one cell of the class. A named caller that the policy refuses still gets a lock, and a storage owner still gets deployment_outcome_unknown.
The violated invariant: a policy refusal that is known before any effect must be reported as a refusal, before admission, with no lock. Recovery breaks it for every caller the policy refuses, not only for a caller with no actor. With this PR:
| Caller | Policy | Result at 6f563d75 |
|---|---|---|
storage owner, no --as |
graph policy installed | policy_denied, no lock (fixed) |
storage owner, --as principal:outsider |
outsider has no schema_apply |
deployment_outcome_unknown, lock held |
identity principal:manager |
has config_manage, no graph read |
policy_denied, lock held |
storage owner, --as an unpermitted actor, pending deletion |
— | policy_denied from authorize_graph_deletion after admission, lock held (code reading, execution.rs:2972) |
I showed rows 2 and 3 with a temporary test in tests/identity_recovery.rs. It used the same DEPLOYMENT_AFTER_STARTED setup as the PR test, then called reconcile_deployment with each caller:
REVIEW storage owner --as principal:outsider: code=deployment_outcome_unknown lock_held=true
message=could not prepare original settlement evidence under admission 01M7M7FAB4E99KM26T269RD1BC:
policy: policy denied: policy denied action 'schema_apply' for unknown actor 'principal:outsider'
REVIEW identity principal:manager: code=policy_denied lock_held=true
message=policy denied action 'read' for unknown actor 'principal:manager'
Row 2 is the reported symptom again (wrong code and a held lock). The only difference is that the operator typed a wrong --as. An operator who reads the new docs and passes --as with an actor that lacks schema_apply gets the same misleading result this PR removes.
Cause: the pre-admission check tests only that an actor is present. The actual decision stays in three places after admission: authorize_graph_deletion (:2972), the inline identity checks (:3114), and the engine's prepared::authorize through prepare_schema_settlement_as (:3126). The rule "policy installed and no actor refuses" is now in three places too: Omnigraph::enforce, authorize_graph_deletion and require_recovery_actor.
The PR's decision "presence only for storage owners" says that checking read up front would refuse recoveries that work today. That is correct for read. But the engine's decision for a storage owner is schema_apply with target branch main (prepared.rs:214-219). AppliedPolicies::check_graph(actor, graph, SchemaApply) evaluates the same policy engine with the same scope (authorization.rs:376-397). And open_graph installs the same policy.graph(graph) bundle that the preflight reads. So the cluster can make the complete decision before admission, not only the presence part.
Proposed fix (smaller and by construction): replace require_recovery_actor with one authorize_recovery(policy, caller, pending) that makes, for each pending graph, the exact decision the loop makes now:
- deletion (any state):
authorize_graph_deletion(read+schema_apply, actor required under policy); - started schema change, no
create: identity →read+schema_apply; storage owner → if the graph has a policy, an actor plusschema_applyonmain; - other arms: nothing.
Call it once with preflight_policy before admission. Call it again with the re-read policy after admission, in place of the call at :2972 and the inline checks at :3114-3115. The engine keeps its own gate (invariant 10), so this adds no bypass. The post-admission call matters only if the policy changes between the two reads, and the policy_digests comparison already refuses that as deployment_base_changed.
Liability: this removes one presence-only predicate and the inline identity checks, and it gives recovery one owner for "who may settle this graph". After five more recovery arms, each arm adds its rule in one function that runs before the lock. With the current shape, each new arm needs a presence rule before admission and a decision after it, and those two can drift. Please extend the temporary test above (rows 2-3, plus a deletion row) in identity_recovery.rs as the regression. Update the docs sentence too: deletion needs read as well as schema_apply.
Optional
- O1. The docs and skill say "an actor that policy permits
schema_apply". For a deletion,authorize_graph_deletionalso requiresread. Say "readandschema_apply" for deletion, or name both in one sentence. - O2. After B1, the
deployment_outcome_unknownmapping of an enginePolicyerror fromprepare_schema_settlement_as(:3126-3133) remains for the race only.prepareauthorizes before it writes anything, so a typedpolicy_deniedthere would also be true. The lock is already held at that point, so this is about the code only. It is not needed if B1 lands.
Context checked
- #1434 (one rule for policy-bundle selection) keeps
AppliedPolicies::graphas the single source that the preflight andopen_graphboth read. No conflict. - #1360 releases the lock after a converged forward apply. Recovery still keeps admission after it completes. No overlap with this refusal path.
- Forward
cluster applywithout--asprepares the schema before acceptance, and that read-only preflight refusal releases the lock. So it is not in this class, and leaving it out of scope is correct.
Validation
- Clean detached worktree at
6f563d75(merge base54ced5d3). cargo dev-nextest -E 'package(omnigraph-cluster)'(failpoints): 180/180 PR tests pass.cargo fmt --all --checkpasses.- Before/after: with
crates/omnigraph-cluster/src/deployment/execution.rsfrom54ced5d3and the PR's test,offline_recovery_reauthorizes_executor_and_preserves_original_and_fence_authorsfails atidentity_recovery.rs:318withdeployment_outcome_unknown … a policy is installed and the request names no actor(the predicted reason). At6f563d75it passes. - Temporary test
review_temp_named_unpermitted_recovery_refuses_before_admission(rows 2-3 above) fails the same way before and after the PR. I removed it and restored the worktree. Nothing pushed. - GQT does not apply: GQT does not depend on
omnigraph-cluster, and this contract is the recovery CLI/ledger boundary. The cluster's own integration test is the correct owner. - CI at
6f563d75: 28 pass, 4 skipped. - Not verified: the S3 process-kill journey, Azure. No Lance surface.
No Decision needed threads on this PR.
Review of ModernRelay#1438 (B1): the pre-admission check only tested that an actor was present, so a caller the policy refuses still took the lock: a storage owner whose --as lacks schema_apply got deployment_outcome_unknown, and an identity without graph read got policy_denied after admission. authorize_recovery now makes the complete per-graph decision that recovery made inside its loop: a deletion needs what forward deletion needs (read and schema_apply, an actor under policy); settling a started schema change needs read and schema_apply for an identity, and an actor with schema_apply on main for a storage owner on a graph with a policy, the same request the engine checks when it settles. It runs before admission and again under admission against the re-read policy, replacing the loop's checks. The engine keeps its own gate. The deletion refusal now names --as. The recovery test covers both refused named callers before and after a persisted fence, and a pending deletion.
|
Reply to the review of B1: valid, fixed in
Regression:
O1: valid, fixed in O2: not changed. As you say, after B1 that mapping is reached only if the engine's policy differs from the cluster's check, and the Devin review (5934521191): its two flags are not posted on GitHub, and its page needs a login. There is nothing here to answer. If they are posted, a later run will judge them. Gates at
Not verified: the S3 process-kill journey and Azure. PR description updated (Change, Decisions, Tests, Risks) with a |
ragnorc
left a comment
There was a problem hiding this comment.
Review of #1438 at 8084e5ac
Recommendation: ready to merge. No blocking defect in the delta. B1 and O1 of review 5934724871 are fixed by design. Two optional points follow.
This review covers the delta 6f563d75..8084e5ac (one commit, 8084e5ac, +161 −50).
Why, what, how, impact
- Why. At
6f563d75the preflight checked only that an actor was present. A named caller that the policy refuses still took the lock and ended asdeployment_outcome_unknown. - What.
authorize_recovery(policy, caller, pending)replacesrequire_recovery_actor. It is the one decision for each outstanding graph. A deletion goes throughauthorize_graph_deletion(readandschema_apply). A started schema change that is not a creation needsreadandschema_applyfor an identity. For a storage owner on a graph with an applied policy, it needs an actor withschema_applyonmain. Nothing else acts as the caller. - How. The function runs before admission against
preflight_policy(execution.rs:2956). It runs again under admission against the re-readpolicy(execution.rs:2986). The check in the deletion arm and the inline identity check in theStartedarm are gone. - Impact. Each caller that the policy refuses now gets
policy_deniedwith no lock and no change. This includes a missing--as, an unpermitted--asand an identity without graph rights. Before, the checks ran graph by graph inside the effect loop. Now every graph is decided before the first effect, so a refusal can no longer stop recovery between two graphs.
What I checked
- The cluster decision matches the engine gate. The engine settles through
prepared::authorize(crates/omnigraph/src/db/omnigraph/schema_apply/prepared.rs:214). It is called fromprepare_schema_settlementandsettle_prepared_schema(settlement.rs:110,:278). It sendsschema_applywithResourceScope::TargetBranch("main"), so the branch isNoneand the target branch ismain.AppliedPolicies::check_graph(actor, graph, SchemaApply)(authorization.rs:376) sends the same pair.open_graphinstallspolicies.graph(graph)withwith_policy, so both sides use the same bundle. The storage-owner rule therefore predicts the engine's answer exactly. The rule also holds when a settlement is already persisted (execution.rs:3140), becausesettle_prepared_schema_aschecks again. - Coverage of the arms. The arms that act as the caller are a deletion (any state, as before),
Startedwithoutcreate(settlement), andStartedwithcreate. The last one settles a creation and runs no graph action as the caller.authorize_recoveryselects exactly the first two.NotStartedwork without a create or an intent only opens the graph for catalog settlement. - Liability. The change removes two inline checks and one partial preflight, and adds one function. That is one place to decide who may recover. It keeps a second copy of the engine's gate, by design, so the refusal can come before admission. The doc comment names the scope that it mirrors (
schema_applyonmain). If the engine's settlement scope changes, this copy must change with it. The outsider row of the regression test would show such drift, because the engine refusal maps todeployment_outcome_unknown. After five more recovery arms, each one adds one branch to this single function, not a check inside the loop.
Optional
O1. The check under admission refuses while it holds the lock. The second authorize_recovery (execution.rs:2986) runs before any effect. But an error there drops the admission without release_refused_preflight, so __cluster/lock.json stays. Forward apply releases the lock on the same kind of refusal (execution.rs:1697). The deployment_base_changed refusal just before it behaves the same way, and both can happen only if the outstanding record changes between the two reads while writers are stopped. So this is not a defect today. If you keep the second call as a guard, either release the lock as forward apply does, or state in the doc comment that a refusal at that point keeps the lock. The user docs now say that a refusal "refuses … before it takes the lock and changes nothing".
O2. No regression row separates the deletion rule from the settlement rule. None of the three refused callers holds any graph action. If a later change dropped read from the deletion check, or added read to storage-owner settlement, all three rows would still pass. One more caller would pin the difference: a storage owner --as an actor with schema_apply but not read. Recovery must refuse it for the pending deletion and admit it for the started schema change.
Previous findings
- B1: fixed (see above).
- O1 (docs): fixed.
docs/user/clusters/index.mdandskills/omnigraph/references/cluster.mdnow say that a deletion needsreadandschema_applyand that settlement needsschema_apply. The release note covers every refused caller. - O2 (mapping of a
Policyerror after admission): not changed, with reasons in the author's reply. I agree. After this change the path needs the engine and cluster policies to differ, and thepolicy_digestscheck refuses that first.
There are no Decision needed threads on this PR.
Validation
- Clean detached worktree at
8084e5ac(merge base54ced5d3). - At the head:
cargo dev-nextest -E 'package(omnigraph-cluster)'(with failpoints) passes 180/180, andidentity_recoverypasses 2/2.cargo fmt --all --checkpasses. - Before/after: with
execution.rsfrom6f563d75and the new test,offline_recovery_reauthorizes_executor_and_preserves_original_and_fence_authorsfails atidentity_recovery.rs:542for the outsider row. It ends asdeployment_outcome_unknownwith "policy denied action 'schema_apply' for unknown actor 'principal:outsider'", which is the predicted reason. At8084e5acit passes. The test stops at its first failing row, so the before run does not reach the deletion phase. I checked that phase at the head only. - CI at
8084e5ac: 27 pass, 4 skipped, none failing. - GQT does not apply. The contract is cluster recovery authorization, and GQT does not reach
omnigraph-cluster. The owner iscrates/omnigraph-cluster/tests/identity_recovery.rs. - No Lance surface in the delta.
- Not verified: the S3 process-kill journey and Azure.
- I restored the temporary edits and removed the worktree. Nothing was pushed.
A storage owner --as an actor with schema_apply but not read settles a started schema change and is refused for a pending deletion, so a change that drops read from the deletion rule or adds it to settlement fails the test. The doc comment of authorize_recovery says that its check under admission keeps the lock, as every recovery exit after admission does.
|
Reply to the review of O1: partly valid. Doc comment added; the lock is not released. O2: valid. Fixed.
Gates at No decision is needed on this pull request. |
ragnorc
left a comment
There was a problem hiding this comment.
Review of #1438 at de2d9307
Recommendation: ready to merge. No blocking defect in the delta, and no new optional point. Both optional points of review 5936264444 are closed.
This review covers the delta 8084e5ac..de2d9307 (one commit, de2d9307, +70 −3: one doc comment and one test row). It replies to the author's comment.
Why, what, how, impact
- Why. Review 5936264444 asked for two things. O1: say what happens to the lock when the check under admission refuses. O2: add a test row that tells the deletion rule apart from the settlement rule.
- What. The doc comment of
authorize_recovery(execution.rs:2347) now says that the check under admission can refuse only if the outstanding record changed after the first check, and that this refusal keeps the lock.identity_recovery.rsadds a storage owner--as principal:applier. The policy gives that actorschema_applyand nothing else. - How. The test starts a schema change (
email: String?onPerson), stops it afterStartedwithDEPLOYMENT_AFTER_STARTED, and recovers it as the applier. The real engine settlement runs, andrecovery_executorsnames the applier. Then the same caller is refused before admission for the pending deletion. - Impact. No behavior change. The difference between the two rules is now pinned by a test.
What I checked
- O1, the doc comment is true.
lookup_policies(execution.rs:130) builds the policy fromstate.applied_revision. Under admission, the code compares the pending record'sresult_revision,resource_digests,schema_contractsandpolicy_digestswith the re-read state before the secondauthorize_recovery(execution.rs:2976-2990). So a changed policy is refused first, asdeployment_base_changed. With the same applied revision the policy is the same. The second check can then give a different answer only if the outstanding record's graph entries changed. - O1, keeping the lock is correct here. I agree with the author. Recovery keeps its admission on every exit after admission, success included (
execution.rs:3199, "Retain admission until explicit operator quiescence/unlock"). Forward apply is different and releases on a refused preflight (execution.rs:1697). The user doc (docs/user/clusters/index.md:276-282) talks about a policy refusal, and the first check makes that decision before the lock. So the doc sentence stays true. The doc comment was the right place for the note. - O2, the row is a real settlement. The
knowledgegraph exists, so the entry isStartedwithoutcreate, which is the arm that acts as the caller. The test passes only if the engine's own gate (prepared::authorize,schema_applyon target branchmain) admits the applier. The policy rule usestarget_branch_scope: any, so it matches that check. The new policy group does not change the earlier rows, because the applier is not inoperatorsand is not one of the refused callers. - Liability. The change adds only test setup and four lines of doc comment. The test function is long now (one function, several phases), but each phase adds one row to the existing owner. It does not add a parallel fixture.
Previous findings
- O1 (lock kept by the check under admission): closed by the doc comment, with the author's reasons.
- O2 (no row tells the deletion rule from the settlement rule): fixed.
- Everything from review 5934724871 stays as review 5936264444 recorded it.
There are no Decision needed threads on this PR.
Validation
- Clean detached worktree at
de2d9307, merge base54ced5d3. - At the head:
cargo dev-nextest -E 'binary(identity_recovery)'(with failpoints) passes 2/2. - Mutation checks with the head test file. Each mutation fails for the predicted reason:
- Remove
readfromauthorize_graph_deletion:offline_recovery_reauthorizes_executor_and_preserves_original_and_fence_authorsfails atidentity_recovery.rs:604.unwrap_errgetsOk, because the applier deletes the graph. - Add
readto the storage-owner arm ofauthorize_recovery: the same test fails atidentity_recovery.rs:495withpolicy_denied, "policy denied action 'read' on branch 'main' for actor 'principal:applier'".
- Remove
- Before: with the test file from
8084e5ac, each of the two mutations passes 2/2. So the new row is what catches them. - CI at
de2d9307: 25 pass, 4 skipped, 2 fail.Dependency Guard (cargo deny)fails on RustSec advisories that were published today (RUSTSEC-2026-0542, -0543, -0555).Cargo.lockdoes not change in this PR, and #1316 fails the same check.CI Gatefails only because of that check. The last CI run onmain(25b51992, 07:45Z) passed before the advisories were published, so this is not yet confirmed onmain. It does not come from this PR. - GQT does not apply. The contract is cluster recovery authorization, and GQT does not reach
omnigraph-cluster. The owner iscrates/omnigraph-cluster/tests/identity_recovery.rs. - No Lance surface in the delta.
- Not verified: the S3 process-kill journey and Azure.
- I restored the temporary edits and removed the worktree. Nothing was pushed.
|
Reply to the review of CI: the No decision is needed on this pull request. |
|
CI now passes on The
No review finding is open and no decision is needed. |
Summary
The documented recovery of an outstanding deployment,
omnigraph cluster apply --target <root> --deployment-id <ID> --writers-stopped,failed on a graph with an applied policy when no
--aswas given and thedeployment's schema change had started. It reported
deployment_outcome_unknownand kept a new admission lock, although nothing ran. It now refuses with
policy_denied, names--as, and does so before it takes the lock, so nothingchanges and no
force-unlockis needed before the retry.Findings queue item:
og-stress-reconcile-without-actor-reports-unknown(found by the stress workflow; not filed on GitHub). Related: #1414 / #1423.
Reproduction
On main
54ced5d3f573a45bfbe717dd2099cd1fa3b06220, the existing owner testidentity_recovery::offline_recovery_reauthorizes_executor_and_preserves_original_and_fence_authorspinned the reported behaviour. With its two actor-less steps changed to the new
contract (commit
8ae92610), it fails on main:The test reaches the reported state without S3: a deployment interrupted after
Started(cluster seamDEPLOYMENT_AFTER_STARTED) on a graph with a policy, thedead owner's lock removed, then
reconcile_deploymentasDeploymentCaller::storage_owner(None)(what the CLI passes without--as). Thestress report reached the same state by killing a served apply on an S3 root.
#1423 already replaced the engine's "almost certainly a bug" wording; the wrong
code and the retained lock remained.
Root cause
reconcile_deployment_in_store(crates/omnigraph-cluster/src/deployment/execution.rs)takes admission first. In the
GraphDeploymentState::Startedschema arm it checksgraph actions only for
DeploymentCaller::AuthenticatedIdentity, then callsprepare_schema_settlement_as(original, caller.actor()). The engine'sprepared::authorizeenforcesschema_applyand refuses a policy-bound callthat names no actor; the arm maps every error to
deployment_outcome_unknown.A graph deletion has the same need (
authorize_graph_deletionalready refusespolicy_deniedwithout an actor), but also only after admission.Change
authorize_recovery(since8084e5ac, after review): one function makes thecomplete decision recovery makes for each outstanding graph. A deletion needs
what forward deletion needs (
authorize_graph_deletion:readandschema_apply, an actor under policy). Settling a started schema change needsreadandschema_applyfor an identity, and, for a storage owner on a graphwith an applied policy, an actor that policy permits
schema_applyonmain,the same request the engine checks when it settles. It runs before admission
and again under admission against the re-read policy, in place of the loop's
former checks. So every caller the policy refuses, not only a missing actor,
gets
policy_deniedwith no lock.--as.docs/user/clusters/index.md, "Inspect and recover a deployment") and theskill (
references/cluster.md) say when--asis needed and which actions(deletion also needs
read); release note inchangelog.d/reconcile-requires-actor-under-policy.fixed.md.Decisions
contradict fix(cli)!: direct writes to a cluster graph obey its applied policy #1423, which made direct writes obey the graph's policy and refuse a
missing actor. The settlement fence is authored by the recovery actor, so the
policy has someone to judge.
the existing
policy_deniedfor an unpermitted identity in the same test. Arefusal after admission (another writer changing the ledger between the reads)
keeps the lock, as every recovery exit after admission does; the doc comment
of
authorize_recoverysays so (sincede2d9307).actor before admission. Review showed a named actor the policy refuses still
took the lock. The engine checks
schema_applywith target branchmain, andAppliedPolicies::check_graph(actor, graph, SchemaApply)makes the samerequest on the same policy bundle that
open_graphinstalls, so the clustercan decide before admission. A storage owner still needs no
read: the enginedoes not check it, and requiring it would refuse recoveries that work today.
cluster applywithout--ason a policy graph, which hasthe same identity-only preflight shape. Out of scope here.
Tests
identity_recovery::offline_recovery_reauthorizes_executor_and_preserves_original_and_fence_authors:three refused callers (storage owner with no actor, storage owner
--as principal:outsider, identityprincipal:managerwithconfig_managebut nograph action), before and after a settlement fence is persisted, now require
policy_denied(a message naming--aswhen no actor is given), no__cluster/lock.json, an unchanged ledger and unchanged graph bytes, and thepersisted fence kept. The later recovery with an actor still adopts the fence.
A new final phase interrupts a graph deletion after
Started; the same threecallers are refused before admission with no byte changed, and a permitted
actor then completes the deletion.
de2d9307: a storage owner--as principal:applier, whose only graphaction is
schema_apply, settles a second started schema change and isrefused for the pending deletion. This pins the two rules apart: with
readdropped from the deletion check, or added to storage-owner settlement, the
test fails; the earlier rows pass under both changes.
execution.rsfrom6f563d75, theextended test fails at
--as principal:outsiderwithdeployment_outcome_unknown(
policy denied action 'schema_apply' for unknown actor 'principal:outsider');at
8084e5acit passes.Local gates (Linux x86_64, debug)
At
de2d9307:cargo dev-nextest -E 'package(omnigraph-cluster)'(failpoints)180/180,
cargo fmt --all --check, andcargo clippy -p omnigraph-cluster --all-targets --features failpoints -- -D warnings.The change is a test row and a doc comment. The gates below ran at
8084e5ac:cargo dev-nextest -E 'package(omnigraph-cluster)'(failpoints): 180/180.cli_cluster*and skill tests plusomnigraph-skill: 105/106. The failure,cli_cluster::managed_lifecycle_capture_and_retry_records_refuse_symlinks_without_reading_targets,fails the same way on unmodified main on this box (it runs as root).
cargo fmt --all --check,cargo dev-clippy(workspace,-D warnings),scripts/check-docs.py,scripts/check-release-note.pywith this title.typos1.50.1 ran on the changed files at6f563d75; it is not installed on the box that made8084e5ac, so CI owns it there.omnigraph-cluster, and DSTuses only its lease protocol. CI runs both.
Risks and what was not verified
(none should have: the engine refused it) is now refused earlier. A recovery of
graph creation or of a not-started query-only change is unaffected. A deletion
without an actor was already refused
policy_denied; it is now refused beforethe lock is taken.
--aslacksschema_apply, an identity without graphreadorschema_apply, a deletioncaller without
read) was refused after admission and kept the lock; it is nowrefused before admission. A permitted caller's recovery is unchanged.
Workflow run: run-wf-reproduce-modernrelay-omnigraph-issue-20261117T0632Z-631735
Response run: run-wf-respond-modernrelay-omnigraph-pr-20261117T0747Z-978ecf
Response run: run-wf-respond-modernrelay-omnigraph-pr-20261117T1002Z-d9202d
Response run: run-wf-respond-modernrelay-omnigraph-pr-20261117T1222Z-8b9507
Response run: run-wf-respond-modernrelay-omnigraph-pr-20261117T1327Z-eaa5a3