v0.3.0

The game feels and looks like the mobile prototype (M15): every op you write is answered on the hub as you write it, and every day's close plays back step by step on main as it stood, ending on what your pack did and where you stand. The bot is a character again, the guided first game lands its first push and goes on to day 3, and Git's output is Git's own. The online rules are unchanged.

Added

• A hint on the hub, as the prototype had (M15k): "hint" shows the pack a good player would write today, the bot's own policy run on your seat's view, with its first reason, and writes it into your pack on a tap.
• The game's view carries, for each closed day, main, the pointers and the scores as the day opened (opened), so a client can draw the table at every step of the day's playback (M15f). Replays carry them too.
• The remote answers "what would a good player do now?" (GET /api/games/:id/hint): the pack the bot's own policy would write from your seat's view, knowing nothing you don't, each op with its why in your words ("you pull first, in case someone pushes before you"), for the hub's hint (M15k). Nothing is sent.

Changed

• Every screen of a game sits in a frame, as in the prototype (M15b): a status bar with the day, main against the release size, the ops your pack leaves as pips, the live score and the Table, which opens as a sheet over the screen on a phone and stays beside it on a laptop. On a phone the game fills the screen and the answer sits at the thumb: send, continue and skip never scroll away. A day opens with its incident dealt, your draws, today's ops, and whether you are at the tip or behind. A moment's screen is titled with its command, Git's output under it.
• The game looks like the mobile prototype (M15c): prose in a sans-serif and Git in monospace; cards with a colored band saying what they are, the BUG tag where a fanned hand can't hide it, and face-down commits as a hatch showing their hash; main with each commit labelled by who pushed it and what it announced, its tip marked, and the pointers as chips; the Table's seats with their tokens. The landing page and its link preview follow.
• The hub is a table, as in the prototype (M15d): your branch shows where you stand and, as you write the pack, what it leaves staged and to push, with the commit it pushes waiting past the tip of main; the four actions (git add, git commit, git push, git pull) sit at the thumb with their cost and what each would do; picking a command card from the hand brings up its action, and the tag appears once main is the release size; undo takes back the last op. The online incidents say "today", not the tabletop's "this round".
• Each op you write is answered on the hub as you write it (M15e): the card flies from your hand into staging, the staged cards stack into one commit, the commit flies to "your push" past the tip of main, and a pull slides your pointer to the tip; a one-line receipt at the thumb says what the op will do. The hub keeps its scroll as it changes. Nothing moves under prefers-reduced-motion.
• A day's close plays back as the prototype played a turn (M15f): step by step in the order the remote ran the packs, each on main as it stood at that point, with its motion (a push's commit arriving at the end of main, a pointer sliding to the tip, a blamed commit turning over, what a force-push erased falling away, a push knocked back off the tip). Every remote op of yours gets a step, including a push that didn't run because the budget ran out; the bot's routine folds into fewer steps that move on by themselves. Each day ends on its receipt: what your pack did, the score the day changed, and where you now stand, the one screen "skip" never passes.
• The bot is a character again (M15g): on each of its steps, its avatar, its ops counted as dots, and a speech bubble saying why it played the op and how that went, so it no longer says it "ships what it has committed" before a push that finds nothing to ship. Someone else's conflict says what it did to the table, a push that didn't fit the budget says why, and what blame found is a # note, as Git's blame judges nothing.
• The guided first game goes on past day 1 (M15h): the guide counts its ten steps at the top of the screen, where it never covers what it points at, speaks while the day plays back (your push landing, the day's end), builds a second commit on day 2 and explains what the day's order did, catching you up with a pull when the bot's push lands first, and lets go on day 3.
• A player's first game against the bot is dealt so that its first day is a full one, with a clean card to play, and their pack resolves first, so their first push lands (M15h). The remote chooses the game's seed; the rules are those of any game.
• The release plays as in the prototype (M15i): CI turns the real commits on main face-up one after another, the bugs that reached production turning red, then stamps the tally. The scoreboard reads across: a headline, who won in their color, each part of the score in a column per player (yours first), the totals, and what decided it. When production is down, the least blame wins, as the remote has always counted it, and the scoreboard now says so.
• On a laptop the Table beside the screen keeps a log of every day, newest first, as the prototype's panel did, and while a day plays back it shows main as the step left it and the log up to the day before (M15j).

Fixed

• The hub's four actions have names a screen reader can say ("git add, 1 op: stage 1 card, +5"), as the prototype's did, and the bot's avatar style no longer reaches a linked player's GitHub avatar.
• A long handle no longer widens its slot on main (its chip and label are cut short), a slot with two pointers keeps its card level with the others, a day's receipt puts what each op did under its command, the day's score changes are plain chips, and another player's staging is a # note, as Git says nothing of it. Found playing a room against a second person and a hotseat game at 390 × 844.
• Git's output wraps on a phone instead of hiding the end of a long line behind a sideways scroll (M15a).
• A pull's conflict strategy is offered by what it does (keep theirs, keep mine, keep both by hand) and printed as Git's flag, which swaps ours and theirs under --rebase; keeping both prints no flag, as in Git. What a rule took (a dropped or crossed-out commit, a merge token, what a force-push erased) is a # comment, not a line in Git's voice, and a failed command names its target (M15a).
• A commit starts with a real message for the files staged, with others to pick from, instead of git commit -m "" (M15a).
• A pack can tag v1.0 only once (M15a).
• A pull whose conflict is settled by -X ours or -X theirs prints what Git prints: Auto-merging and a merge, or under --rebase the commits it dropped and Successfully rebased, rather than a CONFLICT and, when -X theirs took your only commit, a Fast-forward. CONFLICT is printed only for --resolve, resolved by hand, and a pull --rebase with nothing of yours is a fast-forward, as in Git.
• A failed git blame or git revert names its commit in the day log, and the bot no longer blames a commit that its own force-push erased earlier in the same pack, which failed with fatal: no such commit.