fix: the controls sit below the log, and ending a session greys the page
Tier S (fixes inside a boundary; chaos d8=3, no override). Two
observations from play, both about what the page says has happened.
The controls moved BELOW the log: you read what happened, then decide what
to do next. They were above it, which asks for the decision first.
And sealing now marks the WHOLE PAGE inert, not just the controls. A
greyed-out button beside a full-colour table still reads as a live game
with one broken control; the session has ended and everything on screen is
a record of it. The status line stays legible on purpose -- it is the one
thing still worth reading.
THE STUB NEEDED A BODY classList TO MAKE THAT TESTABLE. Without it "the
session visibly ended" would have been a claim about CSS with nothing
checking it, which is precisely CB-WP-0016's finding: a stub too thin to
express a failure is how the failure survives. The harness reports the
sealed page through the status channel with a NUL-separated marker --
ugly, deliberate, and documented, because widening the return type would
touch every caller for one boolean.
Both directions asserted: a `closed` reply seals the page, an `ok:
dealing` reply does NOT -- otherwise the seal test would pass for a page
that greys itself whenever it is touched, breaking `play again`.
63 render tests, 26 cb-play, check and loop-lint clean.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-06 22:38:32 +02:00
|
|
|
scenario: ground/cb-play-session
|
|
|
|
|
description: recorded by cb-play (CB-WP-0008 T02)
|
|
|
|
|
covers: []
|
|
|
|
|
provisional: false
|
|
|
|
|
provisional_owner: ''
|
|
|
|
|
provisional_raised: ''
|
|
|
|
|
ruled: ''
|
|
|
|
|
ruled_by: ''
|
|
|
|
|
ruled_note: ''
|
|
|
|
|
encodes_u_item: ''
|
CB-WP-0029: the tokens on the table — declare and register
Declaration 12 of chaos window 2, which CLOSES IT. Structural M (imports
another edition file under AM-4's budgets), chaos d8=4, no override.
Tokens.csv turns out to carry more than names. Every token has a
`quantity` -- 6 Protection, 5 Denied, 12 relation links -- and a component
count is a limit a simulation does not have unless it is told. protection
is saturating_add(1) at lib.rs:986 with no upper bound, against an edition
that ships six tokens for six players. T03 measures whether that matters
rather than assuming either way.
And `sides` is the second interesting column: Freedom and Focus/Blame are
each ONE DOUBLE-SIDED TOKEN, not two states. The engine holds Focus in a
map and Blame in a list; whether those can disagree with a single physical
token is worth checking.
T03 is shaped against a specific error: whatever it finds is a FINDING,
not a fix. A component limit the rules do not state is underdetermined and
belongs to ground-game, and the engine must not start enforcing a bound
nobody ruled. CB-WP-0023 exists because SOLVE was offered where it could
not act; inventing a limit is the same error in the other direction.
The workplan also names the window-2 verdict as DUE. Its retirement
condition was untestable throughout -- eleven declarations, zero 8s, zero
overrides -- and recording that is a change to how the loop constrains
itself, so it is its own tier-M pass rather than a task here. Named so it
is not lost between passes, which is how the ten rulings went uncollected.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-07 09:45:41 +02:00
|
|
|
seed: 3
|
fix: the controls sit below the log, and ending a session greys the page
Tier S (fixes inside a boundary; chaos d8=3, no override). Two
observations from play, both about what the page says has happened.
The controls moved BELOW the log: you read what happened, then decide what
to do next. They were above it, which asks for the decision first.
And sealing now marks the WHOLE PAGE inert, not just the controls. A
greyed-out button beside a full-colour table still reads as a live game
with one broken control; the session has ended and everything on screen is
a record of it. The status line stays legible on purpose -- it is the one
thing still worth reading.
THE STUB NEEDED A BODY classList TO MAKE THAT TESTABLE. Without it "the
session visibly ended" would have been a claim about CSS with nothing
checking it, which is precisely CB-WP-0016's finding: a stub too thin to
express a failure is how the failure survives. The harness reports the
sealed page through the status channel with a NUL-separated marker --
ugly, deliberate, and documented, because widening the return type would
touch every caller for one boolean.
Both directions asserted: a `closed` reply seals the page, an `ok:
dealing` reply does NOT -- otherwise the seal test would pass for a page
that greys itself whenever it is touched, breaking `play again`.
63 render tests, 26 cb-play, check and loop-lint clean.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-06 22:38:32 +02:00
|
|
|
setup:
|
|
|
|
|
players: 3
|
|
|
|
|
preset: standard-3p
|
|
|
|
|
patch: {}
|
|
|
|
|
commands:
|
|
|
|
|
- actor: P1
|
|
|
|
|
cmd: select_action
|
|
|
|
|
args:
|
CB-WP-0029: the tokens on the table — declare and register
Declaration 12 of chaos window 2, which CLOSES IT. Structural M (imports
another edition file under AM-4's budgets), chaos d8=4, no override.
Tokens.csv turns out to carry more than names. Every token has a
`quantity` -- 6 Protection, 5 Denied, 12 relation links -- and a component
count is a limit a simulation does not have unless it is told. protection
is saturating_add(1) at lib.rs:986 with no upper bound, against an edition
that ships six tokens for six players. T03 measures whether that matters
rather than assuming either way.
And `sides` is the second interesting column: Freedom and Focus/Blame are
each ONE DOUBLE-SIDED TOKEN, not two states. The engine holds Focus in a
map and Blame in a list; whether those can disagree with a single physical
token is worth checking.
T03 is shaped against a specific error: whatever it finds is a FINDING,
not a fix. A component limit the rules do not state is underdetermined and
belongs to ground-game, and the engine must not start enforcing a bound
nobody ruled. CB-WP-0023 exists because SOLVE was offered where it could
not act; inventing a limit is the same error in the other direction.
The workplan also names the window-2 verdict as DUE. Its retirement
condition was untestable throughout -- eleven declarations, zero 8s, zero
overrides -- and recording that is a change to how the loop constrains
itself, so it is its own tier-M pass rather than a task here. Named so it
is not lost between passes, which is how the ten rulings went uncollected.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-07 09:45:41 +02:00
|
|
|
action: INVESTIGATE
|
|
|
|
|
problem: 2
|
fix: the controls sit below the log, and ending a session greys the page
Tier S (fixes inside a boundary; chaos d8=3, no override). Two
observations from play, both about what the page says has happened.
The controls moved BELOW the log: you read what happened, then decide what
to do next. They were above it, which asks for the decision first.
And sealing now marks the WHOLE PAGE inert, not just the controls. A
greyed-out button beside a full-colour table still reads as a live game
with one broken control; the session has ended and everything on screen is
a record of it. The status line stays legible on purpose -- it is the one
thing still worth reading.
THE STUB NEEDED A BODY classList TO MAKE THAT TESTABLE. Without it "the
session visibly ended" would have been a claim about CSS with nothing
checking it, which is precisely CB-WP-0016's finding: a stub too thin to
express a failure is how the failure survives. The harness reports the
sealed page through the status channel with a NUL-separated marker --
ugly, deliberate, and documented, because widening the return type would
touch every caller for one boolean.
Both directions asserted: a `closed` reply seals the page, an `ok:
dealing` reply does NOT -- otherwise the seal test would pass for a page
that greys itself whenever it is touched, breaking `play again`.
63 render tests, 26 cb-play, check and loop-lint clean.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-06 22:38:32 +02:00
|
|
|
- actor: P2
|
|
|
|
|
cmd: select_action
|
|
|
|
|
args:
|
CB-WP-0029: the tokens on the table — declare and register
Declaration 12 of chaos window 2, which CLOSES IT. Structural M (imports
another edition file under AM-4's budgets), chaos d8=4, no override.
Tokens.csv turns out to carry more than names. Every token has a
`quantity` -- 6 Protection, 5 Denied, 12 relation links -- and a component
count is a limit a simulation does not have unless it is told. protection
is saturating_add(1) at lib.rs:986 with no upper bound, against an edition
that ships six tokens for six players. T03 measures whether that matters
rather than assuming either way.
And `sides` is the second interesting column: Freedom and Focus/Blame are
each ONE DOUBLE-SIDED TOKEN, not two states. The engine holds Focus in a
map and Blame in a list; whether those can disagree with a single physical
token is worth checking.
T03 is shaped against a specific error: whatever it finds is a FINDING,
not a fix. A component limit the rules do not state is underdetermined and
belongs to ground-game, and the engine must not start enforcing a bound
nobody ruled. CB-WP-0023 exists because SOLVE was offered where it could
not act; inventing a limit is the same error in the other direction.
The workplan also names the window-2 verdict as DUE. Its retirement
condition was untestable throughout -- eleven declarations, zero 8s, zero
overrides -- and recording that is a change to how the loop constrains
itself, so it is its own tier-M pass rather than a task here. Named so it
is not lost between passes, which is how the ten rulings went uncollected.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-07 09:45:41 +02:00
|
|
|
action: INVESTIGATE
|
|
|
|
|
problem: 2
|
fix: the controls sit below the log, and ending a session greys the page
Tier S (fixes inside a boundary; chaos d8=3, no override). Two
observations from play, both about what the page says has happened.
The controls moved BELOW the log: you read what happened, then decide what
to do next. They were above it, which asks for the decision first.
And sealing now marks the WHOLE PAGE inert, not just the controls. A
greyed-out button beside a full-colour table still reads as a live game
with one broken control; the session has ended and everything on screen is
a record of it. The status line stays legible on purpose -- it is the one
thing still worth reading.
THE STUB NEEDED A BODY classList TO MAKE THAT TESTABLE. Without it "the
session visibly ended" would have been a claim about CSS with nothing
checking it, which is precisely CB-WP-0016's finding: a stub too thin to
express a failure is how the failure survives. The harness reports the
sealed page through the status channel with a NUL-separated marker --
ugly, deliberate, and documented, because widening the return type would
touch every caller for one boolean.
Both directions asserted: a `closed` reply seals the page, an `ok:
dealing` reply does NOT -- otherwise the seal test would pass for a page
that greys itself whenever it is touched, breaking `play again`.
63 render tests, 26 cb-play, check and loop-lint clean.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-06 22:38:32 +02:00
|
|
|
- actor: P3
|
|
|
|
|
cmd: select_action
|
|
|
|
|
args:
|
CB-WP-0029: the tokens on the table — declare and register
Declaration 12 of chaos window 2, which CLOSES IT. Structural M (imports
another edition file under AM-4's budgets), chaos d8=4, no override.
Tokens.csv turns out to carry more than names. Every token has a
`quantity` -- 6 Protection, 5 Denied, 12 relation links -- and a component
count is a limit a simulation does not have unless it is told. protection
is saturating_add(1) at lib.rs:986 with no upper bound, against an edition
that ships six tokens for six players. T03 measures whether that matters
rather than assuming either way.
And `sides` is the second interesting column: Freedom and Focus/Blame are
each ONE DOUBLE-SIDED TOKEN, not two states. The engine holds Focus in a
map and Blame in a list; whether those can disagree with a single physical
token is worth checking.
T03 is shaped against a specific error: whatever it finds is a FINDING,
not a fix. A component limit the rules do not state is underdetermined and
belongs to ground-game, and the engine must not start enforcing a bound
nobody ruled. CB-WP-0023 exists because SOLVE was offered where it could
not act; inventing a limit is the same error in the other direction.
The workplan also names the window-2 verdict as DUE. Its retirement
condition was untestable throughout -- eleven declarations, zero 8s, zero
overrides -- and recording that is a change to how the loop constrains
itself, so it is its own tier-M pass rather than a task here. Named so it
is not lost between passes, which is how the ten rulings went uncollected.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-07 09:45:41 +02:00
|
|
|
action: INVESTIGATE
|
|
|
|
|
problem: 2
|
fix: the controls sit below the log, and ending a session greys the page
Tier S (fixes inside a boundary; chaos d8=3, no override). Two
observations from play, both about what the page says has happened.
The controls moved BELOW the log: you read what happened, then decide what
to do next. They were above it, which asks for the decision first.
And sealing now marks the WHOLE PAGE inert, not just the controls. A
greyed-out button beside a full-colour table still reads as a live game
with one broken control; the session has ended and everything on screen is
a record of it. The status line stays legible on purpose -- it is the one
thing still worth reading.
THE STUB NEEDED A BODY classList TO MAKE THAT TESTABLE. Without it "the
session visibly ended" would have been a claim about CSS with nothing
checking it, which is precisely CB-WP-0016's finding: a stub too thin to
express a failure is how the failure survives. The harness reports the
sealed page through the status channel with a NUL-separated marker --
ugly, deliberate, and documented, because widening the return type would
touch every caller for one boolean.
Both directions asserted: a `closed` reply seals the page, an `ok:
dealing` reply does NOT -- otherwise the seal test would pass for a page
that greys itself whenever it is touched, breaking `play again`.
63 render tests, 26 cb-play, check and loop-lint clean.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-06 22:38:32 +02:00
|
|
|
- actor: SYSTEM
|
|
|
|
|
cmd: reveal
|
|
|
|
|
args: {}
|
|
|
|
|
- actor: SYSTEM
|
|
|
|
|
cmd: resolve
|
|
|
|
|
args: {}
|
|
|
|
|
- actor: SYSTEM
|
|
|
|
|
cmd: end_round
|
|
|
|
|
args: {}
|
|
|
|
|
- actor: P1
|
|
|
|
|
cmd: select_action
|
|
|
|
|
args:
|
CB-WP-0029: the tokens on the table — declare and register
Declaration 12 of chaos window 2, which CLOSES IT. Structural M (imports
another edition file under AM-4's budgets), chaos d8=4, no override.
Tokens.csv turns out to carry more than names. Every token has a
`quantity` -- 6 Protection, 5 Denied, 12 relation links -- and a component
count is a limit a simulation does not have unless it is told. protection
is saturating_add(1) at lib.rs:986 with no upper bound, against an edition
that ships six tokens for six players. T03 measures whether that matters
rather than assuming either way.
And `sides` is the second interesting column: Freedom and Focus/Blame are
each ONE DOUBLE-SIDED TOKEN, not two states. The engine holds Focus in a
map and Blame in a list; whether those can disagree with a single physical
token is worth checking.
T03 is shaped against a specific error: whatever it finds is a FINDING,
not a fix. A component limit the rules do not state is underdetermined and
belongs to ground-game, and the engine must not start enforcing a bound
nobody ruled. CB-WP-0023 exists because SOLVE was offered where it could
not act; inventing a limit is the same error in the other direction.
The workplan also names the window-2 verdict as DUE. Its retirement
condition was untestable throughout -- eleven declarations, zero 8s, zero
overrides -- and recording that is a change to how the loop constrains
itself, so it is its own tier-M pass rather than a task here. Named so it
is not lost between passes, which is how the ten rulings went uncollected.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-07 09:45:41 +02:00
|
|
|
action: SOLVE
|
fix: the controls sit below the log, and ending a session greys the page
Tier S (fixes inside a boundary; chaos d8=3, no override). Two
observations from play, both about what the page says has happened.
The controls moved BELOW the log: you read what happened, then decide what
to do next. They were above it, which asks for the decision first.
And sealing now marks the WHOLE PAGE inert, not just the controls. A
greyed-out button beside a full-colour table still reads as a live game
with one broken control; the session has ended and everything on screen is
a record of it. The status line stays legible on purpose -- it is the one
thing still worth reading.
THE STUB NEEDED A BODY classList TO MAKE THAT TESTABLE. Without it "the
session visibly ended" would have been a claim about CSS with nothing
checking it, which is precisely CB-WP-0016's finding: a stub too thin to
express a failure is how the failure survives. The harness reports the
sealed page through the status channel with a NUL-separated marker --
ugly, deliberate, and documented, because widening the return type would
touch every caller for one boolean.
Both directions asserted: a `closed` reply seals the page, an `ok:
dealing` reply does NOT -- otherwise the seal test would pass for a page
that greys itself whenever it is touched, breaking `play again`.
63 render tests, 26 cb-play, check and loop-lint clean.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-06 22:38:32 +02:00
|
|
|
problem: 2
|
|
|
|
|
- actor: P2
|
|
|
|
|
cmd: select_action
|
|
|
|
|
args:
|
CB-WP-0029: the tokens on the table — declare and register
Declaration 12 of chaos window 2, which CLOSES IT. Structural M (imports
another edition file under AM-4's budgets), chaos d8=4, no override.
Tokens.csv turns out to carry more than names. Every token has a
`quantity` -- 6 Protection, 5 Denied, 12 relation links -- and a component
count is a limit a simulation does not have unless it is told. protection
is saturating_add(1) at lib.rs:986 with no upper bound, against an edition
that ships six tokens for six players. T03 measures whether that matters
rather than assuming either way.
And `sides` is the second interesting column: Freedom and Focus/Blame are
each ONE DOUBLE-SIDED TOKEN, not two states. The engine holds Focus in a
map and Blame in a list; whether those can disagree with a single physical
token is worth checking.
T03 is shaped against a specific error: whatever it finds is a FINDING,
not a fix. A component limit the rules do not state is underdetermined and
belongs to ground-game, and the engine must not start enforcing a bound
nobody ruled. CB-WP-0023 exists because SOLVE was offered where it could
not act; inventing a limit is the same error in the other direction.
The workplan also names the window-2 verdict as DUE. Its retirement
condition was untestable throughout -- eleven declarations, zero 8s, zero
overrides -- and recording that is a change to how the loop constrains
itself, so it is its own tier-M pass rather than a task here. Named so it
is not lost between passes, which is how the ten rulings went uncollected.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-07 09:45:41 +02:00
|
|
|
action: SOLVE
|
fix: the controls sit below the log, and ending a session greys the page
Tier S (fixes inside a boundary; chaos d8=3, no override). Two
observations from play, both about what the page says has happened.
The controls moved BELOW the log: you read what happened, then decide what
to do next. They were above it, which asks for the decision first.
And sealing now marks the WHOLE PAGE inert, not just the controls. A
greyed-out button beside a full-colour table still reads as a live game
with one broken control; the session has ended and everything on screen is
a record of it. The status line stays legible on purpose -- it is the one
thing still worth reading.
THE STUB NEEDED A BODY classList TO MAKE THAT TESTABLE. Without it "the
session visibly ended" would have been a claim about CSS with nothing
checking it, which is precisely CB-WP-0016's finding: a stub too thin to
express a failure is how the failure survives. The harness reports the
sealed page through the status channel with a NUL-separated marker --
ugly, deliberate, and documented, because widening the return type would
touch every caller for one boolean.
Both directions asserted: a `closed` reply seals the page, an `ok:
dealing` reply does NOT -- otherwise the seal test would pass for a page
that greys itself whenever it is touched, breaking `play again`.
63 render tests, 26 cb-play, check and loop-lint clean.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-06 22:38:32 +02:00
|
|
|
problem: 2
|
|
|
|
|
- actor: P3
|
|
|
|
|
cmd: select_action
|
|
|
|
|
args:
|
CB-WP-0029: the tokens on the table — declare and register
Declaration 12 of chaos window 2, which CLOSES IT. Structural M (imports
another edition file under AM-4's budgets), chaos d8=4, no override.
Tokens.csv turns out to carry more than names. Every token has a
`quantity` -- 6 Protection, 5 Denied, 12 relation links -- and a component
count is a limit a simulation does not have unless it is told. protection
is saturating_add(1) at lib.rs:986 with no upper bound, against an edition
that ships six tokens for six players. T03 measures whether that matters
rather than assuming either way.
And `sides` is the second interesting column: Freedom and Focus/Blame are
each ONE DOUBLE-SIDED TOKEN, not two states. The engine holds Focus in a
map and Blame in a list; whether those can disagree with a single physical
token is worth checking.
T03 is shaped against a specific error: whatever it finds is a FINDING,
not a fix. A component limit the rules do not state is underdetermined and
belongs to ground-game, and the engine must not start enforcing a bound
nobody ruled. CB-WP-0023 exists because SOLVE was offered where it could
not act; inventing a limit is the same error in the other direction.
The workplan also names the window-2 verdict as DUE. Its retirement
condition was untestable throughout -- eleven declarations, zero 8s, zero
overrides -- and recording that is a change to how the loop constrains
itself, so it is its own tier-M pass rather than a task here. Named so it
is not lost between passes, which is how the ten rulings went uncollected.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-07 09:45:41 +02:00
|
|
|
action: SOLVE
|
|
|
|
|
problem: 1
|
fix: the controls sit below the log, and ending a session greys the page
Tier S (fixes inside a boundary; chaos d8=3, no override). Two
observations from play, both about what the page says has happened.
The controls moved BELOW the log: you read what happened, then decide what
to do next. They were above it, which asks for the decision first.
And sealing now marks the WHOLE PAGE inert, not just the controls. A
greyed-out button beside a full-colour table still reads as a live game
with one broken control; the session has ended and everything on screen is
a record of it. The status line stays legible on purpose -- it is the one
thing still worth reading.
THE STUB NEEDED A BODY classList TO MAKE THAT TESTABLE. Without it "the
session visibly ended" would have been a claim about CSS with nothing
checking it, which is precisely CB-WP-0016's finding: a stub too thin to
express a failure is how the failure survives. The harness reports the
sealed page through the status channel with a NUL-separated marker --
ugly, deliberate, and documented, because widening the return type would
touch every caller for one boolean.
Both directions asserted: a `closed` reply seals the page, an `ok:
dealing` reply does NOT -- otherwise the seal test would pass for a page
that greys itself whenever it is touched, breaking `play again`.
63 render tests, 26 cb-play, check and loop-lint clean.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-06 22:38:32 +02:00
|
|
|
- actor: SYSTEM
|
|
|
|
|
cmd: reveal
|
|
|
|
|
args: {}
|
|
|
|
|
- actor: SYSTEM
|
|
|
|
|
cmd: resolve
|
|
|
|
|
args: {}
|
|
|
|
|
- actor: SYSTEM
|
|
|
|
|
cmd: end_round
|
|
|
|
|
args: {}
|
|
|
|
|
- actor: P1
|
|
|
|
|
cmd: select_action
|
|
|
|
|
args:
|
|
|
|
|
action: INVESTIGATE
|
|
|
|
|
problem: 3
|
|
|
|
|
- actor: P2
|
|
|
|
|
cmd: select_action
|
|
|
|
|
args:
|
CB-WP-0029: the tokens on the table — declare and register
Declaration 12 of chaos window 2, which CLOSES IT. Structural M (imports
another edition file under AM-4's budgets), chaos d8=4, no override.
Tokens.csv turns out to carry more than names. Every token has a
`quantity` -- 6 Protection, 5 Denied, 12 relation links -- and a component
count is a limit a simulation does not have unless it is told. protection
is saturating_add(1) at lib.rs:986 with no upper bound, against an edition
that ships six tokens for six players. T03 measures whether that matters
rather than assuming either way.
And `sides` is the second interesting column: Freedom and Focus/Blame are
each ONE DOUBLE-SIDED TOKEN, not two states. The engine holds Focus in a
map and Blame in a list; whether those can disagree with a single physical
token is worth checking.
T03 is shaped against a specific error: whatever it finds is a FINDING,
not a fix. A component limit the rules do not state is underdetermined and
belongs to ground-game, and the engine must not start enforcing a bound
nobody ruled. CB-WP-0023 exists because SOLVE was offered where it could
not act; inventing a limit is the same error in the other direction.
The workplan also names the window-2 verdict as DUE. Its retirement
condition was untestable throughout -- eleven declarations, zero 8s, zero
overrides -- and recording that is a change to how the loop constrains
itself, so it is its own tier-M pass rather than a task here. Named so it
is not lost between passes, which is how the ten rulings went uncollected.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-07 09:45:41 +02:00
|
|
|
action: INVESTIGATE
|
|
|
|
|
problem: 3
|
fix: the controls sit below the log, and ending a session greys the page
Tier S (fixes inside a boundary; chaos d8=3, no override). Two
observations from play, both about what the page says has happened.
The controls moved BELOW the log: you read what happened, then decide what
to do next. They were above it, which asks for the decision first.
And sealing now marks the WHOLE PAGE inert, not just the controls. A
greyed-out button beside a full-colour table still reads as a live game
with one broken control; the session has ended and everything on screen is
a record of it. The status line stays legible on purpose -- it is the one
thing still worth reading.
THE STUB NEEDED A BODY classList TO MAKE THAT TESTABLE. Without it "the
session visibly ended" would have been a claim about CSS with nothing
checking it, which is precisely CB-WP-0016's finding: a stub too thin to
express a failure is how the failure survives. The harness reports the
sealed page through the status channel with a NUL-separated marker --
ugly, deliberate, and documented, because widening the return type would
touch every caller for one boolean.
Both directions asserted: a `closed` reply seals the page, an `ok:
dealing` reply does NOT -- otherwise the seal test would pass for a page
that greys itself whenever it is touched, breaking `play again`.
63 render tests, 26 cb-play, check and loop-lint clean.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-06 22:38:32 +02:00
|
|
|
- actor: P3
|
|
|
|
|
cmd: select_action
|
|
|
|
|
args:
|
CB-WP-0029: the tokens on the table — declare and register
Declaration 12 of chaos window 2, which CLOSES IT. Structural M (imports
another edition file under AM-4's budgets), chaos d8=4, no override.
Tokens.csv turns out to carry more than names. Every token has a
`quantity` -- 6 Protection, 5 Denied, 12 relation links -- and a component
count is a limit a simulation does not have unless it is told. protection
is saturating_add(1) at lib.rs:986 with no upper bound, against an edition
that ships six tokens for six players. T03 measures whether that matters
rather than assuming either way.
And `sides` is the second interesting column: Freedom and Focus/Blame are
each ONE DOUBLE-SIDED TOKEN, not two states. The engine holds Focus in a
map and Blame in a list; whether those can disagree with a single physical
token is worth checking.
T03 is shaped against a specific error: whatever it finds is a FINDING,
not a fix. A component limit the rules do not state is underdetermined and
belongs to ground-game, and the engine must not start enforcing a bound
nobody ruled. CB-WP-0023 exists because SOLVE was offered where it could
not act; inventing a limit is the same error in the other direction.
The workplan also names the window-2 verdict as DUE. Its retirement
condition was untestable throughout -- eleven declarations, zero 8s, zero
overrides -- and recording that is a change to how the loop constrains
itself, so it is its own tier-M pass rather than a task here. Named so it
is not lost between passes, which is how the ten rulings went uncollected.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-07 09:45:41 +02:00
|
|
|
action: INVESTIGATE
|
|
|
|
|
problem: 3
|
fix: the controls sit below the log, and ending a session greys the page
Tier S (fixes inside a boundary; chaos d8=3, no override). Two
observations from play, both about what the page says has happened.
The controls moved BELOW the log: you read what happened, then decide what
to do next. They were above it, which asks for the decision first.
And sealing now marks the WHOLE PAGE inert, not just the controls. A
greyed-out button beside a full-colour table still reads as a live game
with one broken control; the session has ended and everything on screen is
a record of it. The status line stays legible on purpose -- it is the one
thing still worth reading.
THE STUB NEEDED A BODY classList TO MAKE THAT TESTABLE. Without it "the
session visibly ended" would have been a claim about CSS with nothing
checking it, which is precisely CB-WP-0016's finding: a stub too thin to
express a failure is how the failure survives. The harness reports the
sealed page through the status channel with a NUL-separated marker --
ugly, deliberate, and documented, because widening the return type would
touch every caller for one boolean.
Both directions asserted: a `closed` reply seals the page, an `ok:
dealing` reply does NOT -- otherwise the seal test would pass for a page
that greys itself whenever it is touched, breaking `play again`.
63 render tests, 26 cb-play, check and loop-lint clean.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-06 22:38:32 +02:00
|
|
|
- actor: SYSTEM
|
|
|
|
|
cmd: reveal
|
|
|
|
|
args: {}
|
|
|
|
|
- actor: SYSTEM
|
|
|
|
|
cmd: resolve
|
|
|
|
|
args: {}
|
|
|
|
|
- actor: SYSTEM
|
|
|
|
|
cmd: end_round
|
|
|
|
|
args: {}
|
|
|
|
|
- actor: P1
|
|
|
|
|
cmd: select_action
|
|
|
|
|
args:
|
CB-WP-0029: the tokens on the table — declare and register
Declaration 12 of chaos window 2, which CLOSES IT. Structural M (imports
another edition file under AM-4's budgets), chaos d8=4, no override.
Tokens.csv turns out to carry more than names. Every token has a
`quantity` -- 6 Protection, 5 Denied, 12 relation links -- and a component
count is a limit a simulation does not have unless it is told. protection
is saturating_add(1) at lib.rs:986 with no upper bound, against an edition
that ships six tokens for six players. T03 measures whether that matters
rather than assuming either way.
And `sides` is the second interesting column: Freedom and Focus/Blame are
each ONE DOUBLE-SIDED TOKEN, not two states. The engine holds Focus in a
map and Blame in a list; whether those can disagree with a single physical
token is worth checking.
T03 is shaped against a specific error: whatever it finds is a FINDING,
not a fix. A component limit the rules do not state is underdetermined and
belongs to ground-game, and the engine must not start enforcing a bound
nobody ruled. CB-WP-0023 exists because SOLVE was offered where it could
not act; inventing a limit is the same error in the other direction.
The workplan also names the window-2 verdict as DUE. Its retirement
condition was untestable throughout -- eleven declarations, zero 8s, zero
overrides -- and recording that is a change to how the loop constrains
itself, so it is its own tier-M pass rather than a task here. Named so it
is not lost between passes, which is how the ten rulings went uncollected.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-07 09:45:41 +02:00
|
|
|
action: SOLVE
|
|
|
|
|
problem: 3
|
fix: the controls sit below the log, and ending a session greys the page
Tier S (fixes inside a boundary; chaos d8=3, no override). Two
observations from play, both about what the page says has happened.
The controls moved BELOW the log: you read what happened, then decide what
to do next. They were above it, which asks for the decision first.
And sealing now marks the WHOLE PAGE inert, not just the controls. A
greyed-out button beside a full-colour table still reads as a live game
with one broken control; the session has ended and everything on screen is
a record of it. The status line stays legible on purpose -- it is the one
thing still worth reading.
THE STUB NEEDED A BODY classList TO MAKE THAT TESTABLE. Without it "the
session visibly ended" would have been a claim about CSS with nothing
checking it, which is precisely CB-WP-0016's finding: a stub too thin to
express a failure is how the failure survives. The harness reports the
sealed page through the status channel with a NUL-separated marker --
ugly, deliberate, and documented, because widening the return type would
touch every caller for one boolean.
Both directions asserted: a `closed` reply seals the page, an `ok:
dealing` reply does NOT -- otherwise the seal test would pass for a page
that greys itself whenever it is touched, breaking `play again`.
63 render tests, 26 cb-play, check and loop-lint clean.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-06 22:38:32 +02:00
|
|
|
- actor: P2
|
|
|
|
|
cmd: select_action
|
|
|
|
|
args:
|
CB-WP-0029: the tokens on the table — declare and register
Declaration 12 of chaos window 2, which CLOSES IT. Structural M (imports
another edition file under AM-4's budgets), chaos d8=4, no override.
Tokens.csv turns out to carry more than names. Every token has a
`quantity` -- 6 Protection, 5 Denied, 12 relation links -- and a component
count is a limit a simulation does not have unless it is told. protection
is saturating_add(1) at lib.rs:986 with no upper bound, against an edition
that ships six tokens for six players. T03 measures whether that matters
rather than assuming either way.
And `sides` is the second interesting column: Freedom and Focus/Blame are
each ONE DOUBLE-SIDED TOKEN, not two states. The engine holds Focus in a
map and Blame in a list; whether those can disagree with a single physical
token is worth checking.
T03 is shaped against a specific error: whatever it finds is a FINDING,
not a fix. A component limit the rules do not state is underdetermined and
belongs to ground-game, and the engine must not start enforcing a bound
nobody ruled. CB-WP-0023 exists because SOLVE was offered where it could
not act; inventing a limit is the same error in the other direction.
The workplan also names the window-2 verdict as DUE. Its retirement
condition was untestable throughout -- eleven declarations, zero 8s, zero
overrides -- and recording that is a change to how the loop constrains
itself, so it is its own tier-M pass rather than a task here. Named so it
is not lost between passes, which is how the ten rulings went uncollected.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-07 09:45:41 +02:00
|
|
|
action: SOLVE
|
|
|
|
|
problem: 3
|
fix: the controls sit below the log, and ending a session greys the page
Tier S (fixes inside a boundary; chaos d8=3, no override). Two
observations from play, both about what the page says has happened.
The controls moved BELOW the log: you read what happened, then decide what
to do next. They were above it, which asks for the decision first.
And sealing now marks the WHOLE PAGE inert, not just the controls. A
greyed-out button beside a full-colour table still reads as a live game
with one broken control; the session has ended and everything on screen is
a record of it. The status line stays legible on purpose -- it is the one
thing still worth reading.
THE STUB NEEDED A BODY classList TO MAKE THAT TESTABLE. Without it "the
session visibly ended" would have been a claim about CSS with nothing
checking it, which is precisely CB-WP-0016's finding: a stub too thin to
express a failure is how the failure survives. The harness reports the
sealed page through the status channel with a NUL-separated marker --
ugly, deliberate, and documented, because widening the return type would
touch every caller for one boolean.
Both directions asserted: a `closed` reply seals the page, an `ok:
dealing` reply does NOT -- otherwise the seal test would pass for a page
that greys itself whenever it is touched, breaking `play again`.
63 render tests, 26 cb-play, check and loop-lint clean.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-06 22:38:32 +02:00
|
|
|
- actor: P3
|
|
|
|
|
cmd: select_action
|
|
|
|
|
args:
|
|
|
|
|
action: INVESTIGATE
|
|
|
|
|
problem: 4
|
|
|
|
|
- actor: SYSTEM
|
|
|
|
|
cmd: reveal
|
|
|
|
|
args: {}
|
|
|
|
|
- actor: SYSTEM
|
|
|
|
|
cmd: resolve
|
|
|
|
|
args: {}
|
|
|
|
|
- actor: SYSTEM
|
|
|
|
|
cmd: end_round
|
|
|
|
|
args: {}
|
|
|
|
|
- actor: P1
|
|
|
|
|
cmd: select_action
|
|
|
|
|
args:
|
CB-WP-0029: the tokens on the table — declare and register
Declaration 12 of chaos window 2, which CLOSES IT. Structural M (imports
another edition file under AM-4's budgets), chaos d8=4, no override.
Tokens.csv turns out to carry more than names. Every token has a
`quantity` -- 6 Protection, 5 Denied, 12 relation links -- and a component
count is a limit a simulation does not have unless it is told. protection
is saturating_add(1) at lib.rs:986 with no upper bound, against an edition
that ships six tokens for six players. T03 measures whether that matters
rather than assuming either way.
And `sides` is the second interesting column: Freedom and Focus/Blame are
each ONE DOUBLE-SIDED TOKEN, not two states. The engine holds Focus in a
map and Blame in a list; whether those can disagree with a single physical
token is worth checking.
T03 is shaped against a specific error: whatever it finds is a FINDING,
not a fix. A component limit the rules do not state is underdetermined and
belongs to ground-game, and the engine must not start enforcing a bound
nobody ruled. CB-WP-0023 exists because SOLVE was offered where it could
not act; inventing a limit is the same error in the other direction.
The workplan also names the window-2 verdict as DUE. Its retirement
condition was untestable throughout -- eleven declarations, zero 8s, zero
overrides -- and recording that is a change to how the loop constrains
itself, so it is its own tier-M pass rather than a task here. Named so it
is not lost between passes, which is how the ten rulings went uncollected.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-07 09:45:41 +02:00
|
|
|
action: SUPPORT
|
|
|
|
|
target: P2
|
fix: the controls sit below the log, and ending a session greys the page
Tier S (fixes inside a boundary; chaos d8=3, no override). Two
observations from play, both about what the page says has happened.
The controls moved BELOW the log: you read what happened, then decide what
to do next. They were above it, which asks for the decision first.
And sealing now marks the WHOLE PAGE inert, not just the controls. A
greyed-out button beside a full-colour table still reads as a live game
with one broken control; the session has ended and everything on screen is
a record of it. The status line stays legible on purpose -- it is the one
thing still worth reading.
THE STUB NEEDED A BODY classList TO MAKE THAT TESTABLE. Without it "the
session visibly ended" would have been a claim about CSS with nothing
checking it, which is precisely CB-WP-0016's finding: a stub too thin to
express a failure is how the failure survives. The harness reports the
sealed page through the status channel with a NUL-separated marker --
ugly, deliberate, and documented, because widening the return type would
touch every caller for one boolean.
Both directions asserted: a `closed` reply seals the page, an `ok:
dealing` reply does NOT -- otherwise the seal test would pass for a page
that greys itself whenever it is touched, breaking `play again`.
63 render tests, 26 cb-play, check and loop-lint clean.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-06 22:38:32 +02:00
|
|
|
- actor: P2
|
|
|
|
|
cmd: select_action
|
|
|
|
|
args:
|
CB-WP-0029: the tokens on the table — declare and register
Declaration 12 of chaos window 2, which CLOSES IT. Structural M (imports
another edition file under AM-4's budgets), chaos d8=4, no override.
Tokens.csv turns out to carry more than names. Every token has a
`quantity` -- 6 Protection, 5 Denied, 12 relation links -- and a component
count is a limit a simulation does not have unless it is told. protection
is saturating_add(1) at lib.rs:986 with no upper bound, against an edition
that ships six tokens for six players. T03 measures whether that matters
rather than assuming either way.
And `sides` is the second interesting column: Freedom and Focus/Blame are
each ONE DOUBLE-SIDED TOKEN, not two states. The engine holds Focus in a
map and Blame in a list; whether those can disagree with a single physical
token is worth checking.
T03 is shaped against a specific error: whatever it finds is a FINDING,
not a fix. A component limit the rules do not state is underdetermined and
belongs to ground-game, and the engine must not start enforcing a bound
nobody ruled. CB-WP-0023 exists because SOLVE was offered where it could
not act; inventing a limit is the same error in the other direction.
The workplan also names the window-2 verdict as DUE. Its retirement
condition was untestable throughout -- eleven declarations, zero 8s, zero
overrides -- and recording that is a change to how the loop constrains
itself, so it is its own tier-M pass rather than a task here. Named so it
is not lost between passes, which is how the ten rulings went uncollected.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-07 09:45:41 +02:00
|
|
|
action: SUPPORT
|
|
|
|
|
target: P1
|
fix: the controls sit below the log, and ending a session greys the page
Tier S (fixes inside a boundary; chaos d8=3, no override). Two
observations from play, both about what the page says has happened.
The controls moved BELOW the log: you read what happened, then decide what
to do next. They were above it, which asks for the decision first.
And sealing now marks the WHOLE PAGE inert, not just the controls. A
greyed-out button beside a full-colour table still reads as a live game
with one broken control; the session has ended and everything on screen is
a record of it. The status line stays legible on purpose -- it is the one
thing still worth reading.
THE STUB NEEDED A BODY classList TO MAKE THAT TESTABLE. Without it "the
session visibly ended" would have been a claim about CSS with nothing
checking it, which is precisely CB-WP-0016's finding: a stub too thin to
express a failure is how the failure survives. The harness reports the
sealed page through the status channel with a NUL-separated marker --
ugly, deliberate, and documented, because widening the return type would
touch every caller for one boolean.
Both directions asserted: a `closed` reply seals the page, an `ok:
dealing` reply does NOT -- otherwise the seal test would pass for a page
that greys itself whenever it is touched, breaking `play again`.
63 render tests, 26 cb-play, check and loop-lint clean.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-06 22:38:32 +02:00
|
|
|
- actor: P3
|
|
|
|
|
cmd: select_action
|
|
|
|
|
args:
|
CB-WP-0029: the tokens on the table — declare and register
Declaration 12 of chaos window 2, which CLOSES IT. Structural M (imports
another edition file under AM-4's budgets), chaos d8=4, no override.
Tokens.csv turns out to carry more than names. Every token has a
`quantity` -- 6 Protection, 5 Denied, 12 relation links -- and a component
count is a limit a simulation does not have unless it is told. protection
is saturating_add(1) at lib.rs:986 with no upper bound, against an edition
that ships six tokens for six players. T03 measures whether that matters
rather than assuming either way.
And `sides` is the second interesting column: Freedom and Focus/Blame are
each ONE DOUBLE-SIDED TOKEN, not two states. The engine holds Focus in a
map and Blame in a list; whether those can disagree with a single physical
token is worth checking.
T03 is shaped against a specific error: whatever it finds is a FINDING,
not a fix. A component limit the rules do not state is underdetermined and
belongs to ground-game, and the engine must not start enforcing a bound
nobody ruled. CB-WP-0023 exists because SOLVE was offered where it could
not act; inventing a limit is the same error in the other direction.
The workplan also names the window-2 verdict as DUE. Its retirement
condition was untestable throughout -- eleven declarations, zero 8s, zero
overrides -- and recording that is a change to how the loop constrains
itself, so it is its own tier-M pass rather than a task here. Named so it
is not lost between passes, which is how the ten rulings went uncollected.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-07 09:45:41 +02:00
|
|
|
action: SUPPORT
|
|
|
|
|
target: P1
|
fix: the controls sit below the log, and ending a session greys the page
Tier S (fixes inside a boundary; chaos d8=3, no override). Two
observations from play, both about what the page says has happened.
The controls moved BELOW the log: you read what happened, then decide what
to do next. They were above it, which asks for the decision first.
And sealing now marks the WHOLE PAGE inert, not just the controls. A
greyed-out button beside a full-colour table still reads as a live game
with one broken control; the session has ended and everything on screen is
a record of it. The status line stays legible on purpose -- it is the one
thing still worth reading.
THE STUB NEEDED A BODY classList TO MAKE THAT TESTABLE. Without it "the
session visibly ended" would have been a claim about CSS with nothing
checking it, which is precisely CB-WP-0016's finding: a stub too thin to
express a failure is how the failure survives. The harness reports the
sealed page through the status channel with a NUL-separated marker --
ugly, deliberate, and documented, because widening the return type would
touch every caller for one boolean.
Both directions asserted: a `closed` reply seals the page, an `ok:
dealing` reply does NOT -- otherwise the seal test would pass for a page
that greys itself whenever it is touched, breaking `play again`.
63 render tests, 26 cb-play, check and loop-lint clean.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-06 22:38:32 +02:00
|
|
|
- actor: SYSTEM
|
|
|
|
|
cmd: reveal
|
|
|
|
|
args: {}
|
CB-WP-0029: the tokens on the table — declare and register
Declaration 12 of chaos window 2, which CLOSES IT. Structural M (imports
another edition file under AM-4's budgets), chaos d8=4, no override.
Tokens.csv turns out to carry more than names. Every token has a
`quantity` -- 6 Protection, 5 Denied, 12 relation links -- and a component
count is a limit a simulation does not have unless it is told. protection
is saturating_add(1) at lib.rs:986 with no upper bound, against an edition
that ships six tokens for six players. T03 measures whether that matters
rather than assuming either way.
And `sides` is the second interesting column: Freedom and Focus/Blame are
each ONE DOUBLE-SIDED TOKEN, not two states. The engine holds Focus in a
map and Blame in a list; whether those can disagree with a single physical
token is worth checking.
T03 is shaped against a specific error: whatever it finds is a FINDING,
not a fix. A component limit the rules do not state is underdetermined and
belongs to ground-game, and the engine must not start enforcing a bound
nobody ruled. CB-WP-0023 exists because SOLVE was offered where it could
not act; inventing a limit is the same error in the other direction.
The workplan also names the window-2 verdict as DUE. Its retirement
condition was untestable throughout -- eleven declarations, zero 8s, zero
overrides -- and recording that is a change to how the loop constrains
itself, so it is its own tier-M pass rather than a task here. Named so it
is not lost between passes, which is how the ten rulings went uncollected.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-07 09:45:41 +02:00
|
|
|
- actor: P1
|
|
|
|
|
cmd: respond_to_support
|
|
|
|
|
args:
|
|
|
|
|
response: accept_bond
|
|
|
|
|
- actor: P2
|
|
|
|
|
cmd: respond_to_support
|
|
|
|
|
args:
|
|
|
|
|
response: accept_bond
|
fix: the controls sit below the log, and ending a session greys the page
Tier S (fixes inside a boundary; chaos d8=3, no override). Two
observations from play, both about what the page says has happened.
The controls moved BELOW the log: you read what happened, then decide what
to do next. They were above it, which asks for the decision first.
And sealing now marks the WHOLE PAGE inert, not just the controls. A
greyed-out button beside a full-colour table still reads as a live game
with one broken control; the session has ended and everything on screen is
a record of it. The status line stays legible on purpose -- it is the one
thing still worth reading.
THE STUB NEEDED A BODY classList TO MAKE THAT TESTABLE. Without it "the
session visibly ended" would have been a claim about CSS with nothing
checking it, which is precisely CB-WP-0016's finding: a stub too thin to
express a failure is how the failure survives. The harness reports the
sealed page through the status channel with a NUL-separated marker --
ugly, deliberate, and documented, because widening the return type would
touch every caller for one boolean.
Both directions asserted: a `closed` reply seals the page, an `ok:
dealing` reply does NOT -- otherwise the seal test would pass for a page
that greys itself whenever it is touched, breaking `play again`.
63 render tests, 26 cb-play, check and loop-lint clean.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-06 22:38:32 +02:00
|
|
|
- actor: SYSTEM
|
|
|
|
|
cmd: resolve
|
|
|
|
|
args: {}
|
|
|
|
|
- actor: SYSTEM
|
|
|
|
|
cmd: end_round
|
|
|
|
|
args: {}
|
|
|
|
|
expect:
|
|
|
|
|
events: []
|
|
|
|
|
state: {}
|
|
|
|
|
rejects: []
|
CB-WP-0029: the tokens on the table — declare and register
Declaration 12 of chaos window 2, which CLOSES IT. Structural M (imports
another edition file under AM-4's budgets), chaos d8=4, no override.
Tokens.csv turns out to carry more than names. Every token has a
`quantity` -- 6 Protection, 5 Denied, 12 relation links -- and a component
count is a limit a simulation does not have unless it is told. protection
is saturating_add(1) at lib.rs:986 with no upper bound, against an edition
that ships six tokens for six players. T03 measures whether that matters
rather than assuming either way.
And `sides` is the second interesting column: Freedom and Focus/Blame are
each ONE DOUBLE-SIDED TOKEN, not two states. The engine holds Focus in a
map and Blame in a list; whether those can disagree with a single physical
token is worth checking.
T03 is shaped against a specific error: whatever it finds is a FINDING,
not a fix. A component limit the rules do not state is underdetermined and
belongs to ground-game, and the engine must not start enforcing a bound
nobody ruled. CB-WP-0023 exists because SOLVE was offered where it could
not act; inventing a limit is the same error in the other direction.
The workplan also names the window-2 verdict as DUE. Its retirement
condition was untestable throughout -- eleven declarations, zero 8s, zero
overrides -- and recording that is a change to how the loop constrains
itself, so it is its own tier-M pass rather than a task here. Named so it
is not lost between passes, which is how the ten rulings went uncollected.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-07 09:45:41 +02:00
|
|
|
state_hash: 4d108b2c07eaa63815cf9b320619c175e78317c696a8d01b1b3ac350d430b95d
|