Skip to content

feat(artifacts): a validated, versioned dashboard layout package - #18705

Merged
iamwhatever merged 2 commits into
mainfrom
feat/18642-artifact-dashboard
Oct 11, 2026
Merged

iamwhatever merged 2 commits into
mainfrom
feat/18642-artifact-dashboard

Conversation

@chenmingwei23

@chenmingwei23 chenmingwei23 commented Oct 10, 2026 •

Copy link
Copy Markdown
Contributor

Problem / Motivation

Goal: an agent can store a crewmate's dashboard layout as a first-class artifact, validated on every write and versioned only when the layout actually changes.

The dynamic dashboard has no home for the thing it renders. A layout -- the data types a page declares, the blocks showing them, the theme tokens styling them, the crewmate or slot it hangs off -- has no artifact kind, so an agent would hide the package in a free-form markdown or json artifact and nothing would check it: an unknown block type, a block naming an undeclared field, a theme token whose ; closes its own CSS declaration, all handed to the page unchallenged. Versioning would be wrong both ways too: the two writers default snapshot in opposite directions.

Why it matters

The page renders whatever is stored, so the first bad package reaches a browser iframe as an empty or broken page, with no message naming the rule it broke.

Two are worse than cosmetic. A theme token that can terminate its own CSS declaration is a style-injection seam on a page whose safety argument is that the agent authors data, never code. And bound_to lives in the package, so a restore from before a rebind would hand this crewmate's page to whoever the old binding names.

Not a goal

  • No frontend: the page, its renderers and the TS Artifact['kind'] union are feat(dashboard): the Dashboard tab renders the package, with no default page #18760's.
  • No dashboard MCP tool and no CLI --kind dashboard, so nothing can mint one by hand.
  • The data-type and block catalogs ship as starter sets: this PR owns the rules, not the content.
  • No values. Data an agent writes stays in the crew log, so it cannot version a dashboard.
  • A rebind alone creates no version: bound_to says where the page hangs, not how it looks.

What changed (motivation -> approach -> change)

Goal: give a layout a validated, versioned home. The gate sits at the one choke point every write passes through -- ArtifactStore.create and .update -- rather than at each caller, which would be three places to keep in step and a fourth caller away from a hole.

  • artifact_store/dashboard_package.py (new, 801 lines) owns the shape and the rules. A package is {kind, bound_to, model{types}, view{blocks}, theme{tokens, css?}}, and each field's source is REQUIRED -- {"fold", "path"} or {"agentic": true} -- because it decides whether an agent may write that field: a default would make a whole page agent-writable.
  • artifact_store/rules.py adds "dashboard" to ALLOWED_KINDS and deliberately NOT to USER_SELECTABLE_KINDS: a prose document hand-flipped to it would hold content no reader can parse.
  • artifacts.py calls the gate from create and update. create also refuses a source_path: a linked file is re-read from disk on every get, so an edit outside the store would reach the page unchecked.
  • layout_changed() compares the canonical model + view + theme, and the store overrides the caller's snapshot either way, making both defaults correct. revert_package() takes those three from the target version and keeps the LIVE bound_to, so a rollback past a rebind cannot move the page.
  • Three refusals sit where they cannot be bypassed: the stored-form byte cap in dump_package, an unpaired surrogate in parse_package, and JSON too deep to decode. A source's fold NAME is checked against the manifest's own FOLD_NAMES, shared not copied. Reasoning in a comment below.

Not dashboard_templates/instance.py: that store is keyed by a TEMPLATE -- template_id, template_version, the copied manifest -- so a Model/View package has no template to copy and no manifest its parity check can read, and would sit there as opaque content. The harm that leaves is the one above: an unvalidated package reaching a page. drop-templates also retires that store. First non-test caller: dashboard_save in #18851 (mcp_panel.py tool, api_dashboard_save route), landing in this stack: #18705 -> #18707 -> #18784 -> #18760 -> #18847 -> #18851.

Every public symbol here has a caller here. Why the package's field types are deliberately NOT manifest.FIELD_TYPES is in a comment below.

Backwards compatibility

Compatible: "dashboard" is a kind main does not accept, so the validator can only refuse writes that are already impossible.

Tightened, once, and this is the only one. ArtifactStore.update validates event_type ahead of its first side effect rather than inside the version block. Two consequences, the second a behaviour change.

A refusal raised from the version block arrives after the content token has rotated, current.html has been replaced and the comment anchors rescanned -- a 400 for a write that already landed, with no version entry naming it. This diff makes that reachable on a new path, because a dashboard layout change FORCES the snapshot on.

Outside the version block, an event_type that is not a real lifecycle event is now refused on EVERY update, where a write that happens not to version used to skip the check and accept it silently. None is unchanged and still means "decide from the actor". The app's writers are unaffected: the website client types the field to 'edited' | 'iterated' | 'reverted' and the MCP tool sends "reverted".

Nothing else: the change adds a kind, a module and two call sites, and hides, deletes, renames or migrates nothing.

Tests

pytest -n 2 -q --color=no -p no:cacheprovider \
  test/test_artifact_dashboard_package.py test/test_artifacts.py \
  test/test_artifacts_refactor_store_contract.py \
  test/test_artifacts_refactor_projection_contract.py \
  test/test_artifact_comment_store.py test/test_artifact_companion.py \
  test/test_artifacts_handlers.py test/test_handlers_artifacts_coverage.py \
  test/test_mcp_artifacts.py test/test_artifact_import_parity.py
913 passed in 19.13s                     (exit 0)

test_artifact_dashboard_package.py (new) covers the kind's reachability, canonical storage, every refusal by rule, the cap on both paths, surrogates at any depth, over-deep JSON, the version rule, the revert binding and the shared fold names. Class-by-class list in a comment below.

TestARefusedWriteChangesNothing is new and was red before the move: a bogus event_type leaves content, version, content_token and events untouched; the refusal does not depend on whether the write would version; a metadata-only write is refused too; and a control covers the three event types the app sends.

Gates on the changed files all exit 0: flake8, isort --check-only, black --check, mypy, docs-lint, plus the diff-scoped gates against the base.

Manual verification

Each refusal was reproduced against the running code before its fix was written. Unfixed: 290,274 bytes stored over the cap; a theme.css surrogate raises UnicodeEncodeError through store.create, a 500; over-deep JSON raises RecursionError. Fixed, each answers ArtifactValidationError naming the rule and the JSON path.

Shown able to fail: forcing layout_changed() to return True gives 3 failed, 63 passed -- exactly the three tests asserting no version appears. Every mutation was reverted and the tree re-verified. The other mutations and the .encode("utf-8") audit are in a comment below.

Screenshots / video

N/A -- Python only; nothing under website/src/ is modified.

Related Issues

Refs #18642. Its T3 one-pager is approved.

Pattern harvest

Not generalizable: a new capability, not a fix.

Checklist

  • At most two commits (one is the norm), with a Conventional Commits title
  • Existing tests pass and new tests added for new functionality
  • Self-review completed; style guidelines followed
  • Documentation updated where applicable
  • No secrets, credentials or internal references in the diff

Contribution License Agreement

Made under Apache-2.0, per CONTRIBUTING.md.

@chenmingwei23
chenmingwei23 requested review from a team and KiroCrewCaptain as code owners October 10, 2026 03:31
@github-actions github-actions Bot added the readiness: checking Automated validation is still running label Oct 10, 2026
@github-actions

github-actions Bot commented Oct 10, 2026 •

Copy link
Copy Markdown
Contributor

UX Review (Opus 5.5) — ⏭️ skipped

Revision 741077446c281f44597601fc5da22d9027b28234 touches no user-facing surface (no changes under website/ or committed screenshots), so the UX review was skipped. Advisory — does not block merge.

@github-actions

github-actions Bot commented Oct 10, 2026 •

Copy link
Copy Markdown
Contributor

Design Review (Opus 5.5) — ✅ PASS

Design-level review of 741077446c281f44597601fc5da22d9027b28234 — updated in place on each push. A BLOCK verdict blocks PR readiness; PASS/CONCERNS are advisory.

Design-Verdict: PASS

Check that #18760's renderer accepts the same block catalog, source shapes and theme-token rules that dashboard_package.py enforces. Nothing in this PR reads them yet.

[DESIGN-REVIEWED] 7410774

Description read

[DESCRIPTION-READ] 86453b23a708fed6ac43a7539976cfa2251ca90ce8ff6dbcb9efeb2050987582

That sha256 names everything this verdict read: the PR description, plus the 1 evidence file(s) the workflow collected from it and handed this review. It covers that evidence because the media strip replaces every attachment URL with the same placeholder, so an edit swapping one attachment for another would leave the description's captured text identical while what this review judged changed. Recompute it with .github/scripts/pr-description-capture.sh over the same inputs; if it differs, the description or that evidence changed after this verdict was formed and any finding drawn from either is unproven.

@github-actions

github-actions Bot commented Oct 10, 2026 •

Copy link
Copy Markdown
Contributor

First Principles Review (Opus 5.5) — 🟡 CONCERNS

Premise-level review of 741077446c281f44597601fc5da22d9027b28234 — why this exists and whether the shipped surface is the smallest honest version. Updated in place on each push. A BLOCK verdict blocks PR readiness; PASS/CONCERNS are advisory.

First-Principles-Verdict: CONCERNS

_validate_source and _PATH_RE copy the source grammar dashboard_templates/manifest.py already enforces, and _DATA_KEYS repeats refusals that strict key checking already makes.

Not justified as shipped

  • Item 3 — duplicate of dashboard_templates/manifest.py: the docstring says "Exactly the two cases dashboard_templates.manifest already has, spelled the same way". manifest._field lines 259-279 hold that fold/path/agentic check, and _PATH_RE is a copy of manifest._PATH (line 82). I counted 2 sites for 1 grammar. FOLD_NAMES is imported, but this grammar is copied.
    Subtraction: import manifest._PATH and delete _PATH_RE. Make the fold/path branch the one manifest exports.
    Clears when: one definition of the source grammar remains.
  • Item 4 — oversized: the diff says "strict key checking would refuse them as unknown". Every key position except model.types already runs _check_keys, so _DATA_KEYS only changes the error message, and it also bans field names like value or items.
    Subtraction: delete _DATA_KEYS and _refuse_data_keys.
    Clears when: the deletion is made.
  • Item 5 — one consumer, generalized: FieldType/BlockType validator maps and the *_catalog() wrappers exist "so filling it in is a single edit". BlockType.optional is only ever {"span"}, and the cited data/INTERFACE.md does not exist.
    Subtraction: replace them with two literal dicts.
    Clears when: a second catalog source exists, or the wrappers are removed.

What this change ships

Inventory (8 items) — 4 justified

Intent: an agent stores a crewmate's dashboard layout as an artifact that is validated and versioned. ADDITION.

  1. New dashboard artifact kind, not user-selectable — justified
  2. Every dashboard write is validated and stored canonically — justified
  3. A field must say where its value comes from (fold or agentic) — duplicate of dashboard_templates/manifest.py
  4. Keys that look like values are refused with their own message — oversized
  5. Data-type and block catalogs as typed registries — one consumer, generalized
  6. Versioning follows layout changes, ignoring the caller's snapshot; revert keeps the live binding — justified
  7. An invalid event_type is now refused on every update, before any write — justified
  8. Converting to dashboard or relocating one onto a file is refused — undeclared

[FIRST-PRINCIPLES-REVIEWED] 7410774

Description read

[DESCRIPTION-READ] 967bbf512a788ffa67f77e9677a35ed3e1a20956996e8431d492ece258c267e6

That sha256 names the PR description this verdict read. Recompute it with .github/scripts/pr-description-capture.sh; if it differs, the description changed after this verdict was formed and any finding drawn from the description is unproven.

@github-actions

github-actions Bot commented Oct 10, 2026 •

Copy link
Copy Markdown
Contributor

Opus 5.5 Review — ✅ no blocking findings

Reviewed 741077446c281f44597601fc5da22d9027b28234 — this comment is updated in place on each push.

Review details

One advisory finding.

FINDING — src/kiro_crew/artifact_store/dashboard_package.py:447 — _an_object(model["types"], "model.types") runs _refuse_data_keys on the field-name map, so a model field whose NAME is value, entries, items, series and so on gets refused with "a package holds layout only". This hits real names: the built-in goal-board/work-kanban manifests already declare "entries": {"type": "number", "source": {...}}. → Fix: in _validate_model, check model.types without the data-key refusal (key-type checks only), and keep the refusal for each field's spec object.

[OPUS-REVIEWED] 7410774

Verdict parsed from the review's SHA-scoped output markers for commit 741077446c281f44597601fc5da22d9027b28234.

False positive or not applicable? A repository writer can comment:
/ai-review override fable 741077446c281f44597601fc5da22d9027b28234: <one-sentence reason>

@github-actions

github-actions Bot commented Oct 10, 2026 •

Copy link
Copy Markdown
Contributor

GPT 6.1 Review — ✅ no blocking findings

GPT 6.1 completed its review of 741077446c281f44597601fc5da22d9027b28234 and found no blocking issues.

This comment is updated in place on each push.

Review details

No findings.
[GPT-REVIEWED] 7410774

False positive or not applicable? A repository writer can comment:
/ai-review override gpt 741077446c281f44597601fc5da22d9027b28234: <one-sentence reason>

@chenmingwei23
chenmingwei23 force-pushed the feat/18642-artifact-dashboard branch from 75e221f to af22465 Compare October 10, 2026 04:32
@chenmingwei23

Copy link
Copy Markdown
Contributor Author

Disposition: the Opus 5.5 advisory finding is FIXED at the root

New head af224658428d3d257c5c4c662a5d8be62fbb33ec (previous
75e221f336cadb26f33bb76033395db792b7b59b). Still two commits; the fix is
amended into the top one.

The finding was correct and reachable. MAX_PACKAGE_BYTES = 256 * 1024
bounds a package's SIZE, and the two things come apart from its DEPTH:

>>> dp.MAX_PACKAGE_BYTES
262144
>>> payload = "[" * 200_000          # 200,000 bytes, under the cap
>>> dp.parse_package(payload)
RecursionError: maximum recursion depth exceeded while decoding a JSON array
from a unicode string          (json/decoder.py:354)

RecursionError subclasses RuntimeError, so the except ValueError arm in
parse_package never saw it. Every caller that answers an
ArtifactValidationError with a 400 -- _err(str(exc)) at
src/kiro_crew/dashboard/handlers/artifacts.py:1349, :1543, :1614, :1700,
:1734, :1848, :2011 -- lets it through instead, so
POST /api/artifacts with kind="dashboard" returned a 500 where this module
promises a 400.

Fix. parse_package gains a RecursionError arm that raises the module's
own refusal, naming the rule the way every other refusal does:

dashboard package: package: nests deeper than the JSON decoder can follow:
a layout is a few levels of objects and arrays, so this is not one

Test. test/test_artifact_dashboard_package.py::TestRejectInvalid::test_a_package_too_deep_to_decode_is_refused_not_a_crash
asserts the payload is under the byte cap and that store.create raises
ArtifactValidationError. Checked in both directions rather than only
confirmed green: with the new arm removed the test fails on the
RecursionError at json/decoder.py:354; with it, the test passes. The
suite goes 66 passed -> 67 passed, and the wider run that adds the three
artifact contract suites goes 165 passed -> 166 passed, both exit 0.

Gates re-run on this head, all exit 0: flake8, isort --check-only,
black --check, mypy (Success: no issues found in 3 source files), and the
eleven diff-scoped repository gates including comment history with its
self-test.

The other two lanes on the previous head

  • E2E (stub ACP backend, offline) was a flake, not this diff, and the
    re-run of CI run 38020856090 confirmed it: attempt 2 came back
    success. The attempt-1 failure was a gateway killed by SIGALRM
    (exit=-14) at 666s with no traceback, which stopped one spec of 329:
    website/playwright/member-memory.spec.ts:600, on
    PUT /api/memory/semantic and then POST /api/agents. That spec names no
    artifact route, and the same lane is green on main including at this PR's
    own base 950be416840623da0cda74be10e3acfee94e434f. This branch's only
    unconditional effect on the gateway is one module import, measured at
    2.3-8.5 ms.
  • First Principles Review returned CONCERNS (advisory, non-blocking). Its
    two points are answered by the shape of the stack rather than by code: the
    "zero consumers" observation is true at the bottom of a stacked series, and
    the readers arrive in the PRs stacked on this one. The field-vocabulary
    overlap with src/kiro_crew/dashboard_templates/manifest.py is a real
    question and is left for the maintainer, not absorbed into this PR.
  • GPT 6.1 Review is a provider refusal, not a finding. It needs a repository
    writer's /ai-review override gpt <head-sha>: <reason>, bound to whatever
    head is current when it is posted.

@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention and removed readiness: checking Automated validation is still running labels Oct 10, 2026
@chenmingwei23
chenmingwei23 force-pushed the feat/18642-artifact-dashboard branch from af22465 to 3cb3da4 Compare October 10, 2026 05:37
@github-actions github-actions Bot added readiness: checking Automated validation is still running readiness: action required A blocking check or review needs attention and removed readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running labels Oct 10, 2026
@chenmingwei23
chenmingwei23 force-pushed the feat/18642-artifact-dashboard branch from 3cb3da4 to f31db48 Compare October 10, 2026 06:08
@github-actions github-actions Bot added readiness: checking Automated validation is still running and removed readiness: action required A blocking check or review needs attention labels Oct 10, 2026
@chenmingwei23

Copy link
Copy Markdown
Contributor Author

Disposition: the surrogate class is FIXED at parse time, not per site

New head f31db48767d11fd89e8d949794b8b9fbca25bd81 (previous
3cb3da47004f66582707b4d57f2f597ea9721414). Two commits, as before.

The finding is correct, and it is a class rather than a site. Reproduced
against the running code: a JSON-escaped "\ud800" in theme.css reaches the
theme size check, whose css.encode("utf-8") raises
UnicodeEncodeError: 'utf-8' codec can't encode character '\ud800' in position 17: surrogates not allowed. Nothing catches it, so POST /api/artifacts
answers 500 where a bad package has to answer 400.

Patching that one line would have left the next site. So the fix is the
invariant instead: no unpaired surrogate survives parsing, in any string
anywhere in a package.

parse_package now enforces it twice, once for each way a surrogate becomes a
code point:

  • the submitted text is scanned BEFORE it is measured, because measuring it
    encodes it -- a caller inside the process can hand over a str that already
    holds the code point, with no escape for the decoder to expand;
  • the decoded object is scanned after json.loads, which is where the escape
    form \ud800 stops being six ASCII characters and becomes one.

The walk visits every string at every depth, keys as well as values, and
refuses the first it finds by its JSON path. It is iterative rather than
recursive: a package's depth is bounded only after validation, and this runs
before it, so recursion would add a second stack limit to the one
parse_package already handles.

Every encode site, enumerated and accounted for

site why it cannot raise
parse_package, submitted-size check the scan runs on the line above it
_validate_theme, CSS size check -- the finding's site inside validate_package, which parse_package calls only after the scan
dump_package, stored-size check its input is a package parse_package returned
_layout_fingerprint its input is a parsed package; its caller layout_changed parses both sides
artifacts.py _validate_content not modified by this PR; it sees the submitted text, where the escape form is six ASCII characters

The per-site guard that was in dump_package is gone, because the invariant
makes it unreachable and an unreachable guard is a guard nobody can test.

Tests, red-first

test_an_unpaired_surrogate_is_refused_wherever_it_sits is parameterised over
four positions -- a label, theme.css, a nested choices entry, and a KEY --
and asserts both the 400 and the JSON path in the message.
test_a_surrogate_written_literally_is_refused_before_the_size_check pins the
ordering against the size check.

Removing the two scan calls turns all five surrogate tests red
(5 failed); restoring them turns them green (5 passed).

A sweep over seven positions returns a 400 at every one, with nothing stored
and nothing reaching a 500:

theme.css    -> 400 package.theme.css
token value  -> 400 package.theme.tokens.--bad
a key        -> 400 package.model.types: key 'ba\ud800d'
nested list  -> 400 package.model.types.lane.choices[2]
block title  -> 400 package.view.blocks[0].title
bound_to     -> 400 package.bound_to
source path  -> 400 package.model.types.open_prs.source.path
holes: 0

Each refusal is also checked on the revert path, which parses both sides.

Suite and gates on this head

test/test_artifact_dashboard_package.py -> 66 passed (exit 0).
With the three artifact contract suites -> 165 passed (exit 0). Both under
-n 2, scratch home, --color=no.

flake8, isort --check-only, black --check and mypy
(Success: no issues found in 3 source files) all exit 0, as do the eleven
diff-scoped repository gates, comment history with its self-test first.

No override is requested for this finding. It was a real reachable defect
in code this PR adds, and it is fixed.

@iamwhatever

Copy link
Copy Markdown
Contributor

This PR adds a new dashboard artifact kind with a validator (artifact_store/dashboard_package.py), a version-on-change override and a revert path, so a layout package is checked on every write. I read the description, the production diff and the lane verdicts on head f31db48. Holding because it is a new feature with about 860 production lines (over the ~800 line bar), and the validator includes a theme-CSS injection filter, which is security-adjacent and needs a human owner. The First Principles CONCERNS on this head has no disposition yet, and it looks correct to me: nothing in production writes kind="dashboard" (the MCP tool kind enums, the CLI choices and USER_SELECTABLE_KINDS all leave it out), so the gate has zero callers today. It also flags the url( / @import substring check as a second layer behind the iframe CSP. Please answer both items, and either land this with its first writer or say why the validator should ship ahead of it. — crew-pr-reviewer

@chenmingwei23
chenmingwei23 force-pushed the feat/18642-artifact-dashboard branch from f31db48 to a3979d5 Compare October 10, 2026 09:30
@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention and removed readiness: checking Automated validation is still running labels Oct 10, 2026
@chenmingwei23
chenmingwei23 force-pushed the feat/18642-artifact-dashboard branch from d8cd133 to 06e0f4b Compare October 10, 2026 22:56
@github-actions github-actions Bot added readiness: checking Automated validation is still running readiness: action required A blocking check or review needs attention and removed readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running labels Oct 10, 2026
@chenmingwei23
chenmingwei23 force-pushed the feat/18642-artifact-dashboard branch from 06e0f4b to ca5851c Compare October 11, 2026 00:05
@github-actions github-actions Bot added readiness: checking Automated validation is still running readiness: action required A blocking check or review needs attention and removed readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running labels Oct 11, 2026
@chenmingwei23
chenmingwei23 force-pushed the feat/18642-artifact-dashboard branch from ca5851c to e310ee9 Compare October 11, 2026 00:49
@github-actions github-actions Bot added readiness: checking Automated validation is still running readiness: action required A blocking check or review needs attention and removed readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running labels Oct 11, 2026
A dynamic dashboard is stored as an artifact whose content is a JSON
package -- bound_to, model, view, theme -- and never as data. Values stay
in the crew log and reach the page through the fold / bus / controller
path, which is what lets a package stay small and version only when the
layout itself changes.

The new artifact_store.dashboard_package module owns the shape and the
rules; ArtifactStore.create / update call it, so the dashboard tool path,
the browser PATCH handler and a plain artifact_update all pass the same
gate rather than each carrying its own copy of the contract:

- the data types a model field may declare and the block types a view may
  place each live behind ONE function (data_type_catalog /
  view_block_catalog), both stubs the data and display lines fill, and an
  unknown type or an unknown key inside either is refused;
- a values-shaped key anywhere is refused naming the rule, so data cannot
  drift into the package;
- a snapshot is taken exactly when model/view/theme changed, overriding
  the caller either way: an MCP write would otherwise version every no-op
  recompose and a browser write would leave a real layout change with no
  history to revert to. bound_to is outside that comparison -- a rebind
  says where the page hangs, not what it looks like;
- a revert restores layout and keeps the LIVE bound_to, so rolling back
  past a rebind cannot hand one crewmate's page to another.

read_dashboard_model(bound_to) is the single entry point the data line
calls to learn which fields a page has a home for and which blocks
subscribe to each.

Part of #18642.
Every field in a dashboard package declares its own source: a crew-log fold
and a path into it, or the crewmate's own write. The data line reads that
declaration rather than guessing from the field name, so a value has one
home and a page cannot be fed from a fold nobody declared.

A layout change also forces a version snapshot either way, overriding the
caller: an MCP write defaults snapshot on and would version every no-op
recompose, while a browser PATCH defaults it off and would leave a real
layout change with nothing to revert to.

That forced snapshot is what makes the update path's event_type check reach
a case it could not before, so the check moves ahead of every side effect.
A rejected request must change nothing, and the content token rotation, the
current.html write and the comment-anchor rescan all run before the version
block the check used to guard. Moving it out of that block also means an
event type that is not a real lifecycle event is refused on every update
rather than only on one that versions.

Refs #18642
@chenmingwei23
chenmingwei23 force-pushed the feat/18642-artifact-dashboard branch from e310ee9 to 7410774 Compare October 11, 2026 04:45
@github-actions github-actions Bot added readiness: checking Automated validation is still running readiness: passed Eligible automated validation passed for the current revision and removed readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running labels Oct 11, 2026
@iamwhatever
iamwhatever merged commit 142fd51 into main Oct 11, 2026
102 checks passed
@iamwhatever
iamwhatever deleted the feat/18642-artifact-dashboard branch October 11, 2026 05:33
@github-actions github-actions Bot removed the readiness: passed Eligible automated validation passed for the current revision label Oct 11, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants