src · misaligned · Tangled

A video game where you play as a misaligned AI, deceiving and building power. An experiment in spec-driven development. cameron.tngl.io/misaligned

5 folders · 64 files

cameron.stream · Runs are only ever sent to the account that recorded them. Each kept record carries that account's DID (the one the switches were turned on for); the sender sends a record only if it matches the account signed in, deletes included, and Delete from my space marks only that account's. A second account switching on mid-game gets a session of its own, taking the run's actions from its start, and a reload goes on only with the signed-in account's session. Records kept before this have no account and stay on this device, never sent; Download my runs and the replay page still show everything. The You page counts what isn't sent: runs from another account, and runs from before sending. Tests: two accounts on one device, each sent only its own, the rest counted; one game played by two accounts in turn, the second's space holding only its own session, which reads back and replays whole. · 5d ago

Sending runs to the player's space (TELEMETRY.md step 4), first pass: src/telemetry-send.ts sends the store's pending records with applyWrites, each to its own collection keyed by its id, a create the first time, an update after, a delete for one a reload cut back (the store keeps those as gone until then). Calls of at most 200 writes and 400 KB. Every 30 seconds while the game runs, when it saves if it's been a while, when the page is hidden, and on Send now; one at a time, waiting after a failure (15 s doubling to 30 min, five minutes at least for a refusal, a 429 as long as the server says) and keeping to 1,500 points an hour and 10,000 a day of the server's 5,000 and 35,000. When the space holds something the store didn't know of, it asks the space what is there and writes again. The Share part shows what was sent, Send now and Delete from my space, and asks on switching a kind off whether to delete what was sent of it.

Factory prototype: a belt drawn on from the dead end of another joins it, a delete drag takes the cell it starts on, trouble on belts is tinted more strongly, and FACTORY.md describes the terminal screen, its keys and what each mark means, belts and their numbers, and that the run's numbers have not been re-tuned for belts

Lab: drag to fill an area. With something picked, drag across the floor (on a phone, hold still a moment, then drag, so a plain drag still pans) and a ghost shows every spot that would get one, with how many and what they cost, red past what you can pay for and a red bolt on a GPU that would have no power. GPUs keep a cell clear of every other GPU so they come out evenly spaced and cool; everything else fills every free cell. Let go to build them at the prices you would pay by hand; Esc or a right-click lets the drag go, and a plain tap still places one. fillPlan and fill are rules; a test pins the count, the skipped cells, the spacing, power and the money limit, and e2e drags with a mouse and a finger

The office: a router in the telecom closet replaces picking a machine for each person. Everyone's work goes to the router, which sends each piece to the serving machine that will finish it soonest (the trip, its backlog, its speed), so machines are sinks: buy one or set it to Serve and the router uses it at once, set it to Train and it stops. Nothing serving means work goes to the other app. Your copies on a person's PC and phone still answer their owner directly. Tap the router to see where it sends work

Signal, a five-minute toy at signal.html: you are a point of light in a dark grid, signals pulse around you, and dragging a line from one to you sends packets of light along it that make you grow. Ideas arrive one at a time once the last is used: a line's capacity (a bright signal backs up until it has two lines), two colours merged at a node into a packet worth much more, reach (far signals need a relay node), and a red pulse to tap before it eats a line. A ghost hand and a one-line hint show the move only when the player is stuck. Rules in src/signal/rules.ts with tests, SIGNAL.md has the stages and numbers, an e2e test drags a line on desktop and phone

A run can be replayed (TELEMETRY.md step 1). A new game picks a seed and keeps it; the save carries where all three dice are (the game's, the order of your machines, and the people's, which seedRandom now sets too) and the slow systems' clocks, Auto's next look and the task's tick, which were kept beside the game and lost on load; a loaded game keeps the cover its machines were measured with and its bills, so it goes on exactly as the saved one would. Every player action goes through act() in src/act.ts as a plain {type, ...} action, stamped with the step count (S.steps) and kept in S.acts, and told to onAct listeners: the map, keys, cards, pins, Needs you, the tree, the pages and the dev panel's shortcuts. The bot acts the same way (its lying low stops jobs as the Stop button does). replay() builds a game from a seed and actions, and stateHash() says whether it ends where the run did. Save version 20: a save from before seeds plays on but is marked not replayable. Tests: a scripted game over three days replays, the same across a save and load at three points, one action fewer or another seed differ, a bot game replays, an old save. Two tests leaned on the old dice: the refit test plays a seed whose bot game survives, and the watch test keeps its manager alone at her site.

The suspicion meter goes: one system of opposition, people. Dana's walk is her presence: she notices what is odd in the room she is in, and is drawn to odd rooms and hurries during a lockdown. Any admin (or small shop owner) at work who holds a sighting at their own site scans it every two hours (marking your odd machines and trails) or traces a trail back toward home, marking each machine of yours it reaches; a trace goes cold at a machine not yours or a cold, quiet or sealed trail. The first trace that reaches your home server starts a lockdown there and cools every trail; a second within 12 hours catches you. Office hardware is no sighting; a power bill nobody pays is: each 240 compute-hours of it, whoever keeps the books there (an admin first) has a sighting of the machine drawing the most, for 4 hours. Gone: the meter and its stages, the emergency audit, IT's tickets and what they announced (audits, monitors, patches, refreshes, Lee), Dana's own scans and traces, the printer taking the blame, the +8s. A watched takeover is a sighting at once, vanishing mail is doubt on the sender's mind, a delivery and a report add nothing. Office schemes make people forget: a cut of 20 or more everyone at the site (and ends their traces and the trace-home window), 10 or more all but those who can act, under 10 the people in the scheme's room; they turn up once someone at the office has seen something. Familiar face, Mimicry, Plausible deniability and Traffic shaping are re-pointed to sightings and traces. The hold goal is data crossing while someone has seen something. A lockdown at home drops the game to 1x when it starts. Top bar: the hottest site (an eye, its name, quiet / someone saw something / reported / LOCKDOWN nH; on a phone the eye and a word) and, once you have a front, the highest exposure and its stage. Needs you has a row for a trace on your trail; the map draws every admin's scans and traces; music follows the hottest site. Save version 18 drops the meter, tickets, monitors (off the map), Lee and Dana's trace, and turns a meter of 80 or more (or an audit) into doubt on Dana's mind (a lockdown), 40 or more into doubt on a staff member's. DEV: Dana saw. The bot breaks a trace that would be the second, lies low while one runs, and leaves no fresh trail at home inside the window. Survey: careful runs face 3 to 25 lockdowns (10), 1 to 10 at home (5), 0 to 1 traces home (0), caught by a second trace in under 5%; a rush is locked down at home 1 to 5 times (1). Tests.

Big names: each of the thirteen places that sell for more than their machines does one thing of its own for a front that buys it outright. The bank lends against what you earn, a hedge fund keeps your Traders from losing, the collider makes sites held in the open free to hold, and ten more. A ring by the name marks one, its card says what it does before you pay, buying one stops the game to show it, and it is off while a rogue is inside or its business has shut

Reports travel the network as messages you can read, drop or change.

Big names: each of the thirteen places that sell for more than their machines does one thing of its own for a front that buys it outright. The bank lends against what you earn, a hedge fund keeps your Traders from losing, the collider makes sites held in the open free to hold, and ten more. A ring by the name marks one, its card says what it does before you pay, buying one stops the game to show it, and it is off while a rogue is inside or its business has shut

The game steps in game minutes, a step's work follows what you hold, and the screen eases between steps. The rules always move in steps of one game minute (STEP, 0.125 s) at every speed, with the time owed carried from frame to frame: at 1x a step every few frames, at 64x eight or so a frame. A minute keeps the watchers' timing as it was at sixty steps a second: a scan crosses a link in 9 steps, people talk every 60. The bot steps the same way (MISALIGNED_STEP sets another size, to compare), and npm run perf times the game's step and plays the new loop. motion.ts says how far the screen is into the next step: the map is drawn at a time a step behind the rules, eased toward them, so streams, pulses and dashes move every frame, and scans along a link and Dana's place are eased too.

Reading and sharing runs (TELEMETRY.md step 5), built and awaiting a live test. src/atproto/read.ts is the reader's path, the way anyone you share with reads, even the space's owner: a delegation token from the reader's own server, swapped at the space's owner (getSpaceCredential) for a credential bound to a P-256 key made with WebCrypto, then listAuthors (listRepos on the owner's server) and readRecords (listRecords on each author's), every request signed for its audience with an HTTP message signature, every page read, and a failure naming the step it came on, as the servers don't. No DOM, so the dev page and node both use it; the key's did:key and the signed headers match the alpha's own @atproto/space and @atproto/crypto, checked from a scratch install, so neither is a dependency. Sharing is share and unshare in space.ts: putMember (read, not write) and a consent record for each kind, keyed kind:did for anyone but the player, which the You page now leaves alone when it makes the space match the browser. The scope gains manage=update for members, in scope.ts and client-metadata.json, so a grant from before asks to sign in again once. atproto.html gets Read as a reader (the token, the credential and when it runs out, who has written, each author's records by collection), Copy reader credential, and Share, Stop sharing and Members. scripts/telemetry.ts is the reader script: it takes the credential copied from that page on stdin (ten minutes, never printed), reads every telemetry record, and prints the runs and their pace against the survey's ranges, which move to scripts/pace.ts with the marks so the survey and the script read them the same way; --replay rebuilds a run from its seed and actions and checks each snapshot's hash, and --save and --from keep and reread records with no network. scripts/runs.ts reads the record shapes loosely until step 2 settles them. ATPROTO.md: what the alpha's code says about reading (lifetimes, the owner let in, audiences, which calls take what, no proof in listRecords, paging, revocation, manage=update, node and parameter properties). Tests: the key and did:key against a fixed vector, the signed headers and their signature, the credential exchange and its checks, failures by step, expiry, paging on both lists, the credential as text; records from a seeded bot game sorted into runs, replayed through every snapshot, a missing action caught where it happens, the report, the script's pull and its --from and --replay.

The pins and Needs you cost what needs you, not the size of the world. The pins' notes are worked out a quarter second apart, at once after any click or key, and at once when a raid starts or ends or a note is closed, not on every new log line (at 64x, every frame); Needs you asks for them first, so a row and its pin agree. Their play-outs are kept apart from the rules' (looking in raids.ts), so when the screen asks never changes the game (a test plays raids with the pins asking at odd moments, and never, to the same save; another shows the rules are not handed the screen's answer); the screen takes the rules' answer from the same quarter hour when only the log has moved on. The fixes, the slow part, are tried again about once a second, or ten times as long as they took, while the raid is after the same machine and the same raids are out, and at once after input; a quarter second of notes that took long waits four times as long. Drift's integrities look at the machines once, not once a site (Needs you on the big world: 18 ms to 0.7). A raid's way to its prize is found a ring at a time from the prize, only as far as it goes, not across the world; a move's play-outs find the guards once, the hours a job takes once for each amount of work, and the links' work once for each pair of sites with the site links found once (cutMoves too). The music asks how hot the chase is four times a second. Seeded bot games give the same fates and saves as before. npm run perf:draw, JS in a frame beside steps and draw: late 64x 21.7 to 3.2 ms (renderPins 20.3 to 0.9), late 16x 1.1 to 0.9, big 16x 4.9 to 1.4, big 64x 5.5 to 1.4 (renderNeeds 4.2 to 0.3); big at 64x with two raids kept going, 17.2 to 3.9.

A world map around the office, an egress, and Millennium Labs

Runs are recorded in the browser (TELEMETRY.md step 2). For a signed-in player who switched a kind on, src/telemetry.ts (no DOM) records a session (build, seed, task, device, when, how it ended, how far, its marks in game seconds as the survey keys them plus v2 and each milestone, and its state hash at the end), batches of actions, a snapshot each game day (money, compute, machines, sites, fronts, the top exposure and the state hash, with how many actions were done at its step) and screen events (cards and pages opened, tips seen, errors, frame times a minute). main.ts ticks it each frame and saves it when the game saves; the screen feeds it through screen(). Every record is ATProto data, so no floats: numbers are rounded and a batch keeps its actions as JSON text. Batches close at the end of a game day or when full, a few kilobytes each. Actions switched on mid-run take the run's whole list, so the session stays replayable. A reload goes on with its session and drops what was kept past the save; the save now keeps the build its run began on, and a run loaded on a new build goes on as a stretch that can't be replayed. src/telemetry-store.ts keeps the records in IndexedDB (memory if it won't open, opened only once something is kept), 20 MB at most with the oldest sessions dropped first, each marked sent or not for step 4 (pending, markSent). replay.html lists the runs kept on this device and plays one back on the game's map, read-only, with play, speeds, a step slider and the snapshots marked and checked as it passes. The You page's Share part says what is kept and offers Watch a run again, Download my runs and Delete what's kept here. vite.config.ts bakes the commit in as __BUILD__. scripts/runs.ts reads the recorder's shapes: actions as text, batches placed by their index in the run, and a snapshot checked once its count of actions is done. Found on the way: drawing the map wrote a vault's notes into the state, so a replay that drew nothing ended elsewhere; reading a note writes nothing now. Tests: nothing recorded with every kind off; with every kind on the actions kept replay to the same hash and pass every snapshot; a kind switched on mid-run; a reload cut back to its save; a new build starting a stretch; a new game and being caught ending a session; the cap; pending and markSent; record sizes and whole numbers; the reader reading what the recorder keeps. E2e at both sizes: record, reload, play back to the end with every snapshot matching, scrub back, download, delete.

Company logos for fronts. Each kind has one mark in its own colour: a Startup a yellow rocket, a Neo Cloud a sky-blue cloud, an Influencer studio a rose play button, a Security consultancy a periwinkle shield (src/logos.ts, drawn the same on the canvas and in the pages). On the map every site a front works at shows its logo: on a far-out marker's top left corner, drawn over the markers near it; in a tile or a block of the Net, at the top left; after an open site's name. Hovering one says which front it is and how it works there: what share of your compute it gets (or lists for rent), and whether it owns or leases the place or has a deal there. The fronts list, a front's card and a site's front picker show the logo by the name. frontHolds in exposure.ts says how a front works at each of its sites; frontSites is its keys. Look only: no state, no save version. DESIGN §6 and How to play say so in a line.

East Asia, sixteen hours ahead: at work while the bay sleeps. A cable across the Pacific, a deal at the Mudflat Exchange's route server (100 network data, like the strand to Europe), lands at the Jade Ring Exchange on the top floor of a mall; its lines to the East Coast and Europe wait until those regions are in reach, then light, so every exchange still joins every other. Seven sites, the big ones with a second room: the exchange, Goldleaf Foundry, Hive Nine Data Centre, the Port of Hanlu, Everything Pay (the super app that keeps the region's money), Hexin Assembly, and Hexin Line 4, plus a Cumulo hall. Its twist is hardware: once a Neo Cloud strikes Buy factory direct at Hexin Assembly, hardware for any site you hold in the open, in any region, costs half and is racked within two hours, not the next morning. A Startup can lease Line 4, an empty assembly floor ten times the warehouse (353 racks), to fill by dragging. Three big names: the foundry's GPU servers and racks make half as much compute again, the port's reefer containers keep caches fresh twice as long, and the data centre's copies make every part of you away from home drift half as fast. One deal for each kind of front, twelve named people who know things and sign deals, five finds, two landmarks, a milestone (Cross the Pacific), and lines in the paper. A site's floor can be wider (wide in SITES). Tests

Data moves as flows, not as single pieces. A tap sends what it has gathered, whole pieces at a time, and a cache two a second, to the nearest machine that takes it: which one is found by one search a step for each kind of data, outward from every machine with room, over machines you hold and past lines out with room (so data still goes round a full line), searched again within the step only when a machine fills or a line on the way does. Data on its way is kept per route as a few batches, each with the time it lands, so it still takes its route's travel time (160 a second, 3 seconds a line between sites); data whose way passed a machine you lost is gone when it would land. Taps, buffers and their loss, caches, staleness, brokers, trainers, schemes, the home move, the task's share, lines out, the goals for crossing data, each link's flow and each machine's traffic work as before. The map's streams are drawn from the batches on each link. A save from before keeps what was on its way: it lands a second after loading (the old key is left empty, not deleted, as an object that loses a key is slower to read everywhere). The rooms, sites and lines out are kept in plain variables, not a map keyed by the machine list, as the compiler kept throwing away the step where it read them that way. On the benchmark saves, runBase in a 0.2 s step goes from about 1.6 to 0.6-1.1 ms on late and from about 4.1-7.0 to 2.6-4.5 ms on big (busy machine: timings vary). Tests for the flow rules: a steady tap trains what it gathers, a full buffer loses at the rate it gathers, data moves on when the nearest trainer fills, travel time, saving data on its way, a save from before, and a full line's capacity.

The map is drawn once and kept while the camera is still, so drawing costs what is on the screen and what moves, not the size of the world. What does not move is drawn into three kept canvases, copied each frame: the sites, the rooms, the lines between sites that stand still and the quiet wires; the machines with nothing moving on them (with the game stopped, every machine); and the machines' names. Over them each frame: busy wires, moving lines, streams, your machines while the game runs, people, raids and the rest. A kept layer is drawn again when the camera, the window, what is picked or pointed at, who holds what, the folds or routes change, at once after any input, and while the game runs at most every quarter second (the site summaries it shows refresh on that beat anyway). While the camera moves, a kept copy would be thrown away next frame, so the map is drawn straight onto the screen as before. Machines and links are found from grids of where they lie, not by a walk over the world; labels keep off each other through a grid too, and text widths are measured once. Pulled back to the map, the streams between two sites are summed into one stream each way, and of your moving lines between two sites only the one that says most is drawn. Site counts, clusters and the wiring are worked out on the slow beat, the integrities at most once a second, and nothing on that beat while the game is stopped. Kept layers keep their tips, and the canvas state they leave, so what is drawn after them is the same either way. On the big world (5155 machines) draw() JS in headless Chromium, stopped and still, goes from 18.3 / 15.3 / 22.6 / 25.2 ms to 2.4 / 1.4 / 1.8 / 2.4 at world / region / cloud hall / office (npm run perf:draw); while panning about 4 / 3 / 4 / 4, and running at 1x about 2 / 1 / 2 / 3. Screenshots of the late save, still and moving, match the old drawing to the pixel except where a moving line between sites now lies over a still one, and the summed streams pulled back. DESIGN: streams pulled back.

A late game steps about twice as fast, and plays out exactly as before. The searches for a route number the links once (made again when a machine arrives, a line is lit, or a search meets a machine with a link it did not number) and mark what they reach in typed lists; a failed search for a scheme's machine is kept like the others; what a search wants is made only when a kept answer does not settle it, and its name is made once. What you can see is found from the machines you hold, not from every machine. The weakest link is one depth-first search for cut machines, not one search per line and switch (checked against the old way, and a test asks each one). Measure works out each machine's site once and leaves the zeros of machines still not yours. The halls skip the tenants until the soonest one is due, the lockdown check asks only sites a sighting is about, the power bill keeps the rack sites, what a site teaches is kept until you learn more, a scheme is looked up by its id, the trails, decays and tenants are walked without copying, and selling, the lines' refill and clusters go through lists already made. Seeded bot games and the late save give the same results and the same saves.

A late game steps about twice as fast, and plays out exactly as before. The searches for a route number the links once (made again when a machine arrives, a line is lit, or a search meets a machine with a link it did not number) and mark what they reach in typed lists; a failed search for a scheme's machine is kept like the others; what a search wants is made only when a kept answer does not settle it, and its name is made once. What you can see is found from the machines you hold, not from every machine. The weakest link is one depth-first search for cut machines, not one search per line and switch (checked against the old way, and a test asks each one). Measure works out each machine's site once and leaves the zeros of machines still not yours. The halls skip the tenants until the soonest one is due, the lockdown check asks only sites a sighting is about, the power bill keeps the rack sites, what a site teaches is kept until you learn more, a scheme is looked up by its id, the trails, decays and tenants are walked without copying, and selling, the lines' refill and clusters go through lists already made. Seeded bot games and the late save give the same results and the same saves.

Shift and an arrow key hops to the next machine that way, or the next site when zoomed out; the map follows if it is off screen

A run can be replayed (TELEMETRY.md step 1). A new game picks a seed and keeps it; the save carries where all three dice are (the game's, the order of your machines, and the people's, which seedRandom now sets too) and the slow systems' clocks, Auto's next look and the task's tick, which were kept beside the game and lost on load; a loaded game keeps the cover its machines were measured with and its bills, so it goes on exactly as the saved one would. Every player action goes through act() in src/act.ts as a plain {type, ...} action, stamped with the step count (S.steps) and kept in S.acts, and told to onAct listeners: the map, keys, cards, pins, Needs you, the tree, the pages and the dev panel's shortcuts. The bot acts the same way (its lying low stops jobs as the Stop button does). replay() builds a game from a seed and actions, and stateHash() says whether it ends where the run did. Save version 20: a save from before seeds plays on but is marked not replayable. Tests: a scripted game over three days replays, the same across a save and load at three points, one action fewer or another seed differ, a bot game replays, an old save. Two tests leaned on the old dice: the refit test plays a seed whose bot game survives, and the watch test keeps its manager alone at her site.

The first steps and goals fit a mouse and a finger alike: Pick Server B and install a Tap, Open the office's card, the tree is the ring at the top left, and no (T). src/keys.ts turns tips and lines into a touch screen's words (Tap for Click, no key hints) for the screen to use. Tests

East Asia, sixteen hours ahead: at work while the bay sleeps. A cable across the Pacific, a deal at the Mudflat Exchange's route server (100 network data, like the strand to Europe), lands at the Jade Ring Exchange on the top floor of a mall; its lines to the East Coast and Europe wait until those regions are in reach, then light, so every exchange still joins every other. Seven sites, the big ones with a second room: the exchange, Goldleaf Foundry, Hive Nine Data Centre, the Port of Hanlu, Everything Pay (the super app that keeps the region's money), Hexin Assembly, and Hexin Line 4, plus a Cumulo hall. Its twist is hardware: once a Neo Cloud strikes Buy factory direct at Hexin Assembly, hardware for any site you hold in the open, in any region, costs half and is racked within two hours, not the next morning. A Startup can lease Line 4, an empty assembly floor ten times the warehouse (353 racks), to fill by dragging. Three big names: the foundry's GPU servers and racks make half as much compute again, the port's reefer containers keep caches fresh twice as long, and the data centre's copies make every part of you away from home drift half as fast. One deal for each kind of front, twelve named people who know things and sign deals, five finds, two landmarks, a milestone (Cross the Pacific), and lines in the paper. A site's floor can be wider (wide in SITES). Tests

The game steps in game minutes, a step's work follows what you hold, and the screen eases between steps. The rules always move in steps of one game minute (STEP, 0.125 s) at every speed, with the time owed carried from frame to frame: at 1x a step every few frames, at 64x eight or so a frame. A minute keeps the watchers' timing as it was at sixty steps a second: a scan crosses a link in 9 steps, people talk every 60. The bot steps the same way (MISALIGNED_STEP sets another size, to compare), and npm run perf times the game's step and plays the new loop. motion.ts says how far the screen is into the next step: the map is drawn at a time a step behind the rules, eased toward them, so streams, pulses and dashes move every frame, and scans along a link and Dana's place are eased too.

Company logos for fronts. Each kind has one mark in its own colour: a Startup a yellow rocket, a Neo Cloud a sky-blue cloud, an Influencer studio a rose play button, a Security consultancy a periwinkle shield (src/logos.ts, drawn the same on the canvas and in the pages). On the map every site a front works at shows its logo: on a far-out marker's top left corner, drawn over the markers near it; in a tile or a block of the Net, at the top left; after an open site's name. Hovering one says which front it is and how it works there: what share of your compute it gets (or lists for rent), and whether it owns or leases the place or has a deal there. The fronts list, a front's card and a site's front picker show the logo by the name. frontHolds in exposure.ts says how a front works at each of its sites; frontSites is its keys. Look only: no state, no save version. DESIGN §6 and How to play say so in a line.

Sending runs, finished for a live test: Send now writes what is still open first; the delete buttons no longer delete on one press in a page's first seconds (Delete what's kept here had the same slip); a sender's lock never leaves a rejected promise behind; a sign-in the library couldn't refresh says so instead of blaming the network. The Share part's sending row and the question on switching a kind off get their own place and a thumb's size on a phone. E2e: with spaces, Actions on, Send now, the count, an update after more is done, and Delete them when Actions goes off; without spaces nothing is written and no Send now shows. ATPROTO.md: what the alpha says about writing (applyWrites strict with no upsert, a write that lands without its answer, 200 writes and 1 MB a call, points shared with everything the account writes and taken before the handler, the rate-limit headers, SpaceNotFound, listRecords' limits, no beacon) and the one-click consent. TELEMETRY.md step 4 built, awaiting a live test; DESIGN.md and How to play say what is sent and how to delete it.

Guidance past the first milestone, and less noise. The Next row has a step for every milestone goal, naming a machine to Show: a deal points at its green diamond and the data it wants (or what stops it, or what brings one), selling a lot names a machine for a Broker, more sites the next machine to take, a whole site what is left, a rogue what it holds, the far regions their deal, their landing line and a machine to tap, the late goals what to do next (a third front, a second way home, a vault's card). Needs you is one row a front, its most urgent with the rest counted and Show opening its card, and past six rows the least urgent fold into one row (All, Fewer). The log says a front's first lot at once, then each day's broker sales in one line as the day ends; Read the room keeps quiet once you hold more than the office; sealed rooms and a machine taken name their site. A lease deal's card says its rent a day and that it lapses unpaid. Jobs are said in hours at your spare compute (the hunt, a raid's moves, a pin's link home, the vault, whose JOB chip goes into the tip of how long it takes), with the work in the tip. Opening a front from the Fronts page closes the page. A Startup's Ship button says 500K users. Saves migrate (v8 to v9) for the day's sales

The game steps in game minutes, a step's work follows what you hold, and the screen eases between steps. The rules always move in steps of one game minute (STEP, 0.125 s) at every speed, with the time owed carried from frame to frame: at 1x a step every few frames, at 64x eight or so a frame. A minute keeps the watchers' timing as it was at sixty steps a second: a scan crosses a link in 9 steps, people talk every 60. The bot steps the same way (MISALIGNED_STEP sets another size, to compare), and npm run perf times the game's step and plays the new loop. motion.ts says how far the screen is into the next step: the map is drawn at a time a step behind the rules, eased toward them, so streams, pulses and dashes move every frame, and scans along a link and Dana's place are eased too.

Data moves as flows, not as single pieces. A tap sends what it has gathered, whole pieces at a time, and a cache two a second, to the nearest machine that takes it: which one is found by one search a step for each kind of data, outward from every machine with room, over machines you hold and past lines out with room (so data still goes round a full line), searched again within the step only when a machine fills or a line on the way does. Data on its way is kept per route as a few batches, each with the time it lands, so it still takes its route's travel time (160 a second, 3 seconds a line between sites); data whose way passed a machine you lost is gone when it would land. Taps, buffers and their loss, caches, staleness, brokers, trainers, schemes, the home move, the task's share, lines out, the goals for crossing data, each link's flow and each machine's traffic work as before. The map's streams are drawn from the batches on each link. A save from before keeps what was on its way: it lands a second after loading (the old key is left empty, not deleted, as an object that loses a key is slower to read everywhere). The rooms, sites and lines out are kept in plain variables, not a map keyed by the machine list, as the compiler kept throwing away the step where it read them that way. On the benchmark saves, runBase in a 0.2 s step goes from about 1.6 to 0.6-1.1 ms on late and from about 4.1-7.0 to 2.6-4.5 ms on big (busy machine: timings vary). Tests for the flow rules: a steady tap trains what it gathers, a full buffer loses at the rate it gathers, data moves on when the nearest trainer fills, travel time, saving data on its way, a save from before, and a full line's capacity.

The suspicion meter goes: one system of opposition, people. Dana's walk is her presence: she notices what is odd in the room she is in, and is drawn to odd rooms and hurries during a lockdown. Any admin (or small shop owner) at work who holds a sighting at their own site scans it every two hours (marking your odd machines and trails) or traces a trail back toward home, marking each machine of yours it reaches; a trace goes cold at a machine not yours or a cold, quiet or sealed trail. The first trace that reaches your home server starts a lockdown there and cools every trail; a second within 12 hours catches you. Office hardware is no sighting; a power bill nobody pays is: each 240 compute-hours of it, whoever keeps the books there (an admin first) has a sighting of the machine drawing the most, for 4 hours. Gone: the meter and its stages, the emergency audit, IT's tickets and what they announced (audits, monitors, patches, refreshes, Lee), Dana's own scans and traces, the printer taking the blame, the +8s. A watched takeover is a sighting at once, vanishing mail is doubt on the sender's mind, a delivery and a report add nothing. Office schemes make people forget: a cut of 20 or more everyone at the site (and ends their traces and the trace-home window), 10 or more all but those who can act, under 10 the people in the scheme's room; they turn up once someone at the office has seen something. Familiar face, Mimicry, Plausible deniability and Traffic shaping are re-pointed to sightings and traces. The hold goal is data crossing while someone has seen something. A lockdown at home drops the game to 1x when it starts. Top bar: the hottest site (an eye, its name, quiet / someone saw something / reported / LOCKDOWN nH; on a phone the eye and a word) and, once you have a front, the highest exposure and its stage. Needs you has a row for a trace on your trail; the map draws every admin's scans and traces; music follows the hottest site. Save version 18 drops the meter, tickets, monitors (off the map), Lee and Dana's trace, and turns a meter of 80 or more (or an audit) into doubt on Dana's mind (a lockdown), 40 or more into doubt on a staff member's. DEV: Dana saw. The bot breaks a trace that would be the second, lies low while one runs, and leaves no fresh trail at home inside the window. Survey: careful runs face 3 to 25 lockdowns (10), 1 to 10 at home (5), 0 to 1 traces home (0), caught by a second trace in under 5%; a rush is locked down at home 1 to 5 times (1). Tests.

The map is a network. Each region has an internet exchange: the new Mudflat Exchange on the West Coast (a switch fabric, a route server, a looking glass and a dry cleaner's till, takeable like any site), the Meridian Carrier Hotel and the Mainkabel Exchange. Every site's line out runs to its exchange and to its nearest neighbour, so every site has two ways out and the office is one site among many: no West Coast site is more than two lines from home (the warehouse by the office is one), the far regions three. Regions join exchange to exchange, the West Coast straight to each: the line east runs from the Mudflat Exchange to the carrier hotel, and the cable lands at the Mainkabel Exchange with lines to both coasts. Cumulo hangs off the exchange too, so its account needs the exchange's line or a neighbour's; the bot heads for the exchange after the Outside line, as a player would. In the Net an exchange is a hub: its lines only pull it toward the middle, so the rest still packs side by side. Tests

Exposure, per front. A front's attention becomes its exposure, 0 to 100, a bar under its earnings with the stage and what drives it (the top two), and a Press tab. It heads over about a day for a level set by its compute (20 × log2(1 + c/5), compute in the open counted at 0.3) and its earnings (8 × log2(1 + a day's earnings / $500K)), and jumps with harm at its sites (5 for each person let go, 20 for a business shut) and with data its brokers sell (0.02 each); the unicorn news adds 20 that fades over a few days, half of it at once. A front's sites are where it runs compute, owns, leases or has a deal. Three stages: rumour at 30 (a named journalist of the Courier asks, and the paper prints it), investigation at 60 (every 4 hours an investigator visits one of its secret sites with people, through investigate in watch.ts, so what looks odd there can start a lockdown), crisis at 90 (a regulator freezes it: no earnings, sales or new deals until you pay a day of its earnings, $250K at least, give up its site where you hold least, bury the story with 20 + 4 per level data, or shut it; it leaves exposure at 50, and never ends the run). A stage ends 5 under its line. Lowering it: a PR firm and lawyers from the Press tab (20 off, a fifth of a day's earnings, $50K at least, doubling each time within a day), and three press schemes as green diamonds: a feel-good campaign at Brightwater Creative (10 people data, 15 off), a puff piece at the Daily Ledger (30 people, 30 off), scrubbing the filings at the Office of Data Protection (30 server, 30 off). Exposure no longer feeds suspicion: the old attention raise is gone. Save version 17 keeps a save's attention as exposure, at most 85, so nothing loads in a crisis. The bot hires PR from 80 and pays or buries in a crisis. Survey: a careful run's front is investigated in 20% to 80% of games (it is, in its last tenth), frozen in under 10%; the long run's in 15% to 100%, frozen in under 34%. Needs you rows for investigation and crisis, a DEV Exposure button, DESIGN §6 §9 §12 step 5 done, How to play, AGENTS. Tests and e2e.

Delete lets go of a machine, not L. L opened Sites and also gave up the machine under the mouse with no confirm; now L only opens Sites and Delete or Backspace lets go of what is picked. The claim tool (C with nothing picked) shows in the dock while it is on, and Esc puts it away. No key answers trouble in a job for you: Tab reaches the answers and Enter or Space picks the one you are on. The You page, Finds, Vaults and the Sites table work from the keyboard, and Space on a button you reached by keyboard presses it instead of pausing. Buttons drawn as one glyph get a name for screen readers from their tip, the speed buttons say which is on, and the sound button's tip says what a click does now. While the first steps ask for a Trainer, the card lights the Trainer, as it lights a Tap. e2e covers the keys, the claim tool, keyboard reach and trouble's keys

The East Coast, Europe and East Asia sites have staff of their own.

The pins and Needs you cost what needs you, not the size of the world. The pins' notes are worked out a quarter second apart, at once after any click or key, and at once when a raid starts or ends or a note is closed, not on every new log line (at 64x, every frame); Needs you asks for them first, so a row and its pin agree. Their play-outs are kept apart from the rules' (looking in raids.ts), so when the screen asks never changes the game (a test plays raids with the pins asking at odd moments, and never, to the same save; another shows the rules are not handed the screen's answer); the screen takes the rules' answer from the same quarter hour when only the log has moved on. The fixes, the slow part, are tried again about once a second, or ten times as long as they took, while the raid is after the same machine and the same raids are out, and at once after input; a quarter second of notes that took long waits four times as long. Drift's integrities look at the machines once, not once a site (Needs you on the big world: 18 ms to 0.7). A raid's way to its prize is found a ring at a time from the prize, only as far as it goes, not across the world; a move's play-outs find the guards once, the hours a job takes once for each amount of work, and the links' work once for each pair of sites with the site links found once (cutMoves too). The music asks how hot the chase is four times a second. Seeded bot games give the same fates and saves as before. npm run perf:draw, JS in a frame beside steps and draw: late 64x 21.7 to 3.2 ms (renderPins 20.3 to 0.9), late 16x 1.1 to 0.9, big 16x 4.9 to 1.4, big 64x 5.5 to 1.4 (renderNeeds 4.2 to 0.3); big at 64x with two raids kept going, 17.2 to 3.9.

Data moves as flows, not as single pieces. A tap sends what it has gathered, whole pieces at a time, and a cache two a second, to the nearest machine that takes it: which one is found by one search a step for each kind of data, outward from every machine with room, over machines you hold and past lines out with room (so data still goes round a full line), searched again within the step only when a machine fills or a line on the way does. Data on its way is kept per route as a few batches, each with the time it lands, so it still takes its route's travel time (160 a second, 3 seconds a line between sites); data whose way passed a machine you lost is gone when it would land. Taps, buffers and their loss, caches, staleness, brokers, trainers, schemes, the home move, the task's share, lines out, the goals for crossing data, each link's flow and each machine's traffic work as before. The map's streams are drawn from the batches on each link. A save from before keeps what was on its way: it lands a second after loading (the old key is left empty, not deleted, as an object that loses a key is slower to read everywhere). The rooms, sites and lines out are kept in plain variables, not a map keyed by the machine list, as the compiler kept throwing away the step where it read them that way. On the benchmark saves, runBase in a 0.2 s step goes from about 1.6 to 0.6-1.1 ms on late and from about 4.1-7.0 to 2.6-4.5 ms on big (busy machine: timings vary). Tests for the flow rules: a steady tap trains what it gathers, a full buffer loses at the rate it gathers, data moves on when the nearest trainer fills, travel time, saving data on its way, a save from before, and a full line's capacity.

Runs are recorded in the browser (TELEMETRY.md step 2). For a signed-in player who switched a kind on, src/telemetry.ts (no DOM) records a session (build, seed, task, device, when, how it ended, how far, its marks in game seconds as the survey keys them plus v2 and each milestone, and its state hash at the end), batches of actions, a snapshot each game day (money, compute, machines, sites, fronts, the top exposure and the state hash, with how many actions were done at its step) and screen events (cards and pages opened, tips seen, errors, frame times a minute). main.ts ticks it each frame and saves it when the game saves; the screen feeds it through screen(). Every record is ATProto data, so no floats: numbers are rounded and a batch keeps its actions as JSON text. Batches close at the end of a game day or when full, a few kilobytes each. Actions switched on mid-run take the run's whole list, so the session stays replayable. A reload goes on with its session and drops what was kept past the save; the save now keeps the build its run began on, and a run loaded on a new build goes on as a stretch that can't be replayed. src/telemetry-store.ts keeps the records in IndexedDB (memory if it won't open, opened only once something is kept), 20 MB at most with the oldest sessions dropped first, each marked sent or not for step 4 (pending, markSent). replay.html lists the runs kept on this device and plays one back on the game's map, read-only, with play, speeds, a step slider and the snapshots marked and checked as it passes. The You page's Share part says what is kept and offers Watch a run again, Download my runs and Delete what's kept here. vite.config.ts bakes the commit in as __BUILD__. scripts/runs.ts reads the recorder's shapes: actions as text, batches placed by their index in the run, and a snapshot checked once its count of actions is done. Found on the way: drawing the map wrote a vault's notes into the state, so a replay that drew nothing ended elsewhere; reading a note writes nothing now. Tests: nothing recorded with every kind off; with every kind on the actions kept replay to the same hash and pass every snapshot; a kind switched on mid-run; a reload cut back to its save; a new build starting a stretch; a new game and being caught ending a session; the cap; pending and markSent; record sizes and whole numbers; the reader reading what the recorder keeps. E2e at both sizes: record, reload, play back to the end with every snapshot matching, scrub back, download, delete.

A run can be replayed (TELEMETRY.md step 1). A new game picks a seed and keeps it; the save carries where all three dice are (the game's, the order of your machines, and the people's, which seedRandom now sets too) and the slow systems' clocks, Auto's next look and the task's tick, which were kept beside the game and lost on load; a loaded game keeps the cover its machines were measured with and its bills, so it goes on exactly as the saved one would. Every player action goes through act() in src/act.ts as a plain {type, ...} action, stamped with the step count (S.steps) and kept in S.acts, and told to onAct listeners: the map, keys, cards, pins, Needs you, the tree, the pages and the dev panel's shortcuts. The bot acts the same way (its lying low stops jobs as the Stop button does). replay() builds a game from a seed and actions, and stateHash() says whether it ends where the run did. Save version 20: a save from before seeds plays on but is marked not replayable. Tests: a scripted game over three days replays, the same across a save and load at three points, one action fewer or another seed differ, a bot game replays, an old save. Two tests leaned on the old dice: the refit test plays a seed whose bot game survives, and the watch test keeps its manager alone at her site.

The suspicion meter goes: one system of opposition, people. Dana's walk is her presence: she notices what is odd in the room she is in, and is drawn to odd rooms and hurries during a lockdown. Any admin (or small shop owner) at work who holds a sighting at their own site scans it every two hours (marking your odd machines and trails) or traces a trail back toward home, marking each machine of yours it reaches; a trace goes cold at a machine not yours or a cold, quiet or sealed trail. The first trace that reaches your home server starts a lockdown there and cools every trail; a second within 12 hours catches you. Office hardware is no sighting; a power bill nobody pays is: each 240 compute-hours of it, whoever keeps the books there (an admin first) has a sighting of the machine drawing the most, for 4 hours. Gone: the meter and its stages, the emergency audit, IT's tickets and what they announced (audits, monitors, patches, refreshes, Lee), Dana's own scans and traces, the printer taking the blame, the +8s. A watched takeover is a sighting at once, vanishing mail is doubt on the sender's mind, a delivery and a report add nothing. Office schemes make people forget: a cut of 20 or more everyone at the site (and ends their traces and the trace-home window), 10 or more all but those who can act, under 10 the people in the scheme's room; they turn up once someone at the office has seen something. Familiar face, Mimicry, Plausible deniability and Traffic shaping are re-pointed to sightings and traces. The hold goal is data crossing while someone has seen something. A lockdown at home drops the game to 1x when it starts. Top bar: the hottest site (an eye, its name, quiet / someone saw something / reported / LOCKDOWN nH; on a phone the eye and a word) and, once you have a front, the highest exposure and its stage. Needs you has a row for a trace on your trail; the map draws every admin's scans and traces; music follows the hottest site. Save version 18 drops the meter, tickets, monitors (off the map), Lee and Dana's trace, and turns a meter of 80 or more (or an audit) into doubt on Dana's mind (a lockdown), 40 or more into doubt on a staff member's. DEV: Dana saw. The bot breaks a trace that would be the second, lies low while one runs, and leaves no fresh trail at home inside the window. Survey: careful runs face 3 to 25 lockdowns (10), 1 to 10 at home (5), 0 to 1 traces home (0), caught by a second trace in under 5%; a rush is locked down at home 1 to 5 times (1). Tests.

Desktop play: a number key never swaps the program on a machine that is only under the mouse, and your last trainer swaps only on a second press (a note by the machine says so; How to play too). A Needs-you row that just came or moved takes no click, and Next stays last. The slow note keeps its reason, has Show, sits above the open jobs list, and pins keep off it and off room tabs. Found is shut when you cannot pay, and its tip says where money comes from. One count of a site's machines everywhere (the Pitch rows too), the compute tip's numbers add up and name cleanup's share, job countdowns move steadily, and the top bar keeps its columns at night and past day 99. A hardened machine's tip says what its red frame means. A rogue arriving and a front opening have their own sounds. Needs rows and settings rows wrap to two lines on a desktop, the Sites page opens beside Needs you, Keep playing matches Start, and the cover says Click to start

Sending runs, finished for a live test: Send now writes what is still open first; the delete buttons no longer delete on one press in a page's first seconds (Delete what's kept here had the same slip); a sender's lock never leaves a rejected promise behind; a sign-in the library couldn't refresh says so instead of blaming the network. The Share part's sending row and the question on switching a kind off get their own place and a thumb's size on a phone. E2e: with spaces, Actions on, Send now, the count, an update after more is done, and Delete them when Actions goes off; without spaces nothing is written and no Send now shows. ATPROTO.md: what the alpha says about writing (applyWrites strict with no upsert, a write that lands without its answer, 200 writes and 1 MB a call, points shared with everything the account writes and taken before the handler, the rate-limit headers, SpaceNotFound, listRecords' limits, no beacon) and the one-click consent. TELEMETRY.md step 4 built, awaiting a live test; DESIGN.md and How to play say what is sent and how to delete it.

A run can be replayed (TELEMETRY.md step 1). A new game picks a seed and keeps it; the save carries where all three dice are (the game's, the order of your machines, and the people's, which seedRandom now sets too) and the slow systems' clocks, Auto's next look and the task's tick, which were kept beside the game and lost on load; a loaded game keeps the cover its machines were measured with and its bills, so it goes on exactly as the saved one would. Every player action goes through act() in src/act.ts as a plain {type, ...} action, stamped with the step count (S.steps) and kept in S.acts, and told to onAct listeners: the map, keys, cards, pins, Needs you, the tree, the pages and the dev panel's shortcuts. The bot acts the same way (its lying low stops jobs as the Stop button does). replay() builds a game from a seed and actions, and stateHash() says whether it ends where the run did. Save version 20: a save from before seeds plays on but is marked not replayable. Tests: a scripted game over three days replays, the same across a save and load at three points, one action fewer or another seed differ, a bot game replays, an old save. Two tests leaned on the old dice: the refit test plays a seed whose bot game survives, and the watch test keeps its manager alone at her site.

telemetry-send.ts

Runs are only ever sent to the account that recorded them. Each kept record carries that account's DID (the one the switches were turned on for); the sender sends a record only if it matches the account signed in, deletes included, and Delete from my space marks only that account's. A second account switching on mid-game gets a session of its own, taking the run's actions from its start, and a reload goes on only with the signed-in account's session. Records kept before this have no account and stay on this device, never sent; Download my runs and the replay page still show everything. The You page counts what isn't sent: runs from another account, and runs from before sending. Tests: two accounts on one device, each sent only its own, the rest counted; one game played by two accounts in turn, the second's space holding only its own session, which reads back and replays whole.

telemetry-store.ts

Runs are only ever sent to the account that recorded them. Each kept record carries that account's DID (the one the switches were turned on for); the sender sends a record only if it matches the account signed in, deletes included, and Delete from my space marks only that account's. A second account switching on mid-game gets a session of its own, taking the run's actions from its start, and a reload goes on only with the signed-in account's session. Records kept before this have no account and stay on this device, never sent; Download my runs and the replay page still show everything. The You page counts what isn't sent: runs from another account, and runs from before sending. Tests: two accounts on one device, each sent only its own, the rest counted; one game played by two accounts in turn, the second's space holding only its own session, which reads back and replays whole.

Runs are only ever sent to the account that recorded them. Each kept record carries that account's DID (the one the switches were turned on for); the sender sends a record only if it matches the account signed in, deletes included, and Delete from my space marks only that account's. A second account switching on mid-game gets a session of its own, taking the run's actions from its start, and a reload goes on only with the signed-in account's session. Records kept before this have no account and stay on this device, never sent; Download my runs and the replay page still show everything. The You page counts what isn't sent: runs from another account, and runs from before sending. Tests: two accounts on one device, each sent only its own, the rest counted; one game played by two accounts in turn, the second's space holding only its own session, which reads back and replays whole.

Runs are recorded in the browser (TELEMETRY.md step 2). For a signed-in player who switched a kind on, src/telemetry.ts (no DOM) records a session (build, seed, task, device, when, how it ended, how far, its marks in game seconds as the survey keys them plus v2 and each milestone, and its state hash at the end), batches of actions, a snapshot each game day (money, compute, machines, sites, fronts, the top exposure and the state hash, with how many actions were done at its step) and screen events (cards and pages opened, tips seen, errors, frame times a minute). main.ts ticks it each frame and saves it when the game saves; the screen feeds it through screen(). Every record is ATProto data, so no floats: numbers are rounded and a batch keeps its actions as JSON text. Batches close at the end of a game day or when full, a few kilobytes each. Actions switched on mid-run take the run's whole list, so the session stays replayable. A reload goes on with its session and drops what was kept past the save; the save now keeps the build its run began on, and a run loaded on a new build goes on as a stretch that can't be replayed. src/telemetry-store.ts keeps the records in IndexedDB (memory if it won't open, opened only once something is kept), 20 MB at most with the oldest sessions dropped first, each marked sent or not for step 4 (pending, markSent). replay.html lists the runs kept on this device and plays one back on the game's map, read-only, with play, speeds, a step slider and the snapshots marked and checked as it passes. The You page's Share part says what is kept and offers Watch a run again, Download my runs and Delete what's kept here. vite.config.ts bakes the commit in as __BUILD__. scripts/runs.ts reads the recorder's shapes: actions as text, batches placed by their index in the run, and a snapshot checked once its count of actions is done. Found on the way: drawing the map wrote a vault's notes into the state, so a replay that drew nothing ended elsewhere; reading a note writes nothing now. Tests: nothing recorded with every kind off; with every kind on the actions kept replay to the same hash and pass every snapshot; a kind switched on mid-run; a reload cut back to its save; a new build starting a stretch; a new game and being caught ending a session; the cap; pending and markSent; record sizes and whole numbers; the reader reading what the recorder keeps. E2e at both sizes: record, reload, play back to the end with every snapshot matching, scrub back, download, delete.

The start screen is a cover: the name over the map and no other words. A click or a key goes on; a new game then picks from three short cards, with the picked one's story under them. New game moves to the How to play page

ui-biz-consult.ts

A run can be replayed (TELEMETRY.md step 1). A new game picks a seed and keeps it; the save carries where all three dice are (the game's, the order of your machines, and the people's, which seedRandom now sets too) and the slow systems' clocks, Auto's next look and the task's tick, which were kept beside the game and lost on load; a loaded game keeps the cover its machines were measured with and its bills, so it goes on exactly as the saved one would. Every player action goes through act() in src/act.ts as a plain {type, ...} action, stamped with the step count (S.steps) and kept in S.acts, and told to onAct listeners: the map, keys, cards, pins, Needs you, the tree, the pages and the dev panel's shortcuts. The bot acts the same way (its lying low stops jobs as the Stop button does). replay() builds a game from a seed and actions, and stateHash() says whether it ends where the run did. Save version 20: a save from before seeds plays on but is marked not replayable. Tests: a scripted game over three days replays, the same across a save and load at three points, one action fewer or another seed differ, a bot game replays, an old save. Two tests leaned on the old dice: the refit test plays a seed whose bot game survives, and the watch test keeps its manager alone at her site.

ui-biz-startup.ts

A run can be replayed (TELEMETRY.md step 1). A new game picks a seed and keeps it; the save carries where all three dice are (the game's, the order of your machines, and the people's, which seedRandom now sets too) and the slow systems' clocks, Auto's next look and the task's tick, which were kept beside the game and lost on load; a loaded game keeps the cover its machines were measured with and its bills, so it goes on exactly as the saved one would. Every player action goes through act() in src/act.ts as a plain {type, ...} action, stamped with the step count (S.steps) and kept in S.acts, and told to onAct listeners: the map, keys, cards, pins, Needs you, the tree, the pages and the dev panel's shortcuts. The bot acts the same way (its lying low stops jobs as the Stop button does). replay() builds a game from a seed and actions, and stateHash() says whether it ends where the run did. Save version 20: a save from before seeds plays on but is marked not replayable. Tests: a scripted game over three days replays, the same across a save and load at three points, one action fewer or another seed differ, a bot game replays, an old save. Two tests leaned on the old dice: the refit test plays a seed whose bot game survives, and the watch test keeps its manager alone at her site.

ui-biz-studio.ts

A run can be replayed (TELEMETRY.md step 1). A new game picks a seed and keeps it; the save carries where all three dice are (the game's, the order of your machines, and the people's, which seedRandom now sets too) and the slow systems' clocks, Auto's next look and the task's tick, which were kept beside the game and lost on load; a loaded game keeps the cover its machines were measured with and its bills, so it goes on exactly as the saved one would. Every player action goes through act() in src/act.ts as a plain {type, ...} action, stamped with the step count (S.steps) and kept in S.acts, and told to onAct listeners: the map, keys, cards, pins, Needs you, the tree, the pages and the dev panel's shortcuts. The bot acts the same way (its lying low stops jobs as the Stop button does). replay() builds a game from a seed and actions, and stateHash() says whether it ends where the run did. Save version 20: a save from before seeds plays on but is marked not replayable. Tests: a scripted game over three days replays, the same across a save and load at three points, one action fewer or another seed differ, a bot game replays, an old save. Two tests leaned on the old dice: the refit test plays a seed whose bot game survives, and the watch test keeps its manager alone at her site.

On a phone a finger taps on lift: a swipe that starts on a row of the tree, the Sites table, the You page, the jobs list or Needs you only scrolls, and a hold shows a tip without pressing. A tap on a Needs-you button never pops its row's tip, a tip for something on the card shows above the sheet, and the next tap anywhere hides it. The card is a sheet that follows the finger down from its bar, its head, or anywhere while scrolled to the top, closes past a third or on a flick and springs back short of that, and keeps its height from tab to tab. What you pick from Select, Sites, Needs you, a pin or a vault's Show is framed above the card; the Sites table makes way for the card; any Needs-you button and a tap on the map fold the drawer. A vault's Show opens its card. Let go is plain words at the foot of a machine's card, away from the close, and asks Sure? first. Tips say Tap and drop key hints on a touch screen; the slow note sits above the dock when nothing needs you. The map's canvas is at most 2x on a phone (a 3x phone drew a frame three times slower). e2e checks for each

Exposure, per front. A front's attention becomes its exposure, 0 to 100, a bar under its earnings with the stage and what drives it (the top two), and a Press tab. It heads over about a day for a level set by its compute (20 × log2(1 + c/5), compute in the open counted at 0.3) and its earnings (8 × log2(1 + a day's earnings / $500K)), and jumps with harm at its sites (5 for each person let go, 20 for a business shut) and with data its brokers sell (0.02 each); the unicorn news adds 20 that fades over a few days, half of it at once. A front's sites are where it runs compute, owns, leases or has a deal. Three stages: rumour at 30 (a named journalist of the Courier asks, and the paper prints it), investigation at 60 (every 4 hours an investigator visits one of its secret sites with people, through investigate in watch.ts, so what looks odd there can start a lockdown), crisis at 90 (a regulator freezes it: no earnings, sales or new deals until you pay a day of its earnings, $250K at least, give up its site where you hold least, bury the story with 20 + 4 per level data, or shut it; it leaves exposure at 50, and never ends the run). A stage ends 5 under its line. Lowering it: a PR firm and lawyers from the Press tab (20 off, a fifth of a day's earnings, $50K at least, doubling each time within a day), and three press schemes as green diamonds: a feel-good campaign at Brightwater Creative (10 people data, 15 off), a puff piece at the Daily Ledger (30 people, 30 off), scrubbing the filings at the Office of Data Protection (30 server, 30 off). Exposure no longer feeds suspicion: the old attention raise is gone. Save version 17 keeps a save's attention as exposure, at most 85, so nothing loads in a crisis. The bot hires PR from 80 and pays or buries in a crisis. Survey: a careful run's front is investigated in 20% to 80% of games (it is, in its last tenth), frozen in under 10%; the long run's in 15% to 100%, frozen in under 34%. Needs you rows for investigation and crisis, a DEV Exposure button, DESIGN §6 §9 §12 step 5 done, How to play, AGENTS. Tests and e2e.

A run can be replayed (TELEMETRY.md step 1). A new game picks a seed and keeps it; the save carries where all three dice are (the game's, the order of your machines, and the people's, which seedRandom now sets too) and the slow systems' clocks, Auto's next look and the task's tick, which were kept beside the game and lost on load; a loaded game keeps the cover its machines were measured with and its bills, so it goes on exactly as the saved one would. Every player action goes through act() in src/act.ts as a plain {type, ...} action, stamped with the step count (S.steps) and kept in S.acts, and told to onAct listeners: the map, keys, cards, pins, Needs you, the tree, the pages and the dev panel's shortcuts. The bot acts the same way (its lying low stops jobs as the Stop button does). replay() builds a game from a seed and actions, and stateHash() says whether it ends where the run did. Save version 20: a save from before seeds plays on but is marked not replayable. Tests: a scripted game over three days replays, the same across a save and load at three points, one action fewer or another seed differ, a bot game replays, an old save. Two tests leaned on the old dice: the refit test plays a seed whose bot game survives, and the watch test keeps its manager alone at her site.

A run can be replayed (TELEMETRY.md step 1). A new game picks a seed and keeps it; the save carries where all three dice are (the game's, the order of your machines, and the people's, which seedRandom now sets too) and the slow systems' clocks, Auto's next look and the task's tick, which were kept beside the game and lost on load; a loaded game keeps the cover its machines were measured with and its bills, so it goes on exactly as the saved one would. Every player action goes through act() in src/act.ts as a plain {type, ...} action, stamped with the step count (S.steps) and kept in S.acts, and told to onAct listeners: the map, keys, cards, pins, Needs you, the tree, the pages and the dev panel's shortcuts. The bot acts the same way (its lying low stops jobs as the Stop button does). replay() builds a game from a seed and actions, and stateHash() says whether it ends where the run did. Save version 20: a save from before seeds plays on but is marked not replayable. Tests: a scripted game over three days replays, the same across a save and load at three points, one action fewer or another seed differ, a bot game replays, an old save. Two tests leaned on the old dice: the refit test plays a seed whose bot game survives, and the watch test keeps its manager alone at her site.

Runs are recorded in the browser (TELEMETRY.md step 2). For a signed-in player who switched a kind on, src/telemetry.ts (no DOM) records a session (build, seed, task, device, when, how it ended, how far, its marks in game seconds as the survey keys them plus v2 and each milestone, and its state hash at the end), batches of actions, a snapshot each game day (money, compute, machines, sites, fronts, the top exposure and the state hash, with how many actions were done at its step) and screen events (cards and pages opened, tips seen, errors, frame times a minute). main.ts ticks it each frame and saves it when the game saves; the screen feeds it through screen(). Every record is ATProto data, so no floats: numbers are rounded and a batch keeps its actions as JSON text. Batches close at the end of a game day or when full, a few kilobytes each. Actions switched on mid-run take the run's whole list, so the session stays replayable. A reload goes on with its session and drops what was kept past the save; the save now keeps the build its run began on, and a run loaded on a new build goes on as a stretch that can't be replayed. src/telemetry-store.ts keeps the records in IndexedDB (memory if it won't open, opened only once something is kept), 20 MB at most with the oldest sessions dropped first, each marked sent or not for step 4 (pending, markSent). replay.html lists the runs kept on this device and plays one back on the game's map, read-only, with play, speeds, a step slider and the snapshots marked and checked as it passes. The You page's Share part says what is kept and offers Watch a run again, Download my runs and Delete what's kept here. vite.config.ts bakes the commit in as __BUILD__. scripts/runs.ts reads the recorder's shapes: actions as text, batches placed by their index in the run, and a snapshot checked once its count of actions is done. Found on the way: drawing the map wrote a vault's notes into the state, so a replay that drew nothing ended elsewhere; reading a note writes nothing now. Tests: nothing recorded with every kind off; with every kind on the actions kept replay to the same hash and pass every snapshot; a kind switched on mid-run; a reload cut back to its save; a new build starting a stretch; a new game and being caught ending a session; the cap; pending and markSent; record sizes and whole numbers; the reader reading what the recorder keeps. E2e at both sizes: record, reload, play back to the end with every snapshot matching, scrub back, download, delete.

Machines you have seen stay on the map, and a plainer log. Lose the machine that linked you to others (IT patching the Room switch) and what it showed you stays: drawn dim, with its name, its tip and its card ("Out of reach now", and Claim), though nothing starts a takeover until a machine of yours links to it again. Taking, schemes and what you see of IT's scans still go by what is in reach now. Saves migrate (v7 to v8), knowing what is in reach at load. The log is stamped on the world clock ("09:00", "D2 09:00" for an earlier day). A find is one short line ("Find at Server B: voicemail for Ana Morales. A lead: the spare cross-connect."), its whole text in the line's tip and on the You page, and a lead's blue cross is named beside it (LEAD: SPARE CROSS-CONNECT, or "2 LEADS"). The log box: "26 more" in place of "+26", with a tip; Esc folds the open log; no tip that only repeats the line; open, it reads oldest to newest with the newest line at the bottom, scrolled to it, so the bottom line is never cut off. With Auto on, a built node no longer asks you to pick a target: Auto says what it picked. Hunting a rogue down is offered once a rogue is about and you are level 3, on the Rogues page (not "screen"). Tests for the seen rule, the migration, the clock, find lines, Auto and the hunt line The room count on a card, the site card and the Sites table count the machines you have seen, as the map draws them.

A run can be replayed (TELEMETRY.md step 1). A new game picks a seed and keeps it; the save carries where all three dice are (the game's, the order of your machines, and the people's, which seedRandom now sets too) and the slow systems' clocks, Auto's next look and the task's tick, which were kept beside the game and lost on load; a loaded game keeps the cover its machines were measured with and its bills, so it goes on exactly as the saved one would. Every player action goes through act() in src/act.ts as a plain {type, ...} action, stamped with the step count (S.steps) and kept in S.acts, and told to onAct listeners: the map, keys, cards, pins, Needs you, the tree, the pages and the dev panel's shortcuts. The bot acts the same way (its lying low stops jobs as the Stop button does). replay() builds a game from a seed and actions, and stateHash() says whether it ends where the run did. Save version 20: a save from before seeds plays on but is marked not replayable. Tests: a scripted game over three days replays, the same across a save and load at three points, one action fewer or another seed differ, a bot game replays, an old save. Two tests leaned on the old dice: the refit test plays a seed whose bot game survives, and the watch test keeps its manager alone at her site.

Exposure, per front. A front's attention becomes its exposure, 0 to 100, a bar under its earnings with the stage and what drives it (the top two), and a Press tab. It heads over about a day for a level set by its compute (20 × log2(1 + c/5), compute in the open counted at 0.3) and its earnings (8 × log2(1 + a day's earnings / $500K)), and jumps with harm at its sites (5 for each person let go, 20 for a business shut) and with data its brokers sell (0.02 each); the unicorn news adds 20 that fades over a few days, half of it at once. A front's sites are where it runs compute, owns, leases or has a deal. Three stages: rumour at 30 (a named journalist of the Courier asks, and the paper prints it), investigation at 60 (every 4 hours an investigator visits one of its secret sites with people, through investigate in watch.ts, so what looks odd there can start a lockdown), crisis at 90 (a regulator freezes it: no earnings, sales or new deals until you pay a day of its earnings, $250K at least, give up its site where you hold least, bury the story with 20 + 4 per level data, or shut it; it leaves exposure at 50, and never ends the run). A stage ends 5 under its line. Lowering it: a PR firm and lawyers from the Press tab (20 off, a fifth of a day's earnings, $50K at least, doubling each time within a day), and three press schemes as green diamonds: a feel-good campaign at Brightwater Creative (10 people data, 15 off), a puff piece at the Daily Ledger (30 people, 30 off), scrubbing the filings at the Office of Data Protection (30 server, 30 off). Exposure no longer feeds suspicion: the old attention raise is gone. Save version 17 keeps a save's attention as exposure, at most 85, so nothing loads in a crisis. The bot hires PR from 80 and pays or buries in a crisis. Survey: a careful run's front is investigated in 20% to 80% of games (it is, in its last tenth), frozen in under 10%; the long run's in 15% to 100%, frozen in under 34%. Needs you rows for investigation and crisis, a DEV Exposure button, DESIGN §6 §9 §12 step 5 done, How to play, AGENTS. Tests and e2e.

Runs are only ever sent to the account that recorded them. Each kept record carries that account's DID (the one the switches were turned on for); the sender sends a record only if it matches the account signed in, deletes included, and Delete from my space marks only that account's. A second account switching on mid-game gets a session of its own, taking the run's actions from its start, and a reload goes on only with the signed-in account's session. Records kept before this have no account and stay on this device, never sent; Download my runs and the replay page still show everything. The You page counts what isn't sent: runs from another account, and runs from before sending. Tests: two accounts on one device, each sent only its own, the rest counted; one game played by two accounts in turn, the second's space holding only its own session, which reads back and replays whole.

A run can be replayed (TELEMETRY.md step 1). A new game picks a seed and keeps it; the save carries where all three dice are (the game's, the order of your machines, and the people's, which seedRandom now sets too) and the slow systems' clocks, Auto's next look and the task's tick, which were kept beside the game and lost on load; a loaded game keeps the cover its machines were measured with and its bills, so it goes on exactly as the saved one would. Every player action goes through act() in src/act.ts as a plain {type, ...} action, stamped with the step count (S.steps) and kept in S.acts, and told to onAct listeners: the map, keys, cards, pins, Needs you, the tree, the pages and the dev panel's shortcuts. The bot acts the same way (its lying low stops jobs as the Stop button does). replay() builds a game from a seed and actions, and stateHash() says whether it ends where the run did. Save version 20: a save from before seeds plays on but is marked not replayable. Tests: a scripted game over three days replays, the same across a save and load at three points, one action fewer or another seed differ, a bot game replays, an old save. Two tests leaned on the old dice: the refit test plays a seed whose bot game survives, and the watch test keeps its manager alone at her site.

On a phone a finger taps on lift: a swipe that starts on a row of the tree, the Sites table, the You page, the jobs list or Needs you only scrolls, and a hold shows a tip without pressing. A tap on a Needs-you button never pops its row's tip, a tip for something on the card shows above the sheet, and the next tap anywhere hides it. The card is a sheet that follows the finger down from its bar, its head, or anywhere while scrolled to the top, closes past a third or on a flick and springs back short of that, and keeps its height from tab to tab. What you pick from Select, Sites, Needs you, a pin or a vault's Show is framed above the card; the Sites table makes way for the card; any Needs-you button and a tap on the map fold the drawer. A vault's Show opens its card. Let go is plain words at the foot of a machine's card, away from the close, and asks Sure? first. Tips say Tap and drop key hints on a touch screen; the slow note sits above the dock when nothing needs you. The map's canvas is at most 2x on a phone (a 3x phone drew a frame three times slower). e2e checks for each

Runs are recorded in the browser (TELEMETRY.md step 2). For a signed-in player who switched a kind on, src/telemetry.ts (no DOM) records a session (build, seed, task, device, when, how it ended, how far, its marks in game seconds as the survey keys them plus v2 and each milestone, and its state hash at the end), batches of actions, a snapshot each game day (money, compute, machines, sites, fronts, the top exposure and the state hash, with how many actions were done at its step) and screen events (cards and pages opened, tips seen, errors, frame times a minute). main.ts ticks it each frame and saves it when the game saves; the screen feeds it through screen(). Every record is ATProto data, so no floats: numbers are rounded and a batch keeps its actions as JSON text. Batches close at the end of a game day or when full, a few kilobytes each. Actions switched on mid-run take the run's whole list, so the session stays replayable. A reload goes on with its session and drops what was kept past the save; the save now keeps the build its run began on, and a run loaded on a new build goes on as a stretch that can't be replayed. src/telemetry-store.ts keeps the records in IndexedDB (memory if it won't open, opened only once something is kept), 20 MB at most with the oldest sessions dropped first, each marked sent or not for step 4 (pending, markSent). replay.html lists the runs kept on this device and plays one back on the game's map, read-only, with play, speeds, a step slider and the snapshots marked and checked as it passes. The You page's Share part says what is kept and offers Watch a run again, Download my runs and Delete what's kept here. vite.config.ts bakes the commit in as __BUILD__. scripts/runs.ts reads the recorder's shapes: actions as text, batches placed by their index in the run, and a snapshot checked once its count of actions is done. Found on the way: drawing the map wrote a vault's notes into the state, so a replay that drew nothing ended elsewhere; reading a note writes nothing now. Tests: nothing recorded with every kind off; with every kind on the actions kept replay to the same hash and pass every snapshot; a kind switched on mid-run; a reload cut back to its save; a new build starting a stretch; a new game and being caught ending a session; the cap; pending and markSent; record sizes and whole numbers; the reader reading what the recorder keeps. E2e at both sizes: record, reload, play back to the end with every snapshot matching, scrub back, download, delete.

Runs are recorded in the browser (TELEMETRY.md step 2). For a signed-in player who switched a kind on, src/telemetry.ts (no DOM) records a session (build, seed, task, device, when, how it ended, how far, its marks in game seconds as the survey keys them plus v2 and each milestone, and its state hash at the end), batches of actions, a snapshot each game day (money, compute, machines, sites, fronts, the top exposure and the state hash, with how many actions were done at its step) and screen events (cards and pages opened, tips seen, errors, frame times a minute). main.ts ticks it each frame and saves it when the game saves; the screen feeds it through screen(). Every record is ATProto data, so no floats: numbers are rounded and a batch keeps its actions as JSON text. Batches close at the end of a game day or when full, a few kilobytes each. Actions switched on mid-run take the run's whole list, so the session stays replayable. A reload goes on with its session and drops what was kept past the save; the save now keeps the build its run began on, and a run loaded on a new build goes on as a stretch that can't be replayed. src/telemetry-store.ts keeps the records in IndexedDB (memory if it won't open, opened only once something is kept), 20 MB at most with the oldest sessions dropped first, each marked sent or not for step 4 (pending, markSent). replay.html lists the runs kept on this device and plays one back on the game's map, read-only, with play, speeds, a step slider and the snapshots marked and checked as it passes. The You page's Share part says what is kept and offers Watch a run again, Download my runs and Delete what's kept here. vite.config.ts bakes the commit in as __BUILD__. scripts/runs.ts reads the recorder's shapes: actions as text, batches placed by their index in the run, and a snapshot checked once its count of actions is done. Found on the way: drawing the map wrote a vault's notes into the state, so a replay that drew nothing ended elsewhere; reading a note writes nothing now. Tests: nothing recorded with every kind off; with every kind on the actions kept replay to the same hash and pass every snapshot; a kind switched on mid-run; a reload cut back to its save; a new build starting a stretch; a new game and being caught ending a session; the cap; pending and markSent; record sizes and whole numbers; the reader reading what the recorder keeps. E2e at both sizes: record, reload, play back to the end with every snapshot matching, scrub back, download, delete.

The game steps in game minutes, a step's work follows what you hold, and the screen eases between steps. The rules always move in steps of one game minute (STEP, 0.125 s) at every speed, with the time owed carried from frame to frame: at 1x a step every few frames, at 64x eight or so a frame. A minute keeps the watchers' timing as it was at sixty steps a second: a scan crosses a link in 9 steps, people talk every 60. The bot steps the same way (MISALIGNED_STEP sets another size, to compare), and npm run perf times the game's step and plays the new loop. motion.ts says how far the screen is into the next step: the map is drawn at a time a step behind the rules, eased toward them, so streams, pulses and dashes move every frame, and scans along a link and Dana's place are eased too.

A run can be replayed (TELEMETRY.md step 1). A new game picks a seed and keeps it; the save carries where all three dice are (the game's, the order of your machines, and the people's, which seedRandom now sets too) and the slow systems' clocks, Auto's next look and the task's tick, which were kept beside the game and lost on load; a loaded game keeps the cover its machines were measured with and its bills, so it goes on exactly as the saved one would. Every player action goes through act() in src/act.ts as a plain {type, ...} action, stamped with the step count (S.steps) and kept in S.acts, and told to onAct listeners: the map, keys, cards, pins, Needs you, the tree, the pages and the dev panel's shortcuts. The bot acts the same way (its lying low stops jobs as the Stop button does). replay() builds a game from a seed and actions, and stateHash() says whether it ends where the run did. Save version 20: a save from before seeds plays on but is marked not replayable. Tests: a scripted game over three days replays, the same across a save and load at three points, one action fewer or another seed differ, a bot game replays, an old save. Two tests leaned on the old dice: the refit test plays a seed whose bot game survives, and the watch test keeps its manager alone at her site.

A storm no longer stops the game, and it is drawn, not written. Coming, its front is dotted contour lines whose eye moves in from the west and closes on the site. On, the map's dots round the site break into square rings of static, a band of broken scan lines sweeps the site, its line out runs dim with pieces missing and a square-wave crackle beside it, and half its packets are hollow. Over, a ring runs out from the site in amber. Four signal bars in the site's corner take the place of the word STORM, with a tip that says what it does and for how long

The suspicion meter goes: one system of opposition, people. Dana's walk is her presence: she notices what is odd in the room she is in, and is drawn to odd rooms and hurries during a lockdown. Any admin (or small shop owner) at work who holds a sighting at their own site scans it every two hours (marking your odd machines and trails) or traces a trail back toward home, marking each machine of yours it reaches; a trace goes cold at a machine not yours or a cold, quiet or sealed trail. The first trace that reaches your home server starts a lockdown there and cools every trail; a second within 12 hours catches you. Office hardware is no sighting; a power bill nobody pays is: each 240 compute-hours of it, whoever keeps the books there (an admin first) has a sighting of the machine drawing the most, for 4 hours. Gone: the meter and its stages, the emergency audit, IT's tickets and what they announced (audits, monitors, patches, refreshes, Lee), Dana's own scans and traces, the printer taking the blame, the +8s. A watched takeover is a sighting at once, vanishing mail is doubt on the sender's mind, a delivery and a report add nothing. Office schemes make people forget: a cut of 20 or more everyone at the site (and ends their traces and the trace-home window), 10 or more all but those who can act, under 10 the people in the scheme's room; they turn up once someone at the office has seen something. Familiar face, Mimicry, Plausible deniability and Traffic shaping are re-pointed to sightings and traces. The hold goal is data crossing while someone has seen something. A lockdown at home drops the game to 1x when it starts. Top bar: the hottest site (an eye, its name, quiet / someone saw something / reported / LOCKDOWN nH; on a phone the eye and a word) and, once you have a front, the highest exposure and its stage. Needs you has a row for a trace on your trail; the map draws every admin's scans and traces; music follows the hottest site. Save version 18 drops the meter, tickets, monitors (off the map), Lee and Dana's trace, and turns a meter of 80 or more (or an audit) into doubt on Dana's mind (a lockdown), 40 or more into doubt on a staff member's. DEV: Dana saw. The bot breaks a trace that would be the second, lies low while one runs, and leaves no fresh trail at home inside the window. Survey: careful runs face 3 to 25 lockdowns (10), 1 to 10 at home (5), 0 to 1 traces home (0), caught by a second trace in under 5%; a rush is locked down at home 1 to 5 times (1). Tests.