diff --git a/SerialPrograms/Source/ComputerPrograms/ComputerPrograms_UnitTestRunner.cpp b/SerialPrograms/Source/ComputerPrograms/ComputerPrograms_UnitTestRunner.cpp
index c40bee0870..ab59c5b97d 100644
--- a/SerialPrograms/Source/ComputerPrograms/ComputerPrograms_UnitTestRunner.cpp
+++ b/SerialPrograms/Source/ComputerPrograms/ComputerPrograms_UnitTestRunner.cpp
@@ -67,8 +67,10 @@ UnitTestDatabase make_UNIT_TESTS_ALL(){
     Kernels::add_tests(ret);
     Pokemon::add_tests_LegPlanner(ret);
     Pokemon::add_tests_MapData(ret);
+    Pokemon::add_tests_RouteLog(ret);
     Pokemon::add_tests_StoryEvents(ret);
     Pokemon::add_tests_StorySegments(ret);
+    Pokemon::add_tests_StorySteps(ret);
     NintendoSwitch::add_tests_CheckOnlineDetector(ret);
     NintendoSwitch::add_tests_FailedToConnectDetector(ret);
     NintendoSwitch::add_tests_UpdatePopupDetector(ret);
diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_Navigation_Tests.h b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_Navigation_Tests.h
index 73eac9841a..2fe4d0e7bb 100644
--- a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_Navigation_Tests.h
+++ b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_Navigation_Tests.h
@@ -18,8 +18,10 @@ namespace Pokemon{
 
 void add_tests_LegPlanner(UnitTestDatabase& database);
 void add_tests_MapData(UnitTestDatabase& database);
+void add_tests_RouteLog(UnitTestDatabase& database);
 void add_tests_StoryEvents(UnitTestDatabase& database);
 void add_tests_StorySegments(UnitTestDatabase& database);
+void add_tests_StorySteps(UnitTestDatabase& database);
 
 //  (name, JSON text) of each map in Pokemon/Navigation/TestMaps/, built into
 //  the program by pa_embed_text_files() (cmake/EmbedTextFiles.cmake).
diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_RouteLog.cpp b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_RouteLog.cpp
new file mode 100644
index 0000000000..3fbf5bb16f
--- /dev/null
+++ b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_RouteLog.cpp
@@ -0,0 +1,98 @@
+/*  Route Log
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ */
+
+#include <format>
+#include "Pokemon_RouteLog.h"
+
+namespace PokemonAutomation{
+namespace Pokemon{
+
+
+std::string to_string(const RouteTile& tile){
+    return tile.map + " " + to_string(tile.pos);
+}
+
+std::string describe(const std::vector<RouteTile>& tiles){
+    if (tiles.empty()){
+        return "an unknown tile";
+    }
+    std::string out;
+    for (const RouteTile& tile : tiles){
+        out += (out.empty() ? "" : ", ") + to_string(tile);
+    }
+    return out;
+}
+
+std::string to_string(const RouteLogLeg& leg){
+    const std::string direction = direction_name(leg.direction);
+    switch (leg.action){
+    case RouteLegAction::SURF:
+        return "surf " + direction;
+    case RouteLegAction::FACE:
+        return "face " + direction;
+    case RouteLegAction::WALK:
+        break;
+    }
+    const char* end = leg.end == RouteLegEnd::WALL ? " (to wall)" : leg.end == RouteLegEnd::WARP ? " (warp)" : " (open)";
+    return direction + " " + std::to_string(leg.tiles) + end;
+}
+
+const char* basis_name(EndBasis basis){
+    switch (basis){
+    case EndBasis::WALKED:
+        return "walked";
+    case EndBasis::ASSUMED:
+        return "assumed";
+    case EndBasis::UNKNOWN:
+        return "unknown";
+    }
+    return "?";
+}
+
+
+std::string route_plan_line(const std::string& label, const std::vector<RouteTile>& from, const std::vector<PlannedRouteLeg>& legs){
+    std::string text = label + ": plan from " + describe(from) + ":";
+    for (const PlannedRouteLeg& leg : legs){
+        text += "\n    " + to_string(leg.leg) + " to " + describe(leg.after);
+    }
+    return text;
+}
+
+std::string route_leg_line(size_t number, size_t count, const PlannedRouteLeg& leg){
+    return std::format("Leg {}/{}: {} to {}", number, count, to_string(leg.leg), describe(leg.after));
+}
+
+std::string route_leg_end_line(
+    const std::string& label, const RouteLogLeg& leg,
+    const std::vector<RouteTile>& at, EndBasis basis, const std::string& why
+){
+    const std::string how = why.empty() ? basis_name(basis) : std::string(basis_name(basis)) + ": " + why;
+    return std::format("{}: {}: ended at {} ({}).", label, to_string(leg), describe(at), how);
+}
+
+std::string route_replan_line(
+    const std::string& label, const RouteLogLeg& leg,
+    const std::string& what, const std::vector<RouteTile>& at
+){
+    return std::format("{}: {}: {}, at {}; planning again.", label, to_string(leg), what, describe(at));
+}
+
+std::string route_found_line(const std::string& label, const std::vector<RouteTile>& at, size_t holds){
+    return std::format("{}: found again at {}, after {} hold(s).", label, describe(at), holds);
+}
+
+std::string route_trainer_line(const std::string& label, const std::string& who, const std::vector<RouteTile>& at){
+    return label + ": " + who + " stopped us about " + describe(at) + ".";
+}
+
+std::string route_arrived_line(const std::string& label, const std::vector<RouteTile>& at){
+    return label + ": arrived at " + describe(at) + ".";
+}
+
+
+
+}
+}
diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_RouteLog.h b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_RouteLog.h
new file mode 100644
index 0000000000..5f5d4f09a4
--- /dev/null
+++ b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_RouteLog.h
@@ -0,0 +1,120 @@
+/*  Route Log
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ *  The log lines a route walk writes, shared by the games' walkers so that
+ *  every game's log reads the same and devtools/maps can draw any run's
+ *  routes from it. These are BDSP AutoStory's route lines, lifted from
+ *  PokemonBDSP_AutoStory_RouteWalk.cpp, with what the other games need:
+ *
+ *      [Route] To the grass: plan from Route 202 (15, 25), Route 202 (16, 25):
+ *          east 15 (to wall) to Route 202 (23, 25), Route 202 (30, 26)
+ *          north 5 (to wall) to Route 202 (23, 24)
+ *      [Route] Leg 1/2: east 15 (to wall) to Route 202 (23, 25), Route 202 (30, 26)
+ *      [Route] To the grass: east 15 (to wall): ended at Route 202 (23, 25) (walked).
+ *      [Route] To the grass: north 5 (to wall): stopped early after about 2 tiles, at Route 202 (23, 23); planning again.
+ *      [Route] To the grass: found again at Route 202 (22, 24), after 2 holds.
+ *      [Route] To the grass: arrived at Route 202 (23, 24).
+ *
+ *  A position is a set of tiles: BDSP plans from every tile the player may
+ *  be on, FRLG from the one it is on. A leg's end says how it is known:
+ *  walked (as planned, or seen), assumed (taken to have ended as planned
+ *  after something interrupted it), or unknown.
+ *
+ *  The functions return a line without the "[Route] " tag, which
+ *  ROUTE_LOG_TAG holds; the caller logs it.
+ *
+ */
+
+#ifndef PokemonAutomation_Pokemon_RouteLog_H
+#define PokemonAutomation_Pokemon_RouteLog_H
+
+#include <cstddef>
+#include <string>
+#include <vector>
+#include "Pokemon_Grid.h"
+
+namespace PokemonAutomation{
+namespace Pokemon{
+
+
+inline constexpr const char* ROUTE_LOG_TAG = "[Route] ";
+
+//  A tile of a named map.
+struct RouteTile{
+    std::string map;
+    TilePos pos;
+};
+//  "Route 202 (23, 25)".
+std::string to_string(const RouteTile& tile);
+//  The tiles, comma-separated; "an unknown tile" for none.
+std::string describe(const std::vector<RouteTile>& tiles);
+
+
+enum class RouteLegAction{
+    WALK,
+    SURF,
+    FACE,
+};
+
+//  How a leg ends: at a wall, on a warp, or where it is timed to.
+enum class RouteLegEnd{
+    OPEN,
+    WALL,
+    WARP,
+};
+
+struct RouteLogLeg{
+    RouteLegAction action = RouteLegAction::WALK;
+    Direction direction = Direction::NORTH;
+    size_t tiles = 0;
+    RouteLegEnd end = RouteLegEnd::OPEN;
+};
+//  "east 15 (to wall)", "south 4 (open)", "north 1 (warp)", "surf east",
+//  "face west".
+std::string to_string(const RouteLogLeg& leg);
+
+//  A planned leg and the tiles it may end on.
+struct PlannedRouteLeg{
+    RouteLogLeg leg;
+    std::vector<RouteTile> after;
+};
+
+//  How the end of a walked leg is known.
+enum class EndBasis{
+    WALKED,     //  walked as planned, or seen
+    ASSUMED,    //  taken to have ended as planned after an interrupt
+    UNKNOWN,    //  stopped somewhere on the way
+};
+const char* basis_name(EndBasis basis);
+
+
+//  "<label>: plan from <tiles>:", then a line per leg.
+std::string route_plan_line(const std::string& label, const std::vector<RouteTile>& from, const std::vector<PlannedRouteLeg>& legs);
+//  "Leg <number>/<count>: <leg> to <tiles>", as the leg starts.
+std::string route_leg_line(size_t number, size_t count, const PlannedRouteLeg& leg);
+//  "<label>: <leg>: ended at <tiles> (<basis>).", or "(<basis>: <why>)".
+std::string route_leg_end_line(
+    const std::string& label, const RouteLogLeg& leg,
+    const std::vector<RouteTile>& at, EndBasis basis, const std::string& why
+);
+//  "<label>: <leg>: <what>, at <tiles>; planning again.": the leg stopped
+//  short, where the player was seen to be, and the route is planned again
+//  from there.
+std::string route_replan_line(
+    const std::string& label, const RouteLogLeg& leg,
+    const std::string& what, const std::vector<RouteTile>& at
+);
+//  "<label>: found again at <tiles>, after <holds> hold(s).": after a stop
+//  where the player wasn't seen, holds to walls found them.
+std::string route_found_line(const std::string& label, const std::vector<RouteTile>& at, size_t holds);
+//  "<label>: <who> stopped us about <tiles>."
+std::string route_trainer_line(const std::string& label, const std::string& who, const std::vector<RouteTile>& at);
+//  "<label>: arrived at <tiles>."
+std::string route_arrived_line(const std::string& label, const std::vector<RouteTile>& at);
+
+
+
+}
+}
+#endif
diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_RouteLog_Tests.cpp b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_RouteLog_Tests.cpp
new file mode 100644
index 0000000000..243f427e51
--- /dev/null
+++ b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_RouteLog_Tests.cpp
@@ -0,0 +1,167 @@
+/*  Route Log Tests
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ *  The route log lines, word for word: BDSP-style position sets (several
+ *  tiles, map names with spaces) and FRLG-style single tiles.
+ *
+ */
+
+#include <functional>
+#include <string>
+#include <utility>
+#include <vector>
+#include "Common/Cpp/Exceptions.h"
+#include "Common/Cpp/TestRunners/UnitTest.h"
+#include "Pokemon_Navigation_Tests.h"
+#include "Pokemon_RouteLog.h"
+
+namespace PokemonAutomation{
+namespace Pokemon{
+
+
+namespace{
+
+class Test_RouteLog : public UnitTest{
+public:
+    Test_RouteLog(std::string name, std::function<UnitTestResult()> body)
+        : UnitTest("Pokemon::RouteLog - " + std::move(name))
+        , m_body(std::move(body))
+    {}
+    virtual UnitTestResult run(Logger&, CancellableScope&) const override{
+        try{
+            return m_body();
+        }catch (Exception& e){
+            return std::string(e.name()) + ": " + e.message();
+        }
+    }
+
+private:
+    std::function<UnitTestResult()> m_body;
+};
+
+//  A BDSP-style position: every tile the player may be on.
+const std::vector<RouteTile> BDSP_FROM{{"Route 202", {15, 25}}, {"Route 202", {16, 25}}};
+const std::vector<RouteTile> BDSP_WALL{{"Route 202", {23, 25}}, {"Route 202", {30, 26}}};
+//  An FRLG-style position: the one tile.
+const std::vector<RouteTile> FRLG_TILE{{"Route1", {12, 21}}};
+const std::vector<RouteTile> BDSP_GRASS{{"Route 202", {23, 17}}};
+const std::vector<RouteTile> FRLG_NORTH{{"Route1", {12, 13}}};
+const std::vector<RouteTile> TRAINER_SEEN{{"Route 202", {20, 10}}};
+const std::vector<RouteTile> ARRIVED{{"Route 202", {20, 25}}};
+
+const RouteLogLeg EAST_TO_WALL{.action = RouteLegAction::WALK, .direction = Direction::EAST, .tiles = 15, .end = RouteLegEnd::WALL};
+const RouteLogLeg NORTH_OPEN{.action = RouteLegAction::WALK, .direction = Direction::NORTH, .tiles = 8, .end = RouteLegEnd::OPEN};
+
+const RouteLogLeg SOUTH_WARP{.action = RouteLegAction::WALK, .direction = Direction::SOUTH, .tiles = 1, .end = RouteLegEnd::WARP};
+const RouteLogLeg SURF_EAST{.action = RouteLegAction::SURF, .direction = Direction::EAST, .tiles = 0, .end = RouteLegEnd::OPEN};
+const RouteLogLeg FACE_WEST{.action = RouteLegAction::FACE, .direction = Direction::WEST, .tiles = 0, .end = RouteLegEnd::OPEN};
+
+struct LineCase{
+    const char* name;
+    std::string line;
+    const char* expected;
+};
+
+UnitTestResult check(const std::vector<LineCase>& cases){
+    for (const LineCase& c : cases){
+        if (c.line != c.expected){
+            return std::string(c.name) + ": expected \"" + c.expected + "\", got \"" + c.line + "\".";
+        }
+    }
+    return true;
+}
+
+UnitTestResult test_legs(){
+    return check({
+        {.name = "to a wall", .line = to_string(EAST_TO_WALL), .expected = "east 15 (to wall)"},
+        {.name = "open", .line = to_string(NORTH_OPEN), .expected = "north 8 (open)"},
+        {.name = "onto a warp", .line = to_string(SOUTH_WARP), .expected = "south 1 (warp)"},
+        {.name = "surf", .line = to_string(SURF_EAST), .expected = "surf east"},
+        {.name = "face", .line = to_string(FACE_WEST), .expected = "face west"},
+    });
+}
+
+UnitTestResult test_plans(){
+    const std::vector<PlannedRouteLeg> bdsp_legs{
+        {.leg = EAST_TO_WALL, .after = BDSP_WALL},
+        {.leg = NORTH_OPEN, .after = BDSP_GRASS},
+    };
+    const std::vector<PlannedRouteLeg> frlg_legs{{.leg = NORTH_OPEN, .after = FRLG_NORTH}};
+    return check({
+        {
+            .name = "plan from a set of tiles",
+            .line = route_plan_line("To the grass", BDSP_FROM, bdsp_legs),
+            .expected = "To the grass: plan from Route 202 (15, 25), Route 202 (16, 25):\n"
+                "    east 15 (to wall) to Route 202 (23, 25), Route 202 (30, 26)\n"
+                "    north 8 (open) to Route 202 (23, 17)",
+        },
+        {
+            .name = "plan from one tile",
+            .line = route_plan_line("00.05/2 below_mart_door", FRLG_TILE, frlg_legs),
+            .expected = "00.05/2 below_mart_door: plan from Route1 (12, 21):\n    north 8 (open) to Route1 (12, 13)",
+        },
+        {.name = "plan from an unknown tile", .line = route_plan_line("x", {}, {}), .expected = "x: plan from an unknown tile:"},
+        {
+            .name = "leg as it starts",
+            .line = route_leg_line(1, 5, bdsp_legs[0]),
+            .expected = "Leg 1/5: east 15 (to wall) to Route 202 (23, 25), Route 202 (30, 26)",
+        },
+    });
+}
+
+UnitTestResult test_leg_ends(){
+    return check({
+        {
+            .name = "walked",
+            .line = route_leg_end_line("To the grass", EAST_TO_WALL, BDSP_WALL, EndBasis::WALKED, ""),
+            .expected = "To the grass: east 15 (to wall): ended at Route 202 (23, 25), Route 202 (30, 26) (walked).",
+        },
+        {
+            .name = "assumed",
+            .line = route_leg_end_line("r", NORTH_OPEN, FRLG_TILE, EndBasis::ASSUMED, "after a wild battle"),
+            .expected = "r: north 8 (open): ended at Route1 (12, 21) (assumed: after a wild battle).",
+        },
+        {
+            .name = "unknown",
+            .line = route_leg_end_line("r", NORTH_OPEN, {}, EndBasis::UNKNOWN, "stopped by a wild battle"),
+            .expected = "r: north 8 (open): ended at an unknown tile (unknown: stopped by a wild battle).",
+        },
+    });
+}
+
+UnitTestResult test_events(){
+    return check({
+        {
+            .name = "replan where seen",
+            .line = route_replan_line("To the grass", EAST_TO_WALL, "stopped early after about 3 tiles", BDSP_FROM),
+            .expected = "To the grass: east 15 (to wall): stopped early after about 3 tiles, at Route 202 (15, 25), Route 202 (16, 25); planning again.",
+        },
+        {.name = "found again", .line = route_found_line("r", FRLG_TILE, 2), .expected = "r: found again at Route1 (12, 21), after 2 hold(s)."},
+        {
+            .name = "trainer",
+            .line = route_trainer_line("To the grass", "Youngster Tristan", TRAINER_SEEN),
+            .expected = "To the grass: Youngster Tristan stopped us about Route 202 (20, 10).",
+        },
+        {
+            .name = "arrived",
+            .line = route_arrived_line("To the grass", ARRIVED),
+            .expected = "To the grass: arrived at Route 202 (20, 25).",
+        },
+    });
+}
+
+}
+
+
+void add_tests_RouteLog(UnitTestDatabase& database){
+    database.add<Test_RouteLog>("legs", test_legs);
+    database.add<Test_RouteLog>("plans, from a set of tiles or one", test_plans);
+    database.add<Test_RouteLog>("leg ends: walked, assumed, unknown", test_leg_ends);
+    database.add<Test_RouteLog>("replans, finds, trainers, arrivals", test_events);
+}
+
+
+
+}
+}
diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_StorySegments.cpp b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_StorySegments.cpp
index e80ff4915f..ad072e3411 100644
--- a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_StorySegments.cpp
+++ b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_StorySegments.cpp
@@ -83,21 +83,67 @@ Outcome reload(RunState& state, SegmentHooks& hooks){
     return outcome_ok();
 }
 
+//  The policy's in-place recovery, after each event's own: the game's
+//  recover hook, if any, then the event again. Counts into `used`.
+void add_policy_recoveries(Checkpoint& checkpoint, const SegmentPolicy& policy, SegmentHooks& hooks, size_t& used){
+    if (policy.recoveries_per_event == 0){
+        return;
+    }
+    for (Event& event : checkpoint.events){
+        Recovery recovery;
+        recovery.kind = RecoveryKind::REANCHOR;
+        recovery.attempts = policy.recoveries_per_event;
+        recovery.why = "the segment's policy: recover in place before reloading";
+        recovery.prepare = [&hooks, &used, name = event.name](RunState& state){
+            used++;
+            return hooks.recover ? hooks.recover(state, name) : outcome_ok();
+        };
+        event.recoveries.push_back(std::move(recovery));
+    }
+}
+
+std::string resets_text(size_t attempts){
+    if (attempts == 1){
+        return "one-shot";
+    }
+    return std::format("{} reset{}", attempts - 1, attempts == 2 ? "" : "s");
+}
+
 //  One row to success, reloading and rebuilding after each failed attempt.
-//  Returns the last attempt's report, or the reload's failure.
+//  Returns the last attempt's report, or the reload's failure; `run` says
+//  how many attempts and recoveries it took.
 CheckpointReport run_row(
     RunState& state, const Segment& segment, CheckpointSpec& spec,
-    const SegmentPolicy& policy, SegmentHooks& hooks, SegmentReport& report
+    const SegmentPolicy& policy, SegmentHooks& hooks, SegmentReport& report, CheckpointRun& run
 ){
     for (size_t attempt = 1; ; attempt++){
+        run.attempts = attempt;
         Checkpoint checkpoint = spec.build();
         if (spec.saves && !checkpoint.save){
             checkpoint.save = [&hooks](RunState& state){
                 return hooks.save ? hooks.save(state) : outcome_failed("no_save_hook");
             };
         }
+        add_policy_recoveries(checkpoint, policy, hooks, run.recoveries);
         CheckpointReport result = run_checkpoint(state, checkpoint, hooks.log);
-        if (result.completed || attempt >= policy.attempts_per_checkpoint){
+        if (result.completed){
+            run.passed = true;
+            hooks.log(std::format(
+                "[Checkpoint] {}: passed on attempt {} ({}){}",
+                spec.id, attempt, resets_text(attempt),
+                run.recoveries == 0 ? "" : std::format(", {} in place", run.recoveries)
+            ));
+            return result;
+        }
+        if (policy.stop_at_first_failure){
+            hooks.log(std::format(
+                "[Segment] {}: {} failed; stopping at the first failure, the game stays where it failed",
+                segment.id, spec.id
+            ));
+            report.stopped_at_first_failure = true;
+            return result;
+        }
+        if (attempt >= policy.attempts_per_checkpoint){
             return result;
         }
         hooks.log(std::format(
@@ -128,6 +174,19 @@ SegmentReport stop_segment(SegmentReport& report, SegmentHooks& hooks, const std
 }
 
 
+bool CheckpointRun::one_shot() const{
+    return passed && attempts == 1 && recoveries == 0;
+}
+
+size_t SegmentReport::one_shot_passes() const{
+    size_t count = 0;
+    for (const CheckpointRun& run : runs){
+        count += run.one_shot() ? 1 : 0;
+    }
+    return count;
+}
+
+
 SegmentReport run_segment(
     RunState& state, Segment& segment, const SegmentRange& range,
     const SegmentPolicy& policy, SegmentHooks& hooks
@@ -141,7 +200,8 @@ SegmentReport run_segment(
     for (size_t c = selected.first; c <= selected.last; c++){
         CheckpointSpec& spec = segment.checkpoints[c];
         report.checkpoints_run++;
-        CheckpointReport result = run_row(state, segment, spec, policy, hooks, report);
+        report.runs.push_back(CheckpointRun{.id = spec.id});
+        CheckpointReport result = run_row(state, segment, spec, policy, hooks, report, report.runs.back());
         if (!result.completed){
             report.failed_checkpoint = spec.id;
             report.failed_event = result.failed_name;
@@ -149,6 +209,7 @@ SegmentReport run_segment(
         }
     }
     report.completed = true;
+    hooks.log(std::format("[Segment] {}: {} of {} checkpoints one-shot", segment.id, report.one_shot_passes(), report.checkpoints_run));
     hooks.log(std::format("[Segment] {}: done, {} checkpoints", segment.id, report.checkpoints_run));
     return report;
 }
diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_StorySegments.h b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_StorySegments.h
index 69e181ef57..5e6bf66e55 100644
--- a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_StorySegments.h
+++ b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_StorySegments.h
@@ -46,15 +46,28 @@ struct Segment{
 //  What the game lends the runner: how to save, how to reload the last save
 //  (the run state is emptied first; the reload's Outcome says where the
 //  player stands), and where to log.
+//  `recover`, if set, is the game's way of recovering in place from a failed
+//  event (re-anchor on a landmark, close a stray dialogue) before the event
+//  is tried again; see SegmentPolicy::recoveries_per_event.
 struct SegmentHooks{
     Act save;
     Act reload;
     EventLogger log;
+    MoveOnlyFunction<Outcome(RunState& state, const std::string& event)> recover;
 };
 
+//  How hard a segment tries, for every game: the one place retries are set.
 struct SegmentPolicy{
-    //  Runs of one checkpoint, reloading between them, before the segment stops.
+    //  Runs of one checkpoint, reloading its save between them, before the
+    //  segment stops.
     size_t attempts_per_checkpoint = 3;
+    //  Lab: stop at the first failed attempt without reloading, leaving the
+    //  game where it failed for a look.
+    bool stop_at_first_failure = false;
+    //  Times each event may recover in place (SegmentHooks::recover, then
+    //  the event again) once its own recoveries are used up, before its
+    //  checkpoint fails and is reloaded. 0 keeps a failure a reload.
+    size_t recoveries_per_event = 0;
 };
 
 //  The checkpoints to run, by id, both inclusive. An unset end is the
@@ -65,8 +78,22 @@ struct SegmentRange{
 };
 
 
+//  How one checkpoint went: one attempt with no in-place recovery is a
+//  one-shot pass.
+struct CheckpointRun{
+    std::string id;
+    bool passed = false;
+    size_t attempts = 0;
+    //  In-place recoveries (SegmentPolicy::recoveries_per_event) used, in all attempts.
+    size_t recoveries = 0;
+
+    bool one_shot() const;
+};
+
 struct SegmentReport{
     bool completed = false;
+    //  The run stopped at its first failure (SegmentPolicy::stop_at_first_failure).
+    bool stopped_at_first_failure = false;
     //  Both empty when nothing failed; the event is empty when a start
     //  check, an end check, a save or a reload failed.
     std::string failed_checkpoint;
@@ -75,13 +102,21 @@ struct SegmentReport{
     size_t checkpoints_run = 0;
     //  Reloads after failed attempts.
     size_t reloads = 0;
+    //  Each checkpoint run, in order, the failed one last.
+    std::vector<CheckpointRun> runs;
+
+    size_t one_shot_passes() const;
 };
 
 //  Runs the checkpoints in `range`, in order. Logs through `hooks.log`,
 //  around the checkpoint lines:
 //      [Segment] 00: start, 3 checkpoints
 //      [Segment] 00: 00.02 failed, reloading for attempt 2/3
+//      [Checkpoint] 00.02: passed on attempt 2 (1 reset)
+//      [Checkpoint] 00.03: passed on attempt 1 (one-shot)
+//      [Segment] 00: 2 of 3 checkpoints one-shot
 //      [Segment] 00: done, 3 checkpoints
+//      [Segment] 00: 00.02 failed; stopping at the first failure, the game stays where it failed
 //      [Segment] 00: failed at 00.02 talk_mom: expect_failed: dialogue opened
 SegmentReport run_segment(
     RunState& state, Segment& segment, const SegmentRange& range,
diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_StorySteps.cpp b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_StorySteps.cpp
new file mode 100644
index 0000000000..c9825391b0
--- /dev/null
+++ b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_StorySteps.cpp
@@ -0,0 +1,278 @@
+/*  Story Steps
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ */
+
+#include <format>
+#include <memory>
+#include <set>
+#include <utility>
+#include "Pokemon_StorySteps.h"
+
+namespace PokemonAutomation{
+namespace Pokemon{
+
+
+const char* story_step_kind_name(StoryStepKind kind){
+    switch (kind){
+    case StoryStepKind::NEW_GAME:
+        return "NEW_GAME";
+    case StoryStepKind::OPTIONS:
+        return "OPTIONS";
+    case StoryStepKind::ROUTE:
+        return "ROUTE";
+    case StoryStepKind::LEGS:
+        return "LEGS";
+    case StoryStepKind::STEP:
+        return "STEP";
+    case StoryStepKind::TALK:
+        return "TALK";
+    case StoryStepKind::ANSWER:
+        return "ANSWER";
+    case StoryStepKind::MASH:
+        return "MASH";
+    case StoryStepKind::BATTLE:
+        return "BATTLE";
+    case StoryStepKind::TRAIN:
+        return "TRAIN";
+    case StoryStepKind::HEAL:
+        return "HEAL";
+    case StoryStepKind::SHOP:
+        return "SHOP";
+    case StoryStepKind::SAVE:
+        return "SAVE";
+    case StoryStepKind::READY:
+        return "READY";
+    case StoryStepKind::GAME:
+        return "GAME";
+    }
+    return "?";
+}
+
+
+const char* story_checks_name(StoryChecks checks){
+    switch (checks){
+    case StoryChecks::THOROUGH:
+        return "thorough";
+    case StoryChecks::FAST:
+        return "fast";
+    }
+    return "?";
+}
+
+
+Outcome unsupported_step(const StoryStep& step){
+    return outcome_failed("unsupported_step", std::format("{} {}", story_step_kind_name(step.kind), step.name));
+}
+
+Outcome StoryStepExecutor::run(RunState& state, const StoryStep& step){
+    return dispatch_story_step(*this, state, step);
+}
+
+void StoryStepExecutor::begin_attempt(const StoryCheckpoint&){}
+
+bool StoryStepExecutor::holds(const std::string& condition, RunState& state){
+    return state.flags.contains(condition);
+}
+
+Outcome StoryStepExecutor::new_game(RunState&, const StoryStep& step){
+    return unsupported_step(step);
+}
+Outcome StoryStepExecutor::options(RunState&, const StoryStep& step){
+    return unsupported_step(step);
+}
+Outcome StoryStepExecutor::route(RunState&, const StoryStep& step){
+    return unsupported_step(step);
+}
+Outcome StoryStepExecutor::legs(RunState&, const StoryStep& step){
+    return unsupported_step(step);
+}
+Outcome StoryStepExecutor::step(RunState&, const StoryStep& step){
+    return unsupported_step(step);
+}
+Outcome StoryStepExecutor::talk(RunState&, const StoryStep& step){
+    return unsupported_step(step);
+}
+Outcome StoryStepExecutor::answer(RunState&, const StoryStep& step){
+    return unsupported_step(step);
+}
+Outcome StoryStepExecutor::mash(RunState&, const StoryStep& step){
+    return unsupported_step(step);
+}
+Outcome StoryStepExecutor::battle(RunState&, const StoryStep& step){
+    return unsupported_step(step);
+}
+Outcome StoryStepExecutor::train(RunState&, const StoryStep& step){
+    return unsupported_step(step);
+}
+Outcome StoryStepExecutor::heal(RunState&, const StoryStep& step){
+    return unsupported_step(step);
+}
+Outcome StoryStepExecutor::shop(RunState&, const StoryStep& step){
+    return unsupported_step(step);
+}
+Outcome StoryStepExecutor::save(RunState&, const StoryStep& step){
+    return unsupported_step(step);
+}
+Outcome StoryStepExecutor::ready(RunState&, const StoryStep& step){
+    return unsupported_step(step);
+}
+Outcome StoryStepExecutor::game(RunState&, const StoryStep& step){
+    return unsupported_step(step);
+}
+
+Outcome dispatch_story_step(StoryStepExecutor& executor, RunState& state, const StoryStep& step){
+    switch (step.kind){
+    case StoryStepKind::NEW_GAME:
+        return executor.new_game(state, step);
+    case StoryStepKind::OPTIONS:
+        return executor.options(state, step);
+    case StoryStepKind::ROUTE:
+        return executor.route(state, step);
+    case StoryStepKind::LEGS:
+        return executor.legs(state, step);
+    case StoryStepKind::STEP:
+        return executor.step(state, step);
+    case StoryStepKind::TALK:
+        return executor.talk(state, step);
+    case StoryStepKind::ANSWER:
+        return executor.answer(state, step);
+    case StoryStepKind::MASH:
+        return executor.mash(state, step);
+    case StoryStepKind::BATTLE:
+        return executor.battle(state, step);
+    case StoryStepKind::TRAIN:
+        return executor.train(state, step);
+    case StoryStepKind::HEAL:
+        return executor.heal(state, step);
+    case StoryStepKind::SHOP:
+        return executor.shop(state, step);
+    case StoryStepKind::SAVE:
+        return executor.save(state, step);
+    case StoryStepKind::READY:
+        return executor.ready(state, step);
+    case StoryStepKind::GAME:
+        return executor.game(state, step);
+    }
+    return unsupported_step(step);
+}
+
+
+Event story_event(const StoryStep& step, StoryStepExecutor& executor){
+    Event event;
+    event.name = step.name;
+    event.why = step.why;
+    for (const std::string& name : step.skip_if){
+        event.skip_if.push_back(condition(name, [&executor, name](RunState& state){
+            return executor.holds(name, state);
+        }));
+    }
+    event.act = [&executor, &step](RunState& state){
+        return executor.run(state, step);
+    };
+    event.pose_learned = step.pose_after;
+    return event;
+}
+
+namespace{
+
+//  The first event of a checkpoint that starts from a save: where the save
+//  leaves the player, for a run that reloaded it.
+Event from_save_event(const Pose& start){
+    Event event;
+    event.name = "from_save";
+    event.why = "where the checkpoint's save leaves the player";
+    event.act = [](RunState&){ return outcome_ok(); };
+    event.pose_learned = start;
+    return event;
+}
+
+}
+
+Checkpoint build_story_checkpoint(const StoryCheckpoint& data, StoryStepExecutor& executor){
+    executor.begin_attempt(data);
+    Checkpoint checkpoint;
+    checkpoint.id = data.id;
+    if (data.start){
+        checkpoint.events.push_back(from_save_event(*data.start));
+    }
+    for (const StoryStep& step : data.steps){
+        checkpoint.events.push_back(story_event(step, executor));
+    }
+    return checkpoint;
+}
+
+
+namespace{
+
+//  What a step of its kind must have, or "" if it has it.
+std::string missing_field(const StoryStep& step){
+    switch (step.kind){
+    case StoryStepKind::ROUTE:
+    case StoryStepKind::READY:
+        return step.target ? "" : "no target";
+    case StoryStepKind::LEGS:
+        if (step.legs.empty()){
+            return "no legs";
+        }
+        for (const StoryLeg& leg : step.legs){
+            if (leg.tiles <= 0){
+                return "a leg of no tiles";
+            }
+        }
+        return "";
+    case StoryStepKind::TRAIN:
+        return step.battles > 0 ? "" : "no battles";
+    case StoryStepKind::SHOP:
+        return step.items.empty() ? "no items" : "";
+    case StoryStepKind::GAME:
+        return step.variant.empty() ? "no variant" : "";
+    default:
+        return "";
+    }
+}
+
+}
+
+std::vector<std::string> lint_story_checkpoint(const StoryCheckpoint& data){
+    std::vector<std::string> problems;
+    if (data.id.empty()){
+        problems.emplace_back("a checkpoint has no id");
+    }
+    std::set<std::string> names;
+    for (size_t c = 0; c < data.steps.size(); c++){
+        const StoryStep& step = data.steps[c];
+        const std::string where = std::format("{} step {}", data.id, c + 1);
+        if (step.name.empty()){
+            problems.emplace_back(where + ": no name");
+        }else if (!names.insert(step.name).second){
+            problems.emplace_back(std::format("{}: a second step named {}", where, step.name));
+        }
+        const std::string missing = missing_field(step);
+        if (!missing.empty()){
+            problems.emplace_back(std::format("{} {}: {} {}", where, step.name, story_step_kind_name(step.kind), missing));
+        }
+    }
+    return problems;
+}
+
+
+Pose tile_pose(std::string map, std::vector<TilePos> tiles, std::optional<Direction> facing){
+    Pose pose;
+    pose.map = std::move(map);
+    pose.certainty = tiles.empty() ? PoseCertainty::UNKNOWN
+        : tiles.size() == 1 ? PoseCertainty::TILE : PoseCertainty::SET;
+    pose.where = std::make_shared<const TilePose>(std::move(tiles), facing);
+    return pose;
+}
+
+std::optional<Direction> facing_of(const Pose& pose){
+    const TilePose* tile_pose = dynamic_cast<const TilePose*>(pose.where.get());
+    return tile_pose ? tile_pose->facing : std::nullopt;
+}
+
+
+
+}
+}
diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_StorySteps.h b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_StorySteps.h
new file mode 100644
index 0000000000..84972ead25
--- /dev/null
+++ b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_StorySteps.h
@@ -0,0 +1,227 @@
+/*  Story Steps
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ *  One vocabulary of story steps for the tile games (FRLG, BDSP): a route,
+ *  a fixed walk, a step onto a trigger, a talk, a YES/NO, a scene, a
+ *  battle, the nurse, a shop, a save, and so on. A checkpoint is a list of
+ *  such steps, plain data, so a game's story is a table its unit tests can
+ *  plan without a console.
+ *
+ *  build_story_checkpoint() turns a table row into engine events
+ *  (Pokemon_StoryEvents.h). Each event's action asks the game's
+ *  StoryStepExecutor to do its step: one virtual per kind, so a game
+ *  implements the kinds it uses, and a step the game has no way of doing
+ *  fails by name instead of doing something else.
+ *
+ *  Steps never match dialogue or menu text: they look for screen state (a
+ *  dialogue box, an arrow, a fade, a battle menu, colours, positions). The
+ *  few reads that need text (item names in a shop or the Bag) take the
+ *  game's language from the executor, and with no reader for it fall back
+ *  to checks that need none (a row's position, digits, a changed screen),
+ *  so a run never fails because its language is not supported.
+ *
+ *  Poses are the game's own (Pose, with a TilePose for these games): a
+ *  checkpoint's start, a scene's end and a route's target are poses, and
+ *  an executor that knows where a step left the player says so in its
+ *  Outcome, which the engine writes into the run.
+ *
+ */
+
+#ifndef PokemonAutomation_Pokemon_StorySteps_H
+#define PokemonAutomation_Pokemon_StorySteps_H
+
+#include <cstddef>
+#include <optional>
+#include <string>
+#include <vector>
+#include "CommonFramework/Language.h"
+#include "Pokemon_Grid.h"
+#include "Pokemon_StoryEvents.h"
+#include "Pokemon_TilePose.h"
+
+namespace PokemonAutomation{
+namespace Pokemon{
+
+
+enum class StoryStepKind{
+    NEW_GAME,   //  title screen (no save) to the first room
+    OPTIONS,    //  the game's options as the story needs them
+    ROUTE,      //  plan and walk to `target`
+    LEGS,       //  walk `legs` as given
+    STEP,       //  one step `direction`: onto a trigger, into a door
+    TALK,       //  A at what the player faces
+    ANSWER,     //  text to a YES/NO, then `yes`
+    MASH,       //  text until the overworld is back: a scene
+    BATTLE,     //  text into a battle, fight it, text to the overworld
+    TRAIN,      //  fight `battles` wild battles where the player stands
+    HEAL,       //  the nurse, from in front of her or of the Center's door
+    SHOP,       //  `items` from a shop
+    SAVE,       //  save the game where the player stands
+    READY,      //  before a big battle: items, and the nurse at `target` if they can't
+    GAME,       //  a step only this game has, named by `variant`
+};
+const char* story_step_kind_name(StoryStepKind kind);
+
+//  How much a step reads the screen to confirm what it did. Each game
+//  decides what its steps check at each level.
+enum class StoryChecks{
+    //  Confirm on screen: purchases, the Bag, status after battles, position.
+    THOROUGH,
+    //  In a rush: trust counts and timings.
+    FAST,
+};
+const char* story_checks_name(StoryChecks checks);
+
+
+//  A straight leg of a fixed walk.
+struct StoryLeg{
+    Direction direction = Direction::NORTH;
+    int tiles = 0;
+};
+
+//  An item and how many to get.
+struct StoryItem{
+    std::string item;
+    size_t quantity = 0;
+};
+
+struct StoryStep{
+    StoryStepKind kind = StoryStepKind::TALK;
+    std::string name;
+    std::string why;
+
+    //  ROUTE: where to go; with several tiles, any of them. READY: the nurse.
+    std::optional<Pose> target;
+    //  STEP
+    Direction direction = Direction::NORTH;
+    //  LEGS
+    std::vector<StoryLeg> legs;
+    //  ROUTE, LEGS: fight wild battles on the way instead of running.
+    bool fight_wild = false;
+    //  ANSWER
+    bool yes = true;
+    //  BATTLE: losing goes on (a rival's first battle).
+    bool may_lose = false;
+    //  TRAIN
+    size_t battles = 0;
+    //  SHOP
+    std::vector<StoryItem> items;
+    //  How this game does the kind, when it has more than one way: a
+    //  route's plan costs, a door lined up by sight, the Mart lady instead
+    //  of the clerk. Empty is the game's usual way. GAME: the step's name
+    //  in the game's executor.
+    std::string variant;
+
+    //  Skipped when all of these hold (and there is at least one): names
+    //  the game's executor answers (StoryStepExecutor::holds()), run flags
+    //  unless the game reads them off the screen.
+    std::vector<std::string> skip_if;
+    //  Where the step leaves the player, when its action does not say: the
+    //  end of a scene that moves the player.
+    std::optional<Pose> pose_after;
+};
+
+struct StoryCheckpoint{
+    std::string id;
+    std::string title;
+    //  Where its starting save leaves the player; none for a new game.
+    std::optional<Pose> start;
+    std::vector<StoryStep> steps;
+};
+
+
+//  How a game does each kind of step. Every kind fails as unsupported
+//  unless the game overrides it.
+class StoryStepExecutor{
+public:
+    virtual ~StoryStepExecutor() = default;
+
+    //  A checkpoint is being built for a new attempt: build_story_checkpoint()
+    //  calls this first, so a game can start the attempt afresh (trainers
+    //  who can see us again, the row's own settings). Does nothing by default.
+    virtual void begin_attempt(const StoryCheckpoint& data);
+
+    //  The checks level the program's options chose (StoryRunOptions);
+    //  THOROUGH unless set. Steps read it to decide what to confirm.
+    StoryChecks checks() const{
+        return m_checks;
+    }
+    void set_checks(StoryChecks checks){
+        m_checks = checks;
+    }
+    //  The game's language (StoryRunOptions), for the reads that need text;
+    //  English unless set. A game with no reader for it uses language-free
+    //  checks instead.
+    Language language() const{
+        return m_language;
+    }
+    void set_language(Language language){
+        m_language = language;
+    }
+
+    //  Runs `step`: dispatch_story_step() by default. A game overrides it
+    //  to wrap every step, e.g. to turn a failed console step into a failed
+    //  Outcome.
+    virtual Outcome run(RunState& state, const StoryStep& step);
+
+    //  Whether the condition named in a step's skip_if holds: by default,
+    //  whether the run has the flag (set by an earlier step's action).
+    virtual bool holds(const std::string& condition, RunState& state);
+
+    virtual Outcome new_game(RunState& state, const StoryStep& step);
+    virtual Outcome options(RunState& state, const StoryStep& step);
+    virtual Outcome route(RunState& state, const StoryStep& step);
+    virtual Outcome legs(RunState& state, const StoryStep& step);
+    virtual Outcome step(RunState& state, const StoryStep& step);
+    virtual Outcome talk(RunState& state, const StoryStep& step);
+    virtual Outcome answer(RunState& state, const StoryStep& step);
+    virtual Outcome mash(RunState& state, const StoryStep& step);
+    virtual Outcome battle(RunState& state, const StoryStep& step);
+    virtual Outcome train(RunState& state, const StoryStep& step);
+    virtual Outcome heal(RunState& state, const StoryStep& step);
+    virtual Outcome shop(RunState& state, const StoryStep& step);
+    virtual Outcome save(RunState& state, const StoryStep& step);
+    virtual Outcome ready(RunState& state, const StoryStep& step);
+    virtual Outcome game(RunState& state, const StoryStep& step);
+
+private:
+    StoryChecks m_checks = StoryChecks::THOROUGH;
+    Language m_language = Language::English;
+};
+
+//  Calls the executor's method for the step's kind.
+Outcome dispatch_story_step(StoryStepExecutor& executor, RunState& state, const StoryStep& step);
+
+//  "unsupported_step: TRAIN train_in_grass": what an executor without the kind returns.
+Outcome unsupported_step(const StoryStep& step);
+
+
+//  The step as an event that runs it with `executor`. Both must outlive
+//  the event.
+Event story_event(const StoryStep& step, StoryStepExecutor& executor);
+
+//  The checkpoint `data` as events: "from_save" first when it has a start
+//  (the start pose, for a run that reloaded its save), then one event per
+//  step. `data` and `executor` must outlive the checkpoint. Saving is the
+//  game's: it sets the checkpoint's save, or adds a SAVE step.
+Checkpoint build_story_checkpoint(const StoryCheckpoint& data, StoryStepExecutor& executor);
+
+//  Problems an author should fix before running: an empty id, unnamed or
+//  repeated steps, a route or READY without a target, empty legs, a GAME
+//  step without a variant, TRAIN without battles, SHOP without items.
+std::vector<std::string> lint_story_checkpoint(const StoryCheckpoint& data);
+
+
+//  A pose on one of `tiles` of `map`, facing `facing` if set: TILE for one
+//  tile, SET for several, UNKNOWN for none.
+Pose tile_pose(std::string map, std::vector<TilePos> tiles, std::optional<Direction> facing = std::nullopt);
+
+//  The facing of a tile pose; nothing for another pose or none.
+std::optional<Direction> facing_of(const Pose& pose);
+
+
+
+}
+}
+#endif
diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_StorySteps_Tests.cpp b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_StorySteps_Tests.cpp
new file mode 100644
index 0000000000..4e44b6e3b3
--- /dev/null
+++ b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_StorySteps_Tests.cpp
@@ -0,0 +1,570 @@
+/*  Story Steps Tests
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ *  Story tables built into checkpoints and run against a fake executor
+ *  that writes down each step it is asked to do: the order of the events,
+ *  skipped steps, the pose each step leaves, and how a failure is named.
+ *  Nothing here belongs to one game.
+ *
+ */
+
+#include <algorithm>
+#include <functional>
+#include <map>
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
+#include "Common/Cpp/TestRunners/UnitTest.h"
+#include "Pokemon/Options/Pokemon_StoryRunOptions.h"
+#include "Pokemon_StoryEvents.h"
+#include "Pokemon_StorySegments.h"
+#include "Pokemon_StorySteps.h"
+#include "Pokemon_TilePose.h"
+#include "Pokemon_Navigation_Tests.h"
+
+namespace PokemonAutomation{
+namespace Pokemon{
+
+
+namespace{
+
+//  A world of two maps. Routes arrive on their target; a step moves a tile
+//  from the run's pose. Each step it does is written down as "KIND name",
+//  with the pose it started from when that is known.
+class FakeExecutor : public StoryStepExecutor{
+public:
+    std::vector<std::string> trace;
+    std::set<std::string> conditions;
+    //  Steps by name that always fail, and how.
+    std::set<std::string> failing;
+    //  Steps by name that fail this many more times, then pass.
+    std::map<std::string, size_t> failures_left;
+    //  The pose each step started from, by name.
+    std::vector<std::pair<std::string, std::string>> poses_seen;
+    //  The checkpoints begun, one per attempt.
+    std::vector<std::string> attempts;
+
+    virtual void begin_attempt(const StoryCheckpoint& data) override{
+        attempts.push_back(data.id);
+    }
+
+    virtual Outcome run(RunState& state, const StoryStep& step) override{
+        poses_seen.emplace_back(step.name, to_string(state.pose));
+        trace.push_back(std::string(story_step_kind_name(step.kind)) + " " + step.name);
+        if (failing.contains(step.name)){
+            return outcome_failed("blocked", step.name + " was blocked");
+        }
+        size_t& left = failures_left[step.name];
+        if (left > 0){
+            left--;
+            return outcome_failed("blocked", step.name + " was blocked");
+        }
+        return StoryStepExecutor::run(state, step);
+    }
+    virtual bool holds(const std::string& condition, RunState& state) override{
+        return conditions.contains(condition) || StoryStepExecutor::holds(condition, state);
+    }
+    virtual Outcome route(RunState&, const StoryStep& step) override{
+        return outcome_ok(*step.target);
+    }
+    virtual Outcome step(RunState& state, const StoryStep& step) override{
+        const std::vector<TilePos> tiles = tiles_of(state.pose);
+        if (tiles.size() != 1){
+            return outcome_failed("no_pose", to_string(state.pose));
+        }
+        return outcome_ok(tile_pose(state.pose.map, {tiles[0].next(step.direction)}, step.direction));
+    }
+    virtual Outcome talk(RunState&, const StoryStep&) override{
+        return outcome_ok();
+    }
+    virtual Outcome mash(RunState&, const StoryStep&) override{
+        return outcome_ok();
+    }
+    virtual Outcome battle(RunState&, const StoryStep& step) override{
+        //  The first battle is lost; a step that may lose goes on.
+        return step.may_lose ? outcome_ok() : outcome_failed("blackout");
+    }
+    virtual Outcome shop(RunState&, const StoryStep& step) override{
+        for (const StoryItem& item : step.items){
+            trace.push_back("  bought " + std::to_string(item.quantity) + " " + item.item);
+        }
+        return outcome_ok();
+    }
+    //  A game step sets a run flag named for its variant.
+    virtual Outcome game(RunState& state, const StoryStep& step) override{
+        trace.push_back("  game " + step.variant);
+        state.flags.insert(step.variant);
+        return outcome_ok();
+    }
+};
+
+StoryStep make(StoryStepKind kind, std::string name){
+    StoryStep step;
+    step.kind = kind;
+    step.name = std::move(name);
+    return step;
+}
+
+StoryStep route_to(std::string name, Pose target){
+    StoryStep step = make(StoryStepKind::ROUTE, std::move(name));
+    step.target = std::move(target);
+    return step;
+}
+
+StoryStep step_into(std::string name, Direction direction){
+    StoryStep step = make(StoryStepKind::STEP, std::move(name));
+    step.direction = direction;
+    return step;
+}
+
+StoryStep scene(std::string name, std::optional<Pose> pose_after){
+    StoryStep step = make(StoryStepKind::MASH, std::move(name));
+    step.pose_after = std::move(pose_after);
+    return step;
+}
+
+//  A lab checkpoint: to the table, a trigger, the scene into the lab, a
+//  talk, a shop, a game step.
+StoryCheckpoint lab_checkpoint(){
+    StoryStep shop = make(StoryStepKind::SHOP, "potions");
+    shop.items = {{.item = "potion", .quantity = 5}, {.item = "antidote", .quantity = 3}};
+    StoryStep game = make(StoryStepKind::GAME, "dance");
+    game.variant = "dance";
+    return StoryCheckpoint{
+        .id = "00.03",
+        .title = "to the lab",
+        .start = tile_pose("Town", {{6, 8}}, Direction::SOUTH),
+        .steps = {
+            route_to("below_trigger", tile_pose("Town", {{12, 2}}, Direction::NORTH)),
+            step_into("trigger", Direction::NORTH),
+            scene("to_the_lab", tile_pose("Lab", {{6, 4}}, Direction::NORTH)),
+            make(StoryStepKind::TALK, "talk_oak"),
+            shop,
+            game,
+        },
+    };
+}
+
+struct Run{
+    CheckpointReport report;
+    RunState state;
+    std::vector<std::string> lines;
+};
+
+Run run(const StoryCheckpoint& data, StoryStepExecutor& executor){
+    Run ret;
+    Checkpoint checkpoint = build_story_checkpoint(data, executor);
+    EventLogger log = [&ret](const std::string& line){ ret.lines.push_back(line); };
+    ret.report = run_checkpoint(ret.state, checkpoint, log);
+    return ret;
+}
+
+std::string joined(const std::vector<std::string>& lines){
+    std::string text;
+    for (const std::string& line : lines){
+        text += "\n  " + line;
+    }
+    return text;
+}
+
+
+UnitTestResult test_events_in_table_order(){
+    const StoryCheckpoint data = lab_checkpoint();
+    FakeExecutor executor;
+    const Run result = run(data, executor);
+    const std::vector<std::string> expected{
+        "ROUTE below_trigger",
+        "STEP trigger",
+        "MASH to_the_lab",
+        "TALK talk_oak",
+        "SHOP potions",
+        "  bought 5 potion",
+        "  bought 3 antidote",
+        "GAME dance",
+        "  game dance",
+    };
+    if (!result.report.completed || executor.trace != expected){
+        return "Expected the steps in table order:" + joined(expected) + "\nbut ran:" + joined(executor.trace);
+    }
+    //  "from_save" is the engine's own event: the executor is not asked.
+    const std::string first = event_log_line("00.03", 1, "from_save", "start");
+    if (result.lines.empty() || std::find(result.lines.begin(), result.lines.end(), first) == result.lines.end()){
+        return "Expected the from_save event first:" + joined(result.lines);
+    }
+    return true;
+}
+
+UnitTestResult test_skip_if(){
+    StoryCheckpoint data = lab_checkpoint();
+    data.steps[0].skip_if = {"has_parcel"};
+    data.steps[3].skip_if = {"has_parcel", "talked"};
+    FakeExecutor executor;
+    executor.conditions = {"has_parcel"};
+    //  The route is skipped; the talk needs both conditions, so it runs.
+    const Run result = run(data, executor);
+    if (!result.report.completed || result.report.events_skipped != 1){
+        return "Expected one step skipped, got " + std::to_string(result.report.events_skipped) + ":" + joined(result.lines);
+    }
+    if (std::find(executor.trace.begin(), executor.trace.end(), "ROUTE below_trigger") != executor.trace.end()){
+        return "Expected the route skipped:" + joined(executor.trace);
+    }
+    if (std::find(executor.trace.begin(), executor.trace.end(), "TALK talk_oak") == executor.trace.end()){
+        return "Expected the talk run, one of its conditions not holding:" + joined(executor.trace);
+    }
+
+    //  By default a condition is a run flag: the game step "dance" sets
+    //  one, and a talk after it that needs it is skipped.
+    StoryStep after = make(StoryStepKind::TALK, "talk_after_dance");
+    after.skip_if = {"dance"};
+    data = lab_checkpoint();
+    data.steps.push_back(after);
+    FakeExecutor plain;
+    const Run flagged = run(data, plain);
+    if (!flagged.report.completed || flagged.report.events_skipped != 1 || plain.trace.back() != "  game dance"){
+        return "Expected the talk after the dance skipped on its flag:" + joined(plain.trace);
+    }
+    return true;
+}
+
+UnitTestResult test_pose_propagation(){
+    const StoryCheckpoint data = lab_checkpoint();
+    FakeExecutor executor;
+    const Run result = run(data, executor);
+    //  Each step starts where the one before left the player: the save, the
+    //  route's target, a tile north of it, the scene's end, and the scene's
+    //  end again after a talk that says nothing of where it leaves us.
+    const std::vector<std::pair<std::string, std::string>> expected{
+        {"below_trigger", "Town (6, 8) facing south (tile)"},
+        {"trigger", "Town (12, 2) facing north (tile)"},
+        {"to_the_lab", "Town (12, 1) facing north (tile)"},
+        {"talk_oak", "Lab (6, 4) facing north (tile)"},
+        {"potions", "Lab (6, 4) facing north (tile)"},
+        {"dance", "Lab (6, 4) facing north (tile)"},
+    };
+    if (!result.report.completed || executor.poses_seen != expected){
+        std::string text;
+        for (const auto& item : executor.poses_seen){
+            text += "\n  " + item.first + ": " + item.second;
+        }
+        return "Unexpected poses at the steps' starts:" + text;
+    }
+    if (to_string(result.state.pose) != "Lab (6, 4) facing north (tile)"){
+        return "Expected the run to end at the scene's end, got " + to_string(result.state.pose);
+    }
+    return true;
+}
+
+UnitTestResult test_failure_names_the_step(){
+    const StoryCheckpoint data = lab_checkpoint();
+    FakeExecutor executor;
+    executor.failing = {"trigger"};
+    const Run result = run(data, executor);
+    //  Event 3: from_save is event 1.
+    if (result.report.completed || result.report.failed_event != 3 || result.report.failed_name != "trigger"
+        || result.report.failure.failure != "blocked"
+    ){
+        return "Expected a failure at event 3 trigger, blocked:" + joined(result.lines);
+    }
+    if (executor.trace.size() != 2){
+        return "Expected nothing run after the failed step:" + joined(executor.trace);
+    }
+    return true;
+}
+
+UnitTestResult test_unsupported_and_lost_battles(){
+    //  The fake has no TRAIN, and loses battles a step may not lose.
+    StoryStep train = make(StoryStepKind::TRAIN, "train");
+    train.battles = 3;
+    FakeExecutor executor;
+    Run result = run(StoryCheckpoint{.id = "01", .title = "", .start = std::nullopt, .steps = {train}}, executor);
+    if (result.report.completed || result.report.failure.failure != "unsupported_step" || result.report.failure.detail != "TRAIN train"){
+        return "Expected TRAIN unsupported:" + joined(result.lines);
+    }
+    StoryStep rival = make(StoryStepKind::BATTLE, "rival");
+    rival.may_lose = true;
+    StoryStep brock = make(StoryStepKind::BATTLE, "brock");
+    result = run(StoryCheckpoint{.id = "02", .title = "", .start = std::nullopt, .steps = {rival, brock}}, executor);
+    if (result.report.completed || result.report.failed_name != "brock" || result.report.failure.failure != "blackout"){
+        return "Expected the rival's battle passed and Brock's lost:" + joined(result.lines);
+    }
+    return true;
+}
+
+UnitTestResult test_segment_of_tables(){
+    //  Two rows built into a segment, run with saves and a reload from the
+    //  game's hooks: the second row's first attempt fails, its retry starts
+    //  over from its start pose.
+    const std::vector<StoryCheckpoint> tables{
+        lab_checkpoint(),
+        StoryCheckpoint{
+            .id = "00.04",
+            .title = "the parcel",
+            .start = tile_pose("Lab", {{6, 4}}, Direction::NORTH),
+            .steps = {make(StoryStepKind::TALK, "give_parcel")},
+        },
+    };
+    FakeExecutor executor;
+    Segment segment;
+    segment.id = "00";
+    for (const StoryCheckpoint& data : tables){
+        segment.checkpoints.push_back(CheckpointSpec{
+            .id = data.id, .title = data.title, .saves = true,
+            .build = [&data, &executor]{ return build_story_checkpoint(data, executor); },
+        });
+    }
+    std::vector<std::string> lines;
+    SegmentHooks hooks;
+    hooks.save = [&executor](RunState&){
+        executor.trace.push_back("save");
+        return outcome_ok();
+    };
+    //  Whatever blocked the talk has gone by the reload.
+    hooks.reload = [&executor](RunState&){
+        executor.trace.push_back("reload");
+        executor.failing.clear();
+        return outcome_ok();
+    };
+    hooks.log = [&lines](const std::string& line){ lines.push_back(line); };
+    executor.failing = {"give_parcel"};
+    RunState state;
+    const SegmentReport report = run_segment(state, segment, SegmentRange{}, SegmentPolicy{}, hooks);
+    const std::vector<std::string> tail{"save", "TALK give_parcel", "reload", "TALK give_parcel", "save"};
+    const bool tail_matches = executor.trace.size() >= tail.size()
+        && std::equal(tail.begin(), tail.end(), executor.trace.end() - (std::ptrdiff_t)tail.size());
+    if (!report.completed || report.reloads != 1 || !tail_matches){
+        return "Expected 00.04 reloaded once and passed:" + joined(executor.trace) + joined(lines);
+    }
+    //  Each attempt is begun anew: 00.03 once, 00.04 twice.
+    if (executor.attempts != std::vector<std::string>{"00.03", "00.04", "00.04"}){
+        return "Expected the executor told of each attempt:" + joined(executor.attempts);
+    }
+    //  The report and the log tell a one-shot pass from a retried one.
+    const bool runs_ok = report.runs.size() == 2
+        && report.runs[0].one_shot() && report.runs[0].attempts == 1
+        && !report.runs[1].one_shot() && report.runs[1].attempts == 2 && report.runs[1].passed
+        && report.one_shot_passes() == 1;
+    const auto has = [&lines](const std::string& line){
+        return std::find(lines.begin(), lines.end(), line) != lines.end();
+    };
+    if (!runs_ok
+        || !has("[Checkpoint] 00.03: passed on attempt 1 (one-shot)")
+        || !has("[Checkpoint] 00.04: passed on attempt 2 (1 reset)")
+        || !has("[Segment] 00: 1 of 2 checkpoints one-shot")
+    ){
+        return "Expected 00.03 one-shot and 00.04 passed on attempt 2:" + joined(lines);
+    }
+    return true;
+}
+
+
+//  The two tables of test_segment_of_tables() as a segment run by `executor`,
+//  with hooks that write saves, reloads and recoveries into its trace.
+struct PolicyLab{
+    std::vector<StoryCheckpoint> tables{
+        lab_checkpoint(),
+        StoryCheckpoint{
+            .id = "00.04",
+            .title = "the parcel",
+            .start = tile_pose("Lab", {{6, 4}}, Direction::NORTH),
+            .steps = {make(StoryStepKind::TALK, "give_parcel")},
+        },
+    };
+    FakeExecutor executor;
+    std::vector<std::string> lines;
+
+    SegmentReport run(const SegmentPolicy& policy){
+        Segment segment;
+        segment.id = "00";
+        for (const StoryCheckpoint& data : tables){
+            segment.checkpoints.push_back(CheckpointSpec{
+                .id = data.id, .title = data.title, .saves = true,
+                .build = [&data, this]{ return build_story_checkpoint(data, executor); },
+            });
+        }
+        SegmentHooks hooks;
+        hooks.save = [this](RunState&){
+            executor.trace.push_back("save");
+            return outcome_ok();
+        };
+        hooks.reload = [this](RunState&){
+            executor.trace.push_back("reload");
+            return outcome_ok();
+        };
+        hooks.recover = [this](RunState&, const std::string& event){
+            executor.trace.push_back("recover " + event);
+            return outcome_ok();
+        };
+        hooks.log = [this](const std::string& line){ lines.push_back(line); };
+        RunState state;
+        return run_segment(state, segment, SegmentRange{}, policy, hooks);
+    }
+    bool has(const std::string& line) const{
+        return std::find(lines.begin(), lines.end(), line) != lines.end();
+    }
+    size_t count(const std::string& item) const{
+        return (size_t)std::count(executor.trace.begin(), executor.trace.end(), item);
+    }
+};
+
+UnitTestResult test_policy_attempts_then_fail(){
+    //  Three attempts by default, then the segment stops on the last one's failure.
+    PolicyLab lab;
+    lab.executor.failing = {"give_parcel"};
+    const SegmentReport report = lab.run(SegmentPolicy{});
+    if (report.completed || report.reloads != 2 || lab.count("TALK give_parcel") != 3
+        || report.runs.size() != 2 || report.runs[1].passed || report.runs[1].attempts != 3
+        || report.failed_checkpoint != "00.04" || report.failure.failure != "blocked"
+    ){
+        return "Expected 00.04 tried 3 times, then failed:" + joined(lab.executor.trace) + joined(lab.lines);
+    }
+    return true;
+}
+
+UnitTestResult test_policy_stop_at_first_failure(){
+    PolicyLab lab;
+    lab.executor.failing = {"give_parcel"};
+    const SegmentReport report = lab.run(SegmentPolicy{.stop_at_first_failure = true});
+    if (report.completed || !report.stopped_at_first_failure || report.reloads != 0 || lab.count("reload") != 0
+        || lab.count("TALK give_parcel") != 1
+        || !lab.has("[Segment] 00: 00.04 failed; stopping at the first failure, the game stays where it failed")
+    ){
+        return "Expected a stop at the first failure, with no reload:" + joined(lab.executor.trace) + joined(lab.lines);
+    }
+    return true;
+}
+
+UnitTestResult test_policy_recovers_in_place(){
+    //  The talk fails twice; two recoveries in place get it through
+    //  without a reload, but not one-shot.
+    PolicyLab lab;
+    lab.executor.failures_left = {{"give_parcel", 2}};
+    const SegmentReport report = lab.run(SegmentPolicy{.recoveries_per_event = 2});
+    if (!report.completed || report.reloads != 0 || lab.count("recover give_parcel") != 2
+        || report.runs.size() != 2 || report.runs[1].recoveries != 2 || report.runs[1].one_shot()
+        || !lab.has("[Checkpoint] 00.04: passed on attempt 1 (one-shot), 2 in place")
+    ){
+        return "Expected 00.04 recovered in place twice:" + joined(lab.executor.trace) + joined(lab.lines);
+    }
+    //  Past the budget, the checkpoint is reloaded as before.
+    PolicyLab reloaded;
+    reloaded.executor.failures_left = {{"give_parcel", 2}};
+    const SegmentReport second = reloaded.run(SegmentPolicy{.recoveries_per_event = 1});
+    if (!second.completed || second.reloads != 1 || second.runs[1].attempts != 2){
+        return "Expected a reload once the in-place budget was used:" + joined(reloaded.executor.trace) + joined(reloaded.lines);
+    }
+    return true;
+}
+
+//  The checks level: THOROUGH by default, and what the program sets is
+//  what a step reads.
+UnitTestResult test_checks_level(){
+    class CheckingExecutor : public FakeExecutor{
+    public:
+        std::vector<std::string> seen;
+        virtual Outcome talk(RunState&, const StoryStep& step) override{
+            seen.push_back(step.name + " " + story_checks_name(checks()));
+            return outcome_ok();
+        }
+    };
+    StoryCheckpoint data = lab_checkpoint();
+    CheckingExecutor executor;
+    run(data, executor);
+    executor.set_checks(StoryChecks::FAST);
+    executor.set_language(Language::Korean);
+    run(data, executor);
+    if (executor.language() != Language::Korean){
+        return "Expected the language set on the executor.";
+    }
+    if (executor.seen != std::vector<std::string>{"talk_oak thorough", "talk_oak fast"}){
+        return "Expected the talk to read thorough, then fast:" + joined(executor.seen);
+    }
+    return true;
+}
+
+//  The program's option group: 3 attempts, no stop, Thorough, by default;
+//  Fast when chosen.
+UnitTestResult test_run_options(){
+    StoryRunOptions options;
+    const SegmentPolicy policy = options.policy();
+    if (policy.attempts_per_checkpoint != 3 || policy.stop_at_first_failure || options.checks() != StoryChecks::THOROUGH){
+        return "Expected 3 attempts, no stop at the first failure, and Thorough checks by default.";
+    }
+    options.CHECKS.set(StoryChecks::FAST);
+    if (options.checks() != StoryChecks::FAST){
+        return "Expected Fast checks once chosen.";
+    }
+    //  Every game language can be chosen, read or not.
+    if (options.language() != Language::English){
+        return "Expected English by default.";
+    }
+    options.LANGUAGE.set(Language::Japanese);
+    if (options.language() != Language::Japanese || !options.check_validity().empty()){
+        return "Expected Japanese to be chosen and valid, reader or not.";
+    }
+    return true;
+}
+
+UnitTestResult test_lint(){
+    StoryStep no_target = make(StoryStepKind::ROUTE, "walk");
+    StoryStep again = make(StoryStepKind::TALK, "walk");
+    StoryStep bad_legs = make(StoryStepKind::LEGS, "legs");
+    bad_legs.legs = {{.direction = Direction::NORTH, .tiles = 0}};
+    StoryStep no_variant = make(StoryStepKind::GAME, "");
+    const StoryCheckpoint data{.id = "", .title = "", .start = std::nullopt, .steps = {no_target, again, bad_legs, no_variant}};
+    const std::vector<std::string> expected{
+        "a checkpoint has no id",
+        " step 1 walk: ROUTE no target",
+        " step 2: a second step named walk",
+        " step 3 legs: LEGS a leg of no tiles",
+        " step 4: no name",
+        " step 4 : GAME no variant",
+    };
+    const std::vector<std::string> problems = lint_story_checkpoint(data);
+    if (problems != expected){
+        return "Unexpected lint:" + joined(problems);
+    }
+    if (!lint_story_checkpoint(lab_checkpoint()).empty()){
+        return "Expected the lab checkpoint to lint clean:" + joined(lint_story_checkpoint(lab_checkpoint()));
+    }
+    return true;
+}
+
+
+class Test_StorySteps : public UnitTest{
+public:
+    Test_StorySteps(std::string name, std::function<UnitTestResult()> body)
+        : UnitTest("Pokemon::StorySteps - " + std::move(name))
+        , m_body(std::move(body))
+    {}
+    virtual UnitTestResult run(Logger&, CancellableScope&) const override{
+        return m_body();
+    }
+
+private:
+    std::function<UnitTestResult()> m_body;
+};
+
+}
+
+
+void add_tests_StorySteps(UnitTestDatabase& database){
+    database.add<Test_StorySteps>("steps run in table order", test_events_in_table_order);
+    database.add<Test_StorySteps>("skip_if asks the executor", test_skip_if);
+    database.add<Test_StorySteps>("each step starts where the last left the player", test_pose_propagation);
+    database.add<Test_StorySteps>("a failure names its step", test_failure_names_the_step);
+    database.add<Test_StorySteps>("unsupported kinds and lost battles", test_unsupported_and_lost_battles);
+    database.add<Test_StorySteps>("tables as a segment, with a reload", test_segment_of_tables);
+    database.add<Test_StorySteps>("lint", test_lint);
+    database.add<Test_StorySteps>("the checks level reaches the steps", test_checks_level);
+    database.add<Test_StorySteps>("the run options' defaults", test_run_options);
+    database.add<Test_StorySteps>("policy: attempts per checkpoint, then fail", test_policy_attempts_then_fail);
+    database.add<Test_StorySteps>("policy: stop at the first failure", test_policy_stop_at_first_failure);
+    database.add<Test_StorySteps>("policy: recover in place before reloading", test_policy_recovers_in_place);
+}
+
+
+
+}
+}
diff --git a/SerialPrograms/Source/Pokemon/Options/Pokemon_StoryRunOptions.cpp b/SerialPrograms/Source/Pokemon/Options/Pokemon_StoryRunOptions.cpp
new file mode 100644
index 0000000000..c68a783002
--- /dev/null
+++ b/SerialPrograms/Source/Pokemon/Options/Pokemon_StoryRunOptions.cpp
@@ -0,0 +1,87 @@
+/*  Story Run Options
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ */
+
+#include "Pokemon_StoryRunOptions.h"
+
+namespace PokemonAutomation{
+namespace Pokemon{
+
+
+const EnumDropdownDatabase<StoryChecks>& StoryChecks_Database(){
+    static const EnumDropdownDatabase<StoryChecks> database({
+        {StoryChecks::THOROUGH, "thorough", "Thorough: confirm purchases, the Bag, status and position on screen"},
+        {StoryChecks::FAST,     "fast",     "Fast: trust counts and timings"},
+    });
+    return database;
+}
+
+const EnumDropdownDatabase<Language>& StoryLanguage_Database(){
+    static const EnumDropdownDatabase<Language> database({
+        {Language::English,            "en",      "English"},
+        {Language::Japanese,           "ja",      "Japanese"},
+        {Language::Spanish,            "es",      "Spanish"},
+        {Language::French,             "fr",      "French"},
+        {Language::German,             "de",      "German"},
+        {Language::Italian,            "it",      "Italian"},
+        {Language::Korean,             "ko",      "Korean"},
+        {Language::ChineseSimplified,  "zh-Hans", "Chinese (Simplified)"},
+        {Language::ChineseTraditional, "zh-Hant", "Chinese (Traditional)"},
+    });
+    return database;
+}
+
+
+StoryRunOptions::StoryRunOptions()
+    : GroupOption("Checkpoint Retries", LockMode::LOCK_WHILE_RUNNING)
+    , ATTEMPTS_PER_CHECKPOINT(
+        "<b>Attempts per checkpoint:</b><br>A failed checkpoint reloads its save and runs again, up to this many times in all.",
+        LockMode::LOCK_WHILE_RUNNING,
+        3, 1, 20
+    )
+    , STOP_AT_FIRST_FAILURE(
+        "<b>Stop at the first failure:</b><br>Stop without reloading, leaving the game where it failed for a look.",
+        LockMode::LOCK_WHILE_RUNNING,
+        false
+    )
+    , CHECKS(
+        "<b>Checks:</b><br>Thorough reads the screen to confirm what each step did; Fast trusts counts and timings, for a run in a rush.",
+        StoryChecks_Database(),
+        LockMode::LOCK_WHILE_RUNNING,
+        StoryChecks::THOROUGH
+    )
+    , LANGUAGE(
+        "<b>Game language:</b><br>For the few reads that need text (item names in a shop or the Bag). "
+        "Story steps never match dialogue text; with no reader for this language they check positions, digits and the screen instead.",
+        StoryLanguage_Database(),
+        LockMode::LOCK_WHILE_RUNNING,
+        Language::English
+    )
+{
+    PA_ADD_OPTION(ATTEMPTS_PER_CHECKPOINT);
+    PA_ADD_OPTION(STOP_AT_FIRST_FAILURE);
+    PA_ADD_OPTION(CHECKS);
+    PA_ADD_OPTION(LANGUAGE);
+}
+
+SegmentPolicy StoryRunOptions::policy() const{
+    SegmentPolicy policy;
+    policy.attempts_per_checkpoint = ATTEMPTS_PER_CHECKPOINT;
+    policy.stop_at_first_failure = STOP_AT_FIRST_FAILURE;
+    return policy;
+}
+
+StoryChecks StoryRunOptions::checks() const{
+    return CHECKS;
+}
+
+Language StoryRunOptions::language() const{
+    return LANGUAGE;
+}
+
+
+
+}
+}
diff --git a/SerialPrograms/Source/Pokemon/Options/Pokemon_StoryRunOptions.h b/SerialPrograms/Source/Pokemon/Options/Pokemon_StoryRunOptions.h
new file mode 100644
index 0000000000..4f9a3a506b
--- /dev/null
+++ b/SerialPrograms/Source/Pokemon/Options/Pokemon_StoryRunOptions.h
@@ -0,0 +1,52 @@
+/*  Story Run Options
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ *  The options every AutoStory program shows for how hard to try and how
+ *  much to check: the same group in each game, read into the shared
+ *  SegmentPolicy (Pokemon/Navigation/Pokemon_StorySegments.h) and the
+ *  executor's checks level (Pokemon_StorySteps.h).
+ *
+ */
+
+#ifndef PokemonAutomation_Pokemon_StoryRunOptions_H
+#define PokemonAutomation_Pokemon_StoryRunOptions_H
+
+#include <cstdint>
+#include "Common/Cpp/Options/BooleanCheckBoxOption.h"
+#include "Common/Cpp/Options/EnumDropdownOption.h"
+#include "Common/Cpp/Options/GroupOption.h"
+#include "Common/Cpp/Options/SimpleIntegerOption.h"
+#include "Pokemon/Navigation/Pokemon_StorySegments.h"
+#include "Pokemon/Navigation/Pokemon_StorySteps.h"
+
+namespace PokemonAutomation{
+namespace Pokemon{
+
+
+class StoryRunOptions : public GroupOption{
+public:
+    StoryRunOptions();
+
+    //  The policy these options set. In-place recoveries are the game's to
+    //  set, not the user's.
+    SegmentPolicy policy() const;
+    //  The checks level for the game's story step executor (set_checks()).
+    StoryChecks checks() const;
+    //  The game's language, for the executor (set_language()).
+    Language language() const;
+
+public:
+    SimpleIntegerOption<uint8_t> ATTEMPTS_PER_CHECKPOINT;
+    BooleanCheckBoxOption STOP_AT_FIRST_FAILURE;
+    EnumDropdownOption<StoryChecks> CHECKS;
+    //  Any language the game has, whether or not a reader supports it:
+    //  steps without one use language-free checks, so none is refused.
+    EnumDropdownOption<Language> LANGUAGE;
+};
+
+
+
+}
+}
+#endif
diff --git a/SerialPrograms/Source/PokemonBDSP/PokemonBDSP_Tests.cpp b/SerialPrograms/Source/PokemonBDSP/PokemonBDSP_Tests.cpp
index 258b5b7789..1d98998358 100644
--- a/SerialPrograms/Source/PokemonBDSP/PokemonBDSP_Tests.cpp
+++ b/SerialPrograms/Source/PokemonBDSP/PokemonBDSP_Tests.cpp
@@ -21,6 +21,7 @@
 #include "Programs/AutoStory/PokemonBDSP_AutoStory_MapGrid_Tests.h"
 #include "Programs/AutoStory/PokemonBDSP_AutoStory_Tests.h"
 #include "Programs/AutoStory/PokemonBDSP_AutoStory_Segment00_Tests.h"
+#include "Programs/AutoStory/PokemonBDSP_AutoStory_StorySimulation_Tests.h"
 #include "Programs/AutoStory/PokemonBDSP_AutoStory_StoryTables_Tests.h"
 #include "Programs/AutoStory/PokemonBDSP_AutoStory_Indoors_Tests.h"
 
@@ -296,6 +297,7 @@ void add_tests(UnitTestDatabase& database){
     add_tests_AutoStory_MapGrids(database);
     add_tests_AutoStory(database);
     add_tests_AutoStory_Segment00(database);
+    add_tests_AutoStory_StorySimulation(database);
     add_tests_AutoStory_StoryTables(database);
     add_tests_AutoStory_Indoors(database);
 }
diff --git a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory.cpp b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory.cpp
index 324ae32dc2..ba6801157d 100644
--- a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory.cpp
+++ b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory.cpp
@@ -2,6 +2,7 @@
 #include <memory>
 
 #include "PokemonBDSP_AutoStory.h"
+#include "Utils/PokemonBDSP_AutoStory_Location.h"
 #include "Utils/PokemonBDSP_AutoStory_NewGame.h"
 
 #include "CommonFramework/Globals.h"
@@ -142,14 +143,6 @@ BDSPAutoStory::~BDSPAutoStory(){
 
 BDSPAutoStory::BDSPAutoStory()
     : SingleSwitchProgramInstance()
-    // DIAGNOSTIC ONLY: Remove before pushing to production.
-    , STOP_AT_FIRST_FAILURE(
-          "<b>Lab: Stop at the first failure</b><br>"
-          "Save the failure screenshot and stop, leaving the game where it failed for a look, "
-          "instead of closing it and retrying. Remove before pushing to production.",
-          LockMode::LOCK_WHILE_RUNNING,
-          false
-      )
     , DIAGNOSTIC_POST_CATCH_ONLY(
           "<b>Diagnostic only: Run 00.04 after catch through 00.05</b><br>"
           "Start at the saved position immediately after catching the second Pokemon. "
@@ -412,7 +405,7 @@ BDSPAutoStory::BDSPAutoStory()
     //  Options
     // -----------------------------------------------------------------------
 
-    PA_ADD_OPTION(STOP_AT_FIRST_FAILURE);
+    PA_ADD_OPTION(RETRIES);
     PA_ADD_OPTION(DIAGNOSTIC_POST_CATCH_ONLY);
     PA_ADD_OPTION(DIAGNOSTIC_FAKE_CHECKPOINT_SAVE);
     PA_ADD_OPTION(DIAGNOSTIC_ROUTE202_TO_SANDGEM_CENTER);
@@ -538,10 +531,12 @@ void BDSPAutoStory::program(
     ProControllerContext& context
 ){
     AutoStoryStats& stats = env.current_stats<AutoStoryStats>();
-    g_stop_at_first_failure = STOP_AT_FIRST_FAILURE;
+    //  The checkpoints not yet in tables still run checkpoint_reattempt_loop().
+    g_stop_at_first_failure = RETRIES.STOP_AT_FIRST_FAILURE;
+    g_story_language = RETRIES.language();
 
     AutoStoryOptions options{
-        Language::English,
+        RETRIES.language(),
         STARTERCHOICE,
         NOTIFICATION_STATUS_UPDATE,
         (HelpMode)HELP_MODE,
@@ -556,6 +551,8 @@ void BDSPAutoStory::program(
         },
         DIAGNOSTIC_FAKE_CHECKPOINT_SAVE ? CheckpointSaveMode::FAKE : CheckpointSaveMode::REAL
     };
+    options.policy = RETRIES.policy();
+    options.checks = RETRIES.checks();
 
     const bool fake_saves = options.checkpoint_save_mode == CheckpointSaveMode::FAKE;
     if (fake_saves) options.checkpoint_retry_scope = CheckpointRetryScope::DEFER_TO_SELECTED_RANGE;
@@ -690,7 +687,7 @@ void BDSPAutoStory::program(
             run_selected_range(0);
         }
     }catch (OperationFailedException&){
-        if (STOP_AT_FIRST_FAILURE){
+        if (RETRIES.STOP_AT_FIRST_FAILURE){
             env.log("AutoStory failed: leaving the game where it failed (lab option).", COLOR_RED);
             throw;
         }
diff --git a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory.h b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory.h
index d42aa4717f..6677d84e2e 100644
--- a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory.h
+++ b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory.h
@@ -10,6 +10,7 @@
 #include "CommonTools/Options/StringSelectOption.h"
 #include "NintendoSwitch/NintendoSwitch_SingleSwitchProgram.h"
 #include "PokemonBDSP_AutoStoryTools.h"
+#include "Pokemon/Options/Pokemon_StoryRunOptions.h"
 
 namespace PokemonAutomation{
 namespace NintendoSwitch{
@@ -39,8 +40,8 @@ class BDSPAutoStory : public SingleSwitchProgramInstance, public ConfigOption::L
     virtual void on_config_value_changed(void* object) override;
     void update_ui_state();
 private:
-    // DIAGNOSTIC ONLY: Remove before pushing to production.
-    BooleanCheckBoxOption STOP_AT_FIRST_FAILURE;
+    //  Attempts per checkpoint and stop at the first failure, as in FRLG.
+    Pokemon::StoryRunOptions RETRIES;
     BooleanCheckBoxOption DIAGNOSTIC_POST_CATCH_ONLY;
     // DIAGNOSTIC ONLY: Remove before pushing to production.
     BooleanCheckBoxOption DIAGNOSTIC_FAKE_CHECKPOINT_SAVE;
diff --git a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStoryTools.cpp b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStoryTools.cpp
index f2a1bfe6cf..98587454ea 100644
--- a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStoryTools.cpp
+++ b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStoryTools.cpp
@@ -1932,6 +1932,17 @@ bool find_bag_item_in_open_bag(
     context.wait_for_all_requests();
     if (!bag_navigate_to_pocket(stream, context, target_pocket)) return false;
 
+    //  No reader for the game's language: the cursor's row, the pocket's
+    //  first, if the pocket has one. Early in the story the pocket holds only
+    //  what was bought or given (Potions in Medicine).
+    if (!story_reads_text()){
+        const VideoSnapshot frame = stream.video().snapshot();
+        const bool any = frame && !bag_list_is_empty(*frame.frame) && bag_cursor_position(*frame.frame) != 0;
+        stream.log("[Bag search] " + name + ": no text reader for the game's language; " +
+            (any ? "taking the pocket's cursor row." : "the pocket is empty."), COLOR_ORANGE);
+        return any;
+    }
+
     //  Walk down the list reading the cursor row. The list does not wrap, so
     //  turn around once the cursor stops moving.
     DpadPosition direction = DPAD_DOWN;
diff --git a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStoryTools.h b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStoryTools.h
index 6089ee78d7..9435548d14 100644
--- a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStoryTools.h
+++ b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStoryTools.h
@@ -14,6 +14,8 @@
 #include <vector>
 
 #include "Common/Cpp/Options/EnumDropdownOption.h"
+#include "Pokemon/Navigation/Pokemon_StorySegments.h"
+#include "Pokemon/Navigation/Pokemon_StorySteps.h"
 
 #include "CommonFramework/GlobalAutoPaths.h"
 #include "CommonFramework/ImageTools/ImageBoxes.h"
@@ -139,6 +141,10 @@ struct AutoStoryOptions {
     OutsideHelpConfig outside_help;
     CheckpointSaveMode checkpoint_save_mode = CheckpointSaveMode::REAL;
     CheckpointRetryScope checkpoint_retry_scope = CheckpointRetryScope::CHECKPOINT;
+    //  How the story tables retry a checkpoint (StoryRunOptions).
+    Pokemon::SegmentPolicy policy = {};
+    //  What the story steps confirm on screen (StoryRunOptions).
+    Pokemon::StoryChecks checks = Pokemon::StoryChecks::THOROUGH;
 };
 
 
diff --git a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory_StorySimulation_Tests.cpp b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory_StorySimulation_Tests.cpp
new file mode 100644
index 0000000000..a3b6f3f2b6
--- /dev/null
+++ b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory_StorySimulation_Tests.cpp
@@ -0,0 +1,508 @@
+/*  BDSP AutoStory Story Simulation Tests
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ *  A run of the whole story table, new game to Floaroma, without the
+ *  console: segment_00_table() and segment_01_table() built into segments
+ *  as the program builds them (story_table_segment()), run by the shared
+ *  runner with the program's retry policy, against a fake game. The fake
+ *  plans each ROUTE on the built-in JSON maps from where the run's pose
+ *  says we stand, walks each LEGS tile by tile on them, and passes every
+ *  other step unless told to fail it. Steps that still call an old
+ *  function pass as a whole.
+ *
+ */
+
+#include <algorithm>
+#include <format>
+#include <functional>
+#include <map>
+#include <optional>
+#include <set>
+#include <string>
+#include <vector>
+#include "Common/Cpp/Exceptions.h"
+#include "Common/Cpp/TestRunners/UnitTest.h"
+#include "Pokemon/Navigation/Pokemon_MapSet.h"
+#include "Pokemon/Navigation/Pokemon_StorySegments.h"
+#include "Pokemon/Navigation/Pokemon_StorySteps.h"
+#include "Pokemon/Navigation/Pokemon_TileGrid.h"
+#include "Data/PokemonBDSP_AutoStory_StoryMaps.h"
+#include "StorySegments/PokemonBDSP_AutoStory_Segment_00.h"
+#include "StorySegments/PokemonBDSP_AutoStory_Segment_01.h"
+#include "Utils/PokemonBDSP_AutoStory_Location.h"
+#include "Utils/PokemonBDSP_AutoStory_RouteWalk.h"
+#include "Utils/PokemonBDSP_AutoStory_StoryExecutor.h"
+#include "Utils/PokemonBDSP_AutoStory_StoryTables.h"
+#include "PokemonBDSP_AutoStory_StoryTable.h"
+#include "PokemonBDSP_AutoStory_StorySimulation_Tests.h"
+
+namespace PokemonAutomation{
+namespace NintendoSwitch{
+namespace PokemonBDSP{
+
+
+namespace{
+
+using Pokemon::Outcome;
+using Pokemon::RunState;
+using Pokemon::StoryStepKind;
+using Pokemon::TilePos;
+
+std::string describe(const std::vector<TilePos>& tiles){
+    std::string text;
+    for (const TilePos& pos : tiles){
+        const std::optional<Pokemon::MapTile> local = story_maps().to_local(pos);
+        text += " " + (local ? local->map + " " + Pokemon::to_string(local->pos) : Pokemon::to_string(pos));
+    }
+    return text;
+}
+
+std::string joined(const std::vector<std::string>& lines){
+    std::string text;
+    for (const std::string& line : lines){
+        text += "\n    " + line;
+    }
+    return text;
+}
+
+bool contains(const std::vector<TilePos>& tiles, const TilePos& pos){
+    return std::find(tiles.begin(), tiles.end(), pos) != tiles.end();
+}
+
+//  Where a ROUTE step ends from `from`, planned as ConsoleStoryExecutor
+//  plans it, or why it does not plan.
+struct Walked{
+    std::vector<TilePos> at;
+    std::string error;
+    std::string plan;
+};
+Walked plan_route(const std::vector<TilePos>& from, const Pokemon::StoryStep& step){
+    const std::optional<Pokemon::RobustPlanCosts> costs = story_route_costs(step.variant);
+    if (!costs){
+        return {{}, step.name + ": no plan costs named \"" + step.variant + "\".", ""};
+    }
+    const std::vector<TilePos> goal = Pokemon::tiles_of(*step.target);
+    const auto plan = Pokemon::plan_robust_route(story_maps().world(), from,
+        [&](const TilePos& pos){ return contains(goal, pos); }, *costs);
+    if (!plan){
+        return {{}, step.name + ": no plan from" + describe(from) + ".", ""};
+    }
+    Walked walked{from, "", std::format("{}: {} legs from{}", step.name, plan->size(), describe(from))};
+    for (const Pokemon::PlannedLeg& leg : *plan){
+        walked.plan += "\n    " + to_string(leg.leg) + " to" + describe(leg.after);
+    }
+    if (!plan->empty()){
+        walked.at = plan->back().after;
+    }
+    for (const TilePos& pos : walked.at){
+        if (!contains(goal, pos)){
+            return {{}, step.name + ": the plan may end off the target, at" + describe({pos}) + ".", walked.plan};
+        }
+    }
+    return walked;
+}
+
+//  Where a LEGS step ends from `from`, walked tile by tile on the maps, a
+//  tile short too where the step allows it.
+Walked walk_legs(const std::vector<TilePos>& from, const Pokemon::StoryStep& step){
+    const Pokemon::TileGrid& world = story_maps().world();
+    std::vector<TilePos> at = from;
+    for (const Pokemon::StoryLeg& leg : step.legs){
+        std::vector<TilePos> next;
+        for (TilePos pos : at){
+            for (int i = 0; i < leg.tiles; i++){
+                const std::optional<TilePos> stepped = world.step(pos, leg.direction);
+                if (!stepped){
+                    return {{}, step.name + ": " + direction_name(leg.direction) + " is blocked at" + describe({pos}) + ".", ""};
+                }
+                if (step.variant == "one_short_ok" && i + 1 == leg.tiles){
+                    next.push_back(pos);
+                }
+                pos = *stepped;
+            }
+            next.push_back(pos);
+        }
+        at = std::move(next);
+    }
+    return {at, "", ""};
+}
+
+
+//  Saves at a row's start into the trace, as the console runner saves.
+class FakeRunner : public StoryStepRunner{
+public:
+    std::vector<std::string>& trace;
+    std::set<std::string> saved;
+
+    explicit FakeRunner(std::vector<std::string>& trace)
+        : trace(trace)
+    {}
+    virtual bool saved_at_start(const std::string& id) const override{
+        return saved.contains(id);
+    }
+    virtual Outcome save_at_start(const std::string& id) override{
+        saved.insert(id);
+        trace.push_back("save " + id);
+        return Pokemon::outcome_ok();
+    }
+    virtual Outcome run_step(const std::string&, StoryFailure, const StoryAction&) override{
+        return Pokemon::outcome_failed("no_console");
+    }
+};
+
+//  The game: steps pass, routes and legs move the pose on the maps, and
+//  the steps in `failures` ("<row>/<step>") fail, so many times, as said.
+class FakeGame : public Pokemon::StoryStepExecutor{
+public:
+    struct Failure{
+        std::string failure;
+        size_t times = 0;
+    };
+
+    std::vector<std::string>& trace;
+    std::map<std::string, Failure> failures;
+    //  Every route's plan, for the log.
+    std::vector<std::string> plans;
+
+    explicit FakeGame(std::vector<std::string>& trace)
+        : trace(trace)
+    {}
+
+    virtual void begin_attempt(const Pokemon::StoryCheckpoint& data) override{
+        m_row = data.id;
+        trace.push_back("begin " + data.id);
+    }
+    virtual Outcome run(RunState& state, const Pokemon::StoryStep& step) override{
+        const std::string key = m_row + "/" + step.name;
+        trace.push_back(key);
+        auto failure = failures.find(key);
+        if (failure != failures.end() && failure->second.times > 0){
+            failure->second.times--;
+            return Pokemon::outcome_failed(failure->second.failure, key);
+        }
+        return Pokemon::StoryStepExecutor::run(state, step);
+    }
+    virtual Outcome route(RunState& state, const Pokemon::StoryStep& step) override{
+        const Walked walked = plan_route(Pokemon::tiles_of(state.pose), step);
+        if (!walked.error.empty()){
+            return Pokemon::outcome_failed("no_plan", walked.error);
+        }
+        plans.push_back(walked.plan);
+        return Pokemon::outcome_ok(Pokemon::tile_pose(step.target->map, walked.at));
+    }
+    virtual Outcome legs(RunState& state, const Pokemon::StoryStep& step) override{
+        const Walked walked = walk_legs(Pokemon::tiles_of(state.pose), step);
+        if (!walked.error.empty()){
+            return Pokemon::outcome_failed("blocked", walked.error);
+        }
+        return Pokemon::outcome_ok(Pokemon::tile_pose(state.pose.map, walked.at));
+    }
+    virtual Outcome step(RunState&, const Pokemon::StoryStep&) override{ return Pokemon::outcome_ok(); }
+    virtual Outcome mash(RunState&, const Pokemon::StoryStep&) override{ return Pokemon::outcome_ok(); }
+    virtual Outcome battle(RunState&, const Pokemon::StoryStep&) override{ return Pokemon::outcome_ok(); }
+    virtual Outcome train(RunState&, const Pokemon::StoryStep&) override{ return Pokemon::outcome_ok(); }
+    virtual Outcome heal(RunState&, const Pokemon::StoryStep&) override{ return Pokemon::outcome_ok(); }
+    virtual Outcome shop(RunState&, const Pokemon::StoryStep&) override{ return Pokemon::outcome_ok(); }
+    virtual Outcome save(RunState&, const Pokemon::StoryStep&) override{
+        trace.push_back("save in " + m_row);
+        return Pokemon::outcome_ok();
+    }
+    virtual Outcome game(RunState&, const Pokemon::StoryStep&) override{ return Pokemon::outcome_ok(); }
+
+private:
+    std::string m_row;
+};
+
+
+//  One simulated run of both segments, as the program runs them. Its
+//  executor has a language no reader supports (Japanese), so a step that
+//  needed text would show. (The console's global language is left alone:
+//  tests run in parallel.)
+struct Simulation{
+    std::vector<std::string> trace;
+    std::vector<std::string> lines;
+    FakeRunner runner{trace};
+    std::shared_ptr<FakeGame> game = std::make_shared<FakeGame>(trace);
+    Pokemon::SegmentPolicy policy;
+
+    Pokemon::SegmentReport run(const std::string& id, const std::vector<StoryRow>& table, const Pokemon::SegmentRange& range){
+        game->set_language(Language::Japanese);
+        Pokemon::Segment segment = story_table_segment(runner, id, table, game);
+        Pokemon::SegmentHooks hooks;
+        hooks.reload = [this](RunState&){
+            trace.push_back("reload");
+            return Pokemon::outcome_ok();
+        };
+        hooks.log = [this](const std::string& line){ lines.push_back(line); };
+        RunState state;
+        return Pokemon::run_segment(state, segment, range, policy, hooks);
+    }
+    //  The rows begun, in order, one per attempt.
+    std::vector<std::string> begun() const{
+        std::vector<std::string> ids;
+        for (const std::string& item : trace){
+            if (item.starts_with("begin ")){
+                ids.push_back(item.substr(6));
+            }
+        }
+        return ids;
+    }
+    size_t count(const std::string& item) const{
+        return (size_t)std::count(trace.begin(), trace.end(), item);
+    }
+    bool logged(const std::string& line) const{
+        return std::find(lines.begin(), lines.end(), line) != lines.end();
+    }
+};
+
+std::vector<std::string> ids_of(const std::vector<StoryRow>& table){
+    std::vector<std::string> ids;
+    for (const StoryRow& row : table){
+        ids.push_back(row.id);
+    }
+    return ids;
+}
+
+
+UnitTestResult test_whole_table(Logger& logger){
+    Simulation sim;
+    const Pokemon::SegmentReport first = sim.run("00", segment_00_table(), {});
+    const Pokemon::SegmentReport second = sim.run("01", segment_01_table(), {});
+    for (const std::string& plan : sim.game->plans){
+        logger.log(plan);
+    }
+    if (!first.completed || !second.completed){
+        return "Expected both segments through:" + joined(sim.lines);
+    }
+    std::vector<std::string> expected = ids_of(segment_00_table());
+    for (const std::string& id : ids_of(segment_01_table())){
+        expected.push_back(id);
+    }
+    if (sim.begun() != expected){
+        return "Unexpected checkpoint order:" + joined(sim.begun());
+    }
+    //  Every row saves first but 00.00, which a failure ends; 01.10 and
+    //  01.11 save again at their ends.
+    for (const std::string& id : expected){
+        const size_t saves = sim.count("save " + id);
+        if (saves != (id == "00.00" ? 0 : 1)){
+            return std::format("{} saved {} times at its start:{}", id, saves, joined(sim.trace));
+        }
+    }
+    if (sim.count("save in 01.10") != 1 || sim.count("save in 01.11") != 1){
+        return "Expected 01.10 and 01.11 to save at their ends:" + joined(sim.trace);
+    }
+    if (first.one_shot_passes() != first.checkpoints_run || second.one_shot_passes() != second.checkpoints_run){
+        return "Expected every checkpoint one-shot:" + joined(sim.lines);
+    }
+    return true;
+}
+
+UnitTestResult test_start_and_end(Logger&){
+    Simulation sim;
+    Pokemon::SegmentReport report = sim.run("00", segment_00_table(), {.from = "00.04b", .to = "00.04d"});
+    if (!report.completed || sim.begun() != std::vector<std::string>{"00.04b", "00.04c", "00.04d"}){
+        return "Expected 00.04b to 00.04d only:" + joined(sim.begun());
+    }
+    Simulation tail;
+    report = tail.run("01", segment_01_table(), {.from = "01.10", .to = std::nullopt});
+    if (!report.completed || tail.begun() != std::vector<std::string>{"01.10", "01.11"}){
+        return "Expected 01.10 to the end:" + joined(tail.begun());
+    }
+    Simulation one;
+    report = one.run("00", segment_00_table(), {.from = "00.02", .to = "00.02"});
+    if (!report.completed || one.begun() != std::vector<std::string>{"00.02"}){
+        return "Expected 00.02 alone:" + joined(one.begun());
+    }
+    return true;
+}
+
+//  r72: a blackout in 00.04b's training. The checkpoint resets to the save
+//  it made at its start, does not save again, and walks from that save's
+//  pose to the grass again.
+UnitTestResult test_training_blackout(Logger&){
+    Simulation sim;
+    sim.game->failures["00.04b/train"] = {.failure = "blackout", .times = 1};
+    const Pokemon::SegmentReport report = sim.run("00", segment_00_table(), {.from = "00.04b", .to = "00.04d"});
+    const std::vector<std::string> expected{"00.04b", "00.04b", "00.04c", "00.04d"};
+    if (!report.completed || report.reloads != 1 || sim.begun() != expected){
+        return "Expected 00.04b reloaded once, then on:" + joined(sim.trace);
+    }
+    if (sim.count("save 00.04b") != 1 || sim.count("00.04b/to_catch_grass") != 2){
+        return "Expected the retry to start from 00.04b's one save and walk to the grass again:" + joined(sim.trace);
+    }
+    if (!sim.logged("[Checkpoint] 00.04b: passed on attempt 2 (1 reset)")){
+        return "Expected the retried pass logged:" + joined(sim.lines);
+    }
+    return true;
+}
+
+//  A step that fails every time: three attempts from the checkpoint's
+//  save, then the segment stops on it and runs nothing after.
+UnitTestResult test_gives_up_after_attempts(Logger&){
+    Simulation sim;
+    sim.game->failures["01.04/oreburgh_gym"] = {.failure = "operation_failed", .times = 10};
+    const Pokemon::SegmentReport report = sim.run("01", segment_01_table(), {});
+    if (report.completed || report.reloads != 2 || report.failed_checkpoint != "01.04" || report.failed_event != "oreburgh_gym"
+        || report.runs.empty() || report.runs.back().attempts != 3 || sim.count("01.04/oreburgh_gym") != 3
+        || sim.count("save 01.04") != 1 || sim.count("begin 01.05") != 0
+    ){
+        return "Expected 01.04 tried 3 times from its save, then a stop:" + joined(sim.trace) + joined(sim.lines);
+    }
+    //  The stop-at-first-failure option: no reload.
+    Simulation lab;
+    lab.policy.stop_at_first_failure = true;
+    lab.game->failures["01.04/oreburgh_gym"] = {.failure = "operation_failed", .times = 10};
+    const Pokemon::SegmentReport stopped = lab.run("01", segment_01_table(), {});
+    if (stopped.completed || !stopped.stopped_at_first_failure || lab.count("reload") != 0){
+        return "Expected a stop at the first failure without a reload:" + joined(lab.trace);
+    }
+    return true;
+}
+
+//  Each row that has a start pose starts where the row before it leaves
+//  the player, by the same planning and walking the fake run does.
+UnitTestResult test_poses_chain(Logger&){
+    for (const std::vector<StoryRow>* table : {&segment_00_table(), &segment_01_table()}){
+        std::optional<std::vector<TilePos>> at;
+        std::string last = "";
+        for (const StoryRow& row : *table){
+            if (row.start){
+                const std::vector<TilePos> start = Pokemon::tiles_of(*row.start);
+                if (at && !std::ranges::all_of(*at, [&](const TilePos& pos){ return contains(start, pos); })){
+                    return std::format("{} starts at{}, but {} may end at{}.", row.id, describe(start), last, describe(*at));
+                }
+                at = start;
+            }else{
+                at.reset();
+            }
+            for (const Pokemon::StoryStep& step : row.steps){
+                if (step.kind == StoryStepKind::ROUTE || step.kind == StoryStepKind::LEGS){
+                    if (!at){
+                        return row.id + " " + step.name + ": walks from an unknown pose.";
+                    }
+                    const Walked walked = step.kind == StoryStepKind::ROUTE ? plan_route(*at, step) : walk_legs(*at, step);
+                    if (!walked.error.empty()){
+                        return row.id + " " + walked.error;
+                    }
+                    at = walked.at;
+                }else if (step.kind == StoryStepKind::GAME || step.kind == StoryStepKind::SHOP){
+                    //  A call to an old function: where it ends is the table's to say.
+                    at.reset();
+                }
+                if (step.pose_after){
+                    at = Pokemon::tiles_of(*step.pose_after);
+                }
+            }
+            last = row.id;
+        }
+    }
+    return true;
+}
+
+//  Every step that calls an old function names one the segment registers,
+//  and each table lints clean.
+UnitTestResult test_variants_registered(Logger&){
+    const struct{ const std::vector<StoryRow>* table; std::map<std::string, ConsoleStoryExecutor::Variant> variants; } segments[] = {
+        {.table = &segment_00_table(), .variants = segment_00_variants()},
+        {.table = &segment_01_table(), .variants = segment_01_variants()},
+    };
+    const std::set<std::string> built_in{"", "town", "robust", "one_short_ok"};
+    for (const auto& segment : segments){
+        for (const StoryRow& row : *segment.table){
+            const std::vector<std::string> problems = Pokemon::lint_story_checkpoint(row);
+            if (!problems.empty()){
+                return problems[0];
+            }
+            for (const Pokemon::StoryStep& step : row.steps){
+                if (!built_in.contains(step.variant) && !segment.variants.contains(step.variant)){
+                    return std::format("{} {}: no variant \"{}\" is registered.", row.id, step.name, step.variant);
+                }
+            }
+        }
+    }
+    return true;
+}
+
+//  With no reader for the game's language, the reads that used text give
+//  way: a banner or save card that showed matches any map, so walks check
+//  where they stand by the grid.
+UnitTestResult test_no_text_reader(Logger&){
+    for (Language language : {Language::Japanese, Language::Korean, Language::French}){
+        if (story_reads_text(language)){
+            return std::string("Expected no text reader for ") + language_data(language).name + ".";
+        }
+    }
+    if (!location_banner_matches(UNREAD_LOCATION, MAP_ROUTE_202) || location_banner_matches("", MAP_ROUTE_202)){
+        return "Expected a shown, unread banner to match and no banner not to.";
+    }
+    if (!story_reads_text(Language::English) || location_banner_matches("sandgemtown", MAP_ROUTE_202)){
+        return "Expected English banners read and compared.";
+    }
+    return true;
+}
+
+//  r261: out of the Center the walk saw no dark fade and walked on three
+//  rows. The walk stops at the first look that is not a room, fade or not.
+UnitTestResult test_door_exit_looks(Logger&){
+    const struct{ const char* name; std::vector<std::pair<double, bool>> looks; size_t stops_at; } cases[] = {
+        {.name = "no fade: the first look outside", .looks = {{180, true}, {175, true}, {230, false}}, .stops_at = 2},
+        {.name = "the fade, then outside", .looks = {{180, true}, {40, true}, {210, false}}, .stops_at = 2},
+        {.name = "a dim look outside", .looks = {{180, true}, {150, false}, {230, false}}, .stops_at = 1},
+        {.name = "still a room", .looks = {{180, true}, {40, true}, {190, true}}, .stops_at = 3},
+    };
+    for (const auto& c : cases){
+        DoorFadeWatch watch;
+        size_t stopped = c.looks.size();
+        for (size_t i = 0; i < c.looks.size(); i++){
+            if (door_walk_stops(watch, c.looks[i].first, c.looks[i].second)){
+                stopped = i;
+                break;
+            }
+        }
+        if (stopped != c.stops_at){
+            return std::format("{}: stopped at look {}, expected {}.", c.name, stopped, c.stops_at);
+        }
+    }
+    return true;
+}
+
+
+class Test_StorySimulation : public UnitTest{
+public:
+    Test_StorySimulation(std::string name, std::function<UnitTestResult(Logger&)> body)
+        : UnitTest("PokemonBDSP::AutoStory - Simulation: " + std::move(name))
+        , m_body(std::move(body))
+    {}
+    virtual UnitTestResult run(Logger& logger, CancellableScope&) const override{
+        try{
+            return m_body(logger);
+        }catch (Exception& e){
+            return std::string(e.name()) + ": " + e.message();
+        }
+    }
+
+private:
+    std::function<UnitTestResult(Logger&)> m_body;
+};
+
+}
+
+
+void add_tests_AutoStory_StorySimulation(UnitTestDatabase& database){
+    database.add<Test_StorySimulation>("00.00 to Floaroma, in order, each row saved first", test_whole_table);
+    database.add<Test_StorySimulation>("start and end checkpoints", test_start_and_end);
+    database.add<Test_StorySimulation>("a blackout in 00.04b's training resets to its save", test_training_blackout);
+    database.add<Test_StorySimulation>("a step that keeps failing stops after 3 attempts", test_gives_up_after_attempts);
+    database.add<Test_StorySimulation>("each start pose is where the row before ends; routes plan on the maps", test_poses_chain);
+    database.add<Test_StorySimulation>("every called function is registered; tables lint", test_variants_registered);
+    database.add<Test_StorySimulation>("out of a door: the first look that is not a room", test_door_exit_looks);
+    database.add<Test_StorySimulation>("no text reader for the game's language", test_no_text_reader);
+}
+
+
+
+}
+}
+}
diff --git a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory_StorySimulation_Tests.h b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory_StorySimulation_Tests.h
new file mode 100644
index 0000000000..b893232ca3
--- /dev/null
+++ b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory_StorySimulation_Tests.h
@@ -0,0 +1,27 @@
+/*  BDSP AutoStory Story Simulation Tests
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ */
+
+#ifndef PokemonAutomation_PokemonBDSP_AutoStory_StorySimulation_Tests_H
+#define PokemonAutomation_PokemonBDSP_AutoStory_StorySimulation_Tests_H
+
+#include "Common/Cpp/TestRunners/UnitTestDatabase.h"
+
+namespace PokemonAutomation{
+namespace NintendoSwitch{
+namespace PokemonBDSP{
+
+
+//  Segments 00 and 01 run end to end without a console: the story table,
+//  the shared segment runner and its retry policy, against a fake game
+//  that plans every route and walk on the built-in maps.
+void add_tests_AutoStory_StorySimulation(UnitTestDatabase& database);
+
+
+
+}
+}
+}
+#endif
diff --git a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory_StoryTable.cpp b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory_StoryTable.cpp
new file mode 100644
index 0000000000..cc6e2f4c9e
--- /dev/null
+++ b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory_StoryTable.cpp
@@ -0,0 +1,252 @@
+/*  BDSP AutoStory - Story table
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ */
+
+#include <algorithm>
+#include <utility>
+#include "Data/PokemonBDSP_AutoStory_Route202.h"
+#include "Data/PokemonBDSP_AutoStory_SandgemTown.h"
+#include "Data/PokemonBDSP_AutoStory_StoryMaps.h"
+#include "PokemonBDSP_AutoStory_StoryTable.h"
+
+namespace PokemonAutomation{
+namespace NintendoSwitch{
+namespace PokemonBDSP{
+
+using Pokemon::Direction;
+using Pokemon::Pose;
+using Pokemon::StoryLeg;
+using Pokemon::StoryStep;
+using Pokemon::StoryStepKind;
+using Pokemon::TilePos;
+
+
+namespace{
+
+constexpr Direction NORTH = Direction::NORTH;
+constexpr Direction WEST = Direction::WEST;
+
+TilePos world(const char* map, const TilePos& local){
+    return story_maps().to_world(map, local);
+}
+
+//  A pose on any of `tiles`, world tiles of story_maps().
+Pose on(const char* map, std::vector<TilePos> tiles, std::optional<Direction> facing = std::nullopt){
+    return Pokemon::tile_pose(map, std::move(tiles), facing);
+}
+
+Pose save_spot(){
+    return on(MAP_ROUTE_202, {world(MAP_ROUTE_202, Route202::SAVE_SPOT)});
+}
+
+//  The catch grass training walks into: the tall grass of the training area.
+std::vector<TilePos> catch_grass(){
+    std::vector<TilePos> grass = story_after_training_area();
+    std::erase_if(grass, [](const TilePos& pos){
+        return story_maps().world().at(pos) != Pokemon::TileType::TALL_GRASS;
+    });
+    return grass;
+}
+
+//  Route 202's open rows at the top: north from any of them is Jubilife.
+std::vector<TilePos> jubilife_exit(){
+    std::vector<TilePos> exit;
+    const Pokemon::TileGrid& grid = Route202::grid();
+    for (int y = 0; y <= 3; y++){
+        for (int x = 0; x < grid.width(); x++){
+            const TilePos pos = world(MAP_ROUTE_202, {x, y});
+            if (story_maps().world().standable(pos) && story_at_jubilife_exit(pos)){
+                exit.push_back(pos);
+            }
+        }
+    }
+    return exit;
+}
+
+
+StoryStep make(StoryStepKind kind, std::string name, std::string why){
+    StoryStep step;
+    step.kind = kind;
+    step.name = std::move(name);
+    step.why = std::move(why);
+    return step;
+}
+
+//  A step that calls the old function named `name` (the segment's variant).
+StoryStep call(std::string name, std::string why, std::optional<Pose> pose_after = std::nullopt){
+    StoryStep step = make(StoryStepKind::GAME, name, std::move(why));
+    step.variant = std::move(name);
+    step.pose_after = std::move(pose_after);
+    return step;
+}
+
+StoryStep route(std::string name, Pose target, std::string why, std::string costs = ""){
+    StoryStep step = make(StoryStepKind::ROUTE, std::move(name), std::move(why));
+    step.target = std::move(target);
+    step.variant = std::move(costs);
+    return step;
+}
+
+StoryStep legs(std::string name, std::vector<StoryLeg> legs, std::string why, std::string variant = ""){
+    StoryStep step = make(StoryStepKind::LEGS, std::move(name), std::move(why));
+    step.legs = std::move(legs);
+    step.variant = std::move(variant);
+    return step;
+}
+
+StoryStep train(size_t battles, Pose pose_after, std::string why){
+    StoryStep step = make(StoryStepKind::TRAIN, "train", std::move(why));
+    step.battles = battles;
+    step.pose_after = std::move(pose_after);
+    return step;
+}
+
+StoryStep heal(std::string name, Pose pose_after, std::string why){
+    StoryStep step = make(StoryStepKind::HEAL, std::move(name), std::move(why));
+    step.pose_after = std::move(pose_after);
+    return step;
+}
+
+StoryStep with_variant(StoryStep step, std::string variant){
+    step.variant = std::move(variant);
+    return step;
+}
+
+StoryRow row(std::string id, std::string title, std::optional<Pose> start, std::vector<StoryStep> steps,
+    StoryFailure on_failure = StoryFailure::RELOAD_AND_RETRY
+){
+    StoryRow ret;
+    ret.id = std::move(id);
+    ret.title = std::move(title);
+    ret.start = std::move(start);
+    ret.steps = std::move(steps);
+    ret.on_failure = on_failure;
+    return ret;
+}
+
+
+std::vector<StoryRow> make_segment_00(){
+    const int to_center_door = SandgemTown::POKEMON_CENTER_SIGN.x - SandgemTown::POKEMON_CENTER_DOOR.x;
+    const Pose center_door_front = on(MAP_SANDGEM_TOWN, story_door_front(MAP_SANDGEM_TOWN, SandgemTown::POKEMON_CENTER_DOOR));
+    StoryStep potions = make(StoryStepKind::SHOP, "potions",
+        "Potions before Route 202's trainers: the Poke Mart lady's 10 (she stands still, as in the decomp), the clerk's 5 after two misses");
+    potions.items = {{.item = "potion", .quantity = 10}};
+    potions.variant = "sandgem_potions";
+    potions.pose_after = save_spot();
+    StoryStep stairs = make(StoryStepKind::STEP, "into_jubilife",
+        "Jubilife's south edge is a wall with stairs in it, west of where the route may leave us (r78)");
+    stairs.direction = NORTH;
+    stairs.variant = "jubilife_stairs";
+
+    return {
+        row("00.00", "Verify Settings", std::nullopt, {
+            call("verify_settings", "before any route movement or checkpoint save: fail visibly if options cannot be read"),
+        }, StoryFailure::STOP),
+        row("00.01", "After TV", std::nullopt, {
+            call("tutorial_part_1_navigation", "intro and starter selection: Butters' recorded stick holds to the lake"),
+        }),
+        row("00.02", "Outside Verity before starter", std::nullopt, {
+            call("starter_nav", "into the lake's scene"),
+            call("select_starter", "the starter from the program's option"),
+            with_variant(make(StoryStepKind::BATTLE, "fight_starly", "the Starly battle"), "fight_starly"),
+            with_variant(make(StoryStepKind::MASH, "post_starly_cleanup", "the scene after the battle"), "post_starly_cleanup"),
+        }),
+        row("00.03", "Outside Verity after starter", std::nullopt, {
+            call("tutorial_part_2_navigation", "Pokedex acquisition: back through Route 201 to Rowan's lab"),
+        }),
+        row("00.04", "After Pokedex, to the catch", std::nullopt, {
+            call("tutorial_part_3_navigation", "out of the lab, home to Mom, and the catch on Route 202",
+                on(MAP_ROUTE_202, story_catch_save_area())),
+        }),
+        //  A Lv5 starter fainted to Route 202's trainers (r72): training, a
+        //  heal, and Potions first, each row from the save the one before ends on.
+        row("00.04b", "After the catch: train and heal in Sandgem", on(MAP_ROUTE_202, story_catch_save_area()), {
+            route("to_catch_grass", on(MAP_ROUTE_202, catch_grass()), "into the training column's grass"),
+            train(3, on(MAP_ROUTE_202, story_after_training_area()), "three wild battles with the best move"),
+            //  One walk round the houses ended two tiles short (r252): down
+            //  the road first, then the town plan.
+            route("into_sandgem", on(MAP_SANDGEM_TOWN, {world(MAP_SANDGEM_TOWN, SandgemTown::ROUTE_202_ENTRY_STOP)}),
+                "south down the road to above the Mart", "robust"),
+            route("to_center_sign", on(MAP_SANDGEM_TOWN, {world(MAP_SANDGEM_TOWN, SandgemTown::POKEMON_CENTER_SIGN.next(Direction::SOUTH))}),
+                "below the Center's sign, its doorway in sight", "town"),
+            //  From below the sign the finder read the signs' panels as
+            //  doorways (r252, r255): taps instead. One tile short is fine.
+            legs("below_center_door", {{.direction = WEST, .tiles = to_center_door}}, "taps west below the Center's door", "one_short_ok"),
+            heal("heal_sandgem", center_door_front, "Sandgem Town Pokemon Center"),
+        }),
+        row("00.04c", "Potions, back to Route 202's save spot", center_door_front, {
+            potions,
+        }),
+        //  From the one save spot: from both at once the planner gives up.
+        row("00.04d", "Route 202's trainers, Dawn in Jubilife", save_spot(), {
+            route("north_to_jubilife", on(MAP_ROUTE_202, jubilife_exit()), "north past Route 202's trainers, fighting who sees us"),
+            stairs,
+            make(StoryStepKind::MASH, "dawn_scene", "Dawn walks over while we stand still"),
+        }),
+        row("00.05", "Jubilife After Dawn", std::nullopt, {
+            call("tutorial_part_4_navigation", "the Town Map, the president, the coupons, the Poketch and the Center's PC"),
+        }),
+    };
+}
+
+std::vector<StoryRow> make_segment_01(){
+    StoryStep save = make(StoryStepKind::SAVE, "save_here", "the next checkpoint starts here");
+    return {
+        row("01.01", "Jubilife to Barry", std::nullopt, {
+            call("jubilife_to_barry", "from the Center's PC out to Barry on Route 203"),
+        }),
+        row("01.02", "Route 203 to Oreburgh", std::nullopt, {
+            call("route203_to_oreburgh", "east through the Oreburgh Gate into Oreburgh City"),
+        }),
+        row("01.03", "Oreburgh Mine to Roark", std::nullopt, {
+            call("oreburgh_to_roark", "into the Mine to Roark and back to the Center"),
+        }),
+        row("01.04", "Oreburgh Gym", std::nullopt, {
+            call("oreburgh_gym", "the Gym's trainers and Roark for the Coal Badge"),
+        }),
+        row("01.05", "Oreburgh to Route 203", std::nullopt, {
+            call("oreburgh_to_route203", "heal, then west out of the Oreburgh Gate"),
+        }),
+        row("01.06", "Route 203 to Jubilife", std::nullopt, {
+            call("route203_to_jubilife", "west along Route 203 into Jubilife"),
+        }),
+        row("01.07", "Jubilife through Rowan's scene", std::nullopt, {
+            call("jubilife_to_rowan", "to the north street, Rowan's scene and the tag battle"),
+        }),
+        row("01.08", "Jubilife to the Ravaged Path", std::nullopt, {
+            call("jubilife_to_ravaged_path", "up Route 204's south half into the Ravaged Path"),
+        }),
+        row("01.09", "Ravaged Path", std::nullopt, {
+            call("ravaged_path", "through the cave with Rock Smash, out onto Route 204 North"),
+        }),
+        row("01.10", "Route 204 to Floaroma", std::nullopt, {
+            call("route204_to_floaroma", "the human's line north into Floaroma"),
+            save,
+        }),
+        row("01.11", "Floaroma's old couple", std::nullopt, {
+            call("floaroma_old_couple", "the old woman and the old man in the flower field"),
+            save,
+        }),
+    };
+}
+
+}
+
+
+const std::vector<StoryRow>& segment_00_table(){
+    static const std::vector<StoryRow> table = make_segment_00();
+    return table;
+}
+
+const std::vector<StoryRow>& segment_01_table(){
+    static const std::vector<StoryRow> table = make_segment_01();
+    return table;
+}
+
+
+
+}
+}
+}
diff --git a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory_StoryTable.h b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory_StoryTable.h
new file mode 100644
index 0000000000..53a92dd035
--- /dev/null
+++ b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory_StoryTable.h
@@ -0,0 +1,42 @@
+/*  BDSP AutoStory - Story table
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ *  Segments 00 and 01, new game to Floaroma, as rows of the shared story
+ *  steps (Pokemon/Navigation/Pokemon_StorySteps.h): plain data, as FRLG's
+ *  table is, so the tests can plan its routes and run it against a fake
+ *  game. Each row saves at its start, which is where the row before it
+ *  ends.
+ *
+ *  Steps that have no declarative form yet call one of the old functions:
+ *  a GAME step (or another kind with a variant) names it, and the segment
+ *  registers it with its executor (segment_00_variants(),
+ *  segment_01_variants()). Those are the next to split.
+ *
+ */
+
+#ifndef PokemonAutomation_PokemonBDSP_AutoStory_StoryTable_H
+#define PokemonAutomation_PokemonBDSP_AutoStory_StoryTable_H
+
+#include <vector>
+#include "PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_StoryTables.h"
+
+namespace PokemonAutomation{
+namespace NintendoSwitch{
+namespace PokemonBDSP{
+
+
+//  00.00 to 00.05: the settings, the lake, the Pokedex, the catch, Sandgem
+//  and Route 202 (00.04b to 00.04d as story steps), Jubilife to the Poketch.
+const std::vector<StoryRow>& segment_00_table();
+
+//  01.01 to 01.11: Jubilife to Oreburgh and the Coal Badge, back, and north
+//  to Floaroma's old couple.
+const std::vector<StoryRow>& segment_01_table();
+
+
+
+}
+}
+}
+#endif
diff --git a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory_StoryTables_Tests.cpp b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory_StoryTables_Tests.cpp
index 4584f48280..82dcc701ed 100644
--- a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory_StoryTables_Tests.cpp
+++ b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory_StoryTables_Tests.cpp
@@ -31,7 +31,7 @@ class DescribeOnlyRunner : public StoryStepRunner{
     virtual Pokemon::Outcome save_at_start(const std::string&) override{
         return Pokemon::outcome_failed("not_run");
     }
-    virtual Pokemon::Outcome run_step(const std::string&, StoryFailure, const StoryStep&) override{
+    virtual Pokemon::Outcome run_step(const std::string&, StoryFailure, const StoryAction&) override{
         return Pokemon::outcome_failed("not_run");
     }
 };
diff --git a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory_Tests.cpp b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory_Tests.cpp
index 9c117daa5a..9362b8c365 100644
--- a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory_Tests.cpp
+++ b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory_Tests.cpp
@@ -1416,12 +1416,16 @@ class Test_PokemonCenterInside : public UnitTest{
 class FakeMartLady : public MartLadyActions{
 public:
     enum class Where{
-        DOORS_ROW, LAB_EAST, PATH_WEST, GRASS_EDGE, TOP_EDGE, LADY,
+        DOORS_ROW, SHORT_OF_LAB, LAB_EAST, PATH_WEST, GRASS_EDGE, TOP_EDGE, LADY,
         SIGNS_ROW, SHORT_OF_201, ROUTE_201_WEST, PATH_EAST, MART_TREES_LOW, MART_TREES, ROUTE_202,
     };
 
     //  Walks back east that a wild battle ends short of the sign.
     size_t short_walks = 0;
+    //  Walks west along the doors' row that a townsperson ends short of the Lab's sign.
+    size_t short_lab_walks = 0;
+    //  No text reader for the game's language: boxes open and close, unread.
+    bool unread = false;
     //  Talks to the lady before she is there to answer.
     size_t lady_away = 0;
     Where where = Where::DOORS_ROW;
@@ -1451,6 +1455,7 @@ class FakeMartLady : public MartLadyActions{
         trace.push_back("go: " + label);
         const struct{ Where from; Direction direction; Where to; } walks[] = {
             {Where::DOORS_ROW, Direction::WEST, Where::LAB_EAST},
+            {Where::SHORT_OF_LAB, Direction::WEST, Where::LAB_EAST},
             {Where::PATH_WEST, Direction::WEST, Where::GRASS_EDGE},
             {Where::GRASS_EDGE, Direction::NORTH, Where::TOP_EDGE},
             {Where::LADY, Direction::WEST, Where::TOP_EDGE},
@@ -1467,6 +1472,10 @@ class FakeMartLady : public MartLadyActions{
                     short_walks--;
                     where = Where::SHORT_OF_201;
                 }
+                if (where == Where::LAB_EAST && short_lab_walks > 0 && walk.from == Where::DOORS_ROW){
+                    short_lab_walks--;
+                    where = Where::SHORT_OF_LAB;
+                }
                 break;
             }
         }
@@ -1493,10 +1502,10 @@ class FakeMartLady : public MartLadyActions{
     virtual DialogueRead read_sign(Direction facing, const std::string& label) override{
         trace.push_back("read: " + label);
         if (where == Where::LAB_EAST && facing == Direction::WEST){
-            return DialogueRead{.opened = true, .closed = true, .text = "Pokemon Research Lab"};
+            return DialogueRead{.opened = true, .closed = true, .text = unread ? "" : "Pokemon Research Lab"};
         }
         if (where == Where::ROUTE_201_WEST && facing == Direction::EAST){
-            return DialogueRead{.opened = true, .closed = true, .text = "Route 201 Sandgem Town"};
+            return DialogueRead{.opened = true, .closed = true, .text = unread ? "" : "Route 201 Sandgem Town"};
         }
         return DialogueRead{};
     }
@@ -1510,7 +1519,7 @@ class FakeMartLady : public MartLadyActions{
             lady_away--;
             return DialogueRead{};
         }
-        return DialogueRead{.opened = true, .closed = true, .text = "Did you know"};
+        return DialogueRead{.opened = true, .closed = true, .text = unread ? "" : "Did you know"};
     }
     virtual Pokemon::Outcome walk_to_route_202_save_spot() override{
         trace.push_back("to Route 202");
@@ -1548,10 +1557,14 @@ class Test_MartLadyEvents : public UnitTest{
             }
             return all;
         };
+        const std::vector<std::string> TO_LAB = {"go: West to the Lab's sign", "read: the Lab's sign"};
+        const std::vector<std::string> LAB_TO_LADY = {"step: South onto the path", "go: West along the path", "go: North to the trees"};
         struct Case{
             const char* name;
             size_t short_walks;
+            size_t short_lab_walks = 0;
             size_t lady_away;
+            bool unread = false;
             bool completed;
             size_t failed_event;
             std::vector<std::string> trace;
@@ -1560,7 +1573,9 @@ class Test_MartLadyEvents : public UnitTest{
             {
                 .name = "Straight through",
                 .short_walks = 0,
+                .short_lab_walks = 0,
                 .lady_away = 0,
+                .unread = false,
                 .completed = true,
                 .failed_event = 0,
                 .trace = join({TO_LADY, LADY, TO_SIGN, SIGN, HOME}),
@@ -1568,15 +1583,39 @@ class Test_MartLadyEvents : public UnitTest{
             {
                 .name = "Back east, a tile short of the sign",
                 .short_walks = 1,
+                .short_lab_walks = 0,
                 .lady_away = 0,
+                .unread = false,
                 .completed = true,
                 .failed_event = 0,
                 .trace = join({TO_LADY, LADY, TO_SIGN, SIGN, {"go: On to the sign"}, SIGN, HOME}),
             },
+            {
+                .name = "West, a tile short of the Lab's sign: re-anchored on it",
+                .short_walks = 0,
+                .short_lab_walks = 1,
+                .lady_away = 0,
+                .unread = false,
+                .completed = true,
+                .failed_event = 0,
+                .trace = join({TO_LAB, {"go: On to the sign", "read: the Lab's sign"}, LAB_TO_LADY, LADY, TO_SIGN, SIGN, HOME}),
+            },
+            {
+                .name = "No text reader for the game's language: boxes open and close, unread",
+                .short_walks = 1,
+                .short_lab_walks = 1,
+                .lady_away = 0,
+                .unread = true,
+                .completed = true,
+                .failed_event = 0,
+                .trace = join({TO_LAB, {"go: On to the sign", "read: the Lab's sign"}, LAB_TO_LADY, LADY, TO_SIGN, SIGN, {"go: On to the sign"}, SIGN, HOME}),
+            },
             {
                 .name = "The lady answers the second time",
                 .short_walks = 0,
+                .short_lab_walks = 0,
                 .lady_away = 1,
+                .unread = false,
                 .completed = true,
                 .failed_event = 0,
                 .trace = join({TO_LADY, LADY, RETRY, LADY, TO_SIGN, SIGN, HOME}),
@@ -1584,7 +1623,9 @@ class Test_MartLadyEvents : public UnitTest{
             {
                 .name = "The lady never answers",
                 .short_walks = 0,
+                .short_lab_walks = 0,
                 .lady_away = 5,
+                .unread = false,
                 .completed = false,
                 .failed_event = 6,
                 .trace = join({TO_LADY, LADY, RETRY, LADY, RETRY, LADY}),
@@ -1593,6 +1634,8 @@ class Test_MartLadyEvents : public UnitTest{
         for (const Case& c : cases){
             FakeMartLady game;
             game.short_walks = c.short_walks;
+            game.short_lab_walks = c.short_lab_walks;
+            game.unread = c.unread;
             game.lady_away = c.lady_away;
             Pokemon::Checkpoint checkpoint = sandgem_mart_lady_checkpoint(game);
             const std::vector<std::string> problems = Pokemon::lint_checkpoint(checkpoint);
diff --git a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/StorySegments/PokemonBDSP_AutoStory_SandgemCenterEvents.cpp b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/StorySegments/PokemonBDSP_AutoStory_SandgemCenterEvents.cpp
index 32c566f410..81f16f511d 100644
--- a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/StorySegments/PokemonBDSP_AutoStory_SandgemCenterEvents.cpp
+++ b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/StorySegments/PokemonBDSP_AutoStory_SandgemCenterEvents.cpp
@@ -364,7 +364,11 @@ class ConsoleSandgemCenterActions : public SandgemCenterActions{
             return read;
         }
         //  Tesseract read the Lab's white-on-grey text as "e R O e IO" (r131a).
-        read.text = OCR::ocr_read(Language::English, extract_box_reference(*shown.frame, SIGN_TEXT), OCR::PageSegMode::SINGLE_BLOCK);
+        //  Only to say which sign, when there is a reader for the game's
+        //  language; the box opening and closing is the check.
+        if (story_reads_text()){
+            read.text = OCR::ocr_read(g_story_language, extract_box_reference(*shown.frame, SIGN_TEXT), OCR::PageSegMode::SINGLE_BLOCK);
+        }
         stream.log("[Sign] " + label + ": reads \"" + read.text + "\" (change " + std::to_string(opened) + ").");
         for (size_t presses = 0; presses < 3 && !read.closed; presses++){
             pbf_press_button(m_context, BUTTON_B, 80ms, 1000ms);
@@ -625,8 +629,10 @@ class ConsoleMartLadyActionsT : public Base{
     void finish_talk(DialogueRead& read, Button next, const std::string& label){
         VideoStream& stream = m_env.console;
         //  The first box's text, inside its white margins.
-        if (VideoSnapshot screen = stream.video().snapshot()){
-            read.text = OCR::ocr_read(Language::English, extract_box_reference(*screen.frame, SIGN_TEXT), OCR::PageSegMode::SINGLE_BLOCK);
+        //  For the log only; a talk is checked by its box opening and closing.
+        VideoSnapshot screen = stream.video().snapshot();
+        if (screen && story_reads_text()){
+            read.text = OCR::ocr_read(g_story_language, extract_box_reference(*screen.frame, SIGN_TEXT), OCR::PageSegMode::SINGLE_BLOCK);
         }
         stream.log("[Talk] " + label + ": the dialogue reads \"" + read.text + "\".");
         size_t quiet = 0;
diff --git a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/StorySegments/PokemonBDSP_AutoStory_Segment_00.cpp b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/StorySegments/PokemonBDSP_AutoStory_Segment_00.cpp
index 3ed2023a6b..a6221ee38d 100644
--- a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/StorySegments/PokemonBDSP_AutoStory_Segment_00.cpp
+++ b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/StorySegments/PokemonBDSP_AutoStory_Segment_00.cpp
@@ -16,6 +16,8 @@
 #include "../Utils/PokemonBDSP_AutoStory_PokemonCenter.h"
 #include "../Utils/PokemonBDSP_AutoStory_RouteWalk.h"
 #include "../Utils/PokemonBDSP_AutoStory_Segment_00_tools.h"
+#include "../Utils/PokemonBDSP_AutoStory_StoryExecutor.h"
+#include "../PokemonBDSP_AutoStory_StoryTable.h"
 #include "../Utils/PokemonBDSP_AutoStory_Walk.h"
 #include "../Utils/PokemonBDSP_OverworldMatchers.h"
 
@@ -620,40 +622,6 @@ namespace PokemonAutomation {
             align_to_tutorial_landmarks(stream, context, match_sandgem_junction, "Sandgem junction");
         }
 
-        // What the post-catch half of 00.04 does, logged up front and as each
-        // step starts. A Lv5 Piplup fainted to Route 202's trainers (r72), so:
-        // training, a heal at the Center, and Potions (they also saved the
-        // Barry fight in r85) before Route 202's trainers: the Poke Mart lady's
-        // 10 on Route 201 (she stands still, as in the decomp), the clerk's 5 after two misses.
-        static const char* const AFTER_CATCH_STEPS[] = {
-            "Train: fight 3 wild Pokemon in the catch grass, with the best move",
-            "Walk south into Sandgem Town and heal at its Pokemon Center",
-            "Get 10 Potions from the Poke Mart lady on Route 201 (the clerk's 5 after two misses), and check the Bag",
-            "Walk back to Route 202's save spot (00.04d saves there)",
-            "Walk north up Route 202 to the Jubilife exit, fighting trainers who see us; after each, use a Potion if HP is under half",
-            "Enter Jubilife and get through Dawn's scene",
-        };
-        constexpr size_t AFTER_CATCH_STEP_COUNT = sizeof(AFTER_CATCH_STEPS) / sizeof(AFTER_CATCH_STEPS[0]);
-
-        static void log_after_catch_steps(VideoStream& stream) {
-            std::string text = "[00.04] After the catch, the steps are:";
-            for (size_t i = 0; i < AFTER_CATCH_STEP_COUNT; i++) {
-                text += "\n    " + std::to_string(i + 1) + ". " + AFTER_CATCH_STEPS[i];
-            }
-            stream.log(text, COLOR_BLUE);
-        }
-
-        static void after_catch_step(VideoStream& stream, size_t number) {
-            const std::string count = std::to_string(number) + "/" + std::to_string(AFTER_CATCH_STEP_COUNT);
-            std::string text = "[00.04 step " + count + "] " + AFTER_CATCH_STEPS[number - 1];
-            text += number < AFTER_CATCH_STEP_COUNT ? std::string(" -- next: ") + AFTER_CATCH_STEPS[number] : std::string(" -- last step");
-            stream.log(text, COLOR_BLUE);
-            add_wrapped_log(stream.overlay(), "00.04 step " + count + ": " + AFTER_CATCH_STEPS[number - 1], COLOR_WHITE);
-            if (number < AFTER_CATCH_STEP_COUNT) {
-                add_wrapped_log(stream.overlay(), "Next: " + std::string(AFTER_CATCH_STEPS[number]), COLOR_GRAY);
-            }
-        }
-
         // Fights a trainer whose dialogue has opened, with whatever starter we
         // have. Someone who only talks leaves no battle to fight.
         static void fight_route_trainer(VideoStream& stream, ProControllerContext& context, const std::string& name) {
@@ -674,60 +642,6 @@ namespace PokemonAutomation {
             use_potion_first_pokemon(stream, context, 0.5);
         }
 
-        // The starter starts around level 5 with only a Normal move; the Route
-        // 202 trainers need a level or two more. Starts from either save: the
-        // catch spot (00.03's save, in the grass) or the save spot under the
-        // ledge.
-        static void train_in_catch_grass(
-            VideoStream& stream, ProControllerContext& context, const MapSet& maps,
-            std::vector<TrainerSight>& trainers, const RouteTrainerFight& fight
-        ) {
-            // From where the catch's save may stand (a save on the save spot
-            // has Potions and skips training) into the training column's grass.
-            const std::vector<TilePos> grass = story_after_training_area();
-            walk_route(stream, context, maps, story_catch_save_area(),
-                [&](const TilePos& pos) {
-                    return maps.world().at(pos) == Pokemon::TileType::TALL_GRASS &&
-                        std::find(grass.begin(), grass.end(), pos) != grass.end();
-                },
-                trainers, fight, "To the catch grass");
-            for (size_t battle = 0; battle < 3; battle++) {
-                route_status(stream, "Training battle " + std::to_string(battle + 1) + "/3");
-                battle_1_pokemon(stream, context);
-                fail_if_blacked_out(stream, context, "Training battle " + std::to_string(battle + 1));
-            }
-        }
-
-        // South into Sandgem Town in two walks (down the road to where it stops
-        // above the Mart, then the town plan into the Center's sign; one walk
-        // went round the houses and ended two tiles short, r252), three taps
-        // west below the door, and in by sight. Returns: below the door.
-        static std::vector<TilePos> heal_at_sandgem_center(
-            VideoStream& stream, ProControllerContext& context, const MapSet& maps,
-            std::vector<TrainerSight>& trainers, const RouteTrainerFight& fight
-        ) {
-            const TilePos entry = maps.to_world(MAP_SANDGEM_TOWN, SandgemTown::ROUTE_202_ENTRY_STOP);
-            const TilePos below_sign = maps.to_world(MAP_SANDGEM_TOWN, SandgemTown::POKEMON_CENTER_SIGN.next(Pokemon::Direction::SOUTH));
-            const std::vector<TilePos> at = walk_route(stream, context, maps, story_after_training_area(),
-                [&](const TilePos& pos) { return pos == entry; }, trainers, fight, "Into Sandgem Town", {}, Pokemon::RobustPlanCosts());
-            walk_route(stream, context, maps, at,
-                [&](const TilePos& pos) { return pos == below_sign; }, trainers, fight, "To the Pokemon Center", {}, town_plan_costs());
-            // Below the door by D-pad taps before lining up by sight: from below
-            // the sign, the finder read the signs' white panels as doorways and
-            // stepped between them (r252, r255). We face north, and a tap the
-            // other way only turns (r256): turn first. One tile short is fine.
-            route_turn(stream, context, Pokemon::Direction::WEST);
-            const size_t to_door = (size_t)(SandgemTown::POKEMON_CENTER_SIGN.x - SandgemTown::POKEMON_CENTER_DOOR.x);
-            const WalkResult west = walk_tiles_dpad(stream, context, -1, 0, to_door, "west below the Center's door");
-            stream.log("[00.04] Taps west below the Center's door moved " + std::to_string(west.moved_chunks) + " of " + std::to_string(to_door) + " tiles.");
-            if (west.moved_chunks + 1 < to_door) {
-                OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                    "Sandgem Town: the taps west below the Center's door moved " + std::to_string(west.moved_chunks) + " tiles.", stream);
-            }
-            heal_at_pokemon_center(stream, context, "Sandgem Town Pokemon Center");
-            return story_door_front(MAP_SANDGEM_TOWN, SandgemTown::POKEMON_CENTER_DOOR);
-        }
-
         // How many Potions to buy. A Potion is 300 and a new game starts with
         // 3000; the money on screen cannot be read yet. Five heal the starter
         // through Route 202's four trainers and leave half the money.
@@ -915,13 +829,14 @@ namespace PokemonAutomation {
             walk_to_route_202_save_spot(stream, context, maps, at, trainers, fight);
         }
 
-        static void meet_dawn_in_jubilife(VideoStream& stream, ProControllerContext& context) {
-            // Jubilife's south edge is a wall with stairs in it, west of where the
-            // route may leave us (r78 stood at its east end). Entering starts a
-            // scene: Dawn walks over while we stand still. So walk north; if the
-            // wall stops us and no dialogue follows, the stairs are further west.
-            bool met_dawn = false;
-            for (size_t attempt = 0; attempt < 6 && !met_dawn; attempt++) {
+        // North into Jubilife until Dawn's scene starts (00.04d's
+        // into_jubilife). Jubilife's south edge is a wall with stairs in it,
+        // west of where the route may leave us (r78 stood at its east end).
+        // Entering starts a scene: Dawn walks over while we stand still. So
+        // walk north; if the wall stops us and no dialogue follows, the stairs
+        // are further west. The scene itself is the next step.
+        static void up_jubilife_stairs(VideoStream& stream, ProControllerContext& context) {
+            for (size_t attempt = 0; attempt < 6; attempt++) {
                 const WalkResult walk = walk_until(stream, context, 0, 1, 4000ms, "to Dawn in Jubilife");
                 if (walk.stop == WalkStop::TRANSITION) {
                     OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
@@ -929,47 +844,31 @@ namespace PokemonAutomation {
                 }
                 ShortDialogWatcher dialog(COLOR_CYAN);
                 if (walk.stop == WalkStop::DIALOG || wait_until(stream, context, 6s, {{dialog}}) == 0) {
-                    met_dawn = true;
-                    break;
+                    return;
                 }
                 stream.log("[00.04] Jubilife: the wall stopped us; looking for the stairs one tile west.");
                 route_turn(stream, context, Pokemon::Direction::WEST);
                 pbf_move_left_joystick(context, {-1, 0}, route_open_hold(Pokemon::Direction::WEST, 1), 200ms);
                 context.wait_for_all_requests();
             }
-            if (!met_dawn) {
-                OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                    "Jubilife: no stairs found and no Dawn after six tiles west.", stream);
-            }
-            wait_for_dialogue(stream, context, "Phase 21 (dawn Jubilife dialog)");
-
-            pbf_mash_button(context, BUTTON_B, 5000ms);
+            OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                "Jubilife: no stairs found and no Dawn after six tiles west.", stream);
         }
 
-        // 00.04b, 00.04c and 00.04d: the post-catch steps as three rows, each
-        // starting from the save the one before ends on. Mart lady runs that
-        // failed this program run: the clerk after two.
+        // Mart lady runs that failed this program run: the clerk after two.
         static size_t g_mart_lady_misses = 0;
-        // 00.04b, from the catch's save: steps 1 and 2.
-        static void after_catch_train_and_heal(VideoStream& stream, ProControllerContext& context) {
-            log_after_catch_steps(stream);
-            const MapSet& maps = story_maps();
-            std::vector<TrainerSight> trainers = story_trainer_sights();
-            const RouteTrainerFight fight = [&](const std::string& name) { fight_route_trainer(stream, context, name); };
-            pbf_wait(context, 1500ms);
-            after_catch_step(stream, 1);
-            train_in_catch_grass(stream, context, maps, trainers, fight);
-            after_catch_step(stream, 2);
-            heal_at_sandgem_center(stream, context, maps, trainers, fight);
-        }
-        // 00.04c, from the save out of Sandgem's Center: steps 3 and 4, up to
-        // Route 202's save spot, where 00.04d's save goes.
-        static void after_catch_potions(SingleSwitchProgramEnvironment& env, VideoStream& stream, ProControllerContext& context) {
-            const MapSet& maps = story_maps();
-            std::vector<TrainerSight> trainers = story_trainer_sights();
-            const RouteTrainerFight fight = [&](const std::string& name) { fight_route_trainer(stream, context, name); };
-            after_catch_step(stream, 3);
-            if (g_mart_lady_misses < 2) {
+        // 00.04c's potions step, from the save out of Sandgem's Center: the
+        // Poke Mart lady's (her checkpoint without its own save), or the
+        // clerk's after two misses, on to Route 202's save spot, where
+        // 00.04d's save goes. The Bag must have Potions after.
+        static Pokemon::Outcome sandgem_potions(
+            ConsoleStoryExecutor& executor, StoryConsole& c, Pokemon::RunState&, const Pokemon::StoryStep&
+        ) {
+            VideoStream& stream = c.env.console;
+            ProControllerContext& context = c.context;
+            // The clerk's list is found by reading item names, which needs a
+            // reader for the game's language; without one, the lady every time.
+            if (g_mart_lady_misses < 2 || !story_reads_text()) {
                 // Onto the doors' row first: out of the door we stand a tile to
                 // three below it (r261 walked west into the trees from three).
                 route_turn(stream, context, Pokemon::Direction::EAST);
@@ -979,28 +878,15 @@ namespace PokemonAutomation {
                     OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
                         std::string("Sandgem: north to the Center's front ended ") + walk_stop_name(up.stop) + ".", stream);
                 }
-                try { mart_lady_without_save(env, context); } catch (OperationFailedException&) { g_mart_lady_misses++; throw; }
+                try { mart_lady_without_save(c.env, context); } catch (OperationFailedException&) { g_mart_lady_misses++; throw; }
             } else {
-                const std::vector<TilePos> at = buy_potions_in_sandgem(stream, context, maps, trainers, fight);
-                after_catch_step(stream, 4);
-                walk_to_route_202_save_spot(stream, context, maps, at, trainers, fight);
+                const std::vector<TilePos> at = buy_potions_in_sandgem(stream, context, executor.maps(), executor.trainers(), executor.fight(c));
+                walk_to_route_202_save_spot(stream, context, executor.maps(), at, executor.trainers(), executor.fight(c));
             }
             if (!bag_has_item(stream, context, "potion", 1)) {
-                OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT, "00.04: no Potions in the Bag after step 3.", stream);
+                OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT, "00.04: no Potions in the Bag after the shop.", stream);
             }
-        }
-        // 00.04d, from the save on Route 202's save spot: steps 5 and 6. From
-        // both save spots at once the planner gives up (no plan within 400000
-        // sets; 1300 from the one).
-        static void after_catch_to_jubilife(VideoStream& stream, ProControllerContext& context) {
-            const MapSet& maps = story_maps();
-            std::vector<TrainerSight> trainers = story_trainer_sights();
-            const RouteTrainerFight fight = [&](const std::string& name) { fight_route_trainer(stream, context, name); };
-            after_catch_step(stream, 5);
-            const TilePos save_spot = maps.to_world(MAP_ROUTE_202, Route202::SAVE_SPOT);
-            walk_route(stream, context, maps, {save_spot}, story_at_jubilife_exit, trainers, fight, "To Jubilife");
-            after_catch_step(stream, 6);
-            meet_dawn_in_jubilife(stream, context);
+            return Pokemon::outcome_ok();
         }
         // ---------------------------------------------------------------------------
         // End of Segment 00 - 04
@@ -1378,71 +1264,30 @@ namespace PokemonAutomation {
             }
         }
 
-        static StoryCheckpointSpec segment_00_row(
-            std::string id, std::string title, StoryFailure on_failure, std::vector<StoryStepSpec> steps
-        ) {
-            return {.id = std::move(id), .title = std::move(title), .on_failure = on_failure, .steps = std::move(steps)};
-        }
-
-        // 00.00 to 00.03: the settings, the lake and the Pokedex.
-        static std::vector<StoryCheckpointSpec> segment_00_intro_rows() {
-            const StoryFailure retry = StoryFailure::RELOAD_AND_RETRY;
-            return {
-                segment_00_row("00.00", "Verify Settings", StoryFailure::STOP, {
-                    {"verify_settings", "before any route movement or checkpoint save: fail visibly if options cannot be read, rather than navigate with unknown settings", verify_settings_step},
-                }),
-                segment_00_row("00.01", "After TV", retry, {
-                    {"tutorial_part_1_navigation", "intro and starter selection: Butters' recorded stick holds to the lake",
-                        [](StoryConsole& c) { tutorial_part_1_navigation(c.env, c.env.console, c.context); }},
-                }),
-                segment_00_row("00.02", "Outside Verity before starter", retry, {
-                    {"starter_nav", "into the lake's scene", [](StoryConsole& c) { starter_nav(c.env.console, c.context); }},
-                    {"select_starter", "the starter from the program's option", select_starter_step},
-                    {"fight_starly", "the Starly battle", [](StoryConsole& c) { fight_starly(c.env.console, c.context); }},
-                    {"post_starly_cleanup", "the scene after the battle", [](StoryConsole& c) { post_starly_clenaup(c.env.console, c.context); }},
-                }),
-                segment_00_row("00.03", "Outside Verity after starter", retry, {
-                    {"tutorial_part_2_navigation", "Pokedex acquisition: back through Route 201 to Rowan's lab",
-                        [](StoryConsole& c) { tutorial_part_2_navigation(c.env, c.env.console, c.context); }},
-                }),
-            };
-        }
-
-        // 00.04 and 00.05: the catch, Sandgem, and Jubilife to the Poketch.
-        // 00.04 saves twice: a retry after the catch starts from the
-        // caught-Pokemon save, not the old route, so it is two rows.
-        static std::vector<StoryCheckpointSpec> segment_00_town_rows() {
-            const StoryFailure retry = StoryFailure::RELOAD_AND_RETRY;
+        std::map<std::string, ConsoleStoryExecutor::Variant> segment_00_variants() {
             return {
-                segment_00_row("00.04", "After Pokedex, to the catch", retry, {
-                    {"tutorial_part_3_navigation", "out of the lab, home to Mom, and the catch on Route 202",
-                        [](StoryConsole& c) { tutorial_part_3_navigation(c.env, c.env.console, c.context); }},
-                }),
-                segment_00_row("00.04b", "After the catch: train and heal in Sandgem", retry, {
-                    {"train_and_heal", "three wild battles in the catch grass, then Sandgem's Pokemon Center",
-                        [](StoryConsole& c) { after_catch_train_and_heal(c.env.console, c.context); }},
-                }),
-                segment_00_row("00.04c", "Potions, back to Route 202's save spot", retry, {
-                    {"potions", "the Poke Mart lady's (the clerk's after two misses), then Route 202's save spot",
-                        [](StoryConsole& c) { after_catch_potions(c.env, c.env.console, c.context); }},
-                }),
-                segment_00_row("00.04d", "Route 202's trainers, Dawn in Jubilife", retry, {
-                    {"to_jubilife", "north up Route 202 past its trainers, into Jubilife and Dawn's scene",
-                        [](StoryConsole& c) { after_catch_to_jubilife(c.env.console, c.context); }},
-                }),
-                segment_00_row("00.05", "Jubilife After Dawn", retry, {
-                    {"tutorial_part_4_navigation", "the Town Map, the president, the coupons, the Poketch and the Center's PC",
-                        [](StoryConsole& c) { tutorial_part_4_navigation(c.env, c.env.console, c.context); }},
-                }),
+                {"verify_settings", story_call(verify_settings_step)},
+                {"tutorial_part_1_navigation", story_call([](StoryConsole& c) { tutorial_part_1_navigation(c.env, c.env.console, c.context); })},
+                {"starter_nav", story_call([](StoryConsole& c) { starter_nav(c.env.console, c.context); })},
+                {"select_starter", story_call(select_starter_step)},
+                {"fight_starly", story_call([](StoryConsole& c) { fight_starly(c.env.console, c.context); })},
+                {"post_starly_cleanup", story_call([](StoryConsole& c) { post_starly_clenaup(c.env.console, c.context); })},
+                {"tutorial_part_2_navigation", story_call([](StoryConsole& c) { tutorial_part_2_navigation(c.env, c.env.console, c.context); })},
+                {"tutorial_part_3_navigation", story_call([](StoryConsole& c) { tutorial_part_3_navigation(c.env, c.env.console, c.context); })},
+                {"sandgem_potions", sandgem_potions},
+                {"jubilife_stairs", story_call([](StoryConsole& c) { up_jubilife_stairs(c.env.console, c.context); })},
+                {"tutorial_part_4_navigation", story_call([](StoryConsole& c) { tutorial_part_4_navigation(c.env, c.env.console, c.context); })},
             };
         }
 
+        // The table is segment_00_table() (PokemonBDSP_AutoStory_StoryTable.h).
         Pokemon::Segment make_segment_00(StoryStepRunner& runner) {
-            std::vector<StoryCheckpointSpec> rows = segment_00_intro_rows();
-            for (StoryCheckpointSpec& row : segment_00_town_rows()) {
-                rows.push_back(std::move(row));
-            }
-            return story_segment(runner, "00", std::move(rows));
+            const std::vector<StoryRow>& table = segment_00_table();
+            return story_table_segment(runner, "00", table, std::make_shared<ConsoleStoryExecutor>(
+                runner, rows_that_stop(table), story_maps(), story_trainer_sights(),
+                [](StoryConsole& c, const std::string& name) { fight_route_trainer(c.env.console, c.context, name); },
+                segment_00_variants()
+            ));
         }
 
         // DIAGNOSTIC ONLY: Remove before pushing to production.
diff --git a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/StorySegments/PokemonBDSP_AutoStory_Segment_00.h b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/StorySegments/PokemonBDSP_AutoStory_Segment_00.h
index 4ff7d50b0a..a789a26969 100644
--- a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/StorySegments/PokemonBDSP_AutoStory_Segment_00.h
+++ b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/StorySegments/PokemonBDSP_AutoStory_Segment_00.h
@@ -8,9 +8,12 @@
 #ifndef PokemonAutomation_PokemonBDSP_AutoStory_Segment00_H
 #define PokemonAutomation_PokemonBDSP_AutoStory_Segment00_H
 
+#include <map>
+#include <string>
 #include <vector>
 #include "Pokemon/Navigation/Pokemon_Grid.h"
 #include "PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStoryTools.h"
+#include "PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_StoryExecutor.h"
 #include "PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_StoryTables.h"
 
 namespace PokemonAutomation {
@@ -18,10 +21,15 @@ namespace NintendoSwitch {
 namespace PokemonBDSP {
 
 
-// Segment 00 as a table of checkpoints: 00.00 to 00.05, with 00.04 in two
-// rows (00.04 to the catch, 00.04b after it), each saving at its start.
+// Segment 00 as a table of checkpoints, segment_00_table(): 00.00 to 00.05,
+// with 00.04 in four rows (to the catch, then 00.04b to 00.04d as story
+// steps), each saving at its start.
 Pokemon::Segment make_segment_00(StoryStepRunner& runner);
 
+// How segment_00_table()'s steps that call an old function run on the
+// console, by their variants.
+std::map<std::string, ConsoleStoryExecutor::Variant> segment_00_variants();
+
 // DIAGNOSTIC ONLY: Remove before pushing to production.
 // Starts at the post-catch save and runs only the rest of checkpoint 00.04.
 void diagnostic_checkpoint_0004_after_catch(SingleSwitchProgramEnvironment& env,
diff --git a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/StorySegments/PokemonBDSP_AutoStory_Segment_01.cpp b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/StorySegments/PokemonBDSP_AutoStory_Segment_01.cpp
index 418cd19abf..00cc3cf623 100644
--- a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/StorySegments/PokemonBDSP_AutoStory_Segment_01.cpp
+++ b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/StorySegments/PokemonBDSP_AutoStory_Segment_01.cpp
@@ -19,6 +19,7 @@
 #include "../Utils/PokemonBDSP_AutoStory_RouteWalk.h"
 #include "../Utils/PokemonBDSP_AutoStory_Segment_00_tools.h"
 #include "../Utils/PokemonBDSP_AutoStory_Walk.h"
+#include "../PokemonBDSP_AutoStory_StoryTable.h"
 #include "Common/Cpp/PrettyPrint.h"
 #include "Common/Cpp/Filesystem/Filesystem.h"
 #include "CommonFramework/Globals.h"
@@ -1458,75 +1459,30 @@ void floaroma_old_couple(VideoStream& stream, ProControllerContext& context){
 }
 
 
-namespace{
-
-//  Saves where a checkpoint ends, inside its attempt: a failed save is a
-//  failed attempt.
-StoryStepSpec save_here(){
-    return {"save_here", "the next checkpoint starts here", [](StoryConsole& c){
-        checkpoint_save(c.env, c.context, c.options.notif_status_update, c.stats, c.options.checkpoint_save_mode);
-    }};
-}
-
-StoryCheckpointSpec segment_01_row(std::string id, std::string title, std::vector<StoryStepSpec> steps){
-    return {.id = std::move(id), .title = std::move(title), .on_failure = StoryFailure::RELOAD_AND_RETRY, .steps = std::move(steps)};
-}
-
-//  01.01 to 01.05: Jubilife to Oreburgh, the Mine, the Gym and back out.
-std::vector<StoryCheckpointSpec> segment_01_oreburgh_rows(){
+std::map<std::string, ConsoleStoryExecutor::Variant> segment_01_variants(){
     return {
-        segment_01_row("01.01", "Jubilife to Barry", {
-            {"jubilife_to_barry", "from the Center's PC out to Barry on Route 203", [](StoryConsole& c){ jubilife_to_barry(c.env.console, c.context); }},
-        }),
-        segment_01_row("01.02", "Route 203 to Oreburgh", {
-            {"route203_to_oreburgh", "east through the Oreburgh Gate into Oreburgh City", [](StoryConsole& c){ route203_to_oreburgh(c.env.console, c.context); }},
-        }),
-        segment_01_row("01.03", "Oreburgh Mine to Roark", {
-            {"oreburgh_to_roark", "into the Mine to Roark and back to the Center", [](StoryConsole& c){ oreburgh_to_roark(c.env.console, c.context); }},
-        }),
-        segment_01_row("01.04", "Oreburgh Gym", {
-            {"oreburgh_gym", "the Gym's trainers and Roark for the Coal Badge", [](StoryConsole& c){ oreburgh_gym(c.env.console, c.context); }},
-        }),
-        segment_01_row("01.05", "Oreburgh to Route 203", {
-            {"oreburgh_to_route203", "heal, then west out of the Oreburgh Gate", [](StoryConsole& c){ oreburgh_to_route203(c.env.console, c.context); }},
-        }),
+        {"jubilife_to_barry", story_call([](StoryConsole& c){ jubilife_to_barry(c.env.console, c.context); })},
+        {"route203_to_oreburgh", story_call([](StoryConsole& c){ route203_to_oreburgh(c.env.console, c.context); })},
+        {"oreburgh_to_roark", story_call([](StoryConsole& c){ oreburgh_to_roark(c.env.console, c.context); })},
+        {"oreburgh_gym", story_call([](StoryConsole& c){ oreburgh_gym(c.env.console, c.context); })},
+        {"oreburgh_to_route203", story_call([](StoryConsole& c){ oreburgh_to_route203(c.env.console, c.context); })},
+        {"route203_to_jubilife", story_call([](StoryConsole& c){ route203_to_jubilife(c.env.console, c.context); })},
+        {"jubilife_to_rowan", story_call([](StoryConsole& c){ jubilife_to_rowan(c.env.console, c.context); })},
+        {"jubilife_to_ravaged_path", story_call([](StoryConsole& c){ jubilife_to_ravaged_path(c.env.console, c.context); })},
+        {"ravaged_path", story_call([](StoryConsole& c){ ravaged_path(c.env.console, c.context); })},
+        {"route204_to_floaroma", story_call([](StoryConsole& c){ route204_to_floaroma(c.env.console, c.context); })},
+        {"floaroma_old_couple", story_call([](StoryConsole& c){ floaroma_old_couple(c.env.console, c.context); })},
     };
 }
 
-//  01.06 to 01.11: back through Jubilife, north to Floaroma.
-std::vector<StoryCheckpointSpec> segment_01_floaroma_rows(){
-    return {
-        segment_01_row("01.06", "Route 203 to Jubilife", {
-            {"route203_to_jubilife", "west along Route 203 into Jubilife", [](StoryConsole& c){ route203_to_jubilife(c.env.console, c.context); }},
-        }),
-        segment_01_row("01.07", "Jubilife through Rowan's scene", {
-            {"jubilife_to_rowan", "to the north street, Rowan's scene and the tag battle", [](StoryConsole& c){ jubilife_to_rowan(c.env.console, c.context); }},
-        }),
-        segment_01_row("01.08", "Jubilife to the Ravaged Path", {
-            {"jubilife_to_ravaged_path", "up Route 204's south half into the Ravaged Path", [](StoryConsole& c){ jubilife_to_ravaged_path(c.env.console, c.context); }},
-        }),
-        segment_01_row("01.09", "Ravaged Path", {
-            {"ravaged_path", "through the cave with Rock Smash, out onto Route 204 North", [](StoryConsole& c){ ravaged_path(c.env.console, c.context); }},
-        }),
-        segment_01_row("01.10", "Route 204 to Floaroma", {
-            {"route204_to_floaroma", "the human's line north into Floaroma", [](StoryConsole& c){ route204_to_floaroma(c.env.console, c.context); }},
-            save_here(),
-        }),
-        segment_01_row("01.11", "Floaroma's old couple", {
-            {"floaroma_old_couple", "the old woman and the old man in the flower field", [](StoryConsole& c){ floaroma_old_couple(c.env.console, c.context); }},
-            save_here(),
-        }),
-    };
-}
-
-}
-
+//  The table is segment_01_table() (PokemonBDSP_AutoStory_StoryTable.h). Its
+//  steps only call functions, so the executor plans nothing itself.
 Pokemon::Segment make_segment_01(StoryStepRunner& runner){
-    std::vector<StoryCheckpointSpec> rows = segment_01_oreburgh_rows();
-    for (StoryCheckpointSpec& row : segment_01_floaroma_rows()){
-        rows.push_back(std::move(row));
-    }
-    return story_segment(runner, "01", std::move(rows));
+    const std::vector<StoryRow>& table = segment_01_table();
+    return story_table_segment(runner, "01", table, std::make_shared<ConsoleStoryExecutor>(
+        runner, rows_that_stop(table), story_maps(), std::vector<Pokemon::TrainerSight>{},
+        [](StoryConsole&, const std::string&){}, segment_01_variants()
+    ));
 }
 
 
diff --git a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/StorySegments/PokemonBDSP_AutoStory_Segment_01.h b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/StorySegments/PokemonBDSP_AutoStory_Segment_01.h
index 1236c9d995..ccb65f4ca8 100644
--- a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/StorySegments/PokemonBDSP_AutoStory_Segment_01.h
+++ b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/StorySegments/PokemonBDSP_AutoStory_Segment_01.h
@@ -9,6 +9,9 @@
 #define PokemonAutomation_PokemonBDSP_AutoStory_Segment01_H
 
 #include "../PokemonBDSP_AutoStoryTools.h"
+#include <map>
+#include <string>
+#include "../Utils/PokemonBDSP_AutoStory_StoryExecutor.h"
 #include "../Utils/PokemonBDSP_AutoStory_StoryTables.h"
 
 namespace PokemonAutomation{
@@ -16,9 +19,13 @@ namespace NintendoSwitch{
 namespace PokemonBDSP{
 
 
-//  Segment 01 as a table of checkpoints: 01.01 to 01.11.
+//  Segment 01 as a table of checkpoints, segment_01_table(): 01.01 to 01.11.
 Pokemon::Segment make_segment_01(StoryStepRunner& runner);
 
+//  How segment_01_table()'s steps that call an old function run on the
+//  console, by their variants.
+std::map<std::string, ConsoleStoryExecutor::Variant> segment_01_variants();
+
 class AutoStory_Segment_01 : public AutoStory_Segment{
 public:
     virtual std::string name()       const override;
diff --git a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_Location.cpp b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_Location.cpp
index 102cf8b7a7..ecf90056c7 100644
--- a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_Location.cpp
+++ b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_Location.cpp
@@ -58,6 +58,16 @@ std::string normalize_location_name(const std::string& text){
     return out;
 }
 
+Language g_story_language = Language::English;
+
+bool story_reads_text(){
+    return story_reads_text(g_story_language);
+}
+
+bool story_reads_text(Language language){
+    return language == Language::English;
+}
+
 bool location_banner_showing(const ImageViewRGB32& screen){
     const ImageStats white = image_stats(extract_box_reference(screen, LOCATION_BANNER_WHITE));
     return white.average.sum() >= 690 && white.stddev.sum() <= 30;
@@ -72,17 +82,28 @@ std::string read_location_banner(const ImageViewRGB32& screen){
     if (!location_banner_showing(screen)){
         return "";
     }
+    if (!story_reads_text()){
+        return UNREAD_LOCATION;
+    }
     return normalize_location_name(OCR::tesseract_ocr_read(Language::English,
         extract_box_reference(screen, LOCATION_BANNER_TEXT)));
 }
 
 std::string read_save_screen_location(const ImageViewRGB32& screen){
+    if (!story_reads_text()){
+        return UNREAD_LOCATION;
+    }
     const ImageRGB32 text = to_blackwhite_rgb32_range(
         extract_box_reference(screen, SAVE_SCREEN_LOCATION), true, SAVE_SCREEN_TEXT_MIN, SAVE_SCREEN_TEXT_MAX);
     return normalize_location_name(OCR::tesseract_ocr_read(Language::English, text));
 }
 
 bool location_banner_matches(const std::string& read, const std::string& expected){
+    //  No reader for the game's language: a banner (or the save card) that
+    //  showed is all there is; where we stand is the walk's to say.
+    if (read == UNREAD_LOCATION){
+        return true;
+    }
     const std::string a = normalize_location_name(read);
     const std::string b = normalize_location_name(expected);
     if (a.empty() || b.empty()){
diff --git a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_Location.h b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_Location.h
index f74263c5b5..4294ede6eb 100644
--- a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_Location.h
+++ b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_Location.h
@@ -11,6 +11,7 @@
 #define PokemonAutomation_PokemonBDSP_AutoStory_Location_H
 
 #include <string>
+#include "CommonFramework/Language.h"
 #include "CommonFramework/ImageTypes/ImageViewRGB32.h"
 
 namespace PokemonAutomation{
@@ -22,6 +23,21 @@ namespace PokemonBDSP{
 //  by "route202".
 std::string normalize_location_name(const std::string& text);
 
+//  The game's language, for the reads that still use text (item names, the
+//  location banner, a sign's or talk's first box), set from the program's
+//  options (StoryRunOptions). story_reads_text() says whether those reads
+//  have a model and dictionary for it (English only, so far); when not,
+//  callers use language-free checks: the banner's box showing, a sign's box
+//  opening, the first row of a Bag pocket.
+extern Language g_story_language;
+bool story_reads_text();
+bool story_reads_text(Language language);
+
+//  What the reads below return for a banner or save card that showed, when
+//  there is no text reader for the game's language (story_reads_text()):
+//  location_banner_matches() takes it as a match.
+inline const std::string UNREAD_LOCATION = "(unread)";
+
 //  The location banner (the white box at the top left that names a map for a
 //  few seconds after the player enters it), read by OCR and normalized;
 //  empty when no banner shows.
diff --git a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_RouteWalk.cpp b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_RouteWalk.cpp
index f1ac20cb6e..bf10abb6ae 100644
--- a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_RouteWalk.cpp
+++ b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_RouteWalk.cpp
@@ -16,6 +16,7 @@
 #include "CommonFramework/VideoPipeline/VideoFeed.h"
 #include "CommonTools/Async/InferenceRoutines.h"
 #include "NintendoSwitch/Commands/NintendoSwitch_Commands_PushButtons.h"
+#include "Pokemon/Navigation/Pokemon_RouteLog.h"
 #include "PokemonBDSP/Inference/PokemonBDSP_DialogDetector.h"
 #include "PokemonBDSP/Programs/AutoStory/Detect/PokemonBDSP_AutoStory_OverworldDetector.h"
 #include "PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStoryTools.h"
@@ -55,14 +56,47 @@ void stick_for(Direction direction, double& x, double& y){
     }
 }
 
-std::string describe(const MapSet& maps, const std::vector<TilePos>& tiles){
-    std::string out;
+//  World tiles as tiles of the named maps, for the shared route log
+//  (Pokemon_RouteLog.h); a tile no map holds is a "world" tile.
+std::vector<RouteTile> route_tiles(const MapSet& maps, const std::vector<TilePos>& tiles){
+    std::vector<RouteTile> out;
     for (const TilePos& pos : tiles){
-        out += (out.empty() ? "" : ", ") + maps.describe(pos);
+        const std::optional<MapTile> local = maps.to_local(pos);
+        out.push_back(local ? RouteTile{local->map, local->pos} : RouteTile{"world", pos});
     }
     return out;
 }
 
+std::string describe(const MapSet& maps, const std::vector<TilePos>& tiles){
+    return Pokemon::describe(route_tiles(maps, tiles));
+}
+
+RouteLogLeg route_log_leg(const TileLeg& leg){
+    return {.action = RouteLegAction::WALK, .direction = leg.direction, .tiles = leg.tiles,
+        .end = leg.ends_at_wall ? RouteLegEnd::WALL : RouteLegEnd::OPEN};
+}
+
+PlannedRouteLeg planned_route_leg(const MapSet& maps, const PlannedLeg& leg){
+    return {.leg = route_log_leg(leg.leg), .after = route_tiles(maps, leg.after)};
+}
+
+void log_plan(VideoStream& stream, const MapSet& maps, const std::string& label, const std::vector<TilePos>& from, const std::vector<PlannedLeg>& legs){
+    std::vector<PlannedRouteLeg> logged;
+    for (const PlannedLeg& leg : legs){
+        logged.push_back(planned_route_leg(maps, leg));
+    }
+    stream.log(ROUTE_LOG_TAG + route_plan_line(label, route_tiles(maps, from), logged));
+}
+
+//  Logs a leg that ended on its planned tiles, and how that is known: an
+//  open leg counts its taps through a wild battle, so its end is assumed; a
+//  leg to a wall is walked again to its wall.
+void log_leg_done(VideoStream& stream, const MapSet& maps, const std::string& label, const PlannedLeg& planned, size_t wild_battles){
+    const bool assumed = !planned.leg.ends_at_wall && wild_battles > 0;
+    stream.log(ROUTE_LOG_TAG + route_leg_end_line(label, route_log_leg(planned.leg), route_tiles(maps, planned.after),
+        assumed ? EndBasis::ASSUMED : EndBasis::WALKED, assumed ? std::to_string(wild_battles) + " wild battle(s) on the way" : ""));
+}
+
 //  The tiles the player passes when walking `tiles` tiles from `from`, the
 //  first one after `from` first. Stops early where the player is stopped.
 std::vector<TilePos> leg_path(const TileGrid& grid, TilePos from, Direction direction, size_t tiles){
@@ -277,19 +311,14 @@ std::vector<TilePos> walk_route(
                 label + ": no plan from " + describe(maps, from) + ".", stream);
         }
         route_status(stream, label + ": " + std::to_string(legs->size()) + " legs planned");
-        std::string text = "[Route] " + label + ": plan from " + describe(maps, from) + ":";
-        for (const PlannedLeg& leg : *legs){
-            text += "\n    " + to_string(leg.leg) + " to " + describe(maps, leg.after);
-        }
-        stream.log(text);
+        log_plan(stream, maps, label, from, *legs);
 
         bool replanned = false;
         size_t leg_number = 0;
         for (const PlannedLeg& planned : *legs){
             const TileLeg& leg = planned.leg;
             leg_number++;
-            route_status(stream, "Leg " + std::to_string(leg_number) + "/" + std::to_string(legs->size()) + ": " +
-                to_string(leg) + " to " + describe(maps, planned.after));
+            route_status(stream, route_leg_line(leg_number, legs->size(), planned_route_leg(maps, planned)));
             double x, y;
             stick_for(leg.direction, x, y);
             const std::string leg_label = label + ": " + to_string(leg);
@@ -417,8 +446,8 @@ std::vector<TilePos> walk_route(
                         stream.log("[Route] " + leg_label + ": something the map lacks is at " +
                             maps.describe(blocker) + "; marked it.", COLOR_ORANGE);
                     }
-                    stream.log("[Route] " + leg_label + ": stopped early after about " + std::to_string(walked_tiles) +
-                        " tiles, at " + describe(maps, stopped) + "; planning again.", COLOR_ORANGE);
+                    stream.log(ROUTE_LOG_TAG + route_replan_line(label, route_log_leg(leg),
+                        "stopped early after about " + std::to_string(walked_tiles) + " tiles", route_tiles(maps, stopped)), COLOR_ORANGE);
                     facing = leg.direction;
                     from = stopped;
                     replanned = true;
@@ -533,8 +562,8 @@ std::vector<TilePos> walk_route(
                         stream.log("[Route] " + leg_label + ": something the map lacks is at " +
                             maps.describe(blocker) + "; marked it.", COLOR_ORANGE);
                     }
-                    stream.log("[Route] " + leg_label + ": blocked after " + std::to_string(moved) + " of " +
-                        std::to_string(leg.tiles) + " tiles, at " + describe(maps, stopped) + "; planning again.", COLOR_ORANGE);
+                    stream.log(ROUTE_LOG_TAG + route_replan_line(label, route_log_leg(leg),
+                        "blocked after " + std::to_string(moved) + " of " + std::to_string(leg.tiles) + " tiles", route_tiles(maps, stopped)), COLOR_ORANGE);
                     facing = leg.direction;
                     from = stopped;
                     replanned = true;
@@ -604,6 +633,7 @@ std::vector<TilePos> walk_route(
             }
             if (!talking){
                 from = planned.after;
+                log_leg_done(stream, maps, label, planned, result.wild_battles);
                 continue;
             }
 
@@ -626,6 +656,7 @@ std::vector<TilePos> walk_route(
                     stream.log("[Route] " + leg_label + ": on to the wall after the battle.", COLOR_ORANGE);
                     walk_until_dpad(stream, context, x, y, limit, leg_label + ": on to the wall", watch_banner, true);
                     from = planned.after;
+                    log_leg_done(stream, maps, label, planned, 0);
                     continue;
                 }
                 from = anywhere;
@@ -653,7 +684,7 @@ std::vector<TilePos> walk_route(
                 OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
                     leg_label + ": " + trainer.name + " talked, but no path enters their sight.", stream);
             }
-            stream.log("[Route] " + label + ": " + trainer.name + " stopped us about " + describe(maps, stopped) + ".");
+            stream.log(ROUTE_LOG_TAG + route_trainer_line(label, trainer.name, route_tiles(maps, stopped)));
             route_status(stream, "Fighting " + trainer.name + ".");
             fight(trainer.name);
             trainers.erase(trainers.begin() + watching[0]);
@@ -667,6 +698,7 @@ std::vector<TilePos> walk_route(
                 stream.log("[Route] " + leg_label + ": on to the wall after the battle.", COLOR_ORANGE);
                 walk_until_dpad(stream, context, x, y, limit, leg_label + ": on to the wall", watch_banner, true);
                 from = planned.after;
+                log_leg_done(stream, maps, label, planned, 0);
                 continue;
             }
             //  Only the taps that moved count: the trainer freezes the player
@@ -684,8 +716,8 @@ std::vector<TilePos> walk_route(
                 return a.y != b.y ? a.y < b.y : a.x < b.x;
             });
             by_taps.erase(std::unique(by_taps.begin(), by_taps.end()), by_taps.end());
-            stream.log("[Route] " + leg_label + ": " + std::to_string(taps) + " taps before the battle; at " +
-                describe(maps, by_taps) + "; planning again.", COLOR_ORANGE);
+            stream.log(ROUTE_LOG_TAG + route_replan_line(label, route_log_leg(leg),
+                std::to_string(taps) + " taps before the battle", route_tiles(maps, by_taps)), COLOR_ORANGE);
             from = by_taps;
             replanned = true;
             break;
@@ -706,7 +738,7 @@ std::vector<TilePos> walk_route(
                     label + ": arrived at " + describe(maps, from) + " on the map, but " + map_end +
                     "'s location banner never showed (read " + (seen.empty() ? "nothing" : seen) + ").", stream);
             }
-            stream.log("[Route] " + label + ": arrived at " + describe(maps, from) + ".");
+            stream.log(ROUTE_LOG_TAG + route_arrived_line(label, route_tiles(maps, from)));
             return from;
         }
     }
@@ -850,6 +882,12 @@ bool door_fade_look(DoorFadeWatch& watch, double brightness, bool room){
     return watch.saw_dark && !room && brightness >= DOOR_OUTSIDE_BRIGHT;
 }
 
+bool door_walk_stops(DoorFadeWatch& watch, double brightness, bool room){
+    //  Both are asked: the fade watch keeps what it has seen.
+    const bool faded = door_fade_look(watch, brightness, room);
+    return faded || !room;
+}
+
 namespace{
 
 //  Three looks half a second apart, none a room: outside, whatever the fade
@@ -882,7 +920,7 @@ void leave_door_south(VideoStream& stream, ProControllerContext& context, const
     auto out_of_door = [&](const ImageViewRGB32& screen){
         const double brightness = image_stats(screen).average.sum();
         const bool room = indoors(screen);
-        const bool out = door_fade_look(watch, brightness, room) || !room;
+        const bool out = door_walk_stops(watch, brightness, room);
         stream.log(std::format("[Route] {}: look: brightness {:.0f}, {}, fade {}.", label, brightness,
             room ? "a room" : "not a room", watch.saw_dark ? "seen" : "not seen"));
         return out;
diff --git a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_RouteWalk.h b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_RouteWalk.h
index 5dc613496a..8e98f0dfbc 100644
--- a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_RouteWalk.h
+++ b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_RouteWalk.h
@@ -211,6 +211,10 @@ struct DoorFadeWatch{
 //  returns whether we are out: a dark look seen, and now a bright one that
 //  is not a room.
 bool door_fade_look(DoorFadeWatch& watch, double brightness, bool room);
+//  Whether leave_door_south()'s walk stops at this look: at the door's fade
+//  out (door_fade_look()), or at the first look that is not a room, so a
+//  held stick does not walk on outside (r261 three rows).
+bool door_walk_stops(DoorFadeWatch& watch, double brightness, bool room);
 
 
 
diff --git a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_Segment_00_tools.cpp b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_Segment_00_tools.cpp
index 554347d66b..cb198a976d 100644
--- a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_Segment_00_tools.cpp
+++ b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_Segment_00_tools.cpp
@@ -1,2078 +1,2081 @@
-/*  BDSP AutoStory - Segment 00 Tools
- *
- *  Helper implementations for Segment 00.
- * 
- *  From: https://github.com/PokemonAutomation/
- *
- */
-
-
-#include "PokemonBDSP/Inference/PokemonBDSP_TransitionWatchers.h"
-#include "CommonFramework/GlobalAutoPaths.h"
-#include <algorithm>
-#include <cmath>
-#include <chrono>
-#include <array>
-#include <cctype>
-
-#include "PokemonBDSP_AutoStory_RouteWalk.h"
-#include "PokemonBDSP_AutoStory_Segment_00_tools.h"
-#include "PokemonBDSP_Autostory_Segment_01_tools.h"
-
-#include "CommonFramework/Exceptions/OperationFailedException.h"
-#include "CommonFramework/Exceptions/OperationFailedExceptionWithScreenshot.h"
-#include "Common/Cpp/PrettyPrint.h"
-#include "Common/Cpp/Filesystem/Filesystem.h"
-#include "CommonFramework/ImageTools/ImageBoxes.h"
-#include "CommonTools/OCR/OCR_RawTesseractOCR.h"
-#include "CommonFramework/Tools/ErrorDumper.h"
-#include "CommonFramework/VideoPipeline/VideoFeed.h"
-#include "CommonFramework/VideoPipeline/VideoOverlayScopes.h"
-
-#include "CommonTools/Async/InferenceRoutines.h"
-#include "CommonTools/VisualDetectors/BlackScreenDetector.h"
-#include "CommonTools/VisualDetectors/ImageMatchDetector.h"
-
-#include "NintendoSwitch/Commands/NintendoSwitch_Commands_PushButtons.h"
-#include "NintendoSwitch/NintendoSwitch_Settings.h"
-
-#include "NintendoSwitch/Programs/DateManip/NintendoSwitch_DateManip.h"
-#include "NintendoSwitch/Programs/DateSpam/NintendoSwitch_HomeToDateTime.h"
-#include "NintendoSwitch/Programs/NintendoSwitch_GameEntry.h"
-
-#include "PokemonBDSP/Inference/PokemonBDSP_MenuDetector.h"
-#include "PokemonBDSP/Inference/PokemonBDSP_DialogDetector.h"
-#include "PokemonBDSP/Inference/PokemonBDSP_SelectionArrow.h"
-
-#include "PokemonBDSP/Inference/Battles/PokemonBDSP_EndBattleDetector.h"
-#include "PokemonBDSP/Inference/PokemonBDSP_ReceivePokemonDetector.h"
-#include "PokemonBDSP/Inference/Battles/PokemonBDSP_BattleMenuDetector.h"
-#include "PokemonBDSP/Inference/Battles/PokemonBDSP_ExperienceGainDetector.h"
-
-#include "PokemonBDSP/Programs/AutoStory/Detect/PokemonBDSP_AutoStory_OverworldDetector.h"
-
-#include "PokemonBDSP/Programs/PokemonBDSP_GameNavigation.h"
-#include "PokemonBDSP/Programs/PokemonBDSP_BasicCatcher.h"
-#include "PokemonBDSP/Programs/PokemonBDSP_GameEntry.h"
-
-using namespace std::chrono_literals;
-
-namespace PokemonAutomation {
-    namespace NintendoSwitch {
-        namespace PokemonBDSP {
-
-            // ---------------------------------------------------------------------------
-            // BattleDialogWatcher
-            // ---------------------------------------------------------------------------
-
-            BattleDialogWatcher::BattleDialogWatcher(Color color)
-                : DetectorToFinder(
-                    "BattleDialogWatcher",
-                    std::chrono::milliseconds(250),
-                    color
-                )
-            {
-            }
-
-            // ---------------------------------------------------------------------------
-            // Poketech Clown dialog helper
-            // ---------------------------------------------------------------------------
-
-            int detect_clown_choice_arrow(
-                VideoOverlay& overlay,
-                VideoSnapshot snapshot
-            ) {
-                SelectionArrowFinder top_arrow(
-                    overlay,
-                    { 0.62, 0.37, 0.08, 0.10 },
-                    COLOR_RED
-                );
-
-                SelectionArrowFinder bottom_arrow(
-                    overlay,
-                    { 0.62, 0.48, 0.08, 0.10 },
-                    COLOR_RED
-                );
-
-                if (top_arrow.detect(snapshot)) {
-                    return 0;
-                }
-
-                if (bottom_arrow.detect(snapshot)) {
-                    return 1;
-                }
-
-                return -1;
-            }
-
-            void clown_dialog_helper(
-                VideoStream& stream,
-                ProControllerContext& context,
-                DpadPosition direction
-            ) {
-                stream.log(
-                    "[AutoStory] Starting clown dialog helper...",
-                    COLOR_BLUE
-                );
-
-                const auto overall_deadline =
-                    std::chrono::steady_clock::now() + 30s;
-
-                // -------------------------------------------------
-                // Phase 1: Move + interact until dialog is detected.
-                // -------------------------------------------------
-                ShortDialogWatcher dialog(COLOR_YELLOW);
-                bool dialog_started = false;
-
-                while (!dialog_started) {
-
-                    if (std::chrono::steady_clock::now() > overall_deadline) {
-                        stream.log(
-                            "[AutoStory] Clown helper timed out finding dialog.",
-                            COLOR_RED
-                        );
-                        OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                            "[AutoStory] Clown helper timed out finding dialog.", stream);
-                    }
-
-                    context.wait_for_all_requests();
-                    pbf_press_dpad(context, direction, 80ms, 200ms);
-                    pbf_press_button(context, BUTTON_A, 80ms, 500ms);
-
-                    if (wait_until(stream, context, 1500ms, { {dialog} }) == 0) {
-                        dialog_started = true;
-                        stream.log("[AutoStory] Dialog detected.", COLOR_GREEN);
-                    }
-                }
-
-                // -------------------------------------------------
-                // Phase 2: A mash for 2 seconds.
-                // -------------------------------------------------
-                stream.log("[AutoStory] Mashing A to advance dialog...", COLOR_BLUE);
-                pbf_mash_button(context, BUTTON_A, 4000ms);
-                context.wait_for_all_requests();
-
-                // -------------------------------------------------
-                // Phase 3: Clear remaining dialog.
-                // -------------------------------------------------
-                pbf_mash_button(context, BUTTON_B, 4000ms);
-
-                context.wait_for_all_requests();
-
-                stream.log(
-                    "[AutoStory] Clown dialog helper complete.",
-                    COLOR_GREEN
-                );
-            }
-            // ---------------------------------------------------------------------------
-            // Time helper
-            // ---------------------------------------------------------------------------
-
-            // Options chrome and position detectors are independent of setting values.
-            class TutorialOptionsDetector {
-            public:
-                bool detect(const ImageViewRGB32& screen) const {
-                    ImageViewRGB32 panel = extract_box_reference(screen, ImageFloatBox{0.04, 0.065, 0.93, 0.70});
-                    size_t white = 0;
-                    for (size_t y = 0; y < panel.height(); y += 4)
-                        for (size_t x = 0; x < panel.width(); x += 4) {
-                            uint32_t p = panel.pixel(x, y);
-                            if (((p >> 16) & 255) > 225 && ((p >> 8) & 255) > 225 && (p & 255) > 225) white++;
-                        }
-                    double samples = (double)(((panel.width() + 3) / 4) * ((panel.height() + 3) / 4));
-                    // Distinguish Options from the icon menu and bag using its
-                    // blue heading and full-width white settings panel.
-                    ImageViewRGB32 heading = extract_box_reference(screen, ImageFloatBox{0.01, 0.005, 0.20, 0.025});
-                    size_t blue = 0, total = 0;
-                    for (size_t y = 0; y < heading.height(); y++)
-                        for (size_t x = 0; x < heading.width(); x++) {
-                            uint32_t p = heading.pixel(x, y);
-                            int r = (p >> 16) & 255, g = (p >> 8) & 255, b = p & 255;
-                            blue += b > r + 20 && g > r + 10;
-                            total++;
-                        }
-                    return samples > 0 && white / samples > 0.70 && total > 0 && blue > total / 4;
-                }
-            };
-
-            // Options fades in after A on its icon: poll instead of judging one frame.
-            static bool wait_for_options_screen(VideoStream& stream, ProControllerContext& context,
-                const TutorialOptionsDetector& options_screen, Milliseconds timeout) {
-                context.wait_for_all_requests();
-                const WallClock deadline = current_time() + timeout;
-                while (current_time() < deadline) {
-                    auto frame = stream.video().snapshot();
-                    if (frame && options_screen.detect(frame)) return true;
-                    context.wait_for(100ms);
-                }
-                return false;
-            }
-
-            class TutorialOptionPositionDetector {
-            public:
-                // Locate the two long red horizontal lines surrounding the
-                // selected row. Scrolling changes their position automatically.
-                double selected_row(const ImageViewRGB32& screen) const {
-                    int first = -1, last = -1;
-                    for (size_t y = (size_t)(screen.height() * 0.08); y < screen.height() * 0.75; y++) {
-                        size_t red = 0, total = 0;
-                        for (size_t x = (size_t)(screen.width() * 0.08); x < screen.width() * 0.90; x += 2) {
-                            uint32_t p = screen.pixel(x, y);
-                            int r = (p >> 16) & 255, g = (p >> 8) & 255, b = p & 255;
-                            red += r > 150 && r > g + 40 && r > b + 40;
-                            total++;
-                        }
-                        if (total && red > total * 0.70) {
-                            if (first < 0) first = (int)y;
-                            last = (int)y;
-                        }
-                    }
-                    if (first < 0 || last - first < screen.height() * 0.04 || last - first > screen.height() * 0.12) return -1;
-                    return (first + last) / (2.0 * screen.height());
-                }
-                // Locate selected red value text separately from the row border.
-                bool selected_value(const ImageViewRGB32& screen, double y) const {
-                    ImageViewRGB32 value = extract_box_reference(screen, ImageFloatBox{0.33, y - 0.025, 0.54, 0.05});
-                    size_t red = 0;
-                    for (size_t py = 0; py < value.height(); py++)
-                        for (size_t px = 0; px < value.width(); px++) {
-                            uint32_t p = value.pixel(px, py);
-                            int r = (p >> 16) & 255, g = (p >> 8) & 255, b = p & 255;
-                            red += r > g + 20 && r > b + 20;
-                        }
-                    return red > value.width() * value.height() * 0.0005;
-                }
-            };
-
-
-            // Compare binary visual shapes with small alignment tolerance.
-            // No text recognition is needed for fixed English option labels.
-            static double option_image_score(const ImageViewRGB32& screen,
-                const ImageFloatBox& box, const ImageRGB32& reference, bool red_only) {
-                ImageRGB32 actual = extract_box_reference(screen, box).scale_to(384, 32);
-                ImageRGB32 expected = reference.scale_to(384, 32);
-                auto ink = [red_only](uint32_t p){
-                    int r = (p >> 16) & 255, g = (p >> 8) & 255, b = p & 255;
-                    return red_only ? r > g + 20 && r > b + 20 : r + g + b < 500;
-                };
-                double best = 0;
-                for (int dy = -2; dy <= 2; dy++) for (int dx = -2; dx <= 2; dx++) {
-                    size_t overlap = 0, count = 0;
-                    for (int y = 2; y < 30; y++) for (int x = 2; x < 382; x++) {
-                        bool a = ink(actual.pixel(x + dx, y + dy));
-                        bool b = ink(expected.pixel(x, y));
-                        overlap += a && b;
-                        count += a + b;
-                    }
-                    if (count) best = std::max(best, 2.0 * overlap / count);
-                }
-                return best;
-            }
-
-            static bool autosave_off_highlight(const ImageViewRGB32& screen, double y) {
-                auto red_count = [&](const ImageFloatBox& box){
-                    ImageViewRGB32 image = extract_box_reference(screen, box);
-                    size_t red = 0;
-                    for (size_t py = 0; py < image.height(); py++)
-                        for (size_t px = 0; px < image.width(); px++) {
-                            uint32_t p = image.pixel(px, py);
-                            int r = (p >> 16) & 255, g = (p >> 8) & 255, b = p & 255;
-                            red += r > g + 30 && r > b + 30;
-                        }
-                    return red;
-                };
-                size_t off = red_count({0.63, y - 0.022, 0.055, 0.044});
-                size_t on = red_count({0.34, y - 0.022, 0.055, 0.044});
-                // Require a clear Off highlight and reject any competing On highlight.
-                return off >= 10 && on * 10 < off;
-            }
-
-            static void verify_tutorial_settings_once(VideoStream& stream, ProControllerContext& context) {
-                context.wait_for_all_requests();
-                MenuDetector menu;
-                VideoOverlaySet detector_overlays(stream.overlay());
-                menu.make_overlays(detector_overlays);
-                detector_overlays.add(COLOR_CYAN, {0.04, 0.065, 0.93, 0.70}, "");
-                detector_overlays.add(COLOR_BLUE, {0.01, 0.005, 0.20, 0.025}, "");
-                detector_overlays.add(COLOR_RED, {0.08, 0.08, 0.82, 0.67}, "");
-                auto initial = stream.video().snapshot();
-                if (!initial || !menu.detect(initial)) {
-                    pbf_press_button(context, BUTTON_X, 80ms, 1000ms);
-                    context.wait_for_all_requests();
-                }
-                MenuWatcher menu_open;
-                if (wait_until(stream, context, 5s, {{menu_open}}) != 0) {
-                    OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                        "Settings checkpoint: Main menu not detected.", stream);
-                }
-                stream.log("[Tutorial settings] Main menu detected; settling for 500ms before Options navigation.");
-                pbf_wait(context, 500ms);
-                context.wait_for_all_requests();
-                TutorialOptionsDetector options_screen;
-                TutorialOptionPositionDetector position;
-                // Only two icons are available at this initial checkpoint.
-                // Verify the main menu before navigating to the neighboring icon.
-                bool options_open = false;
-                for (size_t attempt = 0; attempt < 2; attempt++) {
-                    pbf_press_dpad(context, attempt == 0 ? DPAD_RIGHT : DPAD_LEFT, 80ms, 350ms);
-                    pbf_press_button(context, BUTTON_A, 80ms, 0ms);
-                    if (wait_for_options_screen(stream, context, options_screen, 5s)) {
-                        options_open = true;
-                        break;
-                    }
-                    pbf_press_button(context, BUTTON_B, 80ms, 1000ms);
-                    context.wait_for_all_requests();
-                    MenuWatcher back_to_menu;
-                    if (wait_until(stream, context, 5s, {{back_to_menu}}) != 0) break;
-                }
-                if (!options_open) {
-                    OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                        "Settings checkpoint: Options screen not detected.", stream);
-                }
-                stream.log("[Tutorial settings] Options screen detected.");
-                pbf_wait(context, 500ms);
-                context.wait_for_all_requests();
-                struct Setting { const char* label; const char* value; };
-                const Setting settings[] = {
-                    {"textspeed", "fast"}, {"changewindow", "type1"},
-                    {"battleeffects", "off"}, {"battlestyle", "set"},
-                    {"sendtoboxes", "automatic"}, {"givenicknames", "dontgive"},
-                    {"gyroscope", "use"}, {"autosave", "off"},
-                    {"shownicknames", "show"}, {"backgroundmusic", "8"},
-                    {"soundeffects", "8"},
-                };
-                for (size_t row = 0; row < sizeof(settings) / sizeof(settings[0]); row++) {
-                    // Detect the selected row afresh after every navigation/correction.
-                    double y = -1;
-                    const std::string base = RESOURCE_PATH() + "PokemonBDSP/Autostory/Options/" + settings[row].label;
-                    const ImageRGB32 label_reference(base + "_label.png");
-                    const ImageRGB32 value_reference(base + "_value.png");
-                    bool slider_reset = false;
-                    bool correct = false;
-                    for (size_t attempt = 0; attempt < 30; attempt++) {
-                        context.wait_for_all_requests();
-                        auto frame = stream.video().snapshot();
-                        if (frame && options_screen.detect(frame)) y = position.selected_row(frame);
-                        else y = -1;
-                        const bool value_visible = y >= 0 && position.selected_value(frame, y);
-                        const double label_score = y >= 0 ? option_image_score(frame,
-                            {0.08, y - 0.025, 0.24, 0.05}, label_reference, false) : 0;
-                        stream.log("[Tutorial settings] Expected row=" + std::string(settings[row].label) +
-                            " row_y=" + std::to_string(y) + " highlighted_value=" + std::to_string(value_visible) +
-                            " label_match=" + std::to_string(label_score));
-                        if (y < 0 || !value_visible || label_score < 0.80) {
-                            // A menu can be detected while its row/text is still
-                            // fading in. Re-read without directional inputs first.
-                            if (attempt < 4) {
-                                pbf_wait(context, 200ms);
-                                context.wait_for_all_requests();
-                                continue;
-                            }
-                            OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                                "Settings checkpoint: Unable to confirm expected row " + std::string(settings[row].label), stream);
-                        }
-                        // These are regular video-overlay boxes, so the existing
-                        // overlay display control can show/hide every active ROI.
-                        OverlayBoxScope row_overlay(stream.overlay(), COLOR_RED,
-                            {0.07, y - 0.04, 0.84, 0.08}, "");
-                        OverlayBoxScope label_overlay(stream.overlay(), COLOR_YELLOW,
-                            {0.08, y - 0.025, 0.24, 0.05}, "");
-                        OverlayBoxScope value_overlay(stream.overlay(), COLOR_GREEN,
-                            {0.33, y - 0.025, 0.54, 0.05}, "");
-                        VideoOverlaySet autosave_rois(stream.overlay());
-                        if (row == 7) {
-                            autosave_rois.add(COLOR_GREEN, {0.63, y - 0.022, 0.055, 0.044});
-                            autosave_rois.add(COLOR_RED, {0.34, y - 0.022, 0.055, 0.044});
-                        }
-                        double score;
-                        if (row >= 9) {
-                            // Compare the numeric value rather than the long slider:
-                            // neighboring slider levels otherwise look too similar.
-                            ImageViewRGB32 number = value_reference.sub_image(
-                                value_reference.width() * 82 / 100, 0,
-                                value_reference.width() - value_reference.width() * 82 / 100,
-                                value_reference.height());
-                            ImageRGB32 number_reference = number.scale_to(96, 32);
-                            score = option_image_score(frame,
-                                {0.7728, y - 0.025, 0.0972, 0.05}, number_reference, true);
-                        } else {
-                            score = option_image_score(frame,
-                                {0.33, y - 0.025, 0.54, 0.05}, value_reference, true);
-                        }
-                        stream.log("[Tutorial settings] " + std::string(settings[row].label) +
-                            " target match=" + std::to_string(score));
-                        // The reference recording uses inactive pale-red text;
-                        // the focused live row has a thicker dark-red glyph mask.
-                        // Verified Fast scores 0.734 while Slow/Normal score 0.
-                        if (score >= 0.65 && (row != 7 || autosave_off_highlight(frame, y))) {
-                            if (row == 7) {
-                                for (size_t confirmation = 0; confirmation < 3; confirmation++) {
-                                    pbf_wait(context, 200ms);
-                                    context.wait_for_all_requests();
-                                    auto check = stream.video().snapshot();
-                                    double check_y = check ? position.selected_row(check) : -1;
-                                    if (!check || !options_screen.detect(check) || check_y < 0 ||
-                                        option_image_score(check, {0.08, check_y - 0.025, 0.24, 0.05}, label_reference, false) < 0.80 ||
-                                        !autosave_off_highlight(check, check_y)) {
-                                        OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                                            "Autosave Off could not be confirmed. Stopping before movement.", stream);
-                                    }
-                                }
-                            }
-                            stream.log("[Tutorial settings] Verified " + std::string(settings[row].label) + "=" + settings[row].value);
-                            correct = true;
-                            break;
-                        }
-                        stream.log("[Tutorial settings] Correcting " + std::string(settings[row].label));
-                        if (row >= 9 && !slider_reset) {
-                            // Sliders clamp at zero. Establish a known endpoint,
-                            // then increment; verify the target image afterward.
-                            for (size_t step = 0; step < 12; step++)
-                                pbf_press_dpad(context, DPAD_LEFT, 80ms, 100ms);
-                            slider_reset = true;
-                        } else {
-                            pbf_press_dpad(context, DPAD_RIGHT, 80ms, 350ms);
-                        }
-                        context.wait_for_all_requests();
-                    }
-                    if (!correct) {
-                        OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                            "Settings checkpoint: Could not apply " + std::string(settings[row].label), stream);
-                    }
-                    if (row + 1 < sizeof(settings) / sizeof(settings[0]))
-                        pbf_press_dpad(context, DPAD_DOWN, 80ms, 350ms);
-                }
-                // Confirm settings before exiting: A A A A B B.
-                pbf_press_button(context, BUTTON_A, 80ms, 1000ms);
-                pbf_press_button(context, BUTTON_A, 80ms, 1000ms);
-                pbf_press_button(context, BUTTON_A, 80ms, 1000ms);
-                pbf_press_button(context, BUTTON_A, 80ms, 1200ms);
-                pbf_press_button(context, BUTTON_B, 80ms, 1000ms);
-                pbf_press_button(context, BUTTON_B, 80ms, 1000ms);
-                context.wait_for_all_requests();
-                OverworldWatcher overworld;
-                if (wait_until(stream, context, 10s, {{overworld}}) != 0) {
-                    OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                        "Settings checkpoint: Did not return to the overworld after saving options.", stream);
-                }
-                // Reopen the saved Options screen and independently verify Autosave.
-                // No route movement is permitted until this persisted-value check passes.
-                pbf_press_button(context, BUTTON_X, 80ms, 1000ms);
-                context.wait_for_all_requests();
-                MenuWatcher verify_menu;
-                if (wait_until(stream, context, 5s, {{verify_menu}}) != 0) {
-                    OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                        "Autosave verification: Main menu not detected.", stream);
-                }
-                bool reopened = false;
-                for (size_t attempt = 0; attempt < 2; attempt++) {
-                    pbf_press_button(context, BUTTON_A, 80ms, 0ms);
-                    if (wait_for_options_screen(stream, context, options_screen, 5s)) { reopened = true; break; }
-                    pbf_press_button(context, BUTTON_B, 80ms, 1000ms);
-                    context.wait_for_all_requests();
-                    MenuWatcher return_menu;
-                    if (wait_until(stream, context, 5s, {{return_menu}}) != 0) break;
-                    pbf_press_dpad(context, DPAD_RIGHT, 80ms, 350ms);
-                }
-                if (!reopened) {
-                    OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                        "Autosave verification: Could not reopen saved Options.", stream);
-                }
-                // Options starts on Text Speed; Autosave is seven rows below it.
-                for (size_t step = 0; step < 7; step++)
-                    pbf_press_dpad(context, DPAD_DOWN, 80ms, 350ms);
-                context.wait_for_all_requests();
-                const ImageRGB32 autosave_label(RESOURCE_PATH() + "PokemonBDSP/Autostory/Options/autosave_label.png");
-                for (size_t confirmation = 0; confirmation < 3; confirmation++) {
-                    auto check = stream.video().snapshot();
-                    double check_y = check ? position.selected_row(check) : -1;
-                    if (!check || !options_screen.detect(check) || check_y < 0 ||
-                        option_image_score(check, {0.08, check_y - 0.025, 0.24, 0.05}, autosave_label, false) < 0.80 ||
-                        !autosave_off_highlight(check, check_y)) {
-                        OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                            "Saved Autosave setting is not verified Off. Stopping before movement.", stream);
-                    }
-                    pbf_wait(context, 200ms);
-                    context.wait_for_all_requests();
-                }
-                stream.log("[Tutorial settings] Autosave = Off: confirmed after reopening saved Options (3 frames).");
-                // Confirm settings before exiting: A A A A B B.
-                pbf_press_button(context, BUTTON_A, 80ms, 1000ms);
-                pbf_press_button(context, BUTTON_A, 80ms, 1000ms);
-                pbf_press_button(context, BUTTON_A, 80ms, 1000ms);
-                pbf_press_button(context, BUTTON_A, 80ms, 1200ms);
-                pbf_press_button(context, BUTTON_B, 80ms, 1000ms);
-                pbf_press_button(context, BUTTON_B, 80ms, 1000ms);
-                context.wait_for_all_requests();
-                OverworldWatcher verified_exit;
-                if (wait_until(stream, context, 10s, {{verified_exit}}) != 0) {
-                    OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                        "Autosave verification: Could not return to the overworld.", stream);
-                }
-                // Report inferred values explicitly: these are visual matches,
-                // allowing the user to compare our conclusions with the screen.
-                stream.log("[Tutorial settings] Completed. Values believed applied (visual matches before saving):");
-                stream.log("[Tutorial settings] Text Speed = Fast; Change Window = Type 1; Battle Effects = Off; Battle Style = Set.");
-                stream.log("[Tutorial settings] Send to Boxes = Automatic; Give Nicknames = Don't give; Gyroscope = Use.");
-                stream.log("[Tutorial settings] Autosave = Off; Show Nicknames = Show; Background Music = 8; Sound Effects = 8.");
-            }
-
-
-            void verify_tutorial_settings(VideoStream& stream, ProControllerContext& context) {
-                // Settings-only recovery: initial attempt plus three retries.
-                // Never permit route movement unless the complete check succeeds.
-                constexpr size_t MAX_RETRIES = 3;
-                for (size_t attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-                    stream.log("[Tutorial settings] Attempt " + std::to_string(attempt + 1) + "/4.");
-                    try {
-                        verify_tutorial_settings_once(stream, context);
-                        return;
-                    } catch (OperationFailedException& error) {
-                        stream.log("[Tutorial settings] Attempt failed: " + error.message(), COLOR_ORANGE);
-                        if (attempt == MAX_RETRIES) {
-                            stream.log("[Tutorial settings] All three retries exhausted; stopping before movement.", COLOR_RED);
-                            throw;
-                        }
-                        // Back out of Options, save prompts, bag, or menu without
-                        // moving the player or resetting/loading the game.
-                        stream.log("[Tutorial settings] Returning to overworld before retry.");
-                        context.wait_for_all_requests();
-                        TutorialOptionsDetector options_screen;
-                        const auto failed_frame = stream.video().snapshot();
-                        if (failed_frame && options_screen.detect(failed_frame)) {
-                            // Finish the known Options save/exit sequence before
-                            // observing state; never cancel it on an Options frame
-                            // misclassified as overworld by the generic detector.
-                            for (size_t press = 0; press < 4; press++)
-                                pbf_press_button(context, BUTTON_A, 80ms, 1000ms);
-                        }
-                        pbf_mash_button(context, BUTTON_B, 3000ms);
-                        context.wait_for_all_requests();
-                        OverworldDetector overworld;
-                        MenuDetector menu;
-                        BlackScreenDetector black;
-                        bool recovered = false;
-                        size_t confirmations = 0;
-                        for (size_t check = 0; check < 15; check++) {
-                            const auto frame = stream.video().snapshot();
-                            const bool clear = frame && !options_screen.detect(frame) &&
-                                !menu.detect(frame) && !black.detect(frame) && bag_pocket_position(frame) == 0 && overworld.detect(frame);
-                            if (clear) {
-                                if (++confirmations >= 3) { recovered = true; break; }
-                                pbf_wait(context, 200ms);
-                            } else {
-                                confirmations = 0;
-                                pbf_mash_button(context, BUTTON_B, 500ms);
-                            }
-                            context.wait_for_all_requests();
-                        }
-                        stream.log(recovered ? "[Tutorial settings] Recovery confirmed outside Options/menu; retrying."
-                            : "[Tutorial settings] Recovery not confirmed; next attempt will recheck the screen.");
-                        pbf_wait(context, 500ms);
-                        context.wait_for_all_requests();
-                    }
-                }
-            }
-
-            void set_time_fast(
-                SingleSwitchProgramEnvironment& env,
-                ProControllerContext& context,
-                const DateTime& target,
-                bool preserve_date
-            ) {
-                env.log("[AutoStory] Fast date set starting...", COLOR_ORANGE);
-
-                // 1) Home
-                NintendoSwitch::go_home(env.console, context);
-
-                // 2) Navigate to Date/Time settings quickly.
-                NintendoSwitch::home_to_date_time(env.console, context, true);
-
-                // 3) Enter date editor.
-                pbf_press_button(context, BUTTON_A, 80ms, 240ms);
-
-                // 4) Wait for date screen and set exact time.
-                NintendoSwitch::DateChangeWatcher date_reader(env.console);
-                int ret = wait_until(
-                    env.console, context, 10s,
-                    { date_reader }
-                );
-                if (ret < 0) {
-                    OperationFailedExceptionWithScreenshot::fire(
-                        ErrorReportMode::SEND_ERROR_REPORT,
-                        "Failed to enter Date Change screen.",
-                        env.console
-                    );
-                }
-
-                {
-                    VideoOverlaySet overlays(env.console.overlay());
-                    date_reader.make_overlays(overlays);
-                    DateTime effective_target = target;
-                    if (preserve_date) {
-                        context.wait_for_all_requests();
-                        const auto snapshot = env.console.video().snapshot();
-                        if (!snapshot) OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                            "Clock-only setup: No date-editor frame.", env.console);
-                        const DateTime current = date_reader.read_date(env.console, snapshot.frame).second;
-                        if (current.year < 2000 || current.year > 2060 || current.month < 1 || current.month > 12 ||
-                            current.day < 1 || current.day > 31)
-                            OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                                "Clock-only setup: Could not reliably read the current console date.", env.console);
-                        effective_target.year = current.year;
-                        effective_target.month = current.month;
-                        effective_target.day = current.day;
-                        env.log("[AutoStory] Clock-only target=" + std::to_string((int)target.hour) + ":" +
-                            std::to_string((int)target.minute) + "; preserving date=" + std::to_string(current.year) + "-" +
-                            std::to_string((int)current.month) + "-" + std::to_string((int)current.day) + ".");
-                    }
-                    date_reader.set_date(env.program_info(), env.console, context, effective_target);
-                }
-
-                // 5) Commit date.
-                pbf_press_button(context, BUTTON_A, 160ms, 240ms);
-
-                // 6) Back to game.
-                pbf_press_button(
-                    context, BUTTON_HOME, 160ms,
-                    ConsoleSettings::instance().SETTINGS_TO_HOME_DELAY0
-                );
-                NintendoSwitch::resume_game_from_home(env.console, context, false);
-
-                context.wait_for_all_requests();
-                context.wait_for(500ms);
-            }
-
-         
-            // ---------------------------------------------------------------------------
-            // Natalie battle
-            // ---------------------------------------------------------------------------
-            // Early moves the starters and their foes have, as type, power and
-            // most PP. A status move has power 0.
-            struct KnownMove { const char* name; const char* type; int power; int pp; };
-            static const KnownMove KNOWN_MOVES[] = {
-                {"pound", "normal", 40, 35}, {"tackle", "normal", 40, 35}, {"scratch", "normal", 40, 35},
-                {"quickattack", "normal", 40, 30}, {"headbutt", "normal", 70, 15},
-                {"watergun", "water", 40, 25}, {"bubble", "water", 40, 30}, {"bubblebeam", "water", 65, 20},
-                {"ember", "fire", 40, 25}, {"flamewheel", "fire", 60, 25}, {"machpunch", "fighting", 40, 30},
-                {"absorb", "grass", 20, 25}, {"razorleaf", "grass", 55, 25}, {"bite", "dark", 60, 25},
-                {"peck", "flying", 35, 35}, {"wingattack", "flying", 60, 35}, {"metalclaw", "steel", 50, 35},
-                {"growl", "normal", 0, 40}, {"leer", "normal", 0, 30}, {"tailwhip", "normal", 0, 30},
-                {"withdraw", "water", 0, 40}, {"taunt", "dark", 0, 20},
-            };
-
-            // A move button's PP left, "8/25" at its right end; -1 if it cannot be
-            // read. The text is dark, or yellow to red as PP runs low, so text is
-            // whatever differs from the button's own color. `max_pp` helps when
-            // the OCR reads the slash as a digit.
-            static int read_move_pp(const ImageViewRGB32& screen, const ImageFloatBox& button, int max_pp) {
-                const ImageViewRGB32 box = extract_box_reference(screen, ImageFloatBox{
-                    button.x + button.width * 0.75, button.y + button.height * 0.10,
-                    button.width * 0.21, button.height * 0.80});
-                if (box.width() == 0 || box.height() == 0) return -1;
-                std::vector<uint32_t> pixels;
-                for (size_t y = 0; y < box.height(); y++) for (size_t x = 0; x < box.width(); x++) pixels.push_back(box.pixel(x, y));
-                auto brightness = [](uint32_t p) { return ((p >> 16) & 255) + ((p >> 8) & 255) + (p & 255); };
-                std::vector<uint32_t> sorted = pixels;
-                std::nth_element(sorted.begin(), sorted.begin() + sorted.size() / 2, sorted.end(),
-                    [&](uint32_t a, uint32_t b) { return brightness(a) < brightness(b); });
-                const uint32_t background = sorted[sorted.size() / 2];
-                const size_t pad = 8;
-                ImageRGB32 text(box.width() + 2 * pad, box.height() + 2 * pad);
-                text.fill(0xffffffff);
-                for (size_t y = 0; y < box.height(); y++) {
-                    for (size_t x = 0; x < box.width(); x++) {
-                        const uint32_t p = box.pixel(x, y);
-                        int distance = 0;
-                        for (int shift : {16, 8, 0}) distance += std::abs((int)((p >> shift) & 255) - (int)((background >> shift) & 255));
-                        if (distance > 120) text.pixel(x + pad, y + pad) = 0xff000000;
-                    }
-                }
-                const std::string read = OCR::tesseract_ocr_read(Language::English, text);
-                const size_t slash = read.find('/');
-                std::string digits;
-                for (size_t i = 0; i < read.size() && i < slash; i++) if (std::isdigit((unsigned char)read[i])) digits.push_back(read[i]);
-                if (slash == std::string::npos && max_pp > 0) {
-                    // "29135" for 29/35: drop the most PP and the misread slash.
-                    const std::string max = std::to_string(max_pp);
-                    if (digits.size() > max.size() + 1 && digits.compare(digits.size() - max.size(), max.size(), max) == 0) {
-                        digits.resize(digits.size() - max.size() - 1);
-                    } else {
-                        return -1;
-                    }
-                }
-                if (digits.empty() || digits.size() > 2) return -1;
-                return std::stoi(digits);
-            }
-
-            // The best move on the move menu: the most powerful one we know, and
-            // on a tie one that is not Normal (an early starter's own type).
-            // Reads the names with OCR; 1 if none is known.
-            static size_t pick_best_move(VideoStream& stream, const ImageViewRGB32& screen,
-                const BattleMoveMenuState& moves, const std::string& label) {
-                // Keep the menu as it looked, to check the reads against.
-                {
-                    const std::string folder = SCREENSHOTS_PATH() + "AutoStory/moves/";
-                    Filesystem::create_directories(Filesystem::Path(folder));
-                    screen.save(folder + now_to_filestring() + "-" + label + ".png");
-                }
-                size_t best = 1;
-                int best_score = -1;
-                bool any_attack = false;
-                size_t last_not_status = 1;
-                for (size_t i = 0; i < moves.move_count; i++) {
-                    // The name is dark text on a light button (grey, or light blue under the
-                    // cursor). Take the box right of the type icon and left of the PP, tall
-                    // enough for a status move's name, which sits lower: it has no "Effective"
-                    // line under it.
-                    const ImageFloatBox& button = moves.buttons[i];
-                    const ImageFloatBox name_box{button.x + button.width * 0.17, button.y + button.height * 0.08,
-                        button.width * 0.53, button.height * 0.80};
-                    const ImageViewRGB32 box = extract_box_reference(screen, name_box);
-                    // Text is darker than halfway between the background and the darkest pixel;
-                    // a fixed cut thins the strokes on the blue button.
-                    std::vector<int> gray(box.width() * box.height());
-                    for (size_t y = 0; y < box.height(); y++) {
-                        for (size_t x = 0; x < box.width(); x++) {
-                            const uint32_t pixel = box.pixel(x, y);
-                            gray[y * box.width() + x] = (int)(((pixel >> 16) & 0xff) + ((pixel >> 8) & 0xff) + (pixel & 0xff)) / 3;
-                        }
-                    }
-                    std::vector<int> sorted = gray;
-                    std::nth_element(sorted.begin(), sorted.begin() + sorted.size() / 2, sorted.end());
-                    const int background = sorted[sorted.size() / 2];
-                    const int darkest = *std::min_element(gray.begin(), gray.end());
-                    const int threshold = (background + darkest) / 2;
-                    // The name is the tallest band of text rows; "Effective" is smaller.
-                    size_t band_top = 0, band_bottom = 0;
-                    for (size_t y = 0; y < box.height();) {
-                        auto has_text = [&](size_t row) {
-                            for (size_t x = 0; x < box.width(); x++) if (gray[row * box.width() + x] < threshold) return true;
-                            return false;
-                        };
-                        if (!has_text(y)) { y++; continue; }
-                        size_t end = y;
-                        while (end < box.height() && has_text(end)) end++;
-                        if (end - y > band_bottom - band_top) { band_top = y; band_bottom = end; }
-                        y = end;
-                    }
-                    // Black text on white, with a margin, for the OCR.
-                    const size_t pad = 6;
-                    const size_t top = band_top >= 4 ? band_top - 4 : 0;
-                    const size_t bottom = std::min(box.height(), band_bottom + 4);
-                    ImageRGB32 text(box.width() + 2 * pad, bottom - top + 2 * pad);
-                    text.fill(0xffffffff);
-                    for (size_t y = top; y < bottom; y++) {
-                        for (size_t x = 0; x < box.width(); x++) {
-                            if (gray[y * box.width() + x] < threshold) text.pixel(x + pad, y - top + pad) = 0xff000000;
-                        }
-                    }
-                    std::string name;
-                    for (unsigned char ch : OCR::tesseract_ocr_read(Language::English, text)) {
-                        if (std::isalpha(ch)) name.push_back((char)std::tolower(ch));
-                    }
-                    // A slot read well once keeps its name when a later read fails.
-                    static std::array<std::string, 4> last_read;
-                    const KnownMove* known = nullptr;
-                    for (int pass = 0; pass < 2 && !known; pass++) {
-                    if (pass == 1) name = last_read[i];
-                    for (const KnownMove& move : KNOWN_MOVES) {
-                        //  The longest name that appears wins: "bubblebeam" over "bubble".
-                        if (name.find(move.name) != std::string::npos &&
-                            (!known || std::string(move.name).size() > std::string(known->name).size())) {
-                            known = &move;
-                        }
-                    }
-                    }
-                    if (known) last_read[i] = known->name;
-                    // A move with no PP left cannot be chosen; the game says so and
-                    // keeps the menu up.
-                    const int pp = read_move_pp(screen, button, known ? known->pp : 0);
-                    stream.log("[" + label + "] Move " + std::to_string(i + 1) + " PP left: " + (pp < 0 ? std::string("unread") : std::to_string(pp)) + ".");
-                    if (pp == 0) {
-                        continue;
-                    }
-                    // An unreadable move counts as a plain attack, ahead of known
-                    // status moves.
-                    const int score = known ? known->power * 2 + (std::string(known->type) != "normal" ? 1 : 0) : 40 * 2 - 1;
-                    stream.log("[" + label + "] Move " + std::to_string(i + 1) + " reads \"" + name + "\"" +
-                        (known ? std::string(" = ") + known->name + " (" + known->type + ", " + std::to_string(known->power) + ")" : " (unknown)") + ".");
-                    if (score > best_score) { best_score = score; best = i + 1; }
-                    if (known && known->power > 0) any_attack = true;
-                    if (!known || known->power > 0) last_not_status = i + 1;
-                }
-                // No attack read: the newest move is the starter's own-type attack
-                // (Water Gun, Ember, Absorb), unless it is a status move.
-                if (!any_attack) best = last_not_status;
-                stream.log("[" + label + "] Best move: " + std::to_string(best) + ".");
-                return best;
-            }
-
-            static void select_battle_move_slot(VideoStream& stream, ProControllerContext& context,
-                BattleType battle_type, size_t target, const std::string& label,
-                bool confirm_default_target = false, size_t current_move = 1) {
-                BattleMenuDetector commands(battle_type);
-                VideoOverlaySet overlays(stream.overlay());
-                commands.make_overlays(overlays);
-                overlays.add(COLOR_GREEN, {0.90, 0.48, 0.075, 0.505});
-                // Reenter Fight from an already-open list without assuming
-                // that this resets the remembered move cursor.
-                if (confirm_default_target) {
-                    context.wait_for_all_requests();
-                    const auto frame=stream.video().snapshot();
-                    if (frame && detect_battle_move_menu(frame).move_count) {
-                        pbf_press_button(context,BUTTON_B,80ms,500ms);
-                    }
-                }
-                bool fight = false;
-                size_t confirmed = 0;
-                for (size_t check = 0; check < 30; check++) {
-                    context.wait_for_all_requests();
-                    auto frame = stream.video().snapshot();
-                    BattleMenuOption selected = frame ? commands.selected_option(frame) : BattleMenuOption::UNKNOWN;
-                    stream.log("[" + label + "] Command cursor=" + std::to_string((int)selected + 1) + "; target Battle=1.");
-                    if (selected == BattleMenuOption::BATTLE) {
-                        if (++confirmed >= 3) { fight = true; break; }
-                        pbf_wait(context, 100ms);
-                    } else {
-                        confirmed = 0;
-                        if (selected == BattleMenuOption::UNKNOWN) pbf_wait(context, 150ms);
-                        else pbf_press_dpad(context, DPAD_UP, 80ms, 250ms);
-                    }
-                }
-                if (!fight) OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                    label + ": Could not confirm Battle command; A not pressed.", stream);
-                pbf_press_button(context,BUTTON_A,80ms,confirm_default_target ? 1000ms : 500ms);
-                if (confirm_default_target) {
-                    // Reuse the farming move/target confirmation sequence, but
-                    // navigate relative to this battle's retained move cursor.
-                    // Reopening Fight does not reset it to move 1.
-                    size_t available=0,stable=0;
-                    for (size_t check=0;check<20 && stable<3;check++) {
-                        context.wait_for_all_requests();
-                        const auto frame=stream.video().snapshot();
-                        const auto moves=frame ? detect_battle_move_menu(frame) : BattleMoveMenuState{};
-                        if (moves.move_count && moves.move_count==available) stable++;
-                        else {available=moves.move_count;stable=moves.move_count ? 1:0;}
-                        if (stable<3) pbf_wait(context,100ms);
-                    }
-                    if (stable<3 || available<target || available<current_move) OperationFailedExceptionWithScreenshot::fire(
-                        ErrorReportMode::SEND_ERROR_REPORT,label+": Requested move position is not available.",stream);
-                    stream.log("["+label+"] Retained move cursor "+std::to_string(current_move)+
-                        " -> "+std::to_string(target)+".");
-                    for (size_t slot=current_move;slot<target;slot++) pbf_press_dpad(context,DPAD_DOWN,80ms,400ms);
-                    for (size_t slot=current_move;slot>target;slot--) pbf_press_dpad(context,DPAD_UP,80ms,400ms);
-                    pbf_press_button(context,BUTTON_A,80ms,1000ms);
-                    pbf_press_button(context,BUTTON_A,80ms,3000ms);
-                    return;
-                }
-                confirmed = 0;
-                size_t previous_move_count = 0, stable_move_count = 0;
-                for (size_t check = 0; check < 30; check++) {
-                    context.wait_for_all_requests();
-                    auto frame = stream.video().snapshot();
-                    const BattleMoveMenuState moves = frame ? detect_battle_move_menu(frame) : BattleMoveMenuState{};
-                    const int slot = (int)moves.selected_slot;
-                    VideoOverlaySet move_overlays(stream.overlay());
-                    for (size_t i = 0; i < moves.move_count; i++)
-                        move_overlays.add(moves.selected_slot == i + 1 ? COLOR_GREEN : COLOR_YELLOW, moves.buttons[i]);
-                    stream.log("[" + label + "] Available moves=" + std::to_string(moves.move_count) +
-                        "; selected slot=" + std::to_string(slot) + "/4; target=" + std::to_string(target) + ".");
-                    if (moves.move_count == previous_move_count && moves.move_count > 0) stable_move_count++;
-                    else { previous_move_count = moves.move_count; stable_move_count = 1; confirmed = 0; }
-                    // Target 0: pick the best move once the menu has settled.
-                    if (target == 0 && stable_move_count >= 3 && frame) {
-                        target = pick_best_move(stream, *frame.frame, moves, label);
-                    }
-                    if (moves.move_count > 0 && moves.move_count < target && stable_move_count >= 3) {
-                        OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                            label + ": Move slot " + std::to_string(target) + " is absent; no move confirmed.", stream);
-                    }
-                    if (slot == (int)target && stable_move_count >= 3) {
-                        if (++confirmed >= 3) {
-                            stream.log("[" + label + "] Move " + std::to_string(target) + " confirmed; using it.");
-                            pbf_press_button(context, BUTTON_A, 80ms, 3000ms);
-                            return;
-                        }
-                        pbf_wait(context, 100ms);
-                    } else {
-                        confirmed = 0;
-                        if (slot == 0 || slot == (int)target) pbf_wait(context, 150ms);
-                        else pbf_press_dpad(context, slot < (int)target ? DPAD_DOWN : DPAD_UP, 80ms, 250ms);
-                    }
-                    context.wait_for_all_requests();
-                }
-                OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                    label + ": Could not confirm move " + std::to_string(target) + "; A not pressed.", stream);
-            }
-
-            // ---------------------------------------------------------------------------
-            // Starly battle
-            // ---------------------------------------------------------------------------
-
-            void fight_starly(VideoStream& stream, ProControllerContext& context) {
-                stream.log("[AutoStory] Starting Starly battle...", COLOR_BLUE);
-
-                // Declare OUTSIDE the loop so accumulated detector state
-                // (trigger counts, black-screen transitions) is preserved across frames.
-                // STARTER type: player has no Pokeballs, so ball-count areas won't
-                // be white. STARTER skips that check and only verifies status bars
-                // and the Fight button color.
-                BattleMenuWatcher battle_menu(BattleType::STARTER, COLOR_YELLOW);
-                EndBattleWatcher  end_battle;
-
-                while (true) {
-                    context.wait_for_all_requests();
-
-                    // Phase 1: wait for either battle menu or battle end.
-                    int ret = run_until<ProControllerContext>(
-                        stream, context,
-                        [](ProControllerContext& ctx) {
-                            pbf_mash_button(ctx, BUTTON_B, 120000ms);
-                        },
-            {
-                {battle_menu},
-                {end_battle},
-            }
-            );
-
-                    switch (ret) {
-                    case 0:
-                    {
-                        stream.log("[AutoStory] Battle menu detected. Selecting move...", COLOR_BLUE);
-
-                        // Select Fight, then move slot 1.
-                        pbf_press_button(context, BUTTON_A, 80ms, 500ms);
-                        pbf_press_button(context, BUTTON_A, 80ms, 3000ms);
-                        // Loop back - mash B through animations until next menu or end.
-                        break;
-                    }
-                    case 1:
-                    {
-                        stream.log("[AutoStory] Starly battle complete.", COLOR_GREEN);
-
-                        // Mash through XP / level-up / dialog screens back to overworld.
-                        OverworldWatcher overworld;
-                        int cleanup_ret = run_until<ProControllerContext>(
-                            stream, context,
-                            [](ProControllerContext& ctx) {
-                                pbf_mash_button(ctx, BUTTON_B, 120000ms);
-                            },
-                            { {overworld} }
-                        );
-                        if (cleanup_ret != 0) {
-                            OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                                "Starly battle: Overworld cleanup timed out.", stream);
-                        }
-                        return;
-                    }
-                    default:
-                        OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                            "Starly battle timed out.", stream);
-                    }
-                }
-            }
-
-            // ---------------------------------------------------------------------------
-            // Tristan battle
-            // ---------------------------------------------------------------------------
-            // Two grass rows at 240 ms each, with room to spare: the wall stops us.
-            static constexpr Milliseconds CATCH_GRASS_WALK = 900ms;
-
-            static void encounter_one_wild_pokemon(VideoStream& stream, ProControllerContext& context) {
-                context.wait_for_all_requests();
-                pbf_wait(context, 1000ms);
-
-                bool encounter_found = false;
-                const auto deadline = std::chrono::steady_clock::now() + 180s;
-
-                // Walk up and down the catch grass until a battle starts. Its three rows
-                // sit between tree walls, so each walk ends at a wall, on the same tile
-                // every time, after two new grass tiles. Short sideways steps drift and
-                // can rock across one tile edge without entering new grass.
-                while (!encounter_found && std::chrono::steady_clock::now() < deadline) {
-                    BlackScreenWatcher battle_start;
-                    BattleMenuWatcher battle_menu(BattleType::STANDARD, COLOR_YELLOW);
-                    BattleDialogWatcher battle_dialog(COLOR_YELLOW);
-
-                    route_turn(stream, context, Pokemon::Direction::NORTH);
-                    pbf_move_left_joystick(context, {0, 1}, CATCH_GRASS_WALK, 200ms);
-                    context.wait_for_all_requests();
-
-                    int ret = wait_until(
-                        stream,
-                        context,
-                        1500ms,
-                        {
-                            {battle_start},
-                            {battle_menu},
-                            {battle_dialog},
-                        }
-                    );
-
-                    if (ret >= 0) {
-                        encounter_found = true;
-                        break;
-                    }
-
-                    route_turn(stream, context, Pokemon::Direction::SOUTH);
-                    pbf_move_left_joystick(context, {0, -1}, CATCH_GRASS_WALK, 200ms);
-                    context.wait_for_all_requests();
-
-                    ret = wait_until(
-                        stream,
-                        context,
-                        1500ms,
-                        {
-                            {battle_start},
-                            {battle_menu},
-                            {battle_dialog},
-                        }
-                    );
-
-                    if (ret >= 0) {
-                        encounter_found = true;
-                        break;
-                    }
-                }
-
-                if (!encounter_found) OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                    "Wild encounter: walking up and down the grass found no battle within three minutes.", stream);
-                stream.log("[AutoStory] Wild battle detected!", COLOR_GREEN);
-
-                // Wait until the actual battle menu appears.
-                BattleMenuWatcher confirm_menu(BattleType::STANDARD);
-
-                int menu_ret = wait_until(
-                    stream,
-                    context,
-                    15s,
-                    {
-                        {confirm_menu},
-                    }
-                );
-
-                if (menu_ret < 0) {
-                    stream.log(
-                        "[AutoStory] Failed to detect battle menu.",
-                        COLOR_RED
-                    );
-                    OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                            "[AutoStory] Failed to detect battle menu.", stream);
-                }
-
-                stream.log("[AutoStory] Battle menu detected.", COLOR_GREEN);
-
-                context.wait_for_all_requests();
-                pbf_wait(context, 500ms);
-
-            }
-
-            static void confirm_battle_overworld(VideoStream& stream, ProControllerContext& context,
-                const std::string& label) {
-                OverworldDetector overworld;
-                ShortDialogDetector dialogue(COLOR_YELLOW);
-                BlackScreenDetector black;
-                VideoOverlaySet overlays(stream.overlay());
-                overworld.make_overlays(overlays);
-                dialogue.make_overlays(overlays);
-                black.make_overlays(overlays);
-                const auto deadline = std::chrono::steady_clock::now() + 180s;
-                auto quiet_since = std::chrono::steady_clock::now();
-                bool finished = false;
-                while (std::chrono::steady_clock::now() < deadline) {
-                    const auto frame = stream.video().snapshot();
-                    if (!frame) OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                        label + ": No video frame.", stream);
-                    const auto now = std::chrono::steady_clock::now();
-                    if (dialogue.detect(frame) || black.detect(frame) || !overworld.detect(frame)) {
-                        quiet_since = now;
-                    } else if (now - quiet_since >= 4s) {
-                        finished = true;
-                        break;
-                    }
-                    pbf_mash_button(context, BUTTON_B, 100ms);
-                    context.wait_for_all_requests();
-                }
-                if (!finished) OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                    label + ": Dialogue-free overworld not confirmed for four seconds.", stream);
-                context.wait_for_all_requests();
-            }
-
-            // Our HP bar in the battle's bottom-left panel, as a fraction; -1 if
-            // no bar is there. Measured on 1920x1080 frames: the bar runs from
-            // x 88 to 466 on rows 961 to 965.
-            static double battle_player_hp(const ImageViewRGB32& frame) {
-                const ImageViewRGB32 bar = extract_box_reference(frame, ImageFloatBox{0.046, 0.890, 0.197, 0.004});
-                size_t filled = 0;
-                for (size_t x = 0; x < bar.width(); x++) {
-                    size_t color = 0;
-                    for (size_t y = 0; y < bar.height(); y++) {
-                        const uint32_t p = bar.pixel(x, y);
-                        const int r = (p >> 16) & 255, g = (p >> 8) & 255, b = p & 255;
-                        const bool green = g > r + 30 && g > b + 20;
-                        const bool yellow = r > 150 && g > 120 && b < 100;
-                        const bool red = r > 150 && r > g + 50 && r > b + 50;
-                        color += green || yellow || red;
-                    }
-                    filled += color > bar.height() / 2;
-                }
-                return bar.width() && filled ? (double)filled / bar.width() : -1;
-            }
-
-            enum class BattleHeal { NOT_NEEDED, USED, NONE_LEFT };
-
-            // At the battle menu: if our HP is under `heal_below`, use a Potion
-            // from the Bag on the lead, which takes the turn. Otherwise the
-            // battle menu is left up.
-            static BattleHeal battle_heal_if_low(VideoStream& stream, ProControllerContext& context,
-                BattleType battle_type, double heal_below, const std::string& label) {
-                context.wait_for_all_requests();
-                double hp = -1;
-                for (size_t check = 0; check < 5 && hp < 0; check++) {
-                    const auto frame = stream.video().snapshot();
-                    if (frame) hp = battle_player_hp(*frame.frame);
-                    if (hp < 0) pbf_wait(context, 150ms);
-                    context.wait_for_all_requests();
-                }
-                stream.log("[" + label + "] Our HP bar reads " + std::to_string((int)(hp * 100)) + "%.");
-                if (hp < 0 || hp >= heal_below) return BattleHeal::NOT_NEEDED;
-                BattleMenuDetector commands(battle_type);
-                bool on_bag = false;
-                for (size_t check = 0; check < 30 && !on_bag; check++) {
-                    context.wait_for_all_requests();
-                    const auto frame = stream.video().snapshot();
-                    const BattleMenuOption selected = frame ? commands.selected_option(frame) : BattleMenuOption::UNKNOWN;
-                    if (selected == BattleMenuOption::BAG) on_bag = true;
-                    else if (selected == BattleMenuOption::UNKNOWN) pbf_wait(context, 150ms);
-                    else pbf_press_dpad(context, (int)selected < (int)BattleMenuOption::BAG ? DPAD_DOWN : DPAD_UP, 80ms, 300ms);
-                }
-                if (!on_bag) {
-                    stream.log("[" + label + "] Could not reach the Bag command; fighting on.", COLOR_ORANGE);
-                    return BattleHeal::NONE_LEFT;
-                }
-                pbf_press_button(context, BUTTON_A, 80ms, 2000ms);
-                if (!find_bag_item_in_open_bag(stream, context, "potion", 1)) {
-                    stream.log("[" + label + "] No Potion left; fighting on.", COLOR_ORANGE);
-                    pbf_press_button(context, BUTTON_B, 80ms, 1500ms);
-                    pbf_press_button(context, BUTTON_B, 80ms, 1500ms);
-                    context.wait_for_all_requests();
-                    return BattleHeal::NONE_LEFT;
-                }
-                // Potion, then the lead in the party list, then Use.
-                stream.log("[" + label + "] Using a Potion on the lead.", COLOR_BLUE);
-                pbf_press_button(context, BUTTON_A, 80ms, 1500ms);
-                pbf_press_button(context, BUTTON_A, 80ms, 1500ms);
-                pbf_press_button(context, BUTTON_A, 80ms, 2500ms);
-                context.wait_for_all_requests();
-                return BattleHeal::USED;
-            }
-
-            static void fight_using_move_list(
-                VideoStream& stream, ProControllerContext& context,
-                BattleType battle_type, const std::vector<size_t>& move_slots,
-                const std::string& label, bool confirm_default_target, bool post_battle_dialogue_cleanup,
-                bool doubles = false, bool switch_on_faint = false
-            ) {
-                if (move_slots.empty() || std::any_of(move_slots.begin(),move_slots.end(),
-                    [](size_t slot) { return slot>4; })) {
-                    OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                        label+": Supply a nonempty move list containing only positions 0 (best) through 4.",stream);
-                }
-                size_t move_index=0;
-                // The first Fight menu starts at move 1. Later turns retain
-                // this Pokemon's previous selection; a new battle resets it.
-                size_t current_move=1;
-                stream.log(
-                    "[AutoStory] Starting " + label + " battle...",
-                    COLOR_BLUE
-                );
-
-                // Scripted battles wait on the menu detector below, so no
-                // extra fixed delay is needed after a caller confirms it.
-                // Preserve the existing early-game transition delay.
-                if (!confirm_default_target) pbf_wait(context,5000ms);
-
-                bool battle_menu_seen = false;
-                bool out_of_potions = false;
-                size_t potions_used = 0;
-                size_t turns = 0;
-                size_t faint_switches = 0;
-                const bool watch_learn_move = confirm_default_target || doubles || switch_on_faint;
-                EndBattleWatcher end_battle;
-
-                while (true) {
-
-                    context.wait_for_all_requests();
-
-                    BattleMenuWatcher battle_menu(battle_type);
-                    // Reuse the farming handlers' move-learning prompt recovery.
-                    SelectionArrowFinder learn_move(stream.overlay(),{0.50,0.62,0.40,0.18},COLOR_YELLOW);
-
-                    int ret = run_until<ProControllerContext>(
-                        stream,
-                        context,
-                        [&](ProControllerContext& context) {
-                            // Clear narration with B while watching for commands.
-                            // A here can open Fight before selection begins.
-                            // With faint switching, a quiet 30 s means the party
-                            // screen after a faint, which B cannot leave.
-                            pbf_mash_button(context,BUTTON_B,switch_on_faint ? 30000ms : 120000ms);
-                        },
-                        {
-                            {battle_menu},
-                            battle_menu_seen
-                                ? PeriodicInferenceCallback{end_battle}
-                                : PeriodicInferenceCallback{},
-                            watch_learn_move ? PeriodicInferenceCallback{learn_move} : PeriodicInferenceCallback{},
-                        }
-                    );
-
-                    switch (ret) {
-
-                        // -------------------------------------------------
-                        // Battle menu detected.
-                        // -------------------------------------------------
-                    case 0:
-                        battle_menu_seen = true;
-                        // Early battles take a few turns; this many means the chosen
-                        // move is not being used (no PP, a misread menu).
-                        if (++turns > 25) {
-                            OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                                label + ": still at the battle menu after 25 turns.", stream);
-                        }
-
-                        stream.log(
-                            "[AutoStory] Battle menu detected.",
-                            COLOR_BLUE
-                        );
-
-                        // A trainer battle we may lose: a Potion when HP is low.
-                        if (battle_type == BattleType::TRAINER && !out_of_potions && potions_used < 4) {
-                            const BattleHeal heal = battle_heal_if_low(stream, context, battle_type, 0.35, label);
-                            if (heal == BattleHeal::USED) {
-                                potions_used++;
-                                break;
-                            }
-                            out_of_potions = heal == BattleHeal::NONE_LEFT;
-                        }
-                        stream.log("["+label+"] Move list position "+std::to_string(move_index+1)+
-                            ": use move "+std::to_string(move_slots[move_index])+".");
-                        select_battle_move_slot(stream, context, battle_type, move_slots[move_index], label,
-                            confirm_default_target,current_move);
-                        current_move=move_slots[move_index];
-                        // A double battle asks for the target next; B would
-                        // back out of it. The default target is an opponent.
-                        if (doubles) {
-                            pbf_wait(context,1200ms);
-                            pbf_press_button(context,BUTTON_A,80ms,1500ms);
-                        }
-                        // Advance once per move selection; retain the final entry.
-                        if (move_index+1<move_slots.size()) move_index++;
-
-                        break;
-
-                        // -------------------------------------------------
-                        // End battle detected.
-                        // -------------------------------------------------
-                    case 1: {
-                        stream.log(
-                            "[AutoStory] " + label + " battle complete.",
-                            COLOR_GREEN
-                        );
-
-                        // EndBattleWatcher has confirmed the completed exit transition.
-                        // Ordinary trainers need no scene-wide dialogue-free gate.
-                        if (!post_battle_dialogue_cleanup) {
-                            context.wait_for_all_requests();
-                            return;
-                        }
-                        // Story NPCs and gym leaders opt into the existing cleanup.
-                        OverworldWatcher overworld;
-                        int cleanup_ret = run_until<ProControllerContext>(stream, context,
-                            [](ProControllerContext& ctx) {
-                                pbf_mash_button(ctx, BUTTON_B, 120000ms);
-                            }, {{overworld}});
-                        if (cleanup_ret != 0) {
-                            OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                                label + ": Post-battle cleanup timed out.", stream);
-                        }
-                        context.wait_for_all_requests();
-                        confirm_battle_overworld(stream, context, label + " cleanup");
-                        return;
-                    }
-
-                    case 2:
-                        stream.log("["+label+"] Declining move learning; preserving scripted move positions.");
-                        pbf_move_right_joystick(context,{0,-1},160ms,840ms);
-                        pbf_press_button(context,BUTTON_ZL,160ms,840ms);
-                        break;
-
-                    default:
-                        // After a faint the game shows the party: Down to the
-                        // next Pokemon, A, then A on "Send out" (by hand,
-                        // 2026-10-29 against Roark).
-                        if (switch_on_faint && faint_switches < 5) {
-                            faint_switches++;
-                            stream.log("[" + label + "] No battle menu for 30 s: a faint; sending out the next Pokemon.", COLOR_ORANGE);
-                            pbf_press_dpad(context, DPAD_DOWN, 80ms, 500ms);
-                            pbf_press_button(context, BUTTON_A, 80ms, 1200ms);
-                            pbf_press_button(context, BUTTON_A, 80ms, 2000ms);
-                            break;
-                        }
-                        stream.log(
-                            "[AutoStory] " + label + " battle timeout.",
-                            COLOR_RED
-                        );
-
-                        OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                            "[AutoStory] " + label + " battle timeout.", stream);
-                    }
-                }
-            }
-
-            // Preserve the existing early-game callers and their B text cleanup.
-            static void fight_using_move_slot(VideoStream& stream, ProControllerContext& context,
-                BattleType battle_type, size_t move_slot, const std::string& label) {
-                fight_using_move_list(stream,context,battle_type,{move_slot},label,false,true);
-            }
-
-            void clear_post_battle_dialogue(VideoStream& stream, ProControllerContext& context,
-                Button button, Milliseconds quiet_period,
-                const char* instruction_card) {
-                context.wait_for_all_requests();
-                std::unique_ptr<ImageMatchDetector> card;
-                if (instruction_card) card = std::make_unique<ImageMatchDetector>(
-                    std::make_shared<ImageRGB32>(RESOURCE_PATH()+instruction_card),
-                    ImageFloatBox{.04,.32,.92,.34},30.0);
-                ShortDialogDetector dialogue(COLOR_YELLOW);
-                BlackScreenDetector black;
-                VideoOverlaySet overlays(stream.overlay());
-                dialogue.make_overlays(overlays);
-                black.make_overlays(overlays);
-                const auto deadline = std::chrono::steady_clock::now() + 120s;
-                auto absent_since = std::chrono::steady_clock::now();
-                while (std::chrono::steady_clock::now() < deadline) {
-                    const auto frame = stream.video().snapshot();
-                    if (!frame) OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                        "Post-battle dialogue: No video frame.", stream);
-                    const auto now = std::chrono::steady_clock::now();
-                    const bool dialogue_visible = dialogue.detect(*frame.frame);
-                    const bool card_visible = card && card->detect(*frame.frame);
-                    if (dialogue_visible || card_visible || black.detect(*frame.frame)) absent_since = now;
-                    else if (now - absent_since >= quiet_period) {
-                        stream.log("[Post-battle dialogue] " + std::to_string(quiet_period.count()) +
-                            "ms without dialogue confirmed.");
-                        return;
-                    }
-                    // A can interact again once dialogue disappears. Only confirm
-                    // visible prompts; B retains the existing post-battle behavior.
-                    if (card_visible) pbf_press_button(context, BUTTON_B, 80ms, 100ms);
-                    else if (button == BUTTON_A && !dialogue_visible) pbf_wait(context, 100ms);
-                    else pbf_mash_button(context, button, 100ms);
-                    context.wait_for_all_requests();
-                }
-                OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                    "Post-battle dialogue: Three clear seconds not confirmed.", stream);
-            }
-
-            void align_to_overworld_landmarks(VideoStream& stream, ProControllerContext& context,
-                OverworldMatchResult (*matcher)(const ImageRGB32&), const std::string& label, bool allow_story_start, bool horizontal_first,
-                bool search_down_first,
-                OverworldMatchResult (*entry_matcher)(const ImageRGB32&),
-                bool* entry_detected,
-                double arrival_tolerance_x, double arrival_tolerance_y,
-                double moderate_entry_confidence, bool* rock_acquisition_timed_out) {
-                if (rock_acquisition_timed_out) *rock_acquisition_timed_out=false;
-                auto missing_rocks_since=std::chrono::steady_clock::time_point::max();
-                if (entry_detected) *entry_detected=false;
-                context.wait_for_all_requests();
-                pbf_wait(context, 500ms);
-                context.wait_for_all_requests();
-                ShortDialogDetector dialogue(COLOR_YELLOW);
-                BattleMenuDetector battle(BattleType::TRAINER, COLOR_GREEN);
-                size_t confirmations = 0, missing = 0;
-                for (size_t attempt = 0; attempt < 80; attempt++) {
-                    const auto frame = stream.video().snapshot();
-                    if (!frame) OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                        label + ": No video frame.", stream);
-                    if (entry_matcher){
-                        BlackScreenDetector transition;
-                        if (entry_matcher(*frame.frame).located || transition.detect(*frame.frame)){
-                            BlackScreenWatcher visible(COLOR_RED,{0.1,0.1,0.8,0.8},
-                                100,10,BlackScreenWatcher::FinderType::GONE,500ms);
-                            if (wait_until(stream,context,30s,{{visible}})!=0)
-                                OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                                    label+": Building transition did not finish.",stream);
-                            const auto inside=stream.video().snapshot();
-                            if (!inside || !entry_matcher(*inside.frame).located)
-                                OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                                    label+": Expected interior not confirmed after transition.",stream);
-                            if(entry_detected)*entry_detected=true;
-                            stream.log("["+label+"] Expected interior confirmed; ending outdoor alignment.",COLOR_GREEN);
-                            return;
-                        }
-                    }
-                    // The story can start before the exact reference point. Hand off
-                    // to battle preparation instead of steering during dialogue.
-                    if (dialogue.detect(*frame.frame) || battle.detect(*frame.frame)) {
-                        if (allow_story_start) {
-                            stream.log("[" + label + "] Story dialogue/battle started; handing off without further movement.");
-                            return;
-                        }
-                        OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                            label + ": Unexpected dialogue/battle during alignment.", stream);
-                    }
-                    const auto result = matcher(*frame.frame);
-                    if (result.located)
-                        missing_rocks_since=std::chrono::steady_clock::time_point::max();
-                    VideoOverlaySet overlays(stream.overlay());
-                    for (const auto& landmark : result.landmarks) {
-                        overlays.add(COLOR_CYAN, landmark.search);
-                        if (landmark.accepted) overlays.add(COLOR_GREEN, landmark.found);
-                        stream.log("[" + label + "] " + landmark.name + " score=" +
-                            std::to_string(landmark.score) + ", margin=" + std::to_string(landmark.margin) +
-                            ", offset=(" + std::to_string(landmark.dx) + "," + std::to_string(landmark.dy) + ")");
-                    }
-                    stream.log("[" + label + "] located=" + std::to_string(result.located) +
-                        ", coarse=" + std::to_string(result.coarse) + ", at_target=" + std::to_string(result.at_target) +
-                        ", consensus offset=(" + std::to_string(result.dx) + "," + std::to_string(result.dy) + ")");
-                    const double entry_confidence=moderate_entry_confidence>0 ? overworld_entry_confidence(result) : 0;
-                    const bool moderate_arrival=moderate_entry_confidence>0 && entry_confidence>=moderate_entry_confidence;
-                    if(moderate_entry_confidence>0) stream.log("["+label+"] Exterior entry confidence="+
-                        std::to_string(entry_confidence)+", moderate threshold="+std::to_string(moderate_entry_confidence)+
-                        ", strict target="+std::to_string(result.at_target));
-                    // Explicit loose bounds are for non-interacting route handoffs.
-                    // Default callers still require the matcher's precise arrival.
-                    const bool rough_arrival=arrival_tolerance_x>0 && arrival_tolerance_y>0 &&
-                        result.located && std::abs(result.dx)<=arrival_tolerance_x &&
-                        std::abs(result.dy)<=arrival_tolerance_y;
-                    if (result.at_target || rough_arrival || moderate_arrival) {
-                        if (++confirmations >= 3) { stream.log("[" + label + "] Position confirmed."); return; }
-                        pbf_wait(context, 250ms);
-                    } else if (result.located) {
-                        confirmations = 0;
-                        missing = 0;
-                        // Wait at an aligned pose while strict visual support
-                        // recovers, rather than stepping away under a cloud.
-                        if ((matcher==match_galactic_hq_jupiter ||
-                            matcher==match_route208_hannah_departure || matcher==match_route208_stair_top) && result.coarse &&
-                            std::abs(result.dx)<=1.0/128 && std::abs(result.dy)<=1.0/54){
-                            pbf_wait(context,500ms);
-                            context.wait_for_all_requests();
-                            continue;
-                        }
-                        // A coarse match cannot confirm position, but two accepted
-                        // anchors can establish a safe horizontal direction when both
-                        // offsets are well outside the uncertainty in their spacing.
-                        bool coarse_horizontal = false;
-                        if (horizontal_first && result.coarse && result.landmarks.size() == 2) {
-                            const auto& a = result.landmarks[0];
-                            const auto& b = result.landmarks[1];
-                            const double nearest = std::min(std::abs(a.dx), std::abs(b.dx));
-                            coarse_horizontal = a.accepted && b.accepted && a.dx*b.dx > 0 &&
-                                nearest > 1.0/64 && nearest > 2*std::abs(a.dx-b.dx);
-                        }
-                        const bool plaza_anchor_horizontal = matcher == match_jubilife_plaza_approach &&
-                            result.coarse && std::abs(result.dx)>1.0/50 && std::abs(result.dy)<=1.0/54;
-                        // A uniquely matched Eterna ball may correct the door
-                        // column while the sign/bush enter the frame. Arrival
-                        // still requires the matcher's full three-anchor check.
-                        const bool eterna_anchor_horizontal = (matcher == match_eterna_center_entrance ||
-                            matcher == match_eterna_underground_house || matcher == match_eterna_underground_man) &&
-                            result.coarse && std::abs(result.dx)>1.0/128;
-                        // Recover the gym's doorway row before moving right if
-                        // the south approach overshot toward the fence/cliff.
-                        const bool gym_anchor_horizontal=matcher==match_eterna_gym_entrance &&
-                            result.coarse && std::abs(result.dx)>1.0/128 && std::abs(result.dy)<=.06;
-                        const bool gym_row_recovery=matcher==match_eterna_gym_entrance &&
-                            result.coarse && std::abs(result.dy)>.06;
-                        // Reach the row north of Jupiter before entering her
-                        // column. From above that row, align sideways before
-                        // moving south so the NPC cannot block the correction.
-                        const bool jupiter_row_recovery=matcher==match_galactic_hq_jupiter &&
-                            result.dy < -1.0/54;
-                        const bool jupiter_anchor_horizontal=matcher==match_galactic_hq_jupiter &&
-                            !jupiter_row_recovery && result.coarse && std::abs(result.dx)>1.0/128;
-                        // Stay south of the Contest Hall wall/sign before crossing to Fantina.
-                        const bool contest_row_recovery=matcher==match_hearthome_contest_fantina && result.dy>1.0/54;
-                        // Keep the stair approach horizontal-first until close to
-                        // its column. Recorded fine poses otherwise spent repeated
-                        // 16ms sideways turns while a larger vertical error waited.
-                        // Fine correction changes axis priority, never arrival gates.
-                        const bool stair_fine_correction=matcher==match_route208_stair_top &&
-                            !result.coarse && std::abs(result.dx)<=1.0/64;
-                        const bool horizontal = !contest_row_recovery && !gym_row_recovery && !jupiter_row_recovery && (jupiter_anchor_horizontal || coarse_horizontal || plaza_anchor_horizontal || eterna_anchor_horizontal || gym_anchor_horizontal || (!result.coarse &&
-                            ((horizontal_first && !stair_fine_correction && std::abs(result.dx)>1.0/128) ||
-                             std::abs(result.dx)>=std::abs(result.dy)*9.0/16)));
-                        if (stair_fine_correction && horizontal_first && !horizontal && std::abs(result.dx)>1.0/128)
-                            stream.log("["+label+"] Near stair column; correcting the larger vertical error first.");
-                        if (coarse_horizontal) stream.log("[" + label +
-                            "] Both landmarks agree on a large horizontal offset; correcting the street lane first.");
-                        const double error = horizontal ? result.dx : result.dy*9.0/16;
-                        auto duration = std::abs(error) > 1.0/24 ? 80ms : std::abs(error) > 1.0/64 ? 40ms : 16ms;
-                        // A 16ms turn may not complete a step. Use a bounded
-                        // full correction while reacquiring the second plaza anchor.
-                        if (matcher == match_jubilife_plaza_approach && result.coarse)
-                            duration = std::max(duration, 60ms);
-                        if (matcher==match_galactic_hq_jupiter){
-                            for (const auto& landmark:result.landmarks){
-                                // The player stands around y=.74. Do not steer
-                                // sideways/north when the stair opening is close
-                                // to that row; a southward correction moves away.
-                                if (landmark.name=="StairBoundary" && landmark.accepted &&
-                                    landmark.found.y+landmark.found.height>.60 &&
-                                    (horizontal || result.dy<0))
-                                    OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                                        label+": Correction would approach the stair boundary.",stream);
-                            }
-                        }
-                        pbf_move_left_joystick(context,
-                            {horizontal ? (result.dx > 0 ? 1.0 : -1.0) : 0.0,
-                             horizontal ? 0.0 : (result.dy < 0 ? 1.0 : -1.0)}, duration, 0ms);
-                        pbf_wait(context, 500ms);
-                    } else {
-                        confirmations = 0;
-                        if (matcher==match_hearthome_center_entrance || matcher==match_hearthome_contest_fantina){
-                            // Do not sweep into a different doorway or around the Hall's
-                            // side when a cloud, NPC or fade hides the required anchors.
-                            if (++missing>20) OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                                label+": Scene anchors missing; stationary reacquisition exhausted.",stream);
-                            pbf_wait(context,500ms);
-                            context.wait_for_all_requests();
-                            continue;
-                        }
-                        if (matcher==match_galactic_hq_jupiter || matcher==match_route208_stair_top){
-                            // Keep generic missing-anchor behavior unchanged. Route208's
-                            // explicit caller can instead request its recorded recovery.
-                            const bool stair_rocks=matcher==match_route208_stair_top;
-                            if (stair_rocks && rock_acquisition_timed_out) {
-                                const auto now=std::chrono::steady_clock::now();
-                                if (missing_rocks_since==std::chrono::steady_clock::time_point::max())
-                                    missing_rocks_since=now;
-                                // Matcher processing can take seconds per observation;
-                                // measure real elapsed time rather than counting waits.
-                                if (now-missing_rocks_since>=10s) {
-                                    context.wait_for_all_requests();
-                                    *rock_acquisition_timed_out=true;
-                                    stream.log("["+label+"] Rock acquisition timed out after 10s; handing off to the requested cliff recovery.");
-                                    return;
-                                }
-                            } else if (++missing>(stair_rocks ? 20 : 6)) {
-                                OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                                    label+(stair_rocks ? ": Rock anchors missing; no blind search near stairs." :
-                                        ": Chair/stair anchors missing; no blind search near stairs."),stream);
-                            }
-                            pbf_wait(context,500ms);
-                            context.wait_for_all_requests();
-                            continue;
-                        }
-                        // Search right first, then across the starting point to the
-                        // left and back. Each complete sweep returns to its origin.
-                        // Try that sweep at the initial height, above it, and below it;
-                        // no missing/weak landmark ever confirms the destination.
-                        if (++missing > (search_down_first ? 78 : 74)) OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                            label + ": Landmarks missing during bounded bidirectional search.", stream);
-                        if (search_down_first && missing <= 4) {
-                            stream.log("[" + label + "] Post-battle acquisition: moving down before lateral search.");
-                            pbf_move_left_joystick(context, {0.0, -1.0}, 100ms, 0ms);
-                        } else {
-                            const size_t search_step = missing - 1 - (search_down_first ? 4 : 0);
-                            const size_t level = search_step / 25;
-                            const size_t slot = search_step % 25;
-                            const bool lateral = slot < 24;
-                            const double direction = slot < 6 || slot >= 18 ? 1.0 : -1.0;
-                            const auto search_duration = lateral ? 100ms : level == 0 ? 600ms : 1200ms;
-                            stream.log("[" + label + "] Acquisition search step=" + std::to_string(missing) +
-                                ", direction=" + (lateral ? (direction>0 ? "right" : "left") : (level==0 ? "up" : "down")));
-                            // On the street, a northward search from the east
-                            // edge can stop at the building/NPC collision row.
-                            // Step west around it before changing height, then
-                            // return to the same lane for the next bounded sweep.
-                            const bool street_height_search=!lateral && matcher==match_jubilife_street_approach;
-                            if (street_height_search) pbf_move_left_joystick(context,{-1.0,0.0},150ms,0ms);
-                            pbf_move_left_joystick(context,
-                                {lateral ? direction : 0.0, lateral ? 0.0 : (level == 0 ? 1.0 : -1.0)}, search_duration, 0ms);
-                            if (street_height_search) pbf_move_left_joystick(context,{1.0,0.0},150ms,0ms);
-                        }
-                        pbf_wait(context, 500ms);
-                    }
-                    context.wait_for_all_requests();
-                }
-                OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                    label + ": Could not confirm the reference position.", stream);
-            }
-
-            void fight_trainer_using_moves(VideoStream& stream, ProControllerContext& context,
-                const std::vector<size_t>& moves, const std::string& label, bool post_battle_dialogue_cleanup) {
-                fight_using_move_list(stream,context,BattleType::TRAINER,moves,label,true,post_battle_dialogue_cleanup);
-            }
-
-            void fight_trainer_using_moves(VideoStream& stream, ProControllerContext& context,
-                size_t move, const std::string& label, bool post_battle_dialogue_cleanup) {
-                fight_trainer_using_moves(stream,context,std::vector<size_t>{move},label,post_battle_dialogue_cleanup);
-            }
-
-            void fight_trainer_using_move_slot(VideoStream& stream, ProControllerContext& context,
-                size_t move_slot, const std::string& label) {
-                fight_using_move_slot(stream,context,BattleType::TRAINER,move_slot,label);
-            }
-
-            void fight_story_battle(VideoStream& stream, ProControllerContext& context, const std::string& label, bool doubles) {
-                // The best move each turn; the next Pokemon after a faint; no new moves.
-                fight_using_move_list(stream, context, BattleType::TRAINER, {0}, label, false, true, doubles, true);
-            }
-
-            void fight_trainer(VideoStream& stream, ProControllerContext& context, const std::string& label) {
-                // Move 0: the best move on the menu each turn, whatever the starter.
-                fight_using_move_slot(stream, context, BattleType::TRAINER, 0, label);
-            }
-
-            void battle_1_pokemon(VideoStream& stream, ProControllerContext& context) {
-                stream.log("[Training] Finding one wild Pokemon using the catch encounter wiggle.", COLOR_BLUE);
-                encounter_one_wild_pokemon(stream, context);
-                // The best move on the menu, whatever the starter.
-                fight_using_move_slot(stream, context, BattleType::STANDARD, 0, "Training");
-                context.wait_for_all_requests();
-                stream.log("[Training] One wild battle completed.", COLOR_GREEN);
-            }
-
-            // ---------------------------------------------------------------------------
-            // Catch 1 Pokemon
-            // ---------------------------------------------------------------------------
-
-            void catch_1_pokemon(
-                VideoStream& stream,
-                ProControllerContext& context
-            ) {
-                stream.log("[AutoStory] Starting catch_1_pokemon helper...", COLOR_BLUE);
-
-                encounter_one_wild_pokemon(stream, context);
-
-                // Catch the pokemon.
-                stream.log("[AutoStory] Throwing Poke Ball (manual bag open)...", COLOR_BLUE);
-                ReceivePokemonDetector received_pokemon;
-                // Preserve exit-transition state from the ball outcome through
-                // receipt/experience cleanup; do not recreate it between phases.
-                EndBattleWatcher battle_ended;
-                bool caught = false;
-                bool exit_seen = false;
-                for (int throw_attempt = 0; throw_attempt < 10; throw_attempt++) {
-                    // Open bag from battle menu (X), confirm first slot (ZL).
-                    pbf_press_button(context, BUTTON_X, 160ms, 840ms);
-                    context.wait_for_all_requests();
-                    pbf_press_button(context, BUTTON_ZL, 160ms, 1000ms);
-                    context.wait_for_all_requests();
-
-                    // Wait to see if the battle menu comes back (ball failed)
-                    // or if the battle ends (caught or fainted).
-                    BattleMenuWatcher menu_back(BattleType::STANDARD, COLOR_YELLOW);
-                    int throw_ret = run_until<ProControllerContext>(
-                        stream, context,
-                        [](ProControllerContext& ctx) {
-                            pbf_mash_button(ctx, BUTTON_B, 120000ms);
-                        },
-                        {{menu_back}, {received_pokemon}, {battle_ended}}
-                    );
-
-                    if (throw_ret == 1 || (throw_ret == 2 && received_pokemon.received())) {
-                        caught = true;
-                        exit_seen = throw_ret == 2;
-                        stream.log("[AutoStory] Pokemon receipt verified.", COLOR_GREEN);
-                        break;
-                    }
-                    if (throw_ret < 0 || throw_ret == 2) {
-                        OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                            "Catch failed: No verified Pokemon receipt before battle ended or timed out.", stream);
-                    }
-                    stream.log(
-                        "[AutoStory] Ball failed, retrying (attempt " + std::to_string(throw_attempt + 2) + ")...",
-                        COLOR_ORANGE
-                    );
-                }
-
-                context.wait_for_all_requests();
-
-                if (!caught) {
-                    OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                        "Catch failed: Exhausted ten ball attempts.", stream);
-                }
-                // Receipt alone is not an overworld return: clear experience,
-                // automatic move learning, dex registration and nickname screens
-                // until the same completed-black-transition watcher used in battles fires.
-                if (!exit_seen) {
-                    stream.log("[Catch cleanup] Receipt confirmed; waiting for battle exit transition.");
-                    const int cleanup_ret = run_until<ProControllerContext>(stream, context,
-                        [](ProControllerContext& ctx) { pbf_mash_button(ctx, BUTTON_B, 120000ms); },
-                        {{battle_ended}});
-                    if (cleanup_ret != 0) {
-                        OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                            "Catch cleanup: Battle exit transition did not finish.", stream);
-                    }
-                }
-                context.wait_for_all_requests();
-                stream.log("[Catch cleanup] Battle exit transition confirmed; checking stable overworld.");
-                confirm_battle_overworld(stream, context, "Catch cleanup");
-                stream.log("[Catch cleanup] Verified receipt, completed battle exit, and four seconds of clear overworld.", COLOR_GREEN);
-            }
-
-            // ---------------------------------------------------------------------------
-            // catch_1_pokemon_v2 - burst wiggle variant for testing.
-            // Uses WIGGLES_PER_BURST consecutive left/right moves before checking for a
-            // battle, reducing total wait time compared to checking after every move.
-            // Commented out - enable for testing when ready.
-            // ---------------------------------------------------------------------------
-            // void catch_1_pokemon_v2(
-            //     SingleSwitchProgramEnvironment& env,
-            //     VideoStream& stream,
-            //     ProControllerContext& context
-            // ) {
-            //     stream.log("[AutoStory] Starting catch_1_pokemon_v2 helper...", COLOR_BLUE);
-            //
-            //     // Save once before attempting to catch. On failure the game
-            //     // resets back to this save, so the save lives outside the loop.
-            //     stream.log("[AutoStory] Saving game before catch attempt...", COLOR_BLUE);
-            //     {
-            //         static constexpr int SAVE_MAX_RETRIES = 3;
-            //         bool save_succeeded = false;
-            //         for (int save_attempt = 0; save_attempt < SAVE_MAX_RETRIES; save_attempt++) {
-            //             try {
-            //                 if (save_attempt > 0) {
-            //                     stream.log(
-            //                         "[AutoStory] Retrying save (attempt " + std::to_string(save_attempt + 1) + ")...",
-            //                         COLOR_ORANGE
-            //                     );
-            //                     pbf_mash_button(context, BUTTON_B, 1000ms);
-            //                     context.wait_for_all_requests();
-            //                 }
-            //                 save_game(stream, context);
-            //                 save_succeeded = true;
-            //                 break;
-            //             }
-            //             catch (OperationFailedException& e) {
-            //                 stream.log(
-            //                     "[AutoStory] Save attempt " + std::to_string(save_attempt + 1) + " failed: " + e.message(),
-            //                     COLOR_RED
-            //                 );
-            //                 context.wait_for(1000ms);
-            //             }
-            //         }
-            //         if (!save_succeeded) {
-            //             stream.log("[AutoStory] All save attempts failed. Using blind fallback save.", COLOR_ORANGE);
-            //             pbf_mash_button(context, BUTTON_B, 1000ms);
-            //             save_game(context);
-            //             pbf_mash_button(context, BUTTON_B, 2000ms);
-            //         }
-            //     }
-            //     context.wait_for_all_requests();
-            //     pbf_wait(context, 1000ms);
-            //
-            //     // -------------------------------------------------------
-            //     // Mini-checkpoint loop: retry from the save above if we
-            //     // run out of balls or our Pokemon faints.
-            //     // -------------------------------------------------------
-            //     while (true) {
-            //
-            //     BlackScreenWatcher battle_start;
-            //     BattleMenuWatcher battle_menu(BattleType::STANDARD, COLOR_YELLOW);
-            //     BattleDialogWatcher battle_dialog(COLOR_YELLOW);
-            //
-            //     bool encounter_found = false;
-            //
-            //     // Wiggle left/right in bursts, checking for a battle after each burst.
-            //     // Doing multiple moves before checking avoids waiting after every step.
-            //     static constexpr int WIGGLES_PER_BURST = 3;
-            //     while (!encounter_found) {
-            //         for (int i = 0; i < WIGGLES_PER_BURST; i++) {
-            //             pbf_move_left_joystick(context, {-1, 0}, 120ms, 80ms);
-            //             pbf_move_left_joystick(context, { 1, 0}, 120ms, 80ms);
-            //         }
-            //         context.wait_for_all_requests();
-            //
-            //         int ret = wait_until(
-            //             stream,
-            //             context,
-            //             1500ms,
-            //             {
-            //                 {battle_start},
-            //                 {battle_menu},
-            //                 {battle_dialog},
-            //             }
-            //         );
-            //
-            //         if (ret >= 0) {
-            //             encounter_found = true;
-            //         }
-            //     }
-            //
-            //     stream.log("[AutoStory] Wild battle detected!", COLOR_GREEN);
-            //
-            //     // Wait until the actual battle menu appears.
-            //     BattleMenuWatcher confirm_menu(BattleType::STANDARD);
-            //
-            //     int menu_ret = wait_until(
-            //         stream,
-            //         context,
-            //         15s,
-            //         {
-            //             {confirm_menu},
-            //         }
-            //     );
-            //
-            //     if (menu_ret < 0) {
-            //         stream.log(
-            //             "[AutoStory] Failed to detect battle menu. Resetting to checkpoint...",
-            //             COLOR_RED
-            //         );
-            //         reset_game_from_home(env, env.console, context, true);
-            //         continue;
-            //     }
-            //
-            //     stream.log("[AutoStory] Battle menu detected.", COLOR_GREEN);
-            //
-            //     context.wait_for_all_requests();
-            //     pbf_wait(context, 500ms);
-            //
-            //     // --- Throw balls ---
-            //     CatchResults result = basic_catcher(
-            //         stream,
-            //         context,
-            //         Language::English,
-            //         "poke-ball",
-            //         10
-            //     );
-            //
-            //     switch (result.result) {
-            //     case CatchResult::POKEMON_CAUGHT:
-            //         stream.log(
-            //             "[AutoStory] Pokemon successfully caught after " +
-            //             std::to_string(result.balls_used) + " ball(s).",
-            //             COLOR_GREEN
-            //         );
-            //         {
-            //             OverworldWatcher overworld;
-            //             run_until<ProControllerContext>(
-            //                 stream, context,
-            //                 [](ProControllerContext& ctx) {
-            //                     pbf_mash_button(ctx, BUTTON_B, 120000ms);
-            //                 },
-            //                 {{overworld}}
-            //             );
-            //         }
-            //         return;
-            //
-            //     case CatchResult::POKEMON_FAINTED:
-            //         stream.log("[AutoStory] Wild Pokemon fainted. Exiting battle.", COLOR_ORANGE);
-            //         {
-            //             OverworldWatcher overworld;
-            //             run_until<ProControllerContext>(
-            //                 stream, context,
-            //                 [](ProControllerContext& ctx) {
-            //                     pbf_mash_button(ctx, BUTTON_B, 120000ms);
-            //                 },
-            //                 {{overworld}}
-            //             );
-            //         }
-            //         return;
-            //
-            //     case CatchResult::OUT_OF_BALLS:
-            //         stream.log(
-            //             "[AutoStory] Ran out of Poke Balls after " +
-            //             std::to_string(result.balls_used) + " throw(s). Resetting to checkpoint...",
-            //             COLOR_RED
-            //         );
-            //         reset_game_from_home(env, env.console, context, true);
-            //         continue;
-            //
-            //     case CatchResult::OWN_FAINTED:
-            //         stream.log(
-            //             "[AutoStory] Own Pokemon fainted. Resetting to checkpoint...",
-            //             COLOR_RED
-            //         );
-            //         reset_game_from_home(env, env.console, context, true);
-            //         continue;
-            //
-            //     case CatchResult::BALL_LIMIT_REACHED:
-            //         stream.log(
-            //             "[AutoStory] Ball limit reached (" +
-            //             std::to_string(result.balls_used) + " throw(s)). Resetting to checkpoint...",
-            //             COLOR_RED
-            //         );
-            //         reset_game_from_home(env, env.console, context, true);
-            //         continue;
-            //
-            //     case CatchResult::CANNOT_THROW_BALL:
-            //         stream.log(
-            //             "[AutoStory] Cannot throw ball (menu timing issue). Resetting to checkpoint...",
-            //             COLOR_RED
-            //         );
-            //         reset_game_from_home(env, env.console, context, true);
-            //         continue;
-            //
-            //     default:
-            //         stream.log(
-            //             "[AutoStory] Catch timed out after " +
-            //             std::to_string(result.balls_used) + " ball(s). Resetting to checkpoint...",
-            //             COLOR_RED
-            //         );
-            //         reset_game_from_home(env, env.console, context, true);
-            //         continue;
-            //     }
-            //
-            //     } // end while(true)
-            // }
-
-            // ---------------------------------------------------------------------------
-            // Movement Helpers
-            // ---------------------------------------------------------------------------
-
-            bool detect_black_screen_after_movement(
-                VideoStream& stream,
-                ProControllerContext& context,
-                Milliseconds timeout
-            ) {
-                BlackScreenWatcher black_screen;
-                return wait_until(stream, context, timeout, {{black_screen}}) == 0;
-            }
-
-            bool try_right_down_exit_search(
-                VideoStream& stream,
-                ProControllerContext& context,
-                size_t iterations
-            ) {
-                for (size_t i = 0; i < iterations; i++) {
-                    pbf_move_left_joystick(context, { 1.0, 0.0 }, 80ms, 0ms);
-                    pbf_move_left_joystick(context, { 0.0, -1.0 }, 220ms, 0ms);
-
-                    if (detect_black_screen_after_movement(stream, context, 1000ms)) {
-                        return true;
-                    }
-                }
-                return false;
-            }
-
-            void leave_pokemon_center_before_barry_1(
-                VideoStream& stream,
-                ProControllerContext& context
-            ) {
-                // Original down movement to leave Pokemon Center.
-                pbf_move_left_joystick(context, { 0.0, -1.0 }, 814ms, 0ms);
-
-                if (detect_black_screen_after_movement(stream, context, 1200ms)) {
-                    pbf_wait(context, 2340ms);
-                    return;
-                }
-
-                stream.log("[AutoStory] Pokemon Center exit black screen not detected. Searching with right/down movement.", COLOR_ORANGE);
-
-                if (try_right_down_exit_search(stream, context, 20)) {
-                    pbf_wait(context, 2340ms);
-                    return;
-                }
-
-                stream.log("[AutoStory] First exit search failed. Repositioning left and retrying.", COLOR_ORANGE);
-                pbf_move_left_joystick(context, { -1.0, 0.0 }, 5000ms, 0ms);
-
-                if (try_right_down_exit_search(stream, context, 30)) {
-                    pbf_wait(context, 2340ms);
-                    return;
-                }
-
-                OperationFailedExceptionWithScreenshot::fire(
-                    ErrorReportMode::SEND_ERROR_REPORT,
-                    "Failed to find Pokemon Center exit black screen before Barry 1. Triggering checkpoint retry.",
-                    stream
-                );
-            }
-
-            // ---------------------------------------------------------------------------
-            // Generic Movement Helper - Walk through grass in specified direction for
-            // specified steps, attempting to run from any battles that are encountered.
-            // ---------------------------------------------------------------------------
-            void walk_through_grass(
-                VideoStream& stream, ProControllerContext& context,
-                int8_t x, int8_t y, size_t steps, const std::string& direction_name,
-                BattleType battle_type, Milliseconds movement_duration,
-                OverworldMatchResult (*destination)(const ImageRGB32&)
-            ) {
-                size_t movements = 0, confirmations = 0;
-                while (true) {
-                    context.wait_for_all_requests();
-                    // Destination checks happen before input and after each step/escape.
-                    // With no matcher, retain the original fixed-step behavior.
-                    VideoOverlaySet overlays(stream.overlay());
-                    OverworldMatchResult location;
-                    if (destination) {
-                        const auto frame = stream.video().snapshot();
-                        if (!frame) OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                            "Grass destination: No video frame.", stream);
-                        location = destination(*frame.frame);
-                        for (const auto& landmark : location.landmarks) {
-                            overlays.add(COLOR_CYAN, landmark.search);
-                            if (landmark.accepted) overlays.add(COLOR_GREEN, landmark.found);
-                            stream.log("[Grass destination] " + direction_name + " " + landmark.name +
-                                " score=" + std::to_string(landmark.score) +
-                                " margin=" + std::to_string(landmark.margin) +
-                                " accepted=" + std::to_string(landmark.accepted));
-                        }
-                        stream.log("[Grass destination] located=" + std::to_string(location.located) +
-                            " at_target=" + std::to_string(location.at_target) +
-                            " screen-relative offset=(" + std::to_string(location.dx) +
-                            "," + std::to_string(location.dy) + ")");
-                        if (location.at_target) {
-                            if (++confirmations >= 3) {
-                                stream.log("[Grass] Destination confirmed; stopped " + direction_name +
-                                    " after " + std::to_string(movements) + "/" + std::to_string(steps) + " movements.", COLOR_GREEN);
-                                return;
-                            }
-                            pbf_wait(context, 250ms);
-                            continue;
-                        }
-                        confirmations = 0;
-                    }
-                    if (movements >= steps) {
-                        if (destination) OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
-                            "Grass destination not confirmed within movement limit: " + direction_name, stream);
-                        stream.log("[Grass] Completed " + direction_name + " (" + std::to_string(steps) + " steps).", COLOR_GREEN);
-                        return;
-                    }
-                    int8_t move_x=x, move_y=y;
-                    Milliseconds duration=movement_duration;
-                    if (destination && location.located && !location.coarse &&
-                        std::abs(location.dx)<=0.10 && std::abs(location.dy)<=0.12) {
-                        // Small corrections prevent stepping past a narrow stop target.
-                        const bool horizontal=std::abs(location.dx)>=std::abs(location.dy)*9.0/16;
-                        const double error=horizontal ? location.dx : location.dy*9.0/16;
-                        duration=std::min(duration, std::abs(error)>0.03125 ? 80ms :
-                            std::abs(error)>0.015625 ? 40ms : 16ms);
-                        move_x=horizontal ? (location.dx>0 ? 1 : -1) : 0;
-                        move_y=horizontal ? 0 : (location.dy<0 ? 1 : -1);
-                        stream.log("[Grass destination] Correcting " + std::string(horizontal ? "horizontal" : "vertical") +
-                            " axis for " + std::to_string(duration.count()) + "ms.");
-                    }
-                    // Each movement gets fresh watcher state. A completed white
-                    // transition from a prior encounter must not trigger again.
-                    BlackScreenWatcher battle_start;
-                    WhiteScreenOverWatcher white_screen(COLOR_YELLOW, {0.1, 0.1, 0.8, 0.8});
-                    BattleMenuWatcher battle_menu(battle_type, COLOR_YELLOW);
-                    BattleDialogWatcher battle_dialog(COLOR_YELLOW);
-                    pbf_move_left_joystick(context, {(double)move_x, (double)move_y}, duration, 0ms);
-                    movements++;
-                    context.wait_for_all_requests();
-                    int ret = wait_until(stream, context, 2500ms,
-                        {{white_screen}, {battle_start}, {battle_dialog}, {battle_menu}});
-                    if (ret >= 0) {
-                        confirmations = 0;
-                        stream.log("[Grass] " + direction_name + " step " + std::to_string(movements) +
-                            "/" + std::to_string(steps) + ": encounter trigger=" + std::to_string(ret) +
-                            "; using shared confirmed-Run escape.");
-                        escape_wild_battle(stream, context, battle_type);
-                        context.wait_for_all_requests();
-                        stream.log("[Grass] Escape confirmed; resuming " + direction_name + ".");
-                    }
-                }
-            }
-
-        }
-    }
-}
+/*  BDSP AutoStory - Segment 00 Tools
+ *
+ *  Helper implementations for Segment 00.
+ * 
+ *  From: https://github.com/PokemonAutomation/
+ *
+ */
+
+
+#include "PokemonBDSP/Inference/PokemonBDSP_TransitionWatchers.h"
+#include "CommonFramework/GlobalAutoPaths.h"
+#include <algorithm>
+#include <cmath>
+#include <chrono>
+#include <array>
+#include <cctype>
+
+#include "PokemonBDSP_AutoStory_Location.h"
+#include "PokemonBDSP_AutoStory_RouteWalk.h"
+#include "PokemonBDSP_AutoStory_Segment_00_tools.h"
+#include "PokemonBDSP_Autostory_Segment_01_tools.h"
+
+#include "CommonFramework/Exceptions/OperationFailedException.h"
+#include "CommonFramework/Exceptions/OperationFailedExceptionWithScreenshot.h"
+#include "Common/Cpp/PrettyPrint.h"
+#include "Common/Cpp/Filesystem/Filesystem.h"
+#include "CommonFramework/ImageTools/ImageBoxes.h"
+#include "CommonTools/OCR/OCR_RawTesseractOCR.h"
+#include "CommonFramework/Tools/ErrorDumper.h"
+#include "CommonFramework/VideoPipeline/VideoFeed.h"
+#include "CommonFramework/VideoPipeline/VideoOverlayScopes.h"
+
+#include "CommonTools/Async/InferenceRoutines.h"
+#include "CommonTools/VisualDetectors/BlackScreenDetector.h"
+#include "CommonTools/VisualDetectors/ImageMatchDetector.h"
+
+#include "NintendoSwitch/Commands/NintendoSwitch_Commands_PushButtons.h"
+#include "NintendoSwitch/NintendoSwitch_Settings.h"
+
+#include "NintendoSwitch/Programs/DateManip/NintendoSwitch_DateManip.h"
+#include "NintendoSwitch/Programs/DateSpam/NintendoSwitch_HomeToDateTime.h"
+#include "NintendoSwitch/Programs/NintendoSwitch_GameEntry.h"
+
+#include "PokemonBDSP/Inference/PokemonBDSP_MenuDetector.h"
+#include "PokemonBDSP/Inference/PokemonBDSP_DialogDetector.h"
+#include "PokemonBDSP/Inference/PokemonBDSP_SelectionArrow.h"
+
+#include "PokemonBDSP/Inference/Battles/PokemonBDSP_EndBattleDetector.h"
+#include "PokemonBDSP/Inference/PokemonBDSP_ReceivePokemonDetector.h"
+#include "PokemonBDSP/Inference/Battles/PokemonBDSP_BattleMenuDetector.h"
+#include "PokemonBDSP/Inference/Battles/PokemonBDSP_ExperienceGainDetector.h"
+
+#include "PokemonBDSP/Programs/AutoStory/Detect/PokemonBDSP_AutoStory_OverworldDetector.h"
+
+#include "PokemonBDSP/Programs/PokemonBDSP_GameNavigation.h"
+#include "PokemonBDSP/Programs/PokemonBDSP_BasicCatcher.h"
+#include "PokemonBDSP/Programs/PokemonBDSP_GameEntry.h"
+
+using namespace std::chrono_literals;
+
+namespace PokemonAutomation {
+    namespace NintendoSwitch {
+        namespace PokemonBDSP {
+
+            // ---------------------------------------------------------------------------
+            // BattleDialogWatcher
+            // ---------------------------------------------------------------------------
+
+            BattleDialogWatcher::BattleDialogWatcher(Color color)
+                : DetectorToFinder(
+                    "BattleDialogWatcher",
+                    std::chrono::milliseconds(250),
+                    color
+                )
+            {
+            }
+
+            // ---------------------------------------------------------------------------
+            // Poketech Clown dialog helper
+            // ---------------------------------------------------------------------------
+
+            int detect_clown_choice_arrow(
+                VideoOverlay& overlay,
+                VideoSnapshot snapshot
+            ) {
+                SelectionArrowFinder top_arrow(
+                    overlay,
+                    { 0.62, 0.37, 0.08, 0.10 },
+                    COLOR_RED
+                );
+
+                SelectionArrowFinder bottom_arrow(
+                    overlay,
+                    { 0.62, 0.48, 0.08, 0.10 },
+                    COLOR_RED
+                );
+
+                if (top_arrow.detect(snapshot)) {
+                    return 0;
+                }
+
+                if (bottom_arrow.detect(snapshot)) {
+                    return 1;
+                }
+
+                return -1;
+            }
+
+            void clown_dialog_helper(
+                VideoStream& stream,
+                ProControllerContext& context,
+                DpadPosition direction
+            ) {
+                stream.log(
+                    "[AutoStory] Starting clown dialog helper...",
+                    COLOR_BLUE
+                );
+
+                const auto overall_deadline =
+                    std::chrono::steady_clock::now() + 30s;
+
+                // -------------------------------------------------
+                // Phase 1: Move + interact until dialog is detected.
+                // -------------------------------------------------
+                ShortDialogWatcher dialog(COLOR_YELLOW);
+                bool dialog_started = false;
+
+                while (!dialog_started) {
+
+                    if (std::chrono::steady_clock::now() > overall_deadline) {
+                        stream.log(
+                            "[AutoStory] Clown helper timed out finding dialog.",
+                            COLOR_RED
+                        );
+                        OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                            "[AutoStory] Clown helper timed out finding dialog.", stream);
+                    }
+
+                    context.wait_for_all_requests();
+                    pbf_press_dpad(context, direction, 80ms, 200ms);
+                    pbf_press_button(context, BUTTON_A, 80ms, 500ms);
+
+                    if (wait_until(stream, context, 1500ms, { {dialog} }) == 0) {
+                        dialog_started = true;
+                        stream.log("[AutoStory] Dialog detected.", COLOR_GREEN);
+                    }
+                }
+
+                // -------------------------------------------------
+                // Phase 2: A mash for 2 seconds.
+                // -------------------------------------------------
+                stream.log("[AutoStory] Mashing A to advance dialog...", COLOR_BLUE);
+                pbf_mash_button(context, BUTTON_A, 4000ms);
+                context.wait_for_all_requests();
+
+                // -------------------------------------------------
+                // Phase 3: Clear remaining dialog.
+                // -------------------------------------------------
+                pbf_mash_button(context, BUTTON_B, 4000ms);
+
+                context.wait_for_all_requests();
+
+                stream.log(
+                    "[AutoStory] Clown dialog helper complete.",
+                    COLOR_GREEN
+                );
+            }
+            // ---------------------------------------------------------------------------
+            // Time helper
+            // ---------------------------------------------------------------------------
+
+            // Options chrome and position detectors are independent of setting values.
+            class TutorialOptionsDetector {
+            public:
+                bool detect(const ImageViewRGB32& screen) const {
+                    ImageViewRGB32 panel = extract_box_reference(screen, ImageFloatBox{0.04, 0.065, 0.93, 0.70});
+                    size_t white = 0;
+                    for (size_t y = 0; y < panel.height(); y += 4)
+                        for (size_t x = 0; x < panel.width(); x += 4) {
+                            uint32_t p = panel.pixel(x, y);
+                            if (((p >> 16) & 255) > 225 && ((p >> 8) & 255) > 225 && (p & 255) > 225) white++;
+                        }
+                    double samples = (double)(((panel.width() + 3) / 4) * ((panel.height() + 3) / 4));
+                    // Distinguish Options from the icon menu and bag using its
+                    // blue heading and full-width white settings panel.
+                    ImageViewRGB32 heading = extract_box_reference(screen, ImageFloatBox{0.01, 0.005, 0.20, 0.025});
+                    size_t blue = 0, total = 0;
+                    for (size_t y = 0; y < heading.height(); y++)
+                        for (size_t x = 0; x < heading.width(); x++) {
+                            uint32_t p = heading.pixel(x, y);
+                            int r = (p >> 16) & 255, g = (p >> 8) & 255, b = p & 255;
+                            blue += b > r + 20 && g > r + 10;
+                            total++;
+                        }
+                    return samples > 0 && white / samples > 0.70 && total > 0 && blue > total / 4;
+                }
+            };
+
+            // Options fades in after A on its icon: poll instead of judging one frame.
+            static bool wait_for_options_screen(VideoStream& stream, ProControllerContext& context,
+                const TutorialOptionsDetector& options_screen, Milliseconds timeout) {
+                context.wait_for_all_requests();
+                const WallClock deadline = current_time() + timeout;
+                while (current_time() < deadline) {
+                    auto frame = stream.video().snapshot();
+                    if (frame && options_screen.detect(frame)) return true;
+                    context.wait_for(100ms);
+                }
+                return false;
+            }
+
+            class TutorialOptionPositionDetector {
+            public:
+                // Locate the two long red horizontal lines surrounding the
+                // selected row. Scrolling changes their position automatically.
+                double selected_row(const ImageViewRGB32& screen) const {
+                    int first = -1, last = -1;
+                    for (size_t y = (size_t)(screen.height() * 0.08); y < screen.height() * 0.75; y++) {
+                        size_t red = 0, total = 0;
+                        for (size_t x = (size_t)(screen.width() * 0.08); x < screen.width() * 0.90; x += 2) {
+                            uint32_t p = screen.pixel(x, y);
+                            int r = (p >> 16) & 255, g = (p >> 8) & 255, b = p & 255;
+                            red += r > 150 && r > g + 40 && r > b + 40;
+                            total++;
+                        }
+                        if (total && red > total * 0.70) {
+                            if (first < 0) first = (int)y;
+                            last = (int)y;
+                        }
+                    }
+                    if (first < 0 || last - first < screen.height() * 0.04 || last - first > screen.height() * 0.12) return -1;
+                    return (first + last) / (2.0 * screen.height());
+                }
+                // Locate selected red value text separately from the row border.
+                bool selected_value(const ImageViewRGB32& screen, double y) const {
+                    ImageViewRGB32 value = extract_box_reference(screen, ImageFloatBox{0.33, y - 0.025, 0.54, 0.05});
+                    size_t red = 0;
+                    for (size_t py = 0; py < value.height(); py++)
+                        for (size_t px = 0; px < value.width(); px++) {
+                            uint32_t p = value.pixel(px, py);
+                            int r = (p >> 16) & 255, g = (p >> 8) & 255, b = p & 255;
+                            red += r > g + 20 && r > b + 20;
+                        }
+                    return red > value.width() * value.height() * 0.0005;
+                }
+            };
+
+
+            // Compare binary visual shapes with small alignment tolerance.
+            // No text recognition is needed for fixed English option labels.
+            static double option_image_score(const ImageViewRGB32& screen,
+                const ImageFloatBox& box, const ImageRGB32& reference, bool red_only) {
+                ImageRGB32 actual = extract_box_reference(screen, box).scale_to(384, 32);
+                ImageRGB32 expected = reference.scale_to(384, 32);
+                auto ink = [red_only](uint32_t p){
+                    int r = (p >> 16) & 255, g = (p >> 8) & 255, b = p & 255;
+                    return red_only ? r > g + 20 && r > b + 20 : r + g + b < 500;
+                };
+                double best = 0;
+                for (int dy = -2; dy <= 2; dy++) for (int dx = -2; dx <= 2; dx++) {
+                    size_t overlap = 0, count = 0;
+                    for (int y = 2; y < 30; y++) for (int x = 2; x < 382; x++) {
+                        bool a = ink(actual.pixel(x + dx, y + dy));
+                        bool b = ink(expected.pixel(x, y));
+                        overlap += a && b;
+                        count += a + b;
+                    }
+                    if (count) best = std::max(best, 2.0 * overlap / count);
+                }
+                return best;
+            }
+
+            static bool autosave_off_highlight(const ImageViewRGB32& screen, double y) {
+                auto red_count = [&](const ImageFloatBox& box){
+                    ImageViewRGB32 image = extract_box_reference(screen, box);
+                    size_t red = 0;
+                    for (size_t py = 0; py < image.height(); py++)
+                        for (size_t px = 0; px < image.width(); px++) {
+                            uint32_t p = image.pixel(px, py);
+                            int r = (p >> 16) & 255, g = (p >> 8) & 255, b = p & 255;
+                            red += r > g + 30 && r > b + 30;
+                        }
+                    return red;
+                };
+                size_t off = red_count({0.63, y - 0.022, 0.055, 0.044});
+                size_t on = red_count({0.34, y - 0.022, 0.055, 0.044});
+                // Require a clear Off highlight and reject any competing On highlight.
+                return off >= 10 && on * 10 < off;
+            }
+
+            static void verify_tutorial_settings_once(VideoStream& stream, ProControllerContext& context) {
+                context.wait_for_all_requests();
+                MenuDetector menu;
+                VideoOverlaySet detector_overlays(stream.overlay());
+                menu.make_overlays(detector_overlays);
+                detector_overlays.add(COLOR_CYAN, {0.04, 0.065, 0.93, 0.70}, "");
+                detector_overlays.add(COLOR_BLUE, {0.01, 0.005, 0.20, 0.025}, "");
+                detector_overlays.add(COLOR_RED, {0.08, 0.08, 0.82, 0.67}, "");
+                auto initial = stream.video().snapshot();
+                if (!initial || !menu.detect(initial)) {
+                    pbf_press_button(context, BUTTON_X, 80ms, 1000ms);
+                    context.wait_for_all_requests();
+                }
+                MenuWatcher menu_open;
+                if (wait_until(stream, context, 5s, {{menu_open}}) != 0) {
+                    OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                        "Settings checkpoint: Main menu not detected.", stream);
+                }
+                stream.log("[Tutorial settings] Main menu detected; settling for 500ms before Options navigation.");
+                pbf_wait(context, 500ms);
+                context.wait_for_all_requests();
+                TutorialOptionsDetector options_screen;
+                TutorialOptionPositionDetector position;
+                // Only two icons are available at this initial checkpoint.
+                // Verify the main menu before navigating to the neighboring icon.
+                bool options_open = false;
+                for (size_t attempt = 0; attempt < 2; attempt++) {
+                    pbf_press_dpad(context, attempt == 0 ? DPAD_RIGHT : DPAD_LEFT, 80ms, 350ms);
+                    pbf_press_button(context, BUTTON_A, 80ms, 0ms);
+                    if (wait_for_options_screen(stream, context, options_screen, 5s)) {
+                        options_open = true;
+                        break;
+                    }
+                    pbf_press_button(context, BUTTON_B, 80ms, 1000ms);
+                    context.wait_for_all_requests();
+                    MenuWatcher back_to_menu;
+                    if (wait_until(stream, context, 5s, {{back_to_menu}}) != 0) break;
+                }
+                if (!options_open) {
+                    OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                        "Settings checkpoint: Options screen not detected.", stream);
+                }
+                stream.log("[Tutorial settings] Options screen detected.");
+                pbf_wait(context, 500ms);
+                context.wait_for_all_requests();
+                struct Setting { const char* label; const char* value; };
+                const Setting settings[] = {
+                    {"textspeed", "fast"}, {"changewindow", "type1"},
+                    {"battleeffects", "off"}, {"battlestyle", "set"},
+                    {"sendtoboxes", "automatic"}, {"givenicknames", "dontgive"},
+                    {"gyroscope", "use"}, {"autosave", "off"},
+                    {"shownicknames", "show"}, {"backgroundmusic", "8"},
+                    {"soundeffects", "8"},
+                };
+                for (size_t row = 0; row < sizeof(settings) / sizeof(settings[0]); row++) {
+                    // Detect the selected row afresh after every navigation/correction.
+                    double y = -1;
+                    const std::string base = RESOURCE_PATH() + "PokemonBDSP/Autostory/Options/" + settings[row].label;
+                    const ImageRGB32 label_reference(base + "_label.png");
+                    const ImageRGB32 value_reference(base + "_value.png");
+                    bool slider_reset = false;
+                    bool correct = false;
+                    for (size_t attempt = 0; attempt < 30; attempt++) {
+                        context.wait_for_all_requests();
+                        auto frame = stream.video().snapshot();
+                        if (frame && options_screen.detect(frame)) y = position.selected_row(frame);
+                        else y = -1;
+                        const bool value_visible = y >= 0 && position.selected_value(frame, y);
+                        const double label_score = y >= 0 ? option_image_score(frame,
+                            {0.08, y - 0.025, 0.24, 0.05}, label_reference, false) : 0;
+                        stream.log("[Tutorial settings] Expected row=" + std::string(settings[row].label) +
+                            " row_y=" + std::to_string(y) + " highlighted_value=" + std::to_string(value_visible) +
+                            " label_match=" + std::to_string(label_score));
+                        if (y < 0 || !value_visible || label_score < 0.80) {
+                            // A menu can be detected while its row/text is still
+                            // fading in. Re-read without directional inputs first.
+                            if (attempt < 4) {
+                                pbf_wait(context, 200ms);
+                                context.wait_for_all_requests();
+                                continue;
+                            }
+                            OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                                "Settings checkpoint: Unable to confirm expected row " + std::string(settings[row].label), stream);
+                        }
+                        // These are regular video-overlay boxes, so the existing
+                        // overlay display control can show/hide every active ROI.
+                        OverlayBoxScope row_overlay(stream.overlay(), COLOR_RED,
+                            {0.07, y - 0.04, 0.84, 0.08}, "");
+                        OverlayBoxScope label_overlay(stream.overlay(), COLOR_YELLOW,
+                            {0.08, y - 0.025, 0.24, 0.05}, "");
+                        OverlayBoxScope value_overlay(stream.overlay(), COLOR_GREEN,
+                            {0.33, y - 0.025, 0.54, 0.05}, "");
+                        VideoOverlaySet autosave_rois(stream.overlay());
+                        if (row == 7) {
+                            autosave_rois.add(COLOR_GREEN, {0.63, y - 0.022, 0.055, 0.044});
+                            autosave_rois.add(COLOR_RED, {0.34, y - 0.022, 0.055, 0.044});
+                        }
+                        double score;
+                        if (row >= 9) {
+                            // Compare the numeric value rather than the long slider:
+                            // neighboring slider levels otherwise look too similar.
+                            ImageViewRGB32 number = value_reference.sub_image(
+                                value_reference.width() * 82 / 100, 0,
+                                value_reference.width() - value_reference.width() * 82 / 100,
+                                value_reference.height());
+                            ImageRGB32 number_reference = number.scale_to(96, 32);
+                            score = option_image_score(frame,
+                                {0.7728, y - 0.025, 0.0972, 0.05}, number_reference, true);
+                        } else {
+                            score = option_image_score(frame,
+                                {0.33, y - 0.025, 0.54, 0.05}, value_reference, true);
+                        }
+                        stream.log("[Tutorial settings] " + std::string(settings[row].label) +
+                            " target match=" + std::to_string(score));
+                        // The reference recording uses inactive pale-red text;
+                        // the focused live row has a thicker dark-red glyph mask.
+                        // Verified Fast scores 0.734 while Slow/Normal score 0.
+                        if (score >= 0.65 && (row != 7 || autosave_off_highlight(frame, y))) {
+                            if (row == 7) {
+                                for (size_t confirmation = 0; confirmation < 3; confirmation++) {
+                                    pbf_wait(context, 200ms);
+                                    context.wait_for_all_requests();
+                                    auto check = stream.video().snapshot();
+                                    double check_y = check ? position.selected_row(check) : -1;
+                                    if (!check || !options_screen.detect(check) || check_y < 0 ||
+                                        option_image_score(check, {0.08, check_y - 0.025, 0.24, 0.05}, label_reference, false) < 0.80 ||
+                                        !autosave_off_highlight(check, check_y)) {
+                                        OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                                            "Autosave Off could not be confirmed. Stopping before movement.", stream);
+                                    }
+                                }
+                            }
+                            stream.log("[Tutorial settings] Verified " + std::string(settings[row].label) + "=" + settings[row].value);
+                            correct = true;
+                            break;
+                        }
+                        stream.log("[Tutorial settings] Correcting " + std::string(settings[row].label));
+                        if (row >= 9 && !slider_reset) {
+                            // Sliders clamp at zero. Establish a known endpoint,
+                            // then increment; verify the target image afterward.
+                            for (size_t step = 0; step < 12; step++)
+                                pbf_press_dpad(context, DPAD_LEFT, 80ms, 100ms);
+                            slider_reset = true;
+                        } else {
+                            pbf_press_dpad(context, DPAD_RIGHT, 80ms, 350ms);
+                        }
+                        context.wait_for_all_requests();
+                    }
+                    if (!correct) {
+                        OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                            "Settings checkpoint: Could not apply " + std::string(settings[row].label), stream);
+                    }
+                    if (row + 1 < sizeof(settings) / sizeof(settings[0]))
+                        pbf_press_dpad(context, DPAD_DOWN, 80ms, 350ms);
+                }
+                // Confirm settings before exiting: A A A A B B.
+                pbf_press_button(context, BUTTON_A, 80ms, 1000ms);
+                pbf_press_button(context, BUTTON_A, 80ms, 1000ms);
+                pbf_press_button(context, BUTTON_A, 80ms, 1000ms);
+                pbf_press_button(context, BUTTON_A, 80ms, 1200ms);
+                pbf_press_button(context, BUTTON_B, 80ms, 1000ms);
+                pbf_press_button(context, BUTTON_B, 80ms, 1000ms);
+                context.wait_for_all_requests();
+                OverworldWatcher overworld;
+                if (wait_until(stream, context, 10s, {{overworld}}) != 0) {
+                    OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                        "Settings checkpoint: Did not return to the overworld after saving options.", stream);
+                }
+                // Reopen the saved Options screen and independently verify Autosave.
+                // No route movement is permitted until this persisted-value check passes.
+                pbf_press_button(context, BUTTON_X, 80ms, 1000ms);
+                context.wait_for_all_requests();
+                MenuWatcher verify_menu;
+                if (wait_until(stream, context, 5s, {{verify_menu}}) != 0) {
+                    OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                        "Autosave verification: Main menu not detected.", stream);
+                }
+                bool reopened = false;
+                for (size_t attempt = 0; attempt < 2; attempt++) {
+                    pbf_press_button(context, BUTTON_A, 80ms, 0ms);
+                    if (wait_for_options_screen(stream, context, options_screen, 5s)) { reopened = true; break; }
+                    pbf_press_button(context, BUTTON_B, 80ms, 1000ms);
+                    context.wait_for_all_requests();
+                    MenuWatcher return_menu;
+                    if (wait_until(stream, context, 5s, {{return_menu}}) != 0) break;
+                    pbf_press_dpad(context, DPAD_RIGHT, 80ms, 350ms);
+                }
+                if (!reopened) {
+                    OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                        "Autosave verification: Could not reopen saved Options.", stream);
+                }
+                // Options starts on Text Speed; Autosave is seven rows below it.
+                for (size_t step = 0; step < 7; step++)
+                    pbf_press_dpad(context, DPAD_DOWN, 80ms, 350ms);
+                context.wait_for_all_requests();
+                const ImageRGB32 autosave_label(RESOURCE_PATH() + "PokemonBDSP/Autostory/Options/autosave_label.png");
+                for (size_t confirmation = 0; confirmation < 3; confirmation++) {
+                    auto check = stream.video().snapshot();
+                    double check_y = check ? position.selected_row(check) : -1;
+                    if (!check || !options_screen.detect(check) || check_y < 0 ||
+                        option_image_score(check, {0.08, check_y - 0.025, 0.24, 0.05}, autosave_label, false) < 0.80 ||
+                        !autosave_off_highlight(check, check_y)) {
+                        OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                            "Saved Autosave setting is not verified Off. Stopping before movement.", stream);
+                    }
+                    pbf_wait(context, 200ms);
+                    context.wait_for_all_requests();
+                }
+                stream.log("[Tutorial settings] Autosave = Off: confirmed after reopening saved Options (3 frames).");
+                // Confirm settings before exiting: A A A A B B.
+                pbf_press_button(context, BUTTON_A, 80ms, 1000ms);
+                pbf_press_button(context, BUTTON_A, 80ms, 1000ms);
+                pbf_press_button(context, BUTTON_A, 80ms, 1000ms);
+                pbf_press_button(context, BUTTON_A, 80ms, 1200ms);
+                pbf_press_button(context, BUTTON_B, 80ms, 1000ms);
+                pbf_press_button(context, BUTTON_B, 80ms, 1000ms);
+                context.wait_for_all_requests();
+                OverworldWatcher verified_exit;
+                if (wait_until(stream, context, 10s, {{verified_exit}}) != 0) {
+                    OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                        "Autosave verification: Could not return to the overworld.", stream);
+                }
+                // Report inferred values explicitly: these are visual matches,
+                // allowing the user to compare our conclusions with the screen.
+                stream.log("[Tutorial settings] Completed. Values believed applied (visual matches before saving):");
+                stream.log("[Tutorial settings] Text Speed = Fast; Change Window = Type 1; Battle Effects = Off; Battle Style = Set.");
+                stream.log("[Tutorial settings] Send to Boxes = Automatic; Give Nicknames = Don't give; Gyroscope = Use.");
+                stream.log("[Tutorial settings] Autosave = Off; Show Nicknames = Show; Background Music = 8; Sound Effects = 8.");
+            }
+
+
+            void verify_tutorial_settings(VideoStream& stream, ProControllerContext& context) {
+                // Settings-only recovery: initial attempt plus three retries.
+                // Never permit route movement unless the complete check succeeds.
+                constexpr size_t MAX_RETRIES = 3;
+                for (size_t attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+                    stream.log("[Tutorial settings] Attempt " + std::to_string(attempt + 1) + "/4.");
+                    try {
+                        verify_tutorial_settings_once(stream, context);
+                        return;
+                    } catch (OperationFailedException& error) {
+                        stream.log("[Tutorial settings] Attempt failed: " + error.message(), COLOR_ORANGE);
+                        if (attempt == MAX_RETRIES) {
+                            stream.log("[Tutorial settings] All three retries exhausted; stopping before movement.", COLOR_RED);
+                            throw;
+                        }
+                        // Back out of Options, save prompts, bag, or menu without
+                        // moving the player or resetting/loading the game.
+                        stream.log("[Tutorial settings] Returning to overworld before retry.");
+                        context.wait_for_all_requests();
+                        TutorialOptionsDetector options_screen;
+                        const auto failed_frame = stream.video().snapshot();
+                        if (failed_frame && options_screen.detect(failed_frame)) {
+                            // Finish the known Options save/exit sequence before
+                            // observing state; never cancel it on an Options frame
+                            // misclassified as overworld by the generic detector.
+                            for (size_t press = 0; press < 4; press++)
+                                pbf_press_button(context, BUTTON_A, 80ms, 1000ms);
+                        }
+                        pbf_mash_button(context, BUTTON_B, 3000ms);
+                        context.wait_for_all_requests();
+                        OverworldDetector overworld;
+                        MenuDetector menu;
+                        BlackScreenDetector black;
+                        bool recovered = false;
+                        size_t confirmations = 0;
+                        for (size_t check = 0; check < 15; check++) {
+                            const auto frame = stream.video().snapshot();
+                            const bool clear = frame && !options_screen.detect(frame) &&
+                                !menu.detect(frame) && !black.detect(frame) && bag_pocket_position(frame) == 0 && overworld.detect(frame);
+                            if (clear) {
+                                if (++confirmations >= 3) { recovered = true; break; }
+                                pbf_wait(context, 200ms);
+                            } else {
+                                confirmations = 0;
+                                pbf_mash_button(context, BUTTON_B, 500ms);
+                            }
+                            context.wait_for_all_requests();
+                        }
+                        stream.log(recovered ? "[Tutorial settings] Recovery confirmed outside Options/menu; retrying."
+                            : "[Tutorial settings] Recovery not confirmed; next attempt will recheck the screen.");
+                        pbf_wait(context, 500ms);
+                        context.wait_for_all_requests();
+                    }
+                }
+            }
+
+            void set_time_fast(
+                SingleSwitchProgramEnvironment& env,
+                ProControllerContext& context,
+                const DateTime& target,
+                bool preserve_date
+            ) {
+                env.log("[AutoStory] Fast date set starting...", COLOR_ORANGE);
+
+                // 1) Home
+                NintendoSwitch::go_home(env.console, context);
+
+                // 2) Navigate to Date/Time settings quickly.
+                NintendoSwitch::home_to_date_time(env.console, context, true);
+
+                // 3) Enter date editor.
+                pbf_press_button(context, BUTTON_A, 80ms, 240ms);
+
+                // 4) Wait for date screen and set exact time.
+                NintendoSwitch::DateChangeWatcher date_reader(env.console);
+                int ret = wait_until(
+                    env.console, context, 10s,
+                    { date_reader }
+                );
+                if (ret < 0) {
+                    OperationFailedExceptionWithScreenshot::fire(
+                        ErrorReportMode::SEND_ERROR_REPORT,
+                        "Failed to enter Date Change screen.",
+                        env.console
+                    );
+                }
+
+                {
+                    VideoOverlaySet overlays(env.console.overlay());
+                    date_reader.make_overlays(overlays);
+                    DateTime effective_target = target;
+                    if (preserve_date) {
+                        context.wait_for_all_requests();
+                        const auto snapshot = env.console.video().snapshot();
+                        if (!snapshot) OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                            "Clock-only setup: No date-editor frame.", env.console);
+                        const DateTime current = date_reader.read_date(env.console, snapshot.frame).second;
+                        if (current.year < 2000 || current.year > 2060 || current.month < 1 || current.month > 12 ||
+                            current.day < 1 || current.day > 31)
+                            OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                                "Clock-only setup: Could not reliably read the current console date.", env.console);
+                        effective_target.year = current.year;
+                        effective_target.month = current.month;
+                        effective_target.day = current.day;
+                        env.log("[AutoStory] Clock-only target=" + std::to_string((int)target.hour) + ":" +
+                            std::to_string((int)target.minute) + "; preserving date=" + std::to_string(current.year) + "-" +
+                            std::to_string((int)current.month) + "-" + std::to_string((int)current.day) + ".");
+                    }
+                    date_reader.set_date(env.program_info(), env.console, context, effective_target);
+                }
+
+                // 5) Commit date.
+                pbf_press_button(context, BUTTON_A, 160ms, 240ms);
+
+                // 6) Back to game.
+                pbf_press_button(
+                    context, BUTTON_HOME, 160ms,
+                    ConsoleSettings::instance().SETTINGS_TO_HOME_DELAY0
+                );
+                NintendoSwitch::resume_game_from_home(env.console, context, false);
+
+                context.wait_for_all_requests();
+                context.wait_for(500ms);
+            }
+
+         
+            // ---------------------------------------------------------------------------
+            // Natalie battle
+            // ---------------------------------------------------------------------------
+            // Early moves the starters and their foes have, as type, power and
+            // most PP. A status move has power 0.
+            struct KnownMove { const char* name; const char* type; int power; int pp; };
+            static const KnownMove KNOWN_MOVES[] = {
+                {"pound", "normal", 40, 35}, {"tackle", "normal", 40, 35}, {"scratch", "normal", 40, 35},
+                {"quickattack", "normal", 40, 30}, {"headbutt", "normal", 70, 15},
+                {"watergun", "water", 40, 25}, {"bubble", "water", 40, 30}, {"bubblebeam", "water", 65, 20},
+                {"ember", "fire", 40, 25}, {"flamewheel", "fire", 60, 25}, {"machpunch", "fighting", 40, 30},
+                {"absorb", "grass", 20, 25}, {"razorleaf", "grass", 55, 25}, {"bite", "dark", 60, 25},
+                {"peck", "flying", 35, 35}, {"wingattack", "flying", 60, 35}, {"metalclaw", "steel", 50, 35},
+                {"growl", "normal", 0, 40}, {"leer", "normal", 0, 30}, {"tailwhip", "normal", 0, 30},
+                {"withdraw", "water", 0, 40}, {"taunt", "dark", 0, 20},
+            };
+
+            // A move button's PP left, "8/25" at its right end; -1 if it cannot be
+            // read. The text is dark, or yellow to red as PP runs low, so text is
+            // whatever differs from the button's own color. `max_pp` helps when
+            // the OCR reads the slash as a digit.
+            static int read_move_pp(const ImageViewRGB32& screen, const ImageFloatBox& button, int max_pp) {
+                const ImageViewRGB32 box = extract_box_reference(screen, ImageFloatBox{
+                    button.x + button.width * 0.75, button.y + button.height * 0.10,
+                    button.width * 0.21, button.height * 0.80});
+                if (box.width() == 0 || box.height() == 0) return -1;
+                std::vector<uint32_t> pixels;
+                for (size_t y = 0; y < box.height(); y++) for (size_t x = 0; x < box.width(); x++) pixels.push_back(box.pixel(x, y));
+                auto brightness = [](uint32_t p) { return ((p >> 16) & 255) + ((p >> 8) & 255) + (p & 255); };
+                std::vector<uint32_t> sorted = pixels;
+                std::nth_element(sorted.begin(), sorted.begin() + sorted.size() / 2, sorted.end(),
+                    [&](uint32_t a, uint32_t b) { return brightness(a) < brightness(b); });
+                const uint32_t background = sorted[sorted.size() / 2];
+                const size_t pad = 8;
+                ImageRGB32 text(box.width() + 2 * pad, box.height() + 2 * pad);
+                text.fill(0xffffffff);
+                for (size_t y = 0; y < box.height(); y++) {
+                    for (size_t x = 0; x < box.width(); x++) {
+                        const uint32_t p = box.pixel(x, y);
+                        int distance = 0;
+                        for (int shift : {16, 8, 0}) distance += std::abs((int)((p >> shift) & 255) - (int)((background >> shift) & 255));
+                        if (distance > 120) text.pixel(x + pad, y + pad) = 0xff000000;
+                    }
+                }
+                const std::string read = OCR::tesseract_ocr_read(Language::English, text);
+                const size_t slash = read.find('/');
+                std::string digits;
+                for (size_t i = 0; i < read.size() && i < slash; i++) if (std::isdigit((unsigned char)read[i])) digits.push_back(read[i]);
+                if (slash == std::string::npos && max_pp > 0) {
+                    // "29135" for 29/35: drop the most PP and the misread slash.
+                    const std::string max = std::to_string(max_pp);
+                    if (digits.size() > max.size() + 1 && digits.compare(digits.size() - max.size(), max.size(), max) == 0) {
+                        digits.resize(digits.size() - max.size() - 1);
+                    } else {
+                        return -1;
+                    }
+                }
+                if (digits.empty() || digits.size() > 2) return -1;
+                return std::stoi(digits);
+            }
+
+            // The best move on the move menu: the most powerful one we know, and
+            // on a tie one that is not Normal (an early starter's own type).
+            // Reads the names with OCR; 1 if none is known.
+            static size_t pick_best_move(VideoStream& stream, const ImageViewRGB32& screen,
+                const BattleMoveMenuState& moves, const std::string& label) {
+                // Keep the menu as it looked, to check the reads against.
+                {
+                    const std::string folder = SCREENSHOTS_PATH() + "AutoStory/moves/";
+                    Filesystem::create_directories(Filesystem::Path(folder));
+                    screen.save(folder + now_to_filestring() + "-" + label + ".png");
+                }
+                size_t best = 1;
+                int best_score = -1;
+                bool any_attack = false;
+                size_t last_not_status = 1;
+                for (size_t i = 0; i < moves.move_count; i++) {
+                    // The name is dark text on a light button (grey, or light blue under the
+                    // cursor). Take the box right of the type icon and left of the PP, tall
+                    // enough for a status move's name, which sits lower: it has no "Effective"
+                    // line under it.
+                    const ImageFloatBox& button = moves.buttons[i];
+                    const ImageFloatBox name_box{button.x + button.width * 0.17, button.y + button.height * 0.08,
+                        button.width * 0.53, button.height * 0.80};
+                    const ImageViewRGB32 box = extract_box_reference(screen, name_box);
+                    // Text is darker than halfway between the background and the darkest pixel;
+                    // a fixed cut thins the strokes on the blue button.
+                    std::vector<int> gray(box.width() * box.height());
+                    for (size_t y = 0; y < box.height(); y++) {
+                        for (size_t x = 0; x < box.width(); x++) {
+                            const uint32_t pixel = box.pixel(x, y);
+                            gray[y * box.width() + x] = (int)(((pixel >> 16) & 0xff) + ((pixel >> 8) & 0xff) + (pixel & 0xff)) / 3;
+                        }
+                    }
+                    std::vector<int> sorted = gray;
+                    std::nth_element(sorted.begin(), sorted.begin() + sorted.size() / 2, sorted.end());
+                    const int background = sorted[sorted.size() / 2];
+                    const int darkest = *std::min_element(gray.begin(), gray.end());
+                    const int threshold = (background + darkest) / 2;
+                    // The name is the tallest band of text rows; "Effective" is smaller.
+                    size_t band_top = 0, band_bottom = 0;
+                    for (size_t y = 0; y < box.height();) {
+                        auto has_text = [&](size_t row) {
+                            for (size_t x = 0; x < box.width(); x++) if (gray[row * box.width() + x] < threshold) return true;
+                            return false;
+                        };
+                        if (!has_text(y)) { y++; continue; }
+                        size_t end = y;
+                        while (end < box.height() && has_text(end)) end++;
+                        if (end - y > band_bottom - band_top) { band_top = y; band_bottom = end; }
+                        y = end;
+                    }
+                    // Black text on white, with a margin, for the OCR.
+                    const size_t pad = 6;
+                    const size_t top = band_top >= 4 ? band_top - 4 : 0;
+                    const size_t bottom = std::min(box.height(), band_bottom + 4);
+                    ImageRGB32 text(box.width() + 2 * pad, bottom - top + 2 * pad);
+                    text.fill(0xffffffff);
+                    for (size_t y = top; y < bottom; y++) {
+                        for (size_t x = 0; x < box.width(); x++) {
+                            if (gray[y * box.width() + x] < threshold) text.pixel(x + pad, y - top + pad) = 0xff000000;
+                        }
+                    }
+                    std::string name;
+                    // Move names only where there is a reader for the game's
+                    // language; an unread move counts as a plain attack.
+                    for (unsigned char ch : story_reads_text() ? OCR::tesseract_ocr_read(g_story_language, text) : std::string()) {
+                        if (std::isalpha(ch)) name.push_back((char)std::tolower(ch));
+                    }
+                    // A slot read well once keeps its name when a later read fails.
+                    static std::array<std::string, 4> last_read;
+                    const KnownMove* known = nullptr;
+                    for (int pass = 0; pass < 2 && !known; pass++) {
+                    if (pass == 1) name = last_read[i];
+                    for (const KnownMove& move : KNOWN_MOVES) {
+                        //  The longest name that appears wins: "bubblebeam" over "bubble".
+                        if (name.find(move.name) != std::string::npos &&
+                            (!known || std::string(move.name).size() > std::string(known->name).size())) {
+                            known = &move;
+                        }
+                    }
+                    }
+                    if (known) last_read[i] = known->name;
+                    // A move with no PP left cannot be chosen; the game says so and
+                    // keeps the menu up.
+                    const int pp = read_move_pp(screen, button, known ? known->pp : 0);
+                    stream.log("[" + label + "] Move " + std::to_string(i + 1) + " PP left: " + (pp < 0 ? std::string("unread") : std::to_string(pp)) + ".");
+                    if (pp == 0) {
+                        continue;
+                    }
+                    // An unreadable move counts as a plain attack, ahead of known
+                    // status moves.
+                    const int score = known ? known->power * 2 + (std::string(known->type) != "normal" ? 1 : 0) : 40 * 2 - 1;
+                    stream.log("[" + label + "] Move " + std::to_string(i + 1) + " reads \"" + name + "\"" +
+                        (known ? std::string(" = ") + known->name + " (" + known->type + ", " + std::to_string(known->power) + ")" : " (unknown)") + ".");
+                    if (score > best_score) { best_score = score; best = i + 1; }
+                    if (known && known->power > 0) any_attack = true;
+                    if (!known || known->power > 0) last_not_status = i + 1;
+                }
+                // No attack read: the newest move is the starter's own-type attack
+                // (Water Gun, Ember, Absorb), unless it is a status move.
+                if (!any_attack) best = last_not_status;
+                stream.log("[" + label + "] Best move: " + std::to_string(best) + ".");
+                return best;
+            }
+
+            static void select_battle_move_slot(VideoStream& stream, ProControllerContext& context,
+                BattleType battle_type, size_t target, const std::string& label,
+                bool confirm_default_target = false, size_t current_move = 1) {
+                BattleMenuDetector commands(battle_type);
+                VideoOverlaySet overlays(stream.overlay());
+                commands.make_overlays(overlays);
+                overlays.add(COLOR_GREEN, {0.90, 0.48, 0.075, 0.505});
+                // Reenter Fight from an already-open list without assuming
+                // that this resets the remembered move cursor.
+                if (confirm_default_target) {
+                    context.wait_for_all_requests();
+                    const auto frame=stream.video().snapshot();
+                    if (frame && detect_battle_move_menu(frame).move_count) {
+                        pbf_press_button(context,BUTTON_B,80ms,500ms);
+                    }
+                }
+                bool fight = false;
+                size_t confirmed = 0;
+                for (size_t check = 0; check < 30; check++) {
+                    context.wait_for_all_requests();
+                    auto frame = stream.video().snapshot();
+                    BattleMenuOption selected = frame ? commands.selected_option(frame) : BattleMenuOption::UNKNOWN;
+                    stream.log("[" + label + "] Command cursor=" + std::to_string((int)selected + 1) + "; target Battle=1.");
+                    if (selected == BattleMenuOption::BATTLE) {
+                        if (++confirmed >= 3) { fight = true; break; }
+                        pbf_wait(context, 100ms);
+                    } else {
+                        confirmed = 0;
+                        if (selected == BattleMenuOption::UNKNOWN) pbf_wait(context, 150ms);
+                        else pbf_press_dpad(context, DPAD_UP, 80ms, 250ms);
+                    }
+                }
+                if (!fight) OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                    label + ": Could not confirm Battle command; A not pressed.", stream);
+                pbf_press_button(context,BUTTON_A,80ms,confirm_default_target ? 1000ms : 500ms);
+                if (confirm_default_target) {
+                    // Reuse the farming move/target confirmation sequence, but
+                    // navigate relative to this battle's retained move cursor.
+                    // Reopening Fight does not reset it to move 1.
+                    size_t available=0,stable=0;
+                    for (size_t check=0;check<20 && stable<3;check++) {
+                        context.wait_for_all_requests();
+                        const auto frame=stream.video().snapshot();
+                        const auto moves=frame ? detect_battle_move_menu(frame) : BattleMoveMenuState{};
+                        if (moves.move_count && moves.move_count==available) stable++;
+                        else {available=moves.move_count;stable=moves.move_count ? 1:0;}
+                        if (stable<3) pbf_wait(context,100ms);
+                    }
+                    if (stable<3 || available<target || available<current_move) OperationFailedExceptionWithScreenshot::fire(
+                        ErrorReportMode::SEND_ERROR_REPORT,label+": Requested move position is not available.",stream);
+                    stream.log("["+label+"] Retained move cursor "+std::to_string(current_move)+
+                        " -> "+std::to_string(target)+".");
+                    for (size_t slot=current_move;slot<target;slot++) pbf_press_dpad(context,DPAD_DOWN,80ms,400ms);
+                    for (size_t slot=current_move;slot>target;slot--) pbf_press_dpad(context,DPAD_UP,80ms,400ms);
+                    pbf_press_button(context,BUTTON_A,80ms,1000ms);
+                    pbf_press_button(context,BUTTON_A,80ms,3000ms);
+                    return;
+                }
+                confirmed = 0;
+                size_t previous_move_count = 0, stable_move_count = 0;
+                for (size_t check = 0; check < 30; check++) {
+                    context.wait_for_all_requests();
+                    auto frame = stream.video().snapshot();
+                    const BattleMoveMenuState moves = frame ? detect_battle_move_menu(frame) : BattleMoveMenuState{};
+                    const int slot = (int)moves.selected_slot;
+                    VideoOverlaySet move_overlays(stream.overlay());
+                    for (size_t i = 0; i < moves.move_count; i++)
+                        move_overlays.add(moves.selected_slot == i + 1 ? COLOR_GREEN : COLOR_YELLOW, moves.buttons[i]);
+                    stream.log("[" + label + "] Available moves=" + std::to_string(moves.move_count) +
+                        "; selected slot=" + std::to_string(slot) + "/4; target=" + std::to_string(target) + ".");
+                    if (moves.move_count == previous_move_count && moves.move_count > 0) stable_move_count++;
+                    else { previous_move_count = moves.move_count; stable_move_count = 1; confirmed = 0; }
+                    // Target 0: pick the best move once the menu has settled.
+                    if (target == 0 && stable_move_count >= 3 && frame) {
+                        target = pick_best_move(stream, *frame.frame, moves, label);
+                    }
+                    if (moves.move_count > 0 && moves.move_count < target && stable_move_count >= 3) {
+                        OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                            label + ": Move slot " + std::to_string(target) + " is absent; no move confirmed.", stream);
+                    }
+                    if (slot == (int)target && stable_move_count >= 3) {
+                        if (++confirmed >= 3) {
+                            stream.log("[" + label + "] Move " + std::to_string(target) + " confirmed; using it.");
+                            pbf_press_button(context, BUTTON_A, 80ms, 3000ms);
+                            return;
+                        }
+                        pbf_wait(context, 100ms);
+                    } else {
+                        confirmed = 0;
+                        if (slot == 0 || slot == (int)target) pbf_wait(context, 150ms);
+                        else pbf_press_dpad(context, slot < (int)target ? DPAD_DOWN : DPAD_UP, 80ms, 250ms);
+                    }
+                    context.wait_for_all_requests();
+                }
+                OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                    label + ": Could not confirm move " + std::to_string(target) + "; A not pressed.", stream);
+            }
+
+            // ---------------------------------------------------------------------------
+            // Starly battle
+            // ---------------------------------------------------------------------------
+
+            void fight_starly(VideoStream& stream, ProControllerContext& context) {
+                stream.log("[AutoStory] Starting Starly battle...", COLOR_BLUE);
+
+                // Declare OUTSIDE the loop so accumulated detector state
+                // (trigger counts, black-screen transitions) is preserved across frames.
+                // STARTER type: player has no Pokeballs, so ball-count areas won't
+                // be white. STARTER skips that check and only verifies status bars
+                // and the Fight button color.
+                BattleMenuWatcher battle_menu(BattleType::STARTER, COLOR_YELLOW);
+                EndBattleWatcher  end_battle;
+
+                while (true) {
+                    context.wait_for_all_requests();
+
+                    // Phase 1: wait for either battle menu or battle end.
+                    int ret = run_until<ProControllerContext>(
+                        stream, context,
+                        [](ProControllerContext& ctx) {
+                            pbf_mash_button(ctx, BUTTON_B, 120000ms);
+                        },
+            {
+                {battle_menu},
+                {end_battle},
+            }
+            );
+
+                    switch (ret) {
+                    case 0:
+                    {
+                        stream.log("[AutoStory] Battle menu detected. Selecting move...", COLOR_BLUE);
+
+                        // Select Fight, then move slot 1.
+                        pbf_press_button(context, BUTTON_A, 80ms, 500ms);
+                        pbf_press_button(context, BUTTON_A, 80ms, 3000ms);
+                        // Loop back - mash B through animations until next menu or end.
+                        break;
+                    }
+                    case 1:
+                    {
+                        stream.log("[AutoStory] Starly battle complete.", COLOR_GREEN);
+
+                        // Mash through XP / level-up / dialog screens back to overworld.
+                        OverworldWatcher overworld;
+                        int cleanup_ret = run_until<ProControllerContext>(
+                            stream, context,
+                            [](ProControllerContext& ctx) {
+                                pbf_mash_button(ctx, BUTTON_B, 120000ms);
+                            },
+                            { {overworld} }
+                        );
+                        if (cleanup_ret != 0) {
+                            OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                                "Starly battle: Overworld cleanup timed out.", stream);
+                        }
+                        return;
+                    }
+                    default:
+                        OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                            "Starly battle timed out.", stream);
+                    }
+                }
+            }
+
+            // ---------------------------------------------------------------------------
+            // Tristan battle
+            // ---------------------------------------------------------------------------
+            // Two grass rows at 240 ms each, with room to spare: the wall stops us.
+            static constexpr Milliseconds CATCH_GRASS_WALK = 900ms;
+
+            static void encounter_one_wild_pokemon(VideoStream& stream, ProControllerContext& context) {
+                context.wait_for_all_requests();
+                pbf_wait(context, 1000ms);
+
+                bool encounter_found = false;
+                const auto deadline = std::chrono::steady_clock::now() + 180s;
+
+                // Walk up and down the catch grass until a battle starts. Its three rows
+                // sit between tree walls, so each walk ends at a wall, on the same tile
+                // every time, after two new grass tiles. Short sideways steps drift and
+                // can rock across one tile edge without entering new grass.
+                while (!encounter_found && std::chrono::steady_clock::now() < deadline) {
+                    BlackScreenWatcher battle_start;
+                    BattleMenuWatcher battle_menu(BattleType::STANDARD, COLOR_YELLOW);
+                    BattleDialogWatcher battle_dialog(COLOR_YELLOW);
+
+                    route_turn(stream, context, Pokemon::Direction::NORTH);
+                    pbf_move_left_joystick(context, {0, 1}, CATCH_GRASS_WALK, 200ms);
+                    context.wait_for_all_requests();
+
+                    int ret = wait_until(
+                        stream,
+                        context,
+                        1500ms,
+                        {
+                            {battle_start},
+                            {battle_menu},
+                            {battle_dialog},
+                        }
+                    );
+
+                    if (ret >= 0) {
+                        encounter_found = true;
+                        break;
+                    }
+
+                    route_turn(stream, context, Pokemon::Direction::SOUTH);
+                    pbf_move_left_joystick(context, {0, -1}, CATCH_GRASS_WALK, 200ms);
+                    context.wait_for_all_requests();
+
+                    ret = wait_until(
+                        stream,
+                        context,
+                        1500ms,
+                        {
+                            {battle_start},
+                            {battle_menu},
+                            {battle_dialog},
+                        }
+                    );
+
+                    if (ret >= 0) {
+                        encounter_found = true;
+                        break;
+                    }
+                }
+
+                if (!encounter_found) OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                    "Wild encounter: walking up and down the grass found no battle within three minutes.", stream);
+                stream.log("[AutoStory] Wild battle detected!", COLOR_GREEN);
+
+                // Wait until the actual battle menu appears.
+                BattleMenuWatcher confirm_menu(BattleType::STANDARD);
+
+                int menu_ret = wait_until(
+                    stream,
+                    context,
+                    15s,
+                    {
+                        {confirm_menu},
+                    }
+                );
+
+                if (menu_ret < 0) {
+                    stream.log(
+                        "[AutoStory] Failed to detect battle menu.",
+                        COLOR_RED
+                    );
+                    OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                            "[AutoStory] Failed to detect battle menu.", stream);
+                }
+
+                stream.log("[AutoStory] Battle menu detected.", COLOR_GREEN);
+
+                context.wait_for_all_requests();
+                pbf_wait(context, 500ms);
+
+            }
+
+            static void confirm_battle_overworld(VideoStream& stream, ProControllerContext& context,
+                const std::string& label) {
+                OverworldDetector overworld;
+                ShortDialogDetector dialogue(COLOR_YELLOW);
+                BlackScreenDetector black;
+                VideoOverlaySet overlays(stream.overlay());
+                overworld.make_overlays(overlays);
+                dialogue.make_overlays(overlays);
+                black.make_overlays(overlays);
+                const auto deadline = std::chrono::steady_clock::now() + 180s;
+                auto quiet_since = std::chrono::steady_clock::now();
+                bool finished = false;
+                while (std::chrono::steady_clock::now() < deadline) {
+                    const auto frame = stream.video().snapshot();
+                    if (!frame) OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                        label + ": No video frame.", stream);
+                    const auto now = std::chrono::steady_clock::now();
+                    if (dialogue.detect(frame) || black.detect(frame) || !overworld.detect(frame)) {
+                        quiet_since = now;
+                    } else if (now - quiet_since >= 4s) {
+                        finished = true;
+                        break;
+                    }
+                    pbf_mash_button(context, BUTTON_B, 100ms);
+                    context.wait_for_all_requests();
+                }
+                if (!finished) OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                    label + ": Dialogue-free overworld not confirmed for four seconds.", stream);
+                context.wait_for_all_requests();
+            }
+
+            // Our HP bar in the battle's bottom-left panel, as a fraction; -1 if
+            // no bar is there. Measured on 1920x1080 frames: the bar runs from
+            // x 88 to 466 on rows 961 to 965.
+            static double battle_player_hp(const ImageViewRGB32& frame) {
+                const ImageViewRGB32 bar = extract_box_reference(frame, ImageFloatBox{0.046, 0.890, 0.197, 0.004});
+                size_t filled = 0;
+                for (size_t x = 0; x < bar.width(); x++) {
+                    size_t color = 0;
+                    for (size_t y = 0; y < bar.height(); y++) {
+                        const uint32_t p = bar.pixel(x, y);
+                        const int r = (p >> 16) & 255, g = (p >> 8) & 255, b = p & 255;
+                        const bool green = g > r + 30 && g > b + 20;
+                        const bool yellow = r > 150 && g > 120 && b < 100;
+                        const bool red = r > 150 && r > g + 50 && r > b + 50;
+                        color += green || yellow || red;
+                    }
+                    filled += color > bar.height() / 2;
+                }
+                return bar.width() && filled ? (double)filled / bar.width() : -1;
+            }
+
+            enum class BattleHeal { NOT_NEEDED, USED, NONE_LEFT };
+
+            // At the battle menu: if our HP is under `heal_below`, use a Potion
+            // from the Bag on the lead, which takes the turn. Otherwise the
+            // battle menu is left up.
+            static BattleHeal battle_heal_if_low(VideoStream& stream, ProControllerContext& context,
+                BattleType battle_type, double heal_below, const std::string& label) {
+                context.wait_for_all_requests();
+                double hp = -1;
+                for (size_t check = 0; check < 5 && hp < 0; check++) {
+                    const auto frame = stream.video().snapshot();
+                    if (frame) hp = battle_player_hp(*frame.frame);
+                    if (hp < 0) pbf_wait(context, 150ms);
+                    context.wait_for_all_requests();
+                }
+                stream.log("[" + label + "] Our HP bar reads " + std::to_string((int)(hp * 100)) + "%.");
+                if (hp < 0 || hp >= heal_below) return BattleHeal::NOT_NEEDED;
+                BattleMenuDetector commands(battle_type);
+                bool on_bag = false;
+                for (size_t check = 0; check < 30 && !on_bag; check++) {
+                    context.wait_for_all_requests();
+                    const auto frame = stream.video().snapshot();
+                    const BattleMenuOption selected = frame ? commands.selected_option(frame) : BattleMenuOption::UNKNOWN;
+                    if (selected == BattleMenuOption::BAG) on_bag = true;
+                    else if (selected == BattleMenuOption::UNKNOWN) pbf_wait(context, 150ms);
+                    else pbf_press_dpad(context, (int)selected < (int)BattleMenuOption::BAG ? DPAD_DOWN : DPAD_UP, 80ms, 300ms);
+                }
+                if (!on_bag) {
+                    stream.log("[" + label + "] Could not reach the Bag command; fighting on.", COLOR_ORANGE);
+                    return BattleHeal::NONE_LEFT;
+                }
+                pbf_press_button(context, BUTTON_A, 80ms, 2000ms);
+                if (!find_bag_item_in_open_bag(stream, context, "potion", 1)) {
+                    stream.log("[" + label + "] No Potion left; fighting on.", COLOR_ORANGE);
+                    pbf_press_button(context, BUTTON_B, 80ms, 1500ms);
+                    pbf_press_button(context, BUTTON_B, 80ms, 1500ms);
+                    context.wait_for_all_requests();
+                    return BattleHeal::NONE_LEFT;
+                }
+                // Potion, then the lead in the party list, then Use.
+                stream.log("[" + label + "] Using a Potion on the lead.", COLOR_BLUE);
+                pbf_press_button(context, BUTTON_A, 80ms, 1500ms);
+                pbf_press_button(context, BUTTON_A, 80ms, 1500ms);
+                pbf_press_button(context, BUTTON_A, 80ms, 2500ms);
+                context.wait_for_all_requests();
+                return BattleHeal::USED;
+            }
+
+            static void fight_using_move_list(
+                VideoStream& stream, ProControllerContext& context,
+                BattleType battle_type, const std::vector<size_t>& move_slots,
+                const std::string& label, bool confirm_default_target, bool post_battle_dialogue_cleanup,
+                bool doubles = false, bool switch_on_faint = false
+            ) {
+                if (move_slots.empty() || std::any_of(move_slots.begin(),move_slots.end(),
+                    [](size_t slot) { return slot>4; })) {
+                    OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                        label+": Supply a nonempty move list containing only positions 0 (best) through 4.",stream);
+                }
+                size_t move_index=0;
+                // The first Fight menu starts at move 1. Later turns retain
+                // this Pokemon's previous selection; a new battle resets it.
+                size_t current_move=1;
+                stream.log(
+                    "[AutoStory] Starting " + label + " battle...",
+                    COLOR_BLUE
+                );
+
+                // Scripted battles wait on the menu detector below, so no
+                // extra fixed delay is needed after a caller confirms it.
+                // Preserve the existing early-game transition delay.
+                if (!confirm_default_target) pbf_wait(context,5000ms);
+
+                bool battle_menu_seen = false;
+                bool out_of_potions = false;
+                size_t potions_used = 0;
+                size_t turns = 0;
+                size_t faint_switches = 0;
+                const bool watch_learn_move = confirm_default_target || doubles || switch_on_faint;
+                EndBattleWatcher end_battle;
+
+                while (true) {
+
+                    context.wait_for_all_requests();
+
+                    BattleMenuWatcher battle_menu(battle_type);
+                    // Reuse the farming handlers' move-learning prompt recovery.
+                    SelectionArrowFinder learn_move(stream.overlay(),{0.50,0.62,0.40,0.18},COLOR_YELLOW);
+
+                    int ret = run_until<ProControllerContext>(
+                        stream,
+                        context,
+                        [&](ProControllerContext& context) {
+                            // Clear narration with B while watching for commands.
+                            // A here can open Fight before selection begins.
+                            // With faint switching, a quiet 30 s means the party
+                            // screen after a faint, which B cannot leave.
+                            pbf_mash_button(context,BUTTON_B,switch_on_faint ? 30000ms : 120000ms);
+                        },
+                        {
+                            {battle_menu},
+                            battle_menu_seen
+                                ? PeriodicInferenceCallback{end_battle}
+                                : PeriodicInferenceCallback{},
+                            watch_learn_move ? PeriodicInferenceCallback{learn_move} : PeriodicInferenceCallback{},
+                        }
+                    );
+
+                    switch (ret) {
+
+                        // -------------------------------------------------
+                        // Battle menu detected.
+                        // -------------------------------------------------
+                    case 0:
+                        battle_menu_seen = true;
+                        // Early battles take a few turns; this many means the chosen
+                        // move is not being used (no PP, a misread menu).
+                        if (++turns > 25) {
+                            OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                                label + ": still at the battle menu after 25 turns.", stream);
+                        }
+
+                        stream.log(
+                            "[AutoStory] Battle menu detected.",
+                            COLOR_BLUE
+                        );
+
+                        // A trainer battle we may lose: a Potion when HP is low.
+                        if (battle_type == BattleType::TRAINER && !out_of_potions && potions_used < 4) {
+                            const BattleHeal heal = battle_heal_if_low(stream, context, battle_type, 0.35, label);
+                            if (heal == BattleHeal::USED) {
+                                potions_used++;
+                                break;
+                            }
+                            out_of_potions = heal == BattleHeal::NONE_LEFT;
+                        }
+                        stream.log("["+label+"] Move list position "+std::to_string(move_index+1)+
+                            ": use move "+std::to_string(move_slots[move_index])+".");
+                        select_battle_move_slot(stream, context, battle_type, move_slots[move_index], label,
+                            confirm_default_target,current_move);
+                        current_move=move_slots[move_index];
+                        // A double battle asks for the target next; B would
+                        // back out of it. The default target is an opponent.
+                        if (doubles) {
+                            pbf_wait(context,1200ms);
+                            pbf_press_button(context,BUTTON_A,80ms,1500ms);
+                        }
+                        // Advance once per move selection; retain the final entry.
+                        if (move_index+1<move_slots.size()) move_index++;
+
+                        break;
+
+                        // -------------------------------------------------
+                        // End battle detected.
+                        // -------------------------------------------------
+                    case 1: {
+                        stream.log(
+                            "[AutoStory] " + label + " battle complete.",
+                            COLOR_GREEN
+                        );
+
+                        // EndBattleWatcher has confirmed the completed exit transition.
+                        // Ordinary trainers need no scene-wide dialogue-free gate.
+                        if (!post_battle_dialogue_cleanup) {
+                            context.wait_for_all_requests();
+                            return;
+                        }
+                        // Story NPCs and gym leaders opt into the existing cleanup.
+                        OverworldWatcher overworld;
+                        int cleanup_ret = run_until<ProControllerContext>(stream, context,
+                            [](ProControllerContext& ctx) {
+                                pbf_mash_button(ctx, BUTTON_B, 120000ms);
+                            }, {{overworld}});
+                        if (cleanup_ret != 0) {
+                            OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                                label + ": Post-battle cleanup timed out.", stream);
+                        }
+                        context.wait_for_all_requests();
+                        confirm_battle_overworld(stream, context, label + " cleanup");
+                        return;
+                    }
+
+                    case 2:
+                        stream.log("["+label+"] Declining move learning; preserving scripted move positions.");
+                        pbf_move_right_joystick(context,{0,-1},160ms,840ms);
+                        pbf_press_button(context,BUTTON_ZL,160ms,840ms);
+                        break;
+
+                    default:
+                        // After a faint the game shows the party: Down to the
+                        // next Pokemon, A, then A on "Send out" (by hand,
+                        // 2026-10-29 against Roark).
+                        if (switch_on_faint && faint_switches < 5) {
+                            faint_switches++;
+                            stream.log("[" + label + "] No battle menu for 30 s: a faint; sending out the next Pokemon.", COLOR_ORANGE);
+                            pbf_press_dpad(context, DPAD_DOWN, 80ms, 500ms);
+                            pbf_press_button(context, BUTTON_A, 80ms, 1200ms);
+                            pbf_press_button(context, BUTTON_A, 80ms, 2000ms);
+                            break;
+                        }
+                        stream.log(
+                            "[AutoStory] " + label + " battle timeout.",
+                            COLOR_RED
+                        );
+
+                        OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                            "[AutoStory] " + label + " battle timeout.", stream);
+                    }
+                }
+            }
+
+            // Preserve the existing early-game callers and their B text cleanup.
+            static void fight_using_move_slot(VideoStream& stream, ProControllerContext& context,
+                BattleType battle_type, size_t move_slot, const std::string& label) {
+                fight_using_move_list(stream,context,battle_type,{move_slot},label,false,true);
+            }
+
+            void clear_post_battle_dialogue(VideoStream& stream, ProControllerContext& context,
+                Button button, Milliseconds quiet_period,
+                const char* instruction_card) {
+                context.wait_for_all_requests();
+                std::unique_ptr<ImageMatchDetector> card;
+                if (instruction_card) card = std::make_unique<ImageMatchDetector>(
+                    std::make_shared<ImageRGB32>(RESOURCE_PATH()+instruction_card),
+                    ImageFloatBox{.04,.32,.92,.34},30.0);
+                ShortDialogDetector dialogue(COLOR_YELLOW);
+                BlackScreenDetector black;
+                VideoOverlaySet overlays(stream.overlay());
+                dialogue.make_overlays(overlays);
+                black.make_overlays(overlays);
+                const auto deadline = std::chrono::steady_clock::now() + 120s;
+                auto absent_since = std::chrono::steady_clock::now();
+                while (std::chrono::steady_clock::now() < deadline) {
+                    const auto frame = stream.video().snapshot();
+                    if (!frame) OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                        "Post-battle dialogue: No video frame.", stream);
+                    const auto now = std::chrono::steady_clock::now();
+                    const bool dialogue_visible = dialogue.detect(*frame.frame);
+                    const bool card_visible = card && card->detect(*frame.frame);
+                    if (dialogue_visible || card_visible || black.detect(*frame.frame)) absent_since = now;
+                    else if (now - absent_since >= quiet_period) {
+                        stream.log("[Post-battle dialogue] " + std::to_string(quiet_period.count()) +
+                            "ms without dialogue confirmed.");
+                        return;
+                    }
+                    // A can interact again once dialogue disappears. Only confirm
+                    // visible prompts; B retains the existing post-battle behavior.
+                    if (card_visible) pbf_press_button(context, BUTTON_B, 80ms, 100ms);
+                    else if (button == BUTTON_A && !dialogue_visible) pbf_wait(context, 100ms);
+                    else pbf_mash_button(context, button, 100ms);
+                    context.wait_for_all_requests();
+                }
+                OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                    "Post-battle dialogue: Three clear seconds not confirmed.", stream);
+            }
+
+            void align_to_overworld_landmarks(VideoStream& stream, ProControllerContext& context,
+                OverworldMatchResult (*matcher)(const ImageRGB32&), const std::string& label, bool allow_story_start, bool horizontal_first,
+                bool search_down_first,
+                OverworldMatchResult (*entry_matcher)(const ImageRGB32&),
+                bool* entry_detected,
+                double arrival_tolerance_x, double arrival_tolerance_y,
+                double moderate_entry_confidence, bool* rock_acquisition_timed_out) {
+                if (rock_acquisition_timed_out) *rock_acquisition_timed_out=false;
+                auto missing_rocks_since=std::chrono::steady_clock::time_point::max();
+                if (entry_detected) *entry_detected=false;
+                context.wait_for_all_requests();
+                pbf_wait(context, 500ms);
+                context.wait_for_all_requests();
+                ShortDialogDetector dialogue(COLOR_YELLOW);
+                BattleMenuDetector battle(BattleType::TRAINER, COLOR_GREEN);
+                size_t confirmations = 0, missing = 0;
+                for (size_t attempt = 0; attempt < 80; attempt++) {
+                    const auto frame = stream.video().snapshot();
+                    if (!frame) OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                        label + ": No video frame.", stream);
+                    if (entry_matcher){
+                        BlackScreenDetector transition;
+                        if (entry_matcher(*frame.frame).located || transition.detect(*frame.frame)){
+                            BlackScreenWatcher visible(COLOR_RED,{0.1,0.1,0.8,0.8},
+                                100,10,BlackScreenWatcher::FinderType::GONE,500ms);
+                            if (wait_until(stream,context,30s,{{visible}})!=0)
+                                OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                                    label+": Building transition did not finish.",stream);
+                            const auto inside=stream.video().snapshot();
+                            if (!inside || !entry_matcher(*inside.frame).located)
+                                OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                                    label+": Expected interior not confirmed after transition.",stream);
+                            if(entry_detected)*entry_detected=true;
+                            stream.log("["+label+"] Expected interior confirmed; ending outdoor alignment.",COLOR_GREEN);
+                            return;
+                        }
+                    }
+                    // The story can start before the exact reference point. Hand off
+                    // to battle preparation instead of steering during dialogue.
+                    if (dialogue.detect(*frame.frame) || battle.detect(*frame.frame)) {
+                        if (allow_story_start) {
+                            stream.log("[" + label + "] Story dialogue/battle started; handing off without further movement.");
+                            return;
+                        }
+                        OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                            label + ": Unexpected dialogue/battle during alignment.", stream);
+                    }
+                    const auto result = matcher(*frame.frame);
+                    if (result.located)
+                        missing_rocks_since=std::chrono::steady_clock::time_point::max();
+                    VideoOverlaySet overlays(stream.overlay());
+                    for (const auto& landmark : result.landmarks) {
+                        overlays.add(COLOR_CYAN, landmark.search);
+                        if (landmark.accepted) overlays.add(COLOR_GREEN, landmark.found);
+                        stream.log("[" + label + "] " + landmark.name + " score=" +
+                            std::to_string(landmark.score) + ", margin=" + std::to_string(landmark.margin) +
+                            ", offset=(" + std::to_string(landmark.dx) + "," + std::to_string(landmark.dy) + ")");
+                    }
+                    stream.log("[" + label + "] located=" + std::to_string(result.located) +
+                        ", coarse=" + std::to_string(result.coarse) + ", at_target=" + std::to_string(result.at_target) +
+                        ", consensus offset=(" + std::to_string(result.dx) + "," + std::to_string(result.dy) + ")");
+                    const double entry_confidence=moderate_entry_confidence>0 ? overworld_entry_confidence(result) : 0;
+                    const bool moderate_arrival=moderate_entry_confidence>0 && entry_confidence>=moderate_entry_confidence;
+                    if(moderate_entry_confidence>0) stream.log("["+label+"] Exterior entry confidence="+
+                        std::to_string(entry_confidence)+", moderate threshold="+std::to_string(moderate_entry_confidence)+
+                        ", strict target="+std::to_string(result.at_target));
+                    // Explicit loose bounds are for non-interacting route handoffs.
+                    // Default callers still require the matcher's precise arrival.
+                    const bool rough_arrival=arrival_tolerance_x>0 && arrival_tolerance_y>0 &&
+                        result.located && std::abs(result.dx)<=arrival_tolerance_x &&
+                        std::abs(result.dy)<=arrival_tolerance_y;
+                    if (result.at_target || rough_arrival || moderate_arrival) {
+                        if (++confirmations >= 3) { stream.log("[" + label + "] Position confirmed."); return; }
+                        pbf_wait(context, 250ms);
+                    } else if (result.located) {
+                        confirmations = 0;
+                        missing = 0;
+                        // Wait at an aligned pose while strict visual support
+                        // recovers, rather than stepping away under a cloud.
+                        if ((matcher==match_galactic_hq_jupiter ||
+                            matcher==match_route208_hannah_departure || matcher==match_route208_stair_top) && result.coarse &&
+                            std::abs(result.dx)<=1.0/128 && std::abs(result.dy)<=1.0/54){
+                            pbf_wait(context,500ms);
+                            context.wait_for_all_requests();
+                            continue;
+                        }
+                        // A coarse match cannot confirm position, but two accepted
+                        // anchors can establish a safe horizontal direction when both
+                        // offsets are well outside the uncertainty in their spacing.
+                        bool coarse_horizontal = false;
+                        if (horizontal_first && result.coarse && result.landmarks.size() == 2) {
+                            const auto& a = result.landmarks[0];
+                            const auto& b = result.landmarks[1];
+                            const double nearest = std::min(std::abs(a.dx), std::abs(b.dx));
+                            coarse_horizontal = a.accepted && b.accepted && a.dx*b.dx > 0 &&
+                                nearest > 1.0/64 && nearest > 2*std::abs(a.dx-b.dx);
+                        }
+                        const bool plaza_anchor_horizontal = matcher == match_jubilife_plaza_approach &&
+                            result.coarse && std::abs(result.dx)>1.0/50 && std::abs(result.dy)<=1.0/54;
+                        // A uniquely matched Eterna ball may correct the door
+                        // column while the sign/bush enter the frame. Arrival
+                        // still requires the matcher's full three-anchor check.
+                        const bool eterna_anchor_horizontal = (matcher == match_eterna_center_entrance ||
+                            matcher == match_eterna_underground_house || matcher == match_eterna_underground_man) &&
+                            result.coarse && std::abs(result.dx)>1.0/128;
+                        // Recover the gym's doorway row before moving right if
+                        // the south approach overshot toward the fence/cliff.
+                        const bool gym_anchor_horizontal=matcher==match_eterna_gym_entrance &&
+                            result.coarse && std::abs(result.dx)>1.0/128 && std::abs(result.dy)<=.06;
+                        const bool gym_row_recovery=matcher==match_eterna_gym_entrance &&
+                            result.coarse && std::abs(result.dy)>.06;
+                        // Reach the row north of Jupiter before entering her
+                        // column. From above that row, align sideways before
+                        // moving south so the NPC cannot block the correction.
+                        const bool jupiter_row_recovery=matcher==match_galactic_hq_jupiter &&
+                            result.dy < -1.0/54;
+                        const bool jupiter_anchor_horizontal=matcher==match_galactic_hq_jupiter &&
+                            !jupiter_row_recovery && result.coarse && std::abs(result.dx)>1.0/128;
+                        // Stay south of the Contest Hall wall/sign before crossing to Fantina.
+                        const bool contest_row_recovery=matcher==match_hearthome_contest_fantina && result.dy>1.0/54;
+                        // Keep the stair approach horizontal-first until close to
+                        // its column. Recorded fine poses otherwise spent repeated
+                        // 16ms sideways turns while a larger vertical error waited.
+                        // Fine correction changes axis priority, never arrival gates.
+                        const bool stair_fine_correction=matcher==match_route208_stair_top &&
+                            !result.coarse && std::abs(result.dx)<=1.0/64;
+                        const bool horizontal = !contest_row_recovery && !gym_row_recovery && !jupiter_row_recovery && (jupiter_anchor_horizontal || coarse_horizontal || plaza_anchor_horizontal || eterna_anchor_horizontal || gym_anchor_horizontal || (!result.coarse &&
+                            ((horizontal_first && !stair_fine_correction && std::abs(result.dx)>1.0/128) ||
+                             std::abs(result.dx)>=std::abs(result.dy)*9.0/16)));
+                        if (stair_fine_correction && horizontal_first && !horizontal && std::abs(result.dx)>1.0/128)
+                            stream.log("["+label+"] Near stair column; correcting the larger vertical error first.");
+                        if (coarse_horizontal) stream.log("[" + label +
+                            "] Both landmarks agree on a large horizontal offset; correcting the street lane first.");
+                        const double error = horizontal ? result.dx : result.dy*9.0/16;
+                        auto duration = std::abs(error) > 1.0/24 ? 80ms : std::abs(error) > 1.0/64 ? 40ms : 16ms;
+                        // A 16ms turn may not complete a step. Use a bounded
+                        // full correction while reacquiring the second plaza anchor.
+                        if (matcher == match_jubilife_plaza_approach && result.coarse)
+                            duration = std::max(duration, 60ms);
+                        if (matcher==match_galactic_hq_jupiter){
+                            for (const auto& landmark:result.landmarks){
+                                // The player stands around y=.74. Do not steer
+                                // sideways/north when the stair opening is close
+                                // to that row; a southward correction moves away.
+                                if (landmark.name=="StairBoundary" && landmark.accepted &&
+                                    landmark.found.y+landmark.found.height>.60 &&
+                                    (horizontal || result.dy<0))
+                                    OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                                        label+": Correction would approach the stair boundary.",stream);
+                            }
+                        }
+                        pbf_move_left_joystick(context,
+                            {horizontal ? (result.dx > 0 ? 1.0 : -1.0) : 0.0,
+                             horizontal ? 0.0 : (result.dy < 0 ? 1.0 : -1.0)}, duration, 0ms);
+                        pbf_wait(context, 500ms);
+                    } else {
+                        confirmations = 0;
+                        if (matcher==match_hearthome_center_entrance || matcher==match_hearthome_contest_fantina){
+                            // Do not sweep into a different doorway or around the Hall's
+                            // side when a cloud, NPC or fade hides the required anchors.
+                            if (++missing>20) OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                                label+": Scene anchors missing; stationary reacquisition exhausted.",stream);
+                            pbf_wait(context,500ms);
+                            context.wait_for_all_requests();
+                            continue;
+                        }
+                        if (matcher==match_galactic_hq_jupiter || matcher==match_route208_stair_top){
+                            // Keep generic missing-anchor behavior unchanged. Route208's
+                            // explicit caller can instead request its recorded recovery.
+                            const bool stair_rocks=matcher==match_route208_stair_top;
+                            if (stair_rocks && rock_acquisition_timed_out) {
+                                const auto now=std::chrono::steady_clock::now();
+                                if (missing_rocks_since==std::chrono::steady_clock::time_point::max())
+                                    missing_rocks_since=now;
+                                // Matcher processing can take seconds per observation;
+                                // measure real elapsed time rather than counting waits.
+                                if (now-missing_rocks_since>=10s) {
+                                    context.wait_for_all_requests();
+                                    *rock_acquisition_timed_out=true;
+                                    stream.log("["+label+"] Rock acquisition timed out after 10s; handing off to the requested cliff recovery.");
+                                    return;
+                                }
+                            } else if (++missing>(stair_rocks ? 20 : 6)) {
+                                OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                                    label+(stair_rocks ? ": Rock anchors missing; no blind search near stairs." :
+                                        ": Chair/stair anchors missing; no blind search near stairs."),stream);
+                            }
+                            pbf_wait(context,500ms);
+                            context.wait_for_all_requests();
+                            continue;
+                        }
+                        // Search right first, then across the starting point to the
+                        // left and back. Each complete sweep returns to its origin.
+                        // Try that sweep at the initial height, above it, and below it;
+                        // no missing/weak landmark ever confirms the destination.
+                        if (++missing > (search_down_first ? 78 : 74)) OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                            label + ": Landmarks missing during bounded bidirectional search.", stream);
+                        if (search_down_first && missing <= 4) {
+                            stream.log("[" + label + "] Post-battle acquisition: moving down before lateral search.");
+                            pbf_move_left_joystick(context, {0.0, -1.0}, 100ms, 0ms);
+                        } else {
+                            const size_t search_step = missing - 1 - (search_down_first ? 4 : 0);
+                            const size_t level = search_step / 25;
+                            const size_t slot = search_step % 25;
+                            const bool lateral = slot < 24;
+                            const double direction = slot < 6 || slot >= 18 ? 1.0 : -1.0;
+                            const auto search_duration = lateral ? 100ms : level == 0 ? 600ms : 1200ms;
+                            stream.log("[" + label + "] Acquisition search step=" + std::to_string(missing) +
+                                ", direction=" + (lateral ? (direction>0 ? "right" : "left") : (level==0 ? "up" : "down")));
+                            // On the street, a northward search from the east
+                            // edge can stop at the building/NPC collision row.
+                            // Step west around it before changing height, then
+                            // return to the same lane for the next bounded sweep.
+                            const bool street_height_search=!lateral && matcher==match_jubilife_street_approach;
+                            if (street_height_search) pbf_move_left_joystick(context,{-1.0,0.0},150ms,0ms);
+                            pbf_move_left_joystick(context,
+                                {lateral ? direction : 0.0, lateral ? 0.0 : (level == 0 ? 1.0 : -1.0)}, search_duration, 0ms);
+                            if (street_height_search) pbf_move_left_joystick(context,{1.0,0.0},150ms,0ms);
+                        }
+                        pbf_wait(context, 500ms);
+                    }
+                    context.wait_for_all_requests();
+                }
+                OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                    label + ": Could not confirm the reference position.", stream);
+            }
+
+            void fight_trainer_using_moves(VideoStream& stream, ProControllerContext& context,
+                const std::vector<size_t>& moves, const std::string& label, bool post_battle_dialogue_cleanup) {
+                fight_using_move_list(stream,context,BattleType::TRAINER,moves,label,true,post_battle_dialogue_cleanup);
+            }
+
+            void fight_trainer_using_moves(VideoStream& stream, ProControllerContext& context,
+                size_t move, const std::string& label, bool post_battle_dialogue_cleanup) {
+                fight_trainer_using_moves(stream,context,std::vector<size_t>{move},label,post_battle_dialogue_cleanup);
+            }
+
+            void fight_trainer_using_move_slot(VideoStream& stream, ProControllerContext& context,
+                size_t move_slot, const std::string& label) {
+                fight_using_move_slot(stream,context,BattleType::TRAINER,move_slot,label);
+            }
+
+            void fight_story_battle(VideoStream& stream, ProControllerContext& context, const std::string& label, bool doubles) {
+                // The best move each turn; the next Pokemon after a faint; no new moves.
+                fight_using_move_list(stream, context, BattleType::TRAINER, {0}, label, false, true, doubles, true);
+            }
+
+            void fight_trainer(VideoStream& stream, ProControllerContext& context, const std::string& label) {
+                // Move 0: the best move on the menu each turn, whatever the starter.
+                fight_using_move_slot(stream, context, BattleType::TRAINER, 0, label);
+            }
+
+            void battle_1_pokemon(VideoStream& stream, ProControllerContext& context) {
+                stream.log("[Training] Finding one wild Pokemon using the catch encounter wiggle.", COLOR_BLUE);
+                encounter_one_wild_pokemon(stream, context);
+                // The best move on the menu, whatever the starter.
+                fight_using_move_slot(stream, context, BattleType::STANDARD, 0, "Training");
+                context.wait_for_all_requests();
+                stream.log("[Training] One wild battle completed.", COLOR_GREEN);
+            }
+
+            // ---------------------------------------------------------------------------
+            // Catch 1 Pokemon
+            // ---------------------------------------------------------------------------
+
+            void catch_1_pokemon(
+                VideoStream& stream,
+                ProControllerContext& context
+            ) {
+                stream.log("[AutoStory] Starting catch_1_pokemon helper...", COLOR_BLUE);
+
+                encounter_one_wild_pokemon(stream, context);
+
+                // Catch the pokemon.
+                stream.log("[AutoStory] Throwing Poke Ball (manual bag open)...", COLOR_BLUE);
+                ReceivePokemonDetector received_pokemon;
+                // Preserve exit-transition state from the ball outcome through
+                // receipt/experience cleanup; do not recreate it between phases.
+                EndBattleWatcher battle_ended;
+                bool caught = false;
+                bool exit_seen = false;
+                for (int throw_attempt = 0; throw_attempt < 10; throw_attempt++) {
+                    // Open bag from battle menu (X), confirm first slot (ZL).
+                    pbf_press_button(context, BUTTON_X, 160ms, 840ms);
+                    context.wait_for_all_requests();
+                    pbf_press_button(context, BUTTON_ZL, 160ms, 1000ms);
+                    context.wait_for_all_requests();
+
+                    // Wait to see if the battle menu comes back (ball failed)
+                    // or if the battle ends (caught or fainted).
+                    BattleMenuWatcher menu_back(BattleType::STANDARD, COLOR_YELLOW);
+                    int throw_ret = run_until<ProControllerContext>(
+                        stream, context,
+                        [](ProControllerContext& ctx) {
+                            pbf_mash_button(ctx, BUTTON_B, 120000ms);
+                        },
+                        {{menu_back}, {received_pokemon}, {battle_ended}}
+                    );
+
+                    if (throw_ret == 1 || (throw_ret == 2 && received_pokemon.received())) {
+                        caught = true;
+                        exit_seen = throw_ret == 2;
+                        stream.log("[AutoStory] Pokemon receipt verified.", COLOR_GREEN);
+                        break;
+                    }
+                    if (throw_ret < 0 || throw_ret == 2) {
+                        OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                            "Catch failed: No verified Pokemon receipt before battle ended or timed out.", stream);
+                    }
+                    stream.log(
+                        "[AutoStory] Ball failed, retrying (attempt " + std::to_string(throw_attempt + 2) + ")...",
+                        COLOR_ORANGE
+                    );
+                }
+
+                context.wait_for_all_requests();
+
+                if (!caught) {
+                    OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                        "Catch failed: Exhausted ten ball attempts.", stream);
+                }
+                // Receipt alone is not an overworld return: clear experience,
+                // automatic move learning, dex registration and nickname screens
+                // until the same completed-black-transition watcher used in battles fires.
+                if (!exit_seen) {
+                    stream.log("[Catch cleanup] Receipt confirmed; waiting for battle exit transition.");
+                    const int cleanup_ret = run_until<ProControllerContext>(stream, context,
+                        [](ProControllerContext& ctx) { pbf_mash_button(ctx, BUTTON_B, 120000ms); },
+                        {{battle_ended}});
+                    if (cleanup_ret != 0) {
+                        OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                            "Catch cleanup: Battle exit transition did not finish.", stream);
+                    }
+                }
+                context.wait_for_all_requests();
+                stream.log("[Catch cleanup] Battle exit transition confirmed; checking stable overworld.");
+                confirm_battle_overworld(stream, context, "Catch cleanup");
+                stream.log("[Catch cleanup] Verified receipt, completed battle exit, and four seconds of clear overworld.", COLOR_GREEN);
+            }
+
+            // ---------------------------------------------------------------------------
+            // catch_1_pokemon_v2 - burst wiggle variant for testing.
+            // Uses WIGGLES_PER_BURST consecutive left/right moves before checking for a
+            // battle, reducing total wait time compared to checking after every move.
+            // Commented out - enable for testing when ready.
+            // ---------------------------------------------------------------------------
+            // void catch_1_pokemon_v2(
+            //     SingleSwitchProgramEnvironment& env,
+            //     VideoStream& stream,
+            //     ProControllerContext& context
+            // ) {
+            //     stream.log("[AutoStory] Starting catch_1_pokemon_v2 helper...", COLOR_BLUE);
+            //
+            //     // Save once before attempting to catch. On failure the game
+            //     // resets back to this save, so the save lives outside the loop.
+            //     stream.log("[AutoStory] Saving game before catch attempt...", COLOR_BLUE);
+            //     {
+            //         static constexpr int SAVE_MAX_RETRIES = 3;
+            //         bool save_succeeded = false;
+            //         for (int save_attempt = 0; save_attempt < SAVE_MAX_RETRIES; save_attempt++) {
+            //             try {
+            //                 if (save_attempt > 0) {
+            //                     stream.log(
+            //                         "[AutoStory] Retrying save (attempt " + std::to_string(save_attempt + 1) + ")...",
+            //                         COLOR_ORANGE
+            //                     );
+            //                     pbf_mash_button(context, BUTTON_B, 1000ms);
+            //                     context.wait_for_all_requests();
+            //                 }
+            //                 save_game(stream, context);
+            //                 save_succeeded = true;
+            //                 break;
+            //             }
+            //             catch (OperationFailedException& e) {
+            //                 stream.log(
+            //                     "[AutoStory] Save attempt " + std::to_string(save_attempt + 1) + " failed: " + e.message(),
+            //                     COLOR_RED
+            //                 );
+            //                 context.wait_for(1000ms);
+            //             }
+            //         }
+            //         if (!save_succeeded) {
+            //             stream.log("[AutoStory] All save attempts failed. Using blind fallback save.", COLOR_ORANGE);
+            //             pbf_mash_button(context, BUTTON_B, 1000ms);
+            //             save_game(context);
+            //             pbf_mash_button(context, BUTTON_B, 2000ms);
+            //         }
+            //     }
+            //     context.wait_for_all_requests();
+            //     pbf_wait(context, 1000ms);
+            //
+            //     // -------------------------------------------------------
+            //     // Mini-checkpoint loop: retry from the save above if we
+            //     // run out of balls or our Pokemon faints.
+            //     // -------------------------------------------------------
+            //     while (true) {
+            //
+            //     BlackScreenWatcher battle_start;
+            //     BattleMenuWatcher battle_menu(BattleType::STANDARD, COLOR_YELLOW);
+            //     BattleDialogWatcher battle_dialog(COLOR_YELLOW);
+            //
+            //     bool encounter_found = false;
+            //
+            //     // Wiggle left/right in bursts, checking for a battle after each burst.
+            //     // Doing multiple moves before checking avoids waiting after every step.
+            //     static constexpr int WIGGLES_PER_BURST = 3;
+            //     while (!encounter_found) {
+            //         for (int i = 0; i < WIGGLES_PER_BURST; i++) {
+            //             pbf_move_left_joystick(context, {-1, 0}, 120ms, 80ms);
+            //             pbf_move_left_joystick(context, { 1, 0}, 120ms, 80ms);
+            //         }
+            //         context.wait_for_all_requests();
+            //
+            //         int ret = wait_until(
+            //             stream,
+            //             context,
+            //             1500ms,
+            //             {
+            //                 {battle_start},
+            //                 {battle_menu},
+            //                 {battle_dialog},
+            //             }
+            //         );
+            //
+            //         if (ret >= 0) {
+            //             encounter_found = true;
+            //         }
+            //     }
+            //
+            //     stream.log("[AutoStory] Wild battle detected!", COLOR_GREEN);
+            //
+            //     // Wait until the actual battle menu appears.
+            //     BattleMenuWatcher confirm_menu(BattleType::STANDARD);
+            //
+            //     int menu_ret = wait_until(
+            //         stream,
+            //         context,
+            //         15s,
+            //         {
+            //             {confirm_menu},
+            //         }
+            //     );
+            //
+            //     if (menu_ret < 0) {
+            //         stream.log(
+            //             "[AutoStory] Failed to detect battle menu. Resetting to checkpoint...",
+            //             COLOR_RED
+            //         );
+            //         reset_game_from_home(env, env.console, context, true);
+            //         continue;
+            //     }
+            //
+            //     stream.log("[AutoStory] Battle menu detected.", COLOR_GREEN);
+            //
+            //     context.wait_for_all_requests();
+            //     pbf_wait(context, 500ms);
+            //
+            //     // --- Throw balls ---
+            //     CatchResults result = basic_catcher(
+            //         stream,
+            //         context,
+            //         Language::English,
+            //         "poke-ball",
+            //         10
+            //     );
+            //
+            //     switch (result.result) {
+            //     case CatchResult::POKEMON_CAUGHT:
+            //         stream.log(
+            //             "[AutoStory] Pokemon successfully caught after " +
+            //             std::to_string(result.balls_used) + " ball(s).",
+            //             COLOR_GREEN
+            //         );
+            //         {
+            //             OverworldWatcher overworld;
+            //             run_until<ProControllerContext>(
+            //                 stream, context,
+            //                 [](ProControllerContext& ctx) {
+            //                     pbf_mash_button(ctx, BUTTON_B, 120000ms);
+            //                 },
+            //                 {{overworld}}
+            //             );
+            //         }
+            //         return;
+            //
+            //     case CatchResult::POKEMON_FAINTED:
+            //         stream.log("[AutoStory] Wild Pokemon fainted. Exiting battle.", COLOR_ORANGE);
+            //         {
+            //             OverworldWatcher overworld;
+            //             run_until<ProControllerContext>(
+            //                 stream, context,
+            //                 [](ProControllerContext& ctx) {
+            //                     pbf_mash_button(ctx, BUTTON_B, 120000ms);
+            //                 },
+            //                 {{overworld}}
+            //             );
+            //         }
+            //         return;
+            //
+            //     case CatchResult::OUT_OF_BALLS:
+            //         stream.log(
+            //             "[AutoStory] Ran out of Poke Balls after " +
+            //             std::to_string(result.balls_used) + " throw(s). Resetting to checkpoint...",
+            //             COLOR_RED
+            //         );
+            //         reset_game_from_home(env, env.console, context, true);
+            //         continue;
+            //
+            //     case CatchResult::OWN_FAINTED:
+            //         stream.log(
+            //             "[AutoStory] Own Pokemon fainted. Resetting to checkpoint...",
+            //             COLOR_RED
+            //         );
+            //         reset_game_from_home(env, env.console, context, true);
+            //         continue;
+            //
+            //     case CatchResult::BALL_LIMIT_REACHED:
+            //         stream.log(
+            //             "[AutoStory] Ball limit reached (" +
+            //             std::to_string(result.balls_used) + " throw(s)). Resetting to checkpoint...",
+            //             COLOR_RED
+            //         );
+            //         reset_game_from_home(env, env.console, context, true);
+            //         continue;
+            //
+            //     case CatchResult::CANNOT_THROW_BALL:
+            //         stream.log(
+            //             "[AutoStory] Cannot throw ball (menu timing issue). Resetting to checkpoint...",
+            //             COLOR_RED
+            //         );
+            //         reset_game_from_home(env, env.console, context, true);
+            //         continue;
+            //
+            //     default:
+            //         stream.log(
+            //             "[AutoStory] Catch timed out after " +
+            //             std::to_string(result.balls_used) + " ball(s). Resetting to checkpoint...",
+            //             COLOR_RED
+            //         );
+            //         reset_game_from_home(env, env.console, context, true);
+            //         continue;
+            //     }
+            //
+            //     } // end while(true)
+            // }
+
+            // ---------------------------------------------------------------------------
+            // Movement Helpers
+            // ---------------------------------------------------------------------------
+
+            bool detect_black_screen_after_movement(
+                VideoStream& stream,
+                ProControllerContext& context,
+                Milliseconds timeout
+            ) {
+                BlackScreenWatcher black_screen;
+                return wait_until(stream, context, timeout, {{black_screen}}) == 0;
+            }
+
+            bool try_right_down_exit_search(
+                VideoStream& stream,
+                ProControllerContext& context,
+                size_t iterations
+            ) {
+                for (size_t i = 0; i < iterations; i++) {
+                    pbf_move_left_joystick(context, { 1.0, 0.0 }, 80ms, 0ms);
+                    pbf_move_left_joystick(context, { 0.0, -1.0 }, 220ms, 0ms);
+
+                    if (detect_black_screen_after_movement(stream, context, 1000ms)) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+            void leave_pokemon_center_before_barry_1(
+                VideoStream& stream,
+                ProControllerContext& context
+            ) {
+                // Original down movement to leave Pokemon Center.
+                pbf_move_left_joystick(context, { 0.0, -1.0 }, 814ms, 0ms);
+
+                if (detect_black_screen_after_movement(stream, context, 1200ms)) {
+                    pbf_wait(context, 2340ms);
+                    return;
+                }
+
+                stream.log("[AutoStory] Pokemon Center exit black screen not detected. Searching with right/down movement.", COLOR_ORANGE);
+
+                if (try_right_down_exit_search(stream, context, 20)) {
+                    pbf_wait(context, 2340ms);
+                    return;
+                }
+
+                stream.log("[AutoStory] First exit search failed. Repositioning left and retrying.", COLOR_ORANGE);
+                pbf_move_left_joystick(context, { -1.0, 0.0 }, 5000ms, 0ms);
+
+                if (try_right_down_exit_search(stream, context, 30)) {
+                    pbf_wait(context, 2340ms);
+                    return;
+                }
+
+                OperationFailedExceptionWithScreenshot::fire(
+                    ErrorReportMode::SEND_ERROR_REPORT,
+                    "Failed to find Pokemon Center exit black screen before Barry 1. Triggering checkpoint retry.",
+                    stream
+                );
+            }
+
+            // ---------------------------------------------------------------------------
+            // Generic Movement Helper - Walk through grass in specified direction for
+            // specified steps, attempting to run from any battles that are encountered.
+            // ---------------------------------------------------------------------------
+            void walk_through_grass(
+                VideoStream& stream, ProControllerContext& context,
+                int8_t x, int8_t y, size_t steps, const std::string& direction_name,
+                BattleType battle_type, Milliseconds movement_duration,
+                OverworldMatchResult (*destination)(const ImageRGB32&)
+            ) {
+                size_t movements = 0, confirmations = 0;
+                while (true) {
+                    context.wait_for_all_requests();
+                    // Destination checks happen before input and after each step/escape.
+                    // With no matcher, retain the original fixed-step behavior.
+                    VideoOverlaySet overlays(stream.overlay());
+                    OverworldMatchResult location;
+                    if (destination) {
+                        const auto frame = stream.video().snapshot();
+                        if (!frame) OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                            "Grass destination: No video frame.", stream);
+                        location = destination(*frame.frame);
+                        for (const auto& landmark : location.landmarks) {
+                            overlays.add(COLOR_CYAN, landmark.search);
+                            if (landmark.accepted) overlays.add(COLOR_GREEN, landmark.found);
+                            stream.log("[Grass destination] " + direction_name + " " + landmark.name +
+                                " score=" + std::to_string(landmark.score) +
+                                " margin=" + std::to_string(landmark.margin) +
+                                " accepted=" + std::to_string(landmark.accepted));
+                        }
+                        stream.log("[Grass destination] located=" + std::to_string(location.located) +
+                            " at_target=" + std::to_string(location.at_target) +
+                            " screen-relative offset=(" + std::to_string(location.dx) +
+                            "," + std::to_string(location.dy) + ")");
+                        if (location.at_target) {
+                            if (++confirmations >= 3) {
+                                stream.log("[Grass] Destination confirmed; stopped " + direction_name +
+                                    " after " + std::to_string(movements) + "/" + std::to_string(steps) + " movements.", COLOR_GREEN);
+                                return;
+                            }
+                            pbf_wait(context, 250ms);
+                            continue;
+                        }
+                        confirmations = 0;
+                    }
+                    if (movements >= steps) {
+                        if (destination) OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT,
+                            "Grass destination not confirmed within movement limit: " + direction_name, stream);
+                        stream.log("[Grass] Completed " + direction_name + " (" + std::to_string(steps) + " steps).", COLOR_GREEN);
+                        return;
+                    }
+                    int8_t move_x=x, move_y=y;
+                    Milliseconds duration=movement_duration;
+                    if (destination && location.located && !location.coarse &&
+                        std::abs(location.dx)<=0.10 && std::abs(location.dy)<=0.12) {
+                        // Small corrections prevent stepping past a narrow stop target.
+                        const bool horizontal=std::abs(location.dx)>=std::abs(location.dy)*9.0/16;
+                        const double error=horizontal ? location.dx : location.dy*9.0/16;
+                        duration=std::min(duration, std::abs(error)>0.03125 ? 80ms :
+                            std::abs(error)>0.015625 ? 40ms : 16ms);
+                        move_x=horizontal ? (location.dx>0 ? 1 : -1) : 0;
+                        move_y=horizontal ? 0 : (location.dy<0 ? 1 : -1);
+                        stream.log("[Grass destination] Correcting " + std::string(horizontal ? "horizontal" : "vertical") +
+                            " axis for " + std::to_string(duration.count()) + "ms.");
+                    }
+                    // Each movement gets fresh watcher state. A completed white
+                    // transition from a prior encounter must not trigger again.
+                    BlackScreenWatcher battle_start;
+                    WhiteScreenOverWatcher white_screen(COLOR_YELLOW, {0.1, 0.1, 0.8, 0.8});
+                    BattleMenuWatcher battle_menu(battle_type, COLOR_YELLOW);
+                    BattleDialogWatcher battle_dialog(COLOR_YELLOW);
+                    pbf_move_left_joystick(context, {(double)move_x, (double)move_y}, duration, 0ms);
+                    movements++;
+                    context.wait_for_all_requests();
+                    int ret = wait_until(stream, context, 2500ms,
+                        {{white_screen}, {battle_start}, {battle_dialog}, {battle_menu}});
+                    if (ret >= 0) {
+                        confirmations = 0;
+                        stream.log("[Grass] " + direction_name + " step " + std::to_string(movements) +
+                            "/" + std::to_string(steps) + ": encounter trigger=" + std::to_string(ret) +
+                            "; using shared confirmed-Run escape.");
+                        escape_wild_battle(stream, context, battle_type);
+                        context.wait_for_all_requests();
+                        stream.log("[Grass] Escape confirmed; resuming " + direction_name + ".");
+                    }
+                }
+            }
+
+        }
+    }
+}
diff --git a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_StoryExecutor.cpp b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_StoryExecutor.cpp
new file mode 100644
index 0000000000..efd43585ea
--- /dev/null
+++ b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_StoryExecutor.cpp
@@ -0,0 +1,202 @@
+/*  BDSP AutoStory - Story step executor
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ */
+
+#include <algorithm>
+#include <format>
+#include <utility>
+#include "Common/Cpp/Exceptions.h"
+#include "NintendoSwitch/Commands/NintendoSwitch_Commands_PushButtons.h"
+#include "PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStoryTools.h"
+#include "PokemonBDSP_AutoStory_PokemonCenter.h"
+#include "PokemonBDSP_AutoStory_Segment_00_tools.h"
+#include "PokemonBDSP_AutoStory_Walk.h"
+#include "PokemonBDSP_AutoStory_StoryExecutor.h"
+
+namespace PokemonAutomation{
+namespace NintendoSwitch{
+namespace PokemonBDSP{
+
+using namespace std::chrono_literals;
+using Pokemon::Direction;
+using Pokemon::Outcome;
+using Pokemon::RunState;
+using Pokemon::TilePos;
+
+
+std::optional<Pokemon::RobustPlanCosts> story_route_costs(const std::string& variant){
+    if (variant.empty()){
+        return route_plan_costs();
+    }
+    if (variant == "town"){
+        return town_plan_costs();
+    }
+    if (variant == "robust"){
+        return Pokemon::RobustPlanCosts();
+    }
+    return std::nullopt;
+}
+
+std::pair<double, double> dpad_of(Direction direction){
+    switch (direction){
+    case Direction::NORTH:
+        return {0, 1};
+    case Direction::EAST:
+        return {1, 0};
+    case Direction::SOUTH:
+        return {0, -1};
+    case Direction::WEST:
+        return {-1, 0};
+    }
+    return {0, 0};
+}
+
+
+ConsoleStoryExecutor::ConsoleStoryExecutor(
+    StoryStepRunner& runner, std::set<std::string> stop_rows,
+    const Pokemon::MapSet& maps, std::vector<Pokemon::TrainerSight> trainers,
+    TrainerFight fight, std::map<std::string, Variant> variants
+)
+    : m_runner(runner)
+    , m_stop_rows(std::move(stop_rows))
+    , m_maps(maps)
+    , m_all_trainers(std::move(trainers))
+    , m_trainers(m_all_trainers)
+    , m_fight(std::move(fight))
+    , m_variants(std::move(variants))
+{}
+
+void ConsoleStoryExecutor::begin_attempt(const Pokemon::StoryCheckpoint& data){
+    m_checkpoint = data.id;
+    m_trainers = m_all_trainers;
+}
+
+RouteTrainerFight ConsoleStoryExecutor::fight(StoryConsole& console){
+    return [this, &console](const std::string& trainer){
+        m_fight(console, trainer);
+    };
+}
+
+StoryConsole& ConsoleStoryExecutor::console(){
+    if (m_console == nullptr){
+        throw InternalProgramError(nullptr, PA_CURRENT_FUNCTION, "A story step ran outside ConsoleStoryExecutor::run().");
+    }
+    return *m_console;
+}
+
+Outcome ConsoleStoryExecutor::run(RunState& state, const Pokemon::StoryStep& step){
+    Outcome result = Pokemon::outcome_ok();
+    const StoryFailure on_failure = m_stop_rows.contains(m_checkpoint) ? StoryFailure::STOP : StoryFailure::RELOAD_AND_RETRY;
+    const Outcome ran = m_runner.run_step(m_checkpoint, on_failure, [&](StoryConsole& console){
+        m_console = &console;
+        set_checks(console.options.checks);
+        set_language(console.options.language);
+        const auto variant = m_variants.find(step.variant);
+        result = variant == m_variants.end()
+            ? Pokemon::StoryStepExecutor::run(state, step)
+            : variant->second(*this, console, state, step);
+        m_console = nullptr;
+    });
+    m_console = nullptr;
+    return ran.succeeded() ? result : ran;
+}
+
+Outcome ConsoleStoryExecutor::route(RunState& state, const Pokemon::StoryStep& step){
+    const std::vector<TilePos> from = Pokemon::tiles_of(state.pose);
+    if (from.empty()){
+        return Pokemon::outcome_failed("no_pose", Pokemon::to_string(state.pose));
+    }
+    const std::optional<Pokemon::RobustPlanCosts> costs = story_route_costs(step.variant);
+    if (!costs){
+        return Pokemon::outcome_failed("unknown_variant", step.variant);
+    }
+    const std::vector<TilePos> goal = Pokemon::tiles_of(*step.target);
+    StoryConsole& c = console();
+    const std::vector<TilePos> at = walk_route(
+        c.env.console, c.context, m_maps, from,
+        [&](const TilePos& pos){ return std::find(goal.begin(), goal.end(), pos) != goal.end(); },
+        m_trainers, fight(c), step.name, {}, *costs
+    );
+    return Pokemon::outcome_ok(Pokemon::tile_pose(step.target->map, at));
+}
+
+Outcome ConsoleStoryExecutor::legs(RunState& state, const Pokemon::StoryStep& step){
+    const bool one_short_ok = step.variant == "one_short_ok";
+    if (!one_short_ok && !step.variant.empty()){
+        return Pokemon::outcome_failed("unknown_variant", step.variant);
+    }
+    StoryConsole& c = console();
+    std::vector<TilePos> at = Pokemon::tiles_of(state.pose);
+    for (const Pokemon::StoryLeg& leg : step.legs){
+        //  Facing another way, a tap only turns (r256): turn first.
+        route_turn(c.env.console, c.context, leg.direction);
+        const auto [x, y] = dpad_of(leg.direction);
+        const size_t tiles = (size_t)leg.tiles;
+        const WalkResult walk = walk_tiles_dpad(c.env.console, c.context, x, y, tiles, step.name);
+        c.env.console.log(std::format("[{}] {}: taps {} moved {} of {} tiles.", m_checkpoint, step.name, direction_name(leg.direction), walk.moved_chunks, tiles));
+        if (walk.moved_chunks + (one_short_ok ? 1 : 0) < tiles){
+            return Pokemon::outcome_failed("short_leg", std::format("{} {} moved {}", direction_name(leg.direction), tiles, walk.moved_chunks));
+        }
+        //  Where we may be: the end, or a tile short of it.
+        std::vector<TilePos> next;
+        for (const TilePos& start : at){
+            TilePos end = start;
+            for (size_t i = 0; i < tiles; i++){
+                if (one_short_ok && i + 1 == tiles){
+                    next.push_back(end);
+                }
+                end = end.next(leg.direction);
+            }
+            next.push_back(end);
+        }
+        at = std::move(next);
+    }
+    return Pokemon::outcome_ok(Pokemon::tile_pose(state.pose.map, at, step.legs.back().direction));
+}
+
+Outcome ConsoleStoryExecutor::train(RunState&, const Pokemon::StoryStep& step){
+    StoryConsole& c = console();
+    for (size_t battle = 0; battle < step.battles; battle++){
+        const std::string label = std::format("Training battle {}/{}", battle + 1, step.battles);
+        route_status(c.env.console, label);
+        battle_1_pokemon(c.env.console, c.context);
+        fail_if_blacked_out(c.env.console, c.context, label);
+    }
+    return Pokemon::outcome_ok();
+}
+
+Outcome ConsoleStoryExecutor::heal(RunState&, const Pokemon::StoryStep& step){
+    StoryConsole& c = console();
+    heal_at_pokemon_center(c.env.console, c.context, step.why.empty() ? step.name : step.why);
+    return Pokemon::outcome_ok();
+}
+
+Outcome ConsoleStoryExecutor::save(RunState&, const Pokemon::StoryStep&){
+    StoryConsole& c = console();
+    checkpoint_save(c.env, c.context, c.options.notif_status_update, c.stats, c.options.checkpoint_save_mode);
+    return Pokemon::outcome_ok();
+}
+
+Outcome ConsoleStoryExecutor::mash(RunState&, const Pokemon::StoryStep& step){
+    StoryConsole& c = console();
+    wait_for_dialogue(c.env.console, c.context, step.name);
+    pbf_mash_button(c.context, BUTTON_B, 5000ms);
+    c.context.wait_for_all_requests();
+    return Pokemon::outcome_ok();
+}
+
+
+ConsoleStoryExecutor::Variant story_call(StoryAction action){
+    return [action = std::move(action)](ConsoleStoryExecutor&, StoryConsole& console, RunState&, const Pokemon::StoryStep&){
+        action(console);
+        return Pokemon::outcome_ok();
+    };
+}
+
+
+
+}
+}
+}
diff --git a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_StoryExecutor.h b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_StoryExecutor.h
new file mode 100644
index 0000000000..48a07aa476
--- /dev/null
+++ b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_StoryExecutor.h
@@ -0,0 +1,123 @@
+/*  BDSP AutoStory - Story step executor
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ *  BDSP's way of doing the shared story steps
+ *  (Pokemon/Navigation/Pokemon_StorySteps.h) on the console. Routes are
+ *  planned on the story's map set from the tiles the run's pose holds,
+ *  with the trainers who can still see us fought on the way; a route's
+ *  variant names its plan costs. A segment adds its own steps by variant
+ *  (the Mart lady, a walk through a gap in town): a variant registered
+ *  here is used for its step whatever the kind.
+ *
+ *  Each step runs through the table's StoryStepRunner, so a failed step
+ *  is answered as the table's other rows are: a screenshot, the
+ *  "checkpoint_reattempt_loop: attempt N failed" line the lab watches
+ *  for, and a failed Outcome that the segment's policy answers.
+ *
+ */
+
+#ifndef PokemonAutomation_PokemonBDSP_AutoStory_StoryExecutor_H
+#define PokemonAutomation_PokemonBDSP_AutoStory_StoryExecutor_H
+
+#include <functional>
+#include <map>
+#include <memory>
+#include <optional>
+#include <set>
+#include <string>
+#include <vector>
+#include "Pokemon/Navigation/Pokemon_MapSet.h"
+#include "Pokemon/Navigation/Pokemon_StorySteps.h"
+#include "Pokemon/Navigation/Pokemon_TileGrid.h"
+#include "PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_RouteWalk.h"
+#include "PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_StoryTables.h"
+
+namespace PokemonAutomation{
+namespace NintendoSwitch{
+namespace PokemonBDSP{
+
+
+//  The plan costs a ROUTE step's variant names: "" the route costs,
+//  "town" town_plan_costs(), "robust" the planner's defaults. Nothing for
+//  another name.
+std::optional<Pokemon::RobustPlanCosts> story_route_costs(const std::string& variant);
+
+//  The D-pad direction (x, y) of `direction`: y is up the screen.
+std::pair<double, double> dpad_of(Pokemon::Direction direction);
+
+
+//  Does BDSP's kinds of story step for one checkpoint of a table.
+class ConsoleStoryExecutor : public Pokemon::StoryStepExecutor{
+public:
+    //  A segment's own way of doing a step, by the step's variant. It may
+    //  set run flags for later steps' skip_if, and returns where it left
+    //  the player if it knows.
+    using Variant = std::function<Pokemon::Outcome(
+        ConsoleStoryExecutor& executor, StoryConsole& console,
+        Pokemon::RunState& state, const Pokemon::StoryStep& step
+    )>;
+    //  Fights a trainer whose dialogue has opened.
+    using TrainerFight = std::function<void(StoryConsole& console, const std::string& trainer)>;
+
+    //  `stop_rows`: the rows whose failure ends the program (rows_that_stop()).
+    ConsoleStoryExecutor(
+        StoryStepRunner& runner, std::set<std::string> stop_rows,
+        const Pokemon::MapSet& maps, std::vector<Pokemon::TrainerSight> trainers,
+        TrainerFight fight, std::map<std::string, Variant> variants
+    );
+
+    //  A new attempt of a row: every trainer can see us again.
+    virtual void begin_attempt(const Pokemon::StoryCheckpoint& data) override;
+
+    const Pokemon::MapSet& maps() const{
+        return m_maps;
+    }
+    //  The trainers who can still see us, and how to fight one, for a
+    //  variant that walks with walk_route().
+    std::vector<Pokemon::TrainerSight>& trainers(){
+        return m_trainers;
+    }
+    RouteTrainerFight fight(StoryConsole& console);
+
+    virtual Pokemon::Outcome run(Pokemon::RunState& state, const Pokemon::StoryStep& step) override;
+
+    virtual Pokemon::Outcome route(Pokemon::RunState& state, const Pokemon::StoryStep& step) override;
+    //  Each leg in D-pad taps, turning first. Variant "one_short_ok": a leg
+    //  may end a tile short (a door lined up by sight after).
+    virtual Pokemon::Outcome legs(Pokemon::RunState& state, const Pokemon::StoryStep& step) override;
+    virtual Pokemon::Outcome train(Pokemon::RunState& state, const Pokemon::StoryStep& step) override;
+    //  In front of a Pokemon Center, its lit doorway on screen: in, the
+    //  nurse, and out (heal_at_pokemon_center()).
+    virtual Pokemon::Outcome heal(Pokemon::RunState& state, const Pokemon::StoryStep& step) override;
+    //  The checkpoint save (checkpoint_save(), real or fake as the options say).
+    virtual Pokemon::Outcome save(Pokemon::RunState& state, const Pokemon::StoryStep& step) override;
+    //  A dialogue opens (or has), then B through it.
+    virtual Pokemon::Outcome mash(Pokemon::RunState& state, const Pokemon::StoryStep& step) override;
+
+private:
+    StoryConsole& console();
+
+    StoryStepRunner& m_runner;
+    std::set<std::string> m_stop_rows;
+    std::string m_checkpoint;
+    const Pokemon::MapSet& m_maps;
+    std::vector<Pokemon::TrainerSight> m_all_trainers;
+    std::vector<Pokemon::TrainerSight> m_trainers;
+    TrainerFight m_fight;
+    std::map<std::string, Variant> m_variants;
+    //  The console of the step running now.
+    StoryConsole* m_console = nullptr;
+};
+
+
+//  A variant that calls an old console function, for a step that has no
+//  declarative form yet.
+ConsoleStoryExecutor::Variant story_call(StoryAction action);
+
+
+
+}
+}
+}
+#endif
diff --git a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_StoryTables.cpp b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_StoryTables.cpp
index 5544ede503..4ff9530c50 100644
--- a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_StoryTables.cpp
+++ b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_StoryTables.cpp
@@ -29,9 +29,6 @@ using Pokemon::RunState;
 
 namespace{
 
-//  The attempts checkpoint_reattempt_loop() gives a checkpoint.
-constexpr size_t STORY_ATTEMPTS = 20;
-
 Event save_event(StoryStepRunner& runner, const std::string& id){
     Event event;
     event.name = "save";
@@ -45,47 +42,46 @@ Event save_event(StoryStepRunner& runner, const std::string& id){
     return event;
 }
 
-Event step_event(StoryStepRunner& runner, const std::string& id, StoryFailure on_failure, StoryStepSpec step){
-    Event event;
-    event.name = std::move(step.name);
-    event.why = std::move(step.why);
-    event.act = [&runner, id, on_failure, run = std::move(step.step)](RunState&){
-        return runner.run_step(id, on_failure, run);
-    };
-    return event;
-}
-
 }
 
 
-Pokemon::CheckpointSpec story_checkpoint(StoryStepRunner& runner, StoryCheckpointSpec spec){
-    Pokemon::CheckpointSpec row;
-    row.id = spec.id;
-    row.title = spec.title;
-    row.build = [&runner, spec = std::move(spec)](){
-        Checkpoint checkpoint;
-        checkpoint.id = spec.id;
-        if (spec.on_failure == StoryFailure::RELOAD_AND_RETRY){
-            checkpoint.events.push_back(save_event(runner, spec.id));
-        }
-        for (const StoryStepSpec& step : spec.steps){
-            checkpoint.events.push_back(step_event(runner, spec.id, spec.on_failure, step));
-        }
-        return checkpoint;
-    };
-    return row;
-}
-
-
-Pokemon::Segment story_segment(StoryStepRunner& runner, std::string id, std::vector<StoryCheckpointSpec> rows){
+Pokemon::Segment story_table_segment(
+    StoryStepRunner& runner, std::string id, const std::vector<StoryRow>& rows,
+    std::shared_ptr<Pokemon::StoryStepExecutor> executor
+){
     Pokemon::Segment segment;
     segment.id = std::move(id);
-    for (StoryCheckpointSpec& row : rows){
-        segment.checkpoints.push_back(story_checkpoint(runner, std::move(row)));
+    for (const StoryRow& row : rows){
+        segment.checkpoints.push_back(Pokemon::CheckpointSpec{
+            .id = row.id, .title = row.title, .saves = false,
+            .build = [&runner, &row, executor]{
+                Checkpoint steps = Pokemon::build_story_checkpoint(row, *executor);
+                if (row.on_failure != StoryFailure::RELOAD_AND_RETRY){
+                    return steps;
+                }
+                Checkpoint checkpoint;
+                checkpoint.id = row.id;
+                checkpoint.events.push_back(save_event(runner, row.id));
+                for (Event& event : steps.events){
+                    checkpoint.events.push_back(std::move(event));
+                }
+                return checkpoint;
+            },
+        });
     }
     return segment;
 }
 
+std::set<std::string> rows_that_stop(const std::vector<StoryRow>& rows){
+    std::set<std::string> ids;
+    for (const StoryRow& row : rows){
+        if (row.on_failure == StoryFailure::STOP){
+            ids.insert(row.id);
+        }
+    }
+    return ids;
+}
+
 
 ConsoleStoryRunner::ConsoleStoryRunner(StoryConsole console)
     : m_console(console)
@@ -105,7 +101,7 @@ Outcome ConsoleStoryRunner::save_at_start(const std::string& id){
     });
 }
 
-Outcome ConsoleStoryRunner::run_step(const std::string& id, StoryFailure on_failure, const StoryStep& step){
+Outcome ConsoleStoryRunner::run_step(const std::string& id, StoryFailure on_failure, const StoryAction& step){
     if (on_failure == StoryFailure::STOP){
         step(m_console);
         return Pokemon::outcome_ok();
@@ -119,8 +115,9 @@ Outcome ConsoleStoryRunner::run_step(const std::string& id, StoryFailure on_fail
         if (m_console.options.checkpoint_retry_scope == CheckpointRetryScope::DEFER_TO_SELECTED_RANGE){
             throw;
         }
+        //  Attempts are the segment's policy (AutoStoryOptions::policy); this
+        //  only counts them for the log line the lab's run watcher reads.
         const size_t attempt = m_failures[id]++;
-        //  The lab's run watcher reads this line as a failed attempt.
         env.console.log(std::format("checkpoint_reattempt_loop: attempt {} failed: {}: {}", attempt, id, e.message()), COLOR_RED);
         //  Keep what the screen showed at the failure; the retry resets the game.
         if (VideoSnapshot screen = env.console.video().snapshot()){
@@ -132,13 +129,6 @@ Outcome ConsoleStoryRunner::run_step(const std::string& id, StoryFailure on_fail
         }
         m_console.stats.m_reset++;
         env.update_stats();
-        if (attempt + 1 >= STORY_ATTEMPTS){
-            throw;
-        }
-        if (g_stop_at_first_failure){
-            env.console.log("Stopping at the first failure; the game stays where it failed.", COLOR_ORANGE);
-            throw;
-        }
         return Pokemon::outcome_failed("operation_failed", e.message());
     }
 }
@@ -168,8 +158,7 @@ void ConsoleStoryRunner::run(Pokemon::Segment& segment, const Pokemon::SegmentRa
     hooks.log = [&env](const std::string& line){
         env.log(line, COLOR_BLUE);
     };
-    Pokemon::SegmentPolicy policy;
-    policy.attempts_per_checkpoint = STORY_ATTEMPTS;
+    const Pokemon::SegmentPolicy& policy = m_console.options.policy;
     RunState state;
     const Pokemon::SegmentReport report = Pokemon::run_segment(state, segment, range, policy, hooks);
     if (!report.completed){
diff --git a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_StoryTables.h b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_StoryTables.h
index 842290c25a..165cc3cbd9 100644
--- a/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_StoryTables.h
+++ b/SerialPrograms/Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_StoryTables.h
@@ -8,7 +8,8 @@
  *  checkpoint saves first, as checkpoint_reattempt_loop() did before its
  *  first attempt; a step that fails is answered the way that loop answered
  *  it: a screenshot, a reset to the save, and the checkpoint again from its
- *  first step, up to the same 20 attempts.
+ *  first step, up to the attempts of the shared policy the program's retry
+ *  options set (AutoStoryOptions::policy; 3 by default, where the loop had 20).
  *
  */
 
@@ -17,10 +18,12 @@
 
 #include <functional>
 #include <map>
+#include <memory>
 #include <set>
 #include <string>
 #include <vector>
 #include "Pokemon/Navigation/Pokemon_StorySegments.h"
+#include "Pokemon/Navigation/Pokemon_StorySteps.h"
 #include "PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStoryTools.h"
 
 namespace PokemonAutomation{
@@ -28,20 +31,15 @@ namespace NintendoSwitch{
 namespace PokemonBDSP{
 
 
-//  What a step runs on.
+//  What a step runs on on the console.
 struct StoryConsole{
     SingleSwitchProgramEnvironment& env;
     ProControllerContext& context;
     const AutoStoryOptions& options;
     AutoStoryStats& stats;
 };
-using StoryStep = std::function<void(StoryConsole& console)>;
-
-struct StoryStepSpec{
-    std::string name;
-    std::string why;
-    StoryStep step;
-};
+//  A console action: what a step that calls an old function runs.
+using StoryAction = std::function<void(StoryConsole& console)>;
 
 //  What a checkpoint does when a step fails.
 enum class StoryFailure{
@@ -52,15 +50,13 @@ enum class StoryFailure{
     STOP,
 };
 
-struct StoryCheckpointSpec{
-    std::string id;
-    std::string title;
+//  A row of a story table: the shared checkpoint, and what a failure does.
+struct StoryRow : public Pokemon::StoryCheckpoint{
     StoryFailure on_failure = StoryFailure::RELOAD_AND_RETRY;
-    std::vector<StoryStepSpec> steps;
 };
 
-//  How a table's events reach the game: the console runner below, or a
-//  fake in the tests, which only describe the tables.
+//  How a table saves at a row's start and runs a console action: the
+//  console runner below, or a fake in the tests.
 class StoryStepRunner{
 public:
     virtual ~StoryStepRunner() = default;
@@ -68,14 +64,20 @@ class StoryStepRunner{
     //  starts from that save and does not save again.
     virtual bool saved_at_start(const std::string& id) const = 0;
     virtual Pokemon::Outcome save_at_start(const std::string& id) = 0;
-    virtual Pokemon::Outcome run_step(const std::string& id, StoryFailure on_failure, const StoryStep& step) = 0;
+    virtual Pokemon::Outcome run_step(const std::string& id, StoryFailure on_failure, const StoryAction& step) = 0;
 };
 
-//  A row of a segment table: builds the checkpoint's events from `spec`.
-Pokemon::CheckpointSpec story_checkpoint(StoryStepRunner& runner, StoryCheckpointSpec spec);
+//  The table `rows` (kept alive by the caller) as segment `id`: each row
+//  that retries saves first, through `runner`, unless this run has saved it
+//  already (a retry starts from that save); then its steps run with
+//  `executor`, which the segment keeps.
+Pokemon::Segment story_table_segment(
+    StoryStepRunner& runner, std::string id, const std::vector<StoryRow>& rows,
+    std::shared_ptr<Pokemon::StoryStepExecutor> executor
+);
 
-//  A segment table of `rows`, in order.
-Pokemon::Segment story_segment(StoryStepRunner& runner, std::string id, std::vector<StoryCheckpointSpec> rows);
+//  The ids of the rows that stop on a failure instead of retrying.
+std::set<std::string> rows_that_stop(const std::vector<StoryRow>& rows);
 
 using StorySegmentFactory = std::function<Pokemon::Segment(StoryStepRunner& runner)>;
 
@@ -87,7 +89,7 @@ class ConsoleStoryRunner : public StoryStepRunner{
 
     virtual bool saved_at_start(const std::string& id) const override;
     virtual Pokemon::Outcome save_at_start(const std::string& id) override;
-    virtual Pokemon::Outcome run_step(const std::string& id, StoryFailure on_failure, const StoryStep& step) override;
+    virtual Pokemon::Outcome run_step(const std::string& id, StoryFailure on_failure, const StoryAction& step) override;
 
     //  Runs the rows of `segment` in `range`; throws as the checkpoint
     //  loop did once a checkpoint has used up its attempts.
diff --git a/SerialPrograms/cmake/SourceFiles.cmake b/SerialPrograms/cmake/SourceFiles.cmake
index 915951bc3d..9b6923466b 100644
--- a/SerialPrograms/cmake/SourceFiles.cmake
+++ b/SerialPrograms/cmake/SourceFiles.cmake
@@ -1462,6 +1462,9 @@ file(GLOB LIBRARY_SOURCES
     Source/Pokemon/Navigation/Pokemon_MapSet.cpp
     Source/Pokemon/Navigation/Pokemon_MapSet.h
     Source/Pokemon/Navigation/Pokemon_Navigation_Tests.h
+    Source/Pokemon/Navigation/Pokemon_RouteLog.cpp
+    Source/Pokemon/Navigation/Pokemon_RouteLog.h
+    Source/Pokemon/Navigation/Pokemon_RouteLog_Tests.cpp
     Source/Pokemon/Navigation/Pokemon_StoryEvents.cpp
     Source/Pokemon/Navigation/Pokemon_StoryEvents.h
     Source/Pokemon/Navigation/Pokemon_StoryEvents_Tests.cpp
@@ -1470,6 +1473,9 @@ file(GLOB LIBRARY_SOURCES
     Source/Pokemon/Navigation/Pokemon_StorySegments.cpp
     Source/Pokemon/Navigation/Pokemon_StorySegments.h
     Source/Pokemon/Navigation/Pokemon_StorySegments_Tests.cpp
+    Source/Pokemon/Navigation/Pokemon_StorySteps.cpp
+    Source/Pokemon/Navigation/Pokemon_StorySteps.h
+    Source/Pokemon/Navigation/Pokemon_StorySteps_Tests.cpp
     Source/Pokemon/Navigation/Pokemon_TilePose.cpp
     Source/Pokemon/Navigation/Pokemon_TilePose.h
     Source/Pokemon/Options/Pokemon_BoxSortingTable.cpp
@@ -1485,6 +1491,8 @@ file(GLOB LIBRARY_SOURCES
     Source/Pokemon/Options/Pokemon_NameSelectWidget.h
     Source/Pokemon/Options/Pokemon_StatsHuntFilter.cpp
     Source/Pokemon/Options/Pokemon_StatsHuntFilter.h
+    Source/Pokemon/Options/Pokemon_StoryRunOptions.cpp
+    Source/Pokemon/Options/Pokemon_StoryRunOptions.h
     Source/Pokemon/Pokemon_AdvRng.cpp
     Source/Pokemon/Pokemon_AdvRng.h
     Source/Pokemon/Pokemon_BdspRng.cpp
@@ -1585,7 +1593,11 @@ file(GLOB LIBRARY_SOURCES
     Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory_Segment00_Tests.cpp
     Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory_Segment00_Tests.h
     Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory_StoryTables_Tests.cpp
+    Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory_StoryTable.cpp
+    Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory_StoryTable.h
     Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory_StoryTables_Tests.h
+    Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory_StorySimulation_Tests.cpp
+    Source/PokemonBDSP/Programs/AutoStory/PokemonBDSP_AutoStory_StorySimulation_Tests.h
     Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_Location.cpp
     Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_Location.h
     Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_NewGame.cpp
@@ -1606,6 +1618,8 @@ file(GLOB LIBRARY_SOURCES
     Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_Segment_00_tools.h
     Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_StoryTables.cpp
     Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_StoryTables.h
+    Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_StoryExecutor.cpp
+    Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_AutoStory_StoryExecutor.h
     Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_Autostory_Segment_01_tools.cpp
     Source/PokemonBDSP/Programs/AutoStory/Utils/PokemonBDSP_Autostory_Segment_01_tools.h
     Source/PokemonBDSP/Inference/Battles/PokemonBDSP_BattleBallReader.cpp