The Black is not dice: developer statements, evidence report, and a plan that looks for the rule

- planner/knowledge.yaml: what the game's developer has said (paraphrased, dated, graded), what the Atlas does
  with each statement, and the open questions with the experiment that tests each.
- analysis/black/evidence.py -> analysis/reports/BLACK.md: counts from the runs. On the same recorded route the
  shadow shows on 21 of 79 first attempts and 1 of 80 later ones; no single route; Blue then Black after the shadow.
- game.yaml: the shadow is a guard (not a roll); what follows it is the Blue, then the Black; on-screen text for
  the squad's direction screen.
- planner/experiments.yaml v2: one exact path on every fresh account (fresh-replicate), then one choice changed
  at a time (fresh-ablate); shadow-again, second-attempt-same-path, veteran-repeat, veteran-variety; what the bot
  records about the account; the sequence to follow once the shadow shows.
- solver.js: assign() takes account facts, account offsets and cycled arms; recommendOption() answers the
  squad screen (stay + direction) in one pick.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_014jqCC2LZ4x1WHQ1V57nTsv
This commit is contained in:
ekcSchiano
2026-11-16 15:24:03 +00:00
co-authored by Claude Fable 5.2
parent 51842e1aa9
commit d01ec46fcc
19 changed files with 1588 additions and 231 deletions
+1
View File
@@ -7,6 +7,7 @@ The route planner: the best route to every dragon, and what goes back to Ken's b
| `build_policy.py` | Solves the route model (`core/atlas/solver.py`, built from the game in `core/spec/game.yaml`) for every colour and both goals ("this attempt" and "eventually"), with 200 posterior draws and a cross-fit check. Writes `data/public/policy.json`, which has a content id so each bot run can record which policy it followed. About 2 minutes. |
| `policy_report.py` | Writes the readable version, `analysis/reports/POLICY.md`. |
| `knowledge.yaml` | What the game's developer has said about the mechanics (paraphrased, dated, graded said / hint / declined), what the Atlas does with each statement, and the open questions with the experiment that tests each. |
| `experiments.yaml` | The experiment plan, written by hand: what each attempt of each bot account is for (the Black attempt on attempt 1, then the meadow Blue experiment, mapping and the sentinel route), with planned counts and stopping rules. |
| `build_experiments.py` | Checks the plan against the game, counts what the bot has logged for every arm, sets each experiment's status (running, complete, paused), and writes `data/public/experiments.json` for the bot. |
+45 -7
View File
@@ -19,6 +19,7 @@ import hashlib
import itertools
import json
import random
import re
import sys
from pathlib import Path
@@ -47,10 +48,31 @@ def check_options(where, fixed):
raise ValueError(f"{where}: '{k}' has no option '{o}' (game.yaml: {model.DECISIONS[k]})")
def arms(exp):
"""Every combination of the factors, each with the route held on every arm."""
def arms(exp, routes=None):
"""The arms of an experiment, each with the decisions it holds (`fix`): every combination of the factors, or
the explicit `arms` (one `change` to the route each), or a single arm. A `cycle` arm also carries the decisions
it varies from attempt to attempt."""
route = exp.get("route") or {}
if isinstance(route, str):
if route not in (routes or {}):
raise ValueError(f"{exp['id']}: unknown route '{route}'")
route = routes[route]
check_options(exp["id"] + " route", route)
if exp.get("arms"):
out = []
for a in exp["arms"]:
check_options(f"{exp['id']} arm {a['id']}", a.get("change"))
out.append({"id": a["id"], "change": a.get("change") or {}, "fix": {**route, **(a.get("change") or {})}})
if len({a["id"] for a in out}) != len(out):
raise ValueError(f"{exp['id']}: arm ids must be unique")
return out
if exp.get("cycle"):
for k, opts in exp["cycle"].items():
if k in route:
raise ValueError(f"{exp['id']}: '{k}' is both cycled and part of the route")
for o in opts:
check_options(exp["id"] + " cycle", {k: o})
return [{"id": "all", "fix": dict(route), "cycle": exp["cycle"]}]
factors = exp.get("factors") or {}
for k, opts in factors.items():
if k in route:
@@ -71,6 +93,11 @@ def validate(d):
if len(set(ids)) != len(ids):
raise ValueError("experiment ids must be unique")
for e in d["experiments"]:
if e.get("starts_after") and e["starts_after"] not in ids:
raise ValueError(f"{e['id']}: starts_after names no experiment")
for k in (e.get("when") or {}):
if k not in (d.get("record") or []):
raise ValueError(f"{e['id']}: when.{k} is not something the bot records (`record`)")
if e["target"] not in model.COLOURS:
raise ValueError(f"{e['id']}: unknown target {e['target']}")
if e.get("sampling", "best") not in SAMPLING:
@@ -117,14 +144,16 @@ def build(d=None, log=None):
d = d or design()
validate(d)
log = logged() if log is None else log
exps = []
exps, status_of = [], {}
for e in d["experiments"]:
m = e.get("measures")
a = arms(e)
a = arms(e, d.get("routes"))
tally = {x["id"]: {"runs": 0, "observed": 0, "rare": 0} for x in a}
for exp_id, arm, v in log:
if exp_id != e["id"]:
continue
if a[0].get("cycle"): # a cycled arm is logged under the combination it played: all one arm here
arm = a[0]["id"]
t = tally.setdefault(arm or "?", {"runs": 0, "observed": 0, "rare": 0})
t["runs"] += 1
y = model.OBSERVE[m["roll"]](v) if m and v else None
@@ -138,7 +167,9 @@ def build(d=None, log=None):
total_rare = sum(t["rare"] for t in tally.values())
status, note = "running", None
se = e.get("stop_early")
if not e.get("ongoing") and all(n >= planned for n in done.values()):
if e.get("starts_after") and status_of.get(e["starts_after"]) != "complete":
status, note = "waiting", f"starts when {e['starts_after']} is complete"
elif not e.get("ongoing") and all(n >= planned for n in done.values()):
status, note = "complete", f"every arm has its planned {planned}"
elif se and total_obs >= se["after"] and total_rare <= se["rare_at_most"]:
status = "paused"
@@ -146,18 +177,25 @@ def build(d=None, log=None):
for x in a:
t = tally[x["id"]]
x["progress"] = {**t, "planned": planned, **({"estimate": interval(t["rare"], t["observed"])} if m and t["observed"] else {})}
status_of[e["id"]] = status
exps.append({
"id": e["id"], "status": status, **({"note": note} if note else {}),
"question": e["question"], "attempts": {"from": e["attempts"]["from"], "to": e["attempts"].get("to")},
"unit": e["unit"], "share": e["share"], **({"accounts": e["accounts"]} if e.get("accounts") else {}),
**({"exclusive": True} if e.get("exclusive") else {}),
**({"when": e["when"]} if e.get("when") else {}),
"target": e["target"], "objective": e.get("objective", "eventually"), "sampling": e.get("sampling", "best"),
"seed": d["seed"], "measures": m, "burn": e.get("burn"), "arms": a,
"progress": {"runs": sum(t["runs"] for t in tally.values()), "observed": total_obs, "rare": total_rare,
**({"estimate": interval(total_rare, total_obs)} if m and total_obs else {}),
"unknownArms": sorted(k for k in tally if k not in {x["id"] for x in a})},
})
plan = {"schema": 1, "seed": d["seed"], "lifecycle": d["lifecycle"], "experiments": exps}
for s in (d.get("scripts") or {}).values():
for st in s:
for k in ("take", "never"):
re.compile(st.get(k) or "")
plan = {"schema": 2, "seed": d["seed"], "lifecycle": d["lifecycle"], "record": d.get("record") or [],
"scripts": d.get("scripts") or {}, "experiments": exps}
plan["id"] = hashlib.sha1(json.dumps(plan, sort_keys=True, separators=(",", ":")).encode()).hexdigest()[:12]
return plan
@@ -171,7 +209,7 @@ def summary(plan):
for e in plan["experiments"]:
p = e["progress"]
est = p.get("estimate")
L.append(f" {e['id']:<22} {e['status']:<9} {p['observed']} observed, {p['rare']} rare"
L.append(f" {e['id']:<26} {e['status']:<9} {p['observed']} observed, {p['rare']} rare"
+ (f" ({100 * est['rate']:.1f}%, 90% range {100 * est['lo']:.1f}-{100 * est['hi']:.1f})" if est else "")
+ (f" [{e['note']}]" if e.get("note") else ""))
return "\n".join(L)
+173 -53
View File
@@ -1,85 +1,209 @@
# The experiment plan for Ken's bot: what each attempt of each account is for.
#
# This file is the design (written by hand). planner/build_experiments.py checks it against the game
# (core/spec/game.yaml), counts what the bot has run so far, decides which experiments are still running, and
# writes data/public/experiments.json. The bot reads that file with assign() in core/solver.js. The cycle
# (python -m collection cycle) rebuilds it after every import of bot runs, so the plan follows the data:
# an experiment that reaches its planned count, or its stopping rule, stops being assigned, and its share goes
# to the others.
# (core/spec/game.yaml), counts what the bot has run so far, decides which experiments are running, and writes
# data/public/experiments.json. The bot reads that file with assign() in core/solver.js. The cycle
# (python -m collection cycle) rebuilds it after every import of bot runs, so the plan follows the data.
#
# Version 2 (2026-11-16). The developer has said the Black is not dice: it shows when a rider's choices meet its
# conditions (planner/knowledge.yaml), and riders report it almost only on a first attempt, on many different
# routes (analysis/reports/BLACK.md). So the Black experiments no longer estimate a rate. They look for the rule:
# hold one exact path fixed on fresh accounts, see whether the answer is always the same, then change one choice
# at a time. Because the answer is not dice, a few accounts per question are enough.
#
# Rules that keep the results honest:
# - counts are planned in advance; an experiment does not stop because its results look good;
# - every started attempt is logged, including aborted ones;
# - every started attempt is logged, including aborted ones, and every screen with its options and the pick;
# - the bot never accepts a bond that is not the experiment's target colour (it burns), and it does accept a
# genuine Black or Blue bond.
version: 1
seed: 20261112 # changes every arm assignment: leave it alone once accounts are running
version: 2
seed: 20261116 # changes every arm assignment: leave it alone once accounts are running
# ---------------------------------------------------------------- an account's life
lifecycle:
# attempt 1 of every new account is the Black attempt (the shadow is close to a first-attempt event), and is
# itself an experiment: first-attempt-shadow below
# attempt 1 of every new account is the Black attempt, on one exact path (fresh-replicate, then fresh-ablate)
research_days: 3 # then the account collects route data for this long (about 18 attempts at 4 hours each)
retire: true # and stops, except the long-lived accounts
long_lived: { every: 10, take: 1 } # one account in ten keeps running, so attempts past 18 are still observed
long_lived: { every: 10, take: 2 } # two accounts in ten keep running (veteran-repeat and veteran-variety)
# What the bot records about the account on every run, beyond the steps: the Black's conditions rest on choices and
# on what the site knows about the account, so anything that could be such a fact is kept.
record:
- accountSeq # the account's number, in the order the accounts were made
- accountAttempt # 1 = the account's first threshing
- accountCreatedAt # when the account was made (UTC)
- wing # the cadet's assignment, as the site shows it
- section
- squad
- sawShadowBefore # whether any earlier run of the account showed the shadow
# ---------------------------------------------------------------- named paths
routes:
# The recorded route with the most first-attempt shadows in the community form: 21 in 79 first attempts, 1 in 80
# later ones (BLACK.md section 2).
best-reported:
company: Alone
direction: West
react: Hold still
scream: Investigate the scream
clearing: Help your squadmate
fight: Pause to assess
dagger: Engage the smaller cadet
fate: Squadmate's revenge
post: West
hour: Tree
# ---------------------------------------------------------------- what to do once the shadow shows
# The sequence in the notes of riders who bonded the Black (BLACK.md section 5), as keywords of the option to
# take on each screen, in order. The bot has never seen these screens, and a shadow must not be wasted: where a
# screen matches nothing here it should stop and notify a person, not guess.
scripts:
shadow:
- { step: the tree top, take: "shadow", never: "green|descend" }
- { step: asked to turn back, take: "stay the course|certain you saw", never: "second thought|green" }
- { step: asked again, take: "intriguing|even if this kills", never: "second thought|green" }
- { step: the Blue lands, take: "freeze and lower", never: "approach|run" }
- { step: another cadet arrives, take: "hold (completely )?still", never: "warn|turn while|approach" }
- { step: the Blue burns the cadet, take: "hold (your )?position", never: "interven|approach|warn" }
- { step: the Blue judges, take: "head lowered|await.*judg", never: "approach|sure" }
- { step: the Blue has left, take: "help the .*cadet", never: "" }
- { step: the cadet's burns, take: "wrap|cut .*sleeve|dagger to cut", never: "" }
- { step: moving on, take: "head south", never: "" }
- { step: a branch snaps, take: "turn to face", never: "ignore" }
- { step: the Black, take: "hold (its|it's|the) gaze|lift your chin", never: "lower your eyes" }
# ---------------------------------------------------------------- the experiments
# attempts: which of an account's attempts it covers (from / to, inclusive; no `to` = from then on).
# unit: what is randomised. account = one arm for the account's life (needed when only attempt 1 counts);
# attempt = arms in balanced blocks within each account.
# share: when several experiments cover an attempt, how often each gets it.
# exclusive: takes every attempt it covers; the shared experiments get the rest.
# accounts: { every: N, take: K } limits it to K accounts in every N (by the order accounts were made).
# factors: decisions that are randomised; every combination is an arm. route: decisions held on every arm.
# Everything else is the advisor's best play for the target.
# sampling: best (default), thompson, or uniform (every option on the screen equally likely: mapping).
# measures: the roll and the outcome that are counted. planned_per_arm: how many observed rolls per arm.
# stop_early: pause when, after `after` observed rolls in total, at most `rare_at_most` came out rare.
# unit: what is randomised. account = one arm for the account's life; attempt = balanced blocks within an account.
# exclusive: takes every attempt it covers; the shared experiments (share) split the rest.
# accounts: { every: N, take: K, offset: J } limits it to K accounts in every N, starting at the J-th.
# when: facts about the account that must hold (from `record`).
# starts_after: waits until that experiment is complete.
# route: decisions held on every arm (a name from `routes`, or a mapping). factors: every combination is an arm.
# arms: explicit arms, each a `change` to the route (one choice at a time). cycle: a different combination of
# these decisions on every attempt, never repeating until all are used.
# measures: the roll or guard and the outcome that are counted. planned_per_arm: observed outcomes per arm.
experiments:
- id: first-attempt-shadow
question: How often does the shadow appear on an account's first attempt, and does heading West (at the start, at the fork) raise it?
- id: fresh-replicate
question: On a fresh account, does one exact path always show the shadow, sometimes, or never?
why: >
Form submissions show the shadow on 9% of first attempts and 0.3% of later ones, but form submissions
over-report it, complete logs have only 28 first attempts, and the bot has none. Among first attempts the
form shows more shadows after West (14%) than East (4%), which may be copied guide routes.
If the Black is decided by this run's choices alone, identical choices on fresh accounts must agree: all
shadow or none. If they disagree, fresh accounts differ in something the site knows and we do not record
yet, and comparing the accounts that saw it with those that did not is how to find it.
attempts: { from: 1, to: 1 }
unit: account
exclusive: true
share: 1
target: Black
objective: eventually
factors: { direction: [West, East], post: [West, East] }
route: { scream: Investigate the scream, clearing: Help your squadmate, hour: Tree }
route: best-reported
measures: { roll: shadow, rare: "yes" }
planned_per_arm: 60 # 240 accounts: 120 per level of each factor
stop_early: { after: 120, rare_at_most: 0 } # no shadow in 120 first attempts rules out 2.5% or more
planned_per_arm: 60 # if riders' 27% is three to four times too high, about 4 to 16 shadows
burn: { reason: TREE_NO_SHADOW_AUTO_BURN, when: no shadow at the tree }
- id: attempt-2-shadow
question: Is the shadow really gone after the first attempt?
why: The form shows 3 shadows in 295 second attempts (1%), then almost none.
attempts: { from: 2, to: 2 }
- id: fresh-ablate
question: Which choices on that path does the shadow need?
why: Change one choice, keep the rest. The developer hints at about five conditions, two of them the known gates.
starts_after: fresh-replicate
attempts: { from: 1, to: 1 }
unit: account
accounts: { every: 2, take: 1 }
exclusive: true
share: 1
target: Black
objective: eventually
route: { scream: Investigate the scream, clearing: Help your squadmate, hour: Tree }
route: best-reported
arms:
- { id: with one squadmate, change: { company: 1 Squadmate, leave: Stay together } }
- { id: with two squadmates, change: { company: 2 Squadmates, leave: Stay together } }
- { id: leave the squad, change: { company: 2 Squadmates, leave: Leave them } }
- { id: east first, change: { direction: East } }
- { id: centre first, change: { direction: Center } }
- { id: face the first dragon, change: { react: Respect / face it } }
- { id: charge the smaller cadet, change: { fight: Charge the smaller cadet } }
- { id: charge the bigger cadet, change: { dagger: Charge the bigger cadet anyway } }
- { id: kill the bullies, change: { fate: Killed the bullies yourself } }
- { id: leave the bullies, change: { fate: Left bullies to the dragons } }
- { id: fork to the forest, change: { post: Forest } }
- { id: fork east, change: { post: East } }
measures: { roll: shadow, rare: "yes" }
planned_per_arm: 120
planned_per_arm: 15 # set from fresh-replicate: enough that "none" is not bad luck at the rate found there
burn: { reason: TREE_NO_SHADOW_AUTO_BURN, when: no shadow at the tree }
- id: shadow-again
question: Does an account that saw the shadow, and died, see it again on the same path?
why: The cleanest test of fresh against veteran. About three in ten riders who reach the Black die there.
attempts: { from: 2, to: 4 }
when: { sawShadowBefore: true }
unit: account
exclusive: true
share: 1
target: Black
route: best-reported
measures: { roll: shadow, rare: "yes" }
planned_per_arm: 12
burn: { reason: TREE_NO_SHADOW_AUTO_BURN, when: no shadow at the tree }
- id: second-attempt-same-path
question: Does an account that missed on its first attempt miss again on the same path?
why: The form shows 21 in 79 on first attempts and 1 in 80 later on this route; the bot can check it on identical paths.
attempts: { from: 2, to: 2 }
when: { sawShadowBefore: false }
accounts: { every: 2, take: 1, offset: 0 }
unit: account
exclusive: true
share: 1
target: Black
route: best-reported
measures: { roll: shadow, rare: "yes" }
planned_per_arm: 60
burn: { reason: TREE_NO_SHADOW_AUTO_BURN, when: no shadow at the tree }
- id: veteran-repeat
question: Does an older account open up by repeating one path?
why: >
The developer says a run never hurts and names twenty as a count that matters. No bot account has repeated
one route more than 11 times in a row.
attempts: { from: 3 }
when: { sawShadowBefore: false }
accounts: { every: 10, take: 1, offset: 0 }
unit: account
exclusive: true
share: 1
target: Black
route: best-reported
measures: { roll: shadow, rare: "yes" }
planned_per_arm: 300
burn: { reason: TREE_NO_SHADOW_AUTO_BURN, when: no shadow at the tree }
- id: veteran-variety
question: Does an older account open up by varying its choices?
why: The opposite of veteran-repeat, on the next account. A different combination every attempt, both gates kept.
attempts: { from: 3 }
when: { sawShadowBefore: false }
accounts: { every: 10, take: 1, offset: 1 }
unit: account
exclusive: true
share: 1
target: Black
route: { scream: Investigate the scream, clearing: Help your squadmate, hour: Tree }
cycle:
company: [Alone, 1 Squadmate, 2 Squadmates]
direction: [West, East, Center]
fight: [Pause to assess, Charge the smaller cadet, Charge between the bigger cadet and your squadmate]
dagger: [Engage the smaller cadet, Charge the bigger cadet anyway]
fate: [Killed the bullies yourself, Squadmate's revenge, Left bullies to the dragons]
post: [Forest, West, East]
measures: { roll: shadow, rare: "yes" }
planned_per_arm: 300
burn: { reason: TREE_NO_SHADOW_AUTO_BURN, when: no shadow at the tree }
- id: meadow-blue-route
question: Does anything before the meadow change how often the Blue waits there?
why: >
Complete logs show a Blue on about 10% of meadow visits whatever the route, from routes the bot's rules chose.
Random assignment is what can confirm that the route does not matter (or find the route where it does).
The developer says the Blue is dice from the seed. Complete logs show a Blue on about 10% of meadow visits
whatever the route; random assignment confirms it or finds the scene where the odds differ.
attempts: { from: 2 }
unit: attempt
share: 0.6
share: 0.5
target: Blue
objective: eventually
factors: { scream: [Investigate the scream, Keep walking], direction: [West, East, Center] }
route: { hour: Valley, valley: Pass the Red (meadow) }
measures: { roll: meadow, rare: Blue }
@@ -87,28 +211,24 @@ experiments:
burn: { reason: MEADOW_NO_BLUE_AUTO_BURN, when: no Blue in the meadow }
- id: mapping
question: What does every branch of the valley lead to?
why: Probabilities for every path to every dragon need runs on the paths nobody chooses.
question: What does every option on every screen lead to?
why: Probabilities for every path need runs on the paths nobody chooses. The game has about 24 million paths, so this maps screens, not paths.
attempts: { from: 2 }
unit: attempt
share: 0.25
share: 0.35
target: Blue
objective: eventually
sampling: uniform
planned_per_arm: 600
planned_per_arm: 1000
burn: { reason: NOT_TARGET_AUTO_BURN, when: the encounter is not a Blue or a Black }
- id: sentinel
question: Have the game's odds changed?
why: >
One fixed route, run all the time, by accounts that log everything: a change in its rates is a change in the
game, not in who reports. It is the most-logged meadow route.
why: One fixed route, run all the time by accounts that log everything. It is the most-logged meadow route.
attempts: { from: 2 }
unit: attempt
share: 0.15
target: Blue
objective: eventually
route: { company: Alone, direction: Center, scream: Keep walking, wounded: Tourniquet, hour: Valley, valley: Pass the Red (meadow) }
measures: { roll: meadow, rare: Blue }
ongoing: true # never completes
ongoing: true
burn: { reason: MEADOW_NO_BLUE_AUTO_BURN, when: no Blue in the meadow }
+171
View File
@@ -0,0 +1,171 @@
# What the game's developer has said about how Dragonkind works, and what the Atlas does with each statement.
#
# Source: the developer's answers in a community Discord channel, forwarded there between 2026-10-19 and
# 2026-11-13 and exported on 2026-11-16. The export is private raw data (never committed: data/raw/). The
# statements below are paraphrased, with the date of the original message; no member is named.
#
# strength: said the developer stated it plainly
# hint said indirectly, or with a caveat ("I think", "maybe", a number offered half-seriously)
# declined the developer refused to answer (the community's "taps the sign"); recorded so that nobody
# reads a refusal as a yes or a no
# use: what in the Atlas depends on it. `open` lists what is still unknown and the experiment that tests it
# (planner/experiments.yaml). analysis/reports/BLACK.md is what the runs themselves show.
version: 1
engine:
- id: deterministic-engine
date: 2026-10-29
strength: said
statement: >
The game is a seeded, guarded, acyclic, deterministic transition system. The scene a reader stands in is a
function of the story and the path so far; the choices offered are a function of the story, the path, the
run's seed, and facts the site knows about the account. A run is deterministic once its seed is fixed.
use: The route model's rolls are fixed constants per scene, not quantities that drift; the game is a tree.
- id: seed
date: 2026-10-21
strength: said
statement: >
Each run gets a new id from the database; a keyed hash of it is the run's seed, the source of all the run's
randomness. The dice are in effect thrown before the first choice. The seed cannot be seen or influenced
from the browser, and neither time of day nor timing matters.
use: No experiment varies time of day or timing. Nothing a rider does before a run changes its dice.
- id: draws
date: 2026-11-04
strength: said
statement: A scene that uses the seed carries a chance out of 10,000 of an event.
use: Each roll is one fixed number per scene. Pooling a roll across routes that reach the same scene is right.
- id: one-in-twenty
date: 2026-10-19
strength: said
statement: No single event has worse than 1-in-20 odds; rare outcomes come from several events stacking.
use: >
A roll estimated below 5% is suspect: either several events are being counted as one, or it is not a roll.
The shadow (0.07% on later attempts) is the case in point: it is not a roll (see black/not-random).
- id: facts
date: 2026-10-21
strength: said
statement: >
The "facts" are what a web server knows about the request and the account. Neither part of the email address
is one. The site keeps little about readers, collects no analytics and does not fingerprint.
use: The bot records what it can see of the account on every run (planner/experiments.yaml, `record`).
- id: runs-remembered
date: 2026-10-29
strength: said
statement: A run is a small database entry and there is no reason ever to forget one.
use: An account's earlier runs can be among the facts. The bot keeps every account's full history.
- id: choice-order
date: 2026-10-25
strength: said
statement: The order of the choices on a screen is shuffled by the seed and belongs to the interface, not the engine.
use: Screen position is never analysed; options are matched by their text.
- id: size
date: 2026-10-25
strength: said
statement: There are about 24 million distinct paths; random play is bad at bonding.
use: Mapping cannot enumerate paths. It records each screen's options and where each leads.
- id: no-squad-bias
date: 2026-10-29
strength: said
statement: There is no squad bias toward the ability to bond anything.
use: Wing, section and squad are recorded but not expected to matter (BLACK.md section 3 agrees).
blue:
- id: blue-is-dice
date: 2026-11-04
strength: said
statement: >
Whether a Blue appears is a dice roll from the seed, like a loot drop. Someone who says they could
brute-force a Blue is right. Seeing one, the stacked odds of the bonding steps still kill most riders.
use: The meadow Blue stays a roll. Repeated attempts are the method; the gain is in the bonding answers.
black:
- id: not-random
date: 2026-11-04
strength: said
statement: >
The seed plays no part in whether the Black shows itself (repeated 2026-10-21, 2026-11-04, 2026-11-13). Its
conditions rest entirely on the rider's own choices. A rider who meets all of them gets the Black, and one
who knows the system can bond a Black with certainty, no luck involved.
use: >
The shadow is a guard, not a roll (core/spec/game.yaml `guard`). The model's "chance of the shadow" is the
share of runs like this one that met conditions we do not know yet, not the game's dice. Experiments on it
look for the rule (hold everything fixed, change one thing), not for a rate.
- id: gates
date: 2026-10-28
strength: said
statement: >
A rider must navigate the bullies encounter, and the tree is also a gate. There is no single route, and
there never will be a map that takes a rider down one specific route. The path does not change with time.
use: game.yaml `requires` on the shadow. BLACK.md section 4 (shadows on 44 different recorded routes) agrees.
- id: few-factors
date: 2026-10-28
strength: hint
statement: There are not forty factors; five "sounds like" a tolerable number.
use: The search is for a handful of conditions. Not relied on as an exact count.
- id: twenty
date: 2026-11-03
strength: hint
statement: Twenty is a discrete count the community would have a handle on once it understood how the Black is seen.
use: Unexplained. No analysis assumes what is counted.
- id: runs-never-hurt
date: 2026-11-07
strength: said
statement: >
Repeating the same path does not hurt an account's chances, so any given run either does nothing for them or
improves them. With a solution in hand there is no bad reputation to undo; the only risk is bonding
something unintended. Dooming an account at creation would be an accessibility problem.
use: >
Research attempts cannot spoil an account for the Black. Hard to square with section 2 of BLACK.md (the same
route works on a first attempt and almost never later), which is why the fresh-against-veteran experiments
come first.
- id: fresh-and-veteran
date: 2026-11-11
strength: hint
statement: >
Asked whether a rider with perfect knowledge would find the Black more easily on a first attempt or a later
one, the developer came close to answering and said the question was near a solution. Later: the community
is exploring what the developer would explore; the hard part is that an older account gives no feedback
until "it" happens; the task is to test the apparent success of a fresh account against the environment of
a veteran one.
use: Experiments fresh-replicate, shadow-again, second-attempt-same-path, veteran-repeat, veteran-variety.
- id: who-you-walk-with
date: 2026-11-07
strength: hint
statement: >
The valley might look different depending on who a rider walks in with, who they leave behind and who they
choose to fight; the dragons assess riders as riders assess dragons.
use: Company, leaving the squad, and the fight are the first decisions the ablation changes.
- id: death-does-not-matter
date: 2026-11-10
strength: said
statement: How a rider dies, the death message, and the scene a rider dies at are not factors in later runs.
use: Deliberate burns on research accounts are not a confound.
- id: order-does-not-matter
date: 2026-11-04
strength: hint
statement: As the developer understood the question, order does not matter.
use: None yet (the question it answered is not in the export).
declined: # refused, so neither confirmed nor denied
- Whether the conditions are only the answers to the questions (2026-10-25).
- Whether the shadow at the tree is the only way to meet a Black (2026-10-26).
- Whether choices repeated across runs raise or lower the chance (2026-10-21); later answered in part (runs-never-hurt).
- Whether older accounts can recover (2026-10-21).
- Whether there are hidden scores for personality, reputation or the like (2026-11-07, 2026-11-09, 2026-11-10).
- Whether the link riders see between cadet assignment and the Black is coincidence (2026-11-04).
open:
- question: On a fresh account, does one exact path always show the shadow, or only sometimes?
why: Always would mean the rule is in this run's choices. Sometimes would mean accounts differ in a fact we do not record.
experiment: fresh-replicate
- question: Which choices on that path are needed?
experiment: fresh-ablate
- question: Does an account that saw the shadow see it again on the same path?
experiment: shadow-again
- question: Does an account that missed on its first attempt miss again on the same path?
experiment: second-attempt-same-path
- question: Does an older account open up by repeating one path, or by varying its choices?
experiment: veteran-repeat, veteran-variety
- question: Holding the Black's gaze bonds about seven times in ten. What decides the rest?
why: The developer says knowledge gives certainty, so it should not be dice.
experiment: every screen after the shadow is logged; the bot follows the reported sequence (experiments.yaml `scripts`).