What roadkeep-gui shipped.
Every entry in docs/CHANGELOG.md, read at 09496d1 and dated by the commit that wrote it.
- RG304 · b8ed6aaEnter in a session's reply box never sends it, so every answer takes a trip to the button
Enter sends a session's reply through the button's own send, Shift+Enter breaks the line, and a composing or held Enter starts no second turn (design recorded in
packages/ui/src/Session.tsx). - RG307 · 4287670the app has no public page, so a release is reachable only by somebody who already knows the repository
A prerendered site in site/ with a Markdown twin per route, every count read from the source at build time, and a Pages deploy that runs only when started.
- RG303 · 3598701a reply typed into a session is never drawn in its stream, so what was asked of it is gone once sent
A reply typed into a session is kept as a line of its stream, drawn as the person's own words wherever that session is read (design recorded in
packages/core/src/session.ts). - RG302 · 11a45d8show refuses every shipped entry: its reader holds the pointer to a string, and a ledger line carries none
showreads a shipped entry, whose pointer comes back null because shipping deleted the design it named. - RG301 · 5d69741a walkthrough is asked through askGloss, so the module that runs every read-only question is named after one of them
The read-only query is named for what it is, so no name on the path a walkthrough takes says gloss (design recorded in
packages/shell/src/question.ts). - RG300 · 3255482no shot fixture keeps an answer, so a kept gloss's notices and the walkthrough dialog are drawn by no picture
The shots run keeps an answer first, so both dialogs are photographed on one: a gloss old two ways, a walkthrough and its verdicts (design recorded in
packages/shell/src/shots-kept.ts). - RG299 · 0a12d07an explanation nests a paragraph inside a paragraph, which React reports as invalid HTML on every answer
The explanation wraps prose in a block wherever it draws it, so no paragraph holds one and React reports no invalid nesting.
- RG298 · a19627fnpm run dev:inspect opens its first window without the debugging port, so Playwright MCP reaches it only after a restart
The first window a development run opens carries the debugging port, so Playwright MCP reaches it with nothing touched.
- RG297 · bc46de9an explanation being written shows only the last files read, so a slow run cannot be told from a stuck one
The waiting explanation draws the run's own stream with the session's rows, beside a clock of how long it has been asked (design recorded in
packages/ui/src/stream.tsx). - RG296 · b06342ea project row says what is open and nothing about what shipped with nobody looking at it
A project row carries how many shipped entries await a person, off the count stats already answers, and none where the engine does not say (design recorded in
packages/core/src/portfolio.ts). - RG295 · e0340b8a validation that failed ends in a sentence nobody files, so the defect it found is lost at the dialog
A failed verdict files the sentence as an open line in the same call, and the offer is absent where the engine lacks the flag (design recorded in
packages/ui/src/useVerdict.ts). - RG294 · b11a548a person who followed a walkthrough has nowhere to say what happened, so the verdict never reaches the ledger
Three answers under the steps send a verdict and a sentence through validate, and the list is asked again once one lands (design recorded in
packages/ui/src/checking.tsx). - RG293 · c11e1fanothing on a project surface says what is shipped and unlooked-at, so the list lives in a terminal
A tab beside the ledger draws what awaits a person newest first, says which of three ways it is empty, and opening a row asks (design recorded in
packages/core/src/validation.ts). - RG292 · b64e1c9a walkthrough is lost when the sheet closes, and the sheet is closed by the person going off to follow it
A walkthrough is kept per entry and language, so coming back costs nothing, and reads as old once the entry ships from another commit (design recorded in
packages/core/src/walkthroughs.ts). - RG291 · d9a7b6ca person told a line is unvalidated has to work out how to check it from one sentence in the ledger
A run reads the commit that shipped an entry and answers steps a person can follow, or says there is nothing to open (design recorded in
packages/core/src/walkthrough.ts). - RG290 · 245c21fa gloss kept before an answer grew a slot says nothing under it, and reads as current
A gloss written under an earlier shape reads as old under its own sentence, apart from one whose line moved (design recorded in
packages/core/src/glosses.ts). - RG289 · 216066bthe app can neither ask which entries await a person nor record a verdict: neither verb is in its tables
Both validation verbs are in the tables with the shapes a live fixture proved, and a build with neither is reported as offering neither (design recorded in
packages/core/src/writes.ts). - RG288 · 6a68ec2an explanation answers from the brief alone, so it cannot say where in the code the work lands or what it will touch
A gloss reads the files its design names and says where the work lands, a lane per folder (design recorded in
packages/shell/src/question.ts). - RG287 · a7c1603an explanation is lost when its dialog closes, so reopening a task pays the whole wait and the tokens again
A gloss is kept per line and language, so reopening a task shows it at once; it reads as old once the brief moved, and Regenerate asks anew (design recorded in
packages/core/src/glosses.ts). - RG286 · 3b5eec6an explanation reads as a column of paragraphs, while a task's chain, its before and after and its steps are shapes
The explanation is drawn as shapes: a chain off the brief, before against after, the steps as a path (design recorded in
packages/ui/src/explained.tsx). - RG285 · 4e04400the task screen offers no plain account of a task, only the line and a design written for whoever builds it
The task screen has an Explain action: a plain-words account of the line, in the window's language, naming who wrote it (design recorded in
packages/ui/src/explain.tsx). - RG284 · 60ba68dthe only door that puts a task before Claude Code is a session that may write, too much to ask what a task means
A task can be asked of Claude Code as a read: one query with no tool, nothing kept, answered against a schema (design recorded in
packages/shell/src/question.ts). - RG283 · 75b50a4nothing asks Claude Code what a task means in plain words, so a line and its design are read in their own terse terms
A brief can be asked of Claude Code as a gloss for a newcomer, read back keyed by the ids and leads the brief carries (design recorded in
packages/core/src/gloss.ts). - RG282 · 406001aan edited file opens as it is now, with no view of it against what it was before the session
An edited file opens on itself against what it was before the session, line by line, inline or side by side (design recorded in
packages/core/src/compare.ts). - RG281 · 27f117fa file that moved on disk while the session ran never says whether it appeared, changed or went away
Each file that moved on disk says whether it appeared, changed, went away or came and went, off the stat the watch already made (design recorded in
packages/core/src/watching.ts). - RG280 · 6b25795an edited file's row never says whether the session created, changed or deleted it
Each edited file's row says whether the session created, changed or deleted it, off the answer its own call came back with (design recorded in
packages/core/src/acts.ts). - RG279 · 23075fethe session screen's side bars are 18rem whatever they hold, so a long path is cut and the stream cannot be widened
A session side bar keeps the width its edge was dragged to, in settings.json rather than in the browser (design recorded in
packages/ui/src/session-cards.tsx). - RG277 · ed1b32athe session screen's side cards stay where the grid puts them, and cannot be dragged to the other side or reordered
A session card moves by its title grip, by pointer or keys, to a place drawn as an insertion line, and settings keep the move (design recorded in
packages/ui/src/session-cards.tsx). - RG276 · b0d0eabthe settings file has nowhere to keep how the session screen's cards are arranged, so none outlives the window
settings.json keeps the session cards as sessionLayout, repaired card by card on read, with a pure moveCard and a strict preference row (design recorded in
packages/core/src/settings.ts). - RG275 · 4c1df2ba session a task hands over grows the page with every act, where one the gate hands over scrolls in its stream
A task's session scrolls inside its stream like the gate's: the region mounts with its first act and is measured then (design recorded in
packages/ui/src/Session.tsx). - RG273 · dddea38a session runs on a hand-written copy of Claude Code's stream protocol, so each change to it is this app's to chase
Sessions run through the Agent SDK, keeping the same record, the person's own claude, and settings and system prompt named (design recorded in
packages/shell/src/session-process.ts). - RG272 · be63e0ea running session is refused every call that needs permission, and the person watching is never asked
A running session's permission questions reach the window: allowed once, for the session or declined from under the stream, kept as lines, and the session drawn as asking.
- RG271 · a058fbaa session's words are drawn with their Markdown literal, so bold, code and lists read as asterisks and backticks
A session's words and its last word render as Markdown (react-markdown, GFM): no raw HTML, no image fetched, links through the guard, wide code scrolling in the stream by keyboard too.
- RG270 · 18ee93ba tool call the session was refused is never shown, and nothing lets a person allow it for the next turn
Each refused call is drawn under the stopped session, and a checked one goes with the reply as --allowedTools for that turn alone (design recorded in
packages/core/src/session.ts). - RG269 · fa4beeda session that stopped to ask something cannot be answered from the window, only from a terminal with its id
A stopped session is answered from the window: the reply resumes it by its own id under the same key, beside its last words (design recorded in
packages/core/src/session.ts). - RG268 · e07af00a session that ends its turn waiting on a person is drawn as done, so a stalled task reads as finished
A turn that ended with a call refused is waiting, and a line session that ended without shipping is drawn as a stop, never as done (design recorded in
packages/core/src/landing.ts). - RG267 · d050ca7the shortcuts sheet lists / for the palette, which nothing binds, and a palette opened by its key searches nothing
The window binds the package's shortcut set, which its sheet reads, and a key opens the palette the way the button does (design recorded in
packages/ui/src/Shell.tsx). - RG266 · 78ff857leading from an edit to its act is never checked to scroll, and throws unhandled in every unit run
The unit setup gives jsdom a scrollIntoView that records what it was asked, so leading from an edit to its act is asserted and the run is clean (design recorded in
packages/ui/src/scroll-record.ts). - RG265 · 480f33athe files a session touched are two flat lists of full paths, sharing a panel with what moved in the backlog
The files a session touched take a card of their own as the design system's Tree, each folder open unless the reader closed it (design recorded in
packages/ui/src/Session.tsx). - RG264 · cba0820a session handed a gate finding is drawn in the reading column, since the width table names one session route
Every route the session screen answers takes the window's width, and a guard reads which those are off the router's own table (design recorded in
packages/ui/src/column.ts). - RG263 · ede0301a door that reads prose has only a box, so the reader who cannot write it has no way to hand it over
A finding and the door that closes it start a Claude Code session, which writes the prose and runs that command itself (design recorded in
packages/core/src/session.ts). - RG262 · 7c8b334the running gate is a sentence that never changes, so a slow run and a window that stopped read the same
A run draws a bar against the deadline that bounds it, with the seconds gone and the seconds it has said beside it (design recorded in
packages/ui/src/Gate.tsx). - RG261 · 3a19480a door whose value is - reads prose on standard input, which no screen asks for and no call ever closes
A door's - is a blank the screen asks for as prose and the shell writes to standard input, which every call now ends (design recorded in
packages/core/src/doors.ts). - RG260 · e461d2bthe window's gate run and a door's carry no deadline, so a call that hangs leaves the screen running for good
The window's lint and a door's command line take the declared deadline, and a door that did not answer is said above the report (design recorded in
packages/ui/src/useGate.ts). - RG259 · eaecceaa door's button says Take it, so the control that runs a command line reads as accepting the finding
The button says Run the fix, Executar conserto in Portuguese, so a control that spawns the engine's own command line no longer reads as accepting the finding.
- RG258 · c937677a finding's code is a bare token, so what a class like ref.unresolved means is still looked up in a terminal
A finding's code opens on what explain says the class is, read once per code and only where this build answers it (design recorded in
packages/ui/src/Gate.tsx). - RG257 · caee50ethe Portuguese verdict divergente names no check, so a reader takes six findings for six items that diverged
The Portuguese verdict is reprovada, the word this catalogue already uses for what the gate does, so the pill, the chip and the gate screen share one family.
- RG256 · a4fffd2a row's gate verdict is plain text, so the findings it counts are reached only by guessing Run the gate holds them
A read row's verdict and count link to that project's gate, named by the project, and a row with nothing to open keeps its text (design recorded in
packages/ui/src/Portfolio.tsx). - RG255 · 3813277the project screen says nothing of its gate, so findings counted on its portfolio row vanish one click later
The gate is the project's last tab, labelled with the ledger's count, and its own address opens the project on it (design recorded in
packages/ui/src/Project.tsx). - RG254 · b1a8845the gate opens on a count when its verdict is fresh, so the findings it counts appear only after a second run
A drifted verdict opens on its rows: the gate runs as the screen opens, with the held count still drawn, and a clean one still runs nothing (design recorded in
packages/ui/src/useGate.ts). - RG253 · bd77f0agate verdicts are forgotten at quit, so every launch runs lint once per project before a row has a verdict
A verdict comes back where the files and the engine are the ones it was taken with, so a launch runs no lint for a project nobody touched (design recorded in
packages/core/src/gate.ts). - RG252 · 880a52da remembered row is still read in full behind the screen, so a launch spends every interpreter a cold start did
A remembered row is kept by resolving the engine and stamping the files, and the project is opened only when something needs it (design recorded in
packages/core/src/readings.ts). - RG251 · 7618b23every launch reads every backlog again, so the portfolio shows skeletons until the slowest engine answers
A launch draws the counts and next line each verb printed last time, marked and checked against the files, while the reads behind them run (design recorded in
packages/core/src/readings.ts). - RG250 · bf5b616a launch starts every project's engine at the same moment, so twenty projects pin the machine together
A cold start reads one project per four cores at a time, or the number the settings name, so twenty projects no longer start every engine at once (design recorded in
packages/core/src/limits.ts). - RG249 · 5c0a7baa portfolio read has no deadline, so one project whose engine hangs keeps every row's next line pending
Every read on the launch path runs under the declared deadline, so a hung engine becomes an unreadable row and the next stage goes on without it (design recorded in
packages/core/src/limits.ts). - RG248 · da6809ca walk that lands after the list is drawn sets every row back to pending, so the portfolio loads twice
A walk landing after the list is drawn keeps every row it filled, adds what it found and drops what it lost, not loading the list twice (design recorded in
packages/core/src/portfolio.ts). - RG247 · aa17637files a session changed through a command and not an edit call appear nowhere on the session screen
The root is watched while the session runs, and what moved that no edit call named is listed, counted and dated, each opening in the viewer (design recorded in
packages/core/src/watching.ts). - RG246 · 6165c02the file viewer shows a file as it is now and not what the session changed in it
The viewer draws what each edit call replaced and put there, in stream order, and says whether it is in the file now (design recorded in
packages/core/src/acts.ts). - RG245 · c50fae3a file the session edited cannot be opened from the window, so reading it means leaving for an editor
A row opens the file as the disk holds it now, numbered and uninterpreted, and says in this app's words why a file was not read (design recorded in
packages/ui/src/file-sheet.tsx). - RG244 · d992f58an edited file is listed on the session's word, so a call that reported success and changed nothing looks the same
Each edited file is asked of the disk under the session's root, and a call that reported success on an unchanged file is flagged (design recorded in
packages/shell/src/edited-at.ts). - RG243 · e228eeathe session screen does not list the files the agent edited, so what it changed is found by reading the stream
What moved lists each file the session's edit calls named, counted, marked governed and failed, as the session's own account (design recorded in
packages/core/src/acts.ts). - RG242 · e24fc90the task and session screens do not show which project they belong to, so finding out means going back
Task, session, files and gate name their project above the title with the portfolio's chip, and the session adds a crumb back to its line (design recorded in
packages/ui/src/trail.tsx). - RG241 · 6a34317the order a person picks for the portfolio is gone at the next launch, so the table opens in the record's order again
The portfolio opens in the order last chosen: settings keep it as portfolioOrder, and an unknown value resets with a notice (design recorded in
packages/core/src/settings.ts). - RG240 · 01d913athe portfolio cannot rank projects by how many lines they have open, so the heaviest backlog is found by reading
The Backlog head ranks the portfolio by open lines, most first, then fewest; uncounted rows follow, and places hold while reads land (design recorded in
packages/core/src/portfolio.ts). - RG239 · ee5df21the portfolio lists projects only in the record's order, so finding one by name means reading every row
The Project head orders the portfolio by name, A to Z, Z to A, then the record's; numbers read as numbers and ties keep the record's order (design recorded in
packages/core/src/portfolio.ts). - RG238 · 5e00212the ground control in the header is a sentence, where Turing wears the design system's icon toggle
The header's ground is the design system's ModeToggle in this app's words, and a choice from any control reaches the settings file (design recorded in
packages/ui/src/ground.tsx). - RG237 · 870d96fthe session is held to the reading column, so its stream between two side columns is left about 360 pixels
The session takes the window's width by the shell's column table, its stream between two side bars from xl and beside both below it (design recorded in
packages/ui/src/column.ts). - RG236 · c8991c1npm run dev and npm start open a window wearing Electron's atom, though build/icon.svg is the app's mark
An unpackaged window names build/icon.png, the render of build/icon.svg, so npm run dev and npm start wear roadkeep's mark (design recorded in
packages/shell/src/window-icon.ts). - RG235 · df4b728on a task, Copy the brief sits higher than Hand to Claude Code beside it, so the hero's two actions share no line
A hero's actions meet at their tops, so Copy the brief and Hand to Claude Code share one line, measured in Chromium (design recorded in
packages/ui/src/hero.tsx). - RG234 · ab7e161the fast suite re-transforms every module on every run, and nothing caches that between runs
Each project keeps its transforms in node_modules/.vitest-cache: core halves, shell and ui drop, and the whole run is setup-bound and unchanged (design recorded in
vitest.config.ts). - RG233 · 2010a44CLAUDE.md and the roadmap skill give opposite commit rules, and both are loaded every turn
CLAUDE.md and the skill give one commit rule, and the row names the shared checkout and what staging by path costs (design recorded in
CLAUDE.md). - RG232 · 17b4f70a task test failed once inside a full run and left no message, so nobody can tell what it waited on
A red run keeps its message in .vitest/failures/, and a loaded worker can meet the renderer's wait budget (design recorded in
packages/shell/src/failure-report.ts). - RG231 · 4c2b9ebthe shortcuts button still shows at 400 wide, which RG215 meant to hide
The shortcuts button is hidden below sm by a wrapper span, and a browser test holds each width-dependent part of the header at 400 and 1280.
- RG230 · 29851a5a responsive class beside a base class the design system ships is overridden at every width, and no gate sees the pair
npm run lint fails a responsive class whose base partner the package ships and it does not, naming both and the form that wins.
- RG229 · dfc99b0at 1280 a project's lines are stacked into one column, which RG223 meant only for phone width
A project's rows are the desktop grid with a max-sm override, measured three columns at 1280 and one at 400 in a browser.
- RG228 · 6245aa7at 400 wide the sessions list draws its headings over each other and cuts each project name to a letter
Below sm the sessions list hides its headings and stacks each row, so at 400 wide a project's name is whole and nothing is drawn over it.
- RG227 · 3b6d5aethe shell drawing's rail draws five tiles against the window's three, and no rail tile is marked
Both shell drawings draw the window's three rail tiles, each marked, and artboards.test.tsx compares the rail tile for tile as it does the header.
- RG226 · 7fa9337tests fail inside a full run and pass on their own, so a red gate can mean the machine was busy
A close and a failed launch answer once the process listing shows nothing on their profile, and four full live runs came back green (design recorded in
packages/shell/src/shots-app.ts). - RG225 · 4340532at 400 wide the session opens on two panels, so the stream a reader came for starts below the fold
The session writes its stream first and places each column at lg, so at 400 wide the newest act is inside the window and 1280 is unchanged.
- RG224 · 0ed84ccthe phone-width run draws every surface in English, so a sentence that overflows only in Portuguese passes
The phone-width run measures every surface in each language LOCALE_TAGS ships, so a sentence that overflows only in Portuguese fails it.
- RG223 · 59aa406a line's symptom is one letter per line at 400 wide, the column left about ten pixels
Below sm a line's row and a ledger entry stack into one column, so at 400 wide the symptom reads across the card in all four tabs.
- RG222 · ae06ae8npm run shots builds the shell alone, so a changed screen is photographed from an older renderer bundle
The shots run builds the renderer it photographs, and a bundle older than the tree refuses the run whichever half of the build is stale (design recorded in
packages/shell/src/freshness.ts). - RG221 · 2bb7fbcthe rail draws only Home, so the settings and the sessions are reached through the palette alone
The rail draws a tile for the sessions and one for the settings beside Home, each leading to its surface and named in both languages (design recorded in
packages/ui/src/areas.ts). - RG217 · 661537athe stream region is taller than the space under the hero, so its end and the jump control sit below the fold
The stream takes the room measured under its own top, so at 1280 by 800 its newest act and the way back are inside the window (design recorded in
packages/core/src/follow.ts). - RG216 · 589abfca count of one is written as a plural, so the portfolio says 1 projetos and 1 lidos
Every number a screen draws agrees with the words beside it: a row of counts is one key each, joined, and a hole a word agrees with is named count (design recorded in
packages/core/src/wording.ts). - RG215 · 56c4a60the header and a hero's actions do not fit at 400 wide, so every surface scrolls sideways at phone width
Every surface is 400 wide at 400 in both languages: the header narrows, a hero's actions wrap under the title, and a path breaks (design recorded in
packages/ui/src/hero.tsx). - RG214 · 1b53a2bno test asks whether a surface scrolls sideways at 400 wide, or whether Tab walks its controls in reading order
Chromium measures every routed surface: no sideways scroll at 400, Tab in reading order, a focus ring in both grounds (design recorded in
packages/ui/src/surfaces.browser.test.tsx). - RG220 · 876007fa screenshot launch that fails before the window draws leaves its Electron process running
A screenshot launch that fails before drawing ends its whole Electron tree, and close does the same past its ceiling (design recorded in
packages/shell/src/shots-app.ts). - RG219 · 01b6ae8the detail and graph tests hunt this backlog for a line waiting on outside work, so a backlog without one reddens them
A fixture files a line waiting on outside work, and the detail and graph tests read it there instead of hunting this backlog (design recorded in
packages/shell/src/fixture.ts). - RG218 · 5c32b29the release tag test runs whichever bash is first on PATH, and on Windows that can be WSL's, which has no node
On Windows the release tag test runs Git's bash, found beside git.exe, so WSL's launcher first on PATH no longer fails it (design recorded in
packages/shell/src/git-bash.ts). - RG213 · 038d1eathe renderer's tests run in jsdom alone, so a test about scroll, overflow or focus order asserts numbers it invented
RG206's follow tests run in headless Chromium, wheel and phone width included, and fail once CSS stops bounding it (design recorded in
packages/ui/src/session.browser.test.tsx). - RG212 · f7c3688an agent checking a screen improvises its own harness, and nothing says what to look for once it has the pictures
A screens skill says how to look and what to check, CLAUDE.md gates on npm run shots, and Playwright MCP attaches to dev:inspect (design recorded in
.claude/skills/screens/SKILL.md). - RG211 · 2e2b3e7no accessibility check runs over a rendered surface, so a defect only real layout and colour show ships green
npm run shots scans every surface with axe and a chosen-state rule in both grounds, and fails on a serious finding nobody excused (design recorded in
packages/shell/src/accessibility.ts). - RG210 · c24033athe session screen only draws behind a real Claude Code run, so its stream, scroll and folded notes are checked blind
An unpackaged app takes ROADKEEP_AGENT, and npm run shots photographs a scripted session following, scrolled and folded (design recorded in
packages/shell/src/scripted-agent.ts). - RG209 · 0745cf2no command shows what a screen looks like, so an agent checks a screen change with tests that never see the window
npm run shots photographs every routed surface through Playwright, in both grounds, both languages and two widths, indexed (design recorded in
packages/shell/src/shots-app.ts). - RG208 · ad5dcdathe session stream draws every system note, init to token counts, between the acts a reader follows
A sessionNotes preference folds each run of system notes into one counted row whose disclosure keeps every note; the default still draws each (design recorded in
packages/core/src/acts.ts). - RG207 · 37a6c23no settings screen, so the ground and the language are loose header controls and a new preference has nowhere to go
A settings screen writes ground and language through one savePreference over a core table; anything outside it is refused aloud (design recorded in
packages/core/src/preferences.ts). - RG206 · d91e965the session stream does not follow new acts, so a running task is read by scrolling the page by hand
The stream scrolls in its own region and follows its end; scrolling up stops it and offers Jump to latest with what arrived since (design recorded in
packages/core/src/follow.ts). - RG205 · 1e57698a session bills an ANTHROPIC_API_KEY the machine carries, not its Claude Code login, and dies for lack of credit
A session runs on the Claude Code login: where auth status answers without ANTHROPIC_API_KEY the child no longer inherits it, and a machine with only the key keeps it.
- RG204 · d9f1771an emoji is the only icon a row can draw, so a project with a logo file cannot show it
A declared logo is resolved and read where the disk is, and the renderer gets a picture or nothing (design recorded in
packages/shell/src/project-logo.ts). - RG203 · e2822d5a declared name is read from the checkout, so a project reverts to its folder name as it goes missing
The record keeps the name a project last declared, so a row that goes grey keeps its identity (design recorded in
packages/core/src/catalogue.ts). - RG202 · 1db40c8five screens still name a project by its folder, so a declared name vanishes the moment one is opened
Four screens take the name off the config they opened with, and the session list keeps the folder (design recorded in
packages/core/src/portfolio.ts). - RG201 · abc5f46a row says a path and never what the project is for, so seventeen rows read as seventeen paths
A row's second line says what the project is for where it declares one, and the path keeps its tooltip (design recorded in
packages/ui/src/Portfolio.tsx). - RG200 · d3867edevery project chip is the same folder glyph tinted by a hash, so no row is recognisable at a glance
The chip draws the emoji the project declared, and keeps the folder glyph where nothing does (design recorded in
packages/core/src/portfolio.ts). - RG199 · 166b85fnothing on a row says which branch a worktree is on, so a declared name renders a family as identical rows
A worktree's row says which branch it is on, read off git's own HEAD, and a short sha where detached (design recorded in
packages/shell/src/git-worktree.ts). - RG198 · cc9056ea row is named by its folder, so two worktrees of one product read as 2026.3 and 2026.2
A row is named what the project calls itself, off the config it was opened with, and the folder where nothing says (design recorded in
packages/core/src/payloads.ts). - RG197 · 277085aa live row test needs this backlog to be a different size from a fixture, and shipping made them equal
Two counts are compared between two fixtures whose sizes this file declares (design recorded in
packages/shell/src/portfolio-live.test.ts). - RG196 · 8e6c807the graph test hunts this backlog for a blocked line, so draining the backlog reddens three assertions
The edges finishing work removes are read from a fixture that holds still, not from this backlog (design recorded in
packages/shell/src/graph-live.test.ts). - RG195 · 065d7f2the fixture hands out an unresolved temp path, so a live assertion fails on a Windows account with a short name
The fixture hands out the spelling the filesystem uses, so an assertion compares one place with itself (design recorded in
packages/shell/src/fixture.ts). - RG194 · c4652aano public page says who may request a signature and what gets signed, so the certificate cannot be applied for
The page the terms ask for is written (design superseded: there is no README here, so SIGNING.md links it) (design recorded in
docs/CODE-SIGNING-POLICY.md). - RG193 · ebcceaaan engine too old for
configreads as an unreadable answer, so a row shows a usage dump and no versionA config the build does not publish names that build and its version, in the window's language (design recorded in
packages/core/src/opening.ts). - RG190 · 78f8f23a handover landing after the reader left the task screen moves the window to the session anyway
A handover that lands after the reader left the task screen no longer moves the window (design recorded in
packages/ui/src/Task.tsx). - RG170 · ae5c2d1list prints no readiness per line, so every row costs a deps read and startable only cannot be offered
A row reads readiness off the listing, and startable only is the flag list takes (design recorded in
packages/core/src/payloads.ts). - RG162 · b666f0eno LICENSE file ships and every build says 0.0.0, so the first release the maintainer decided on cannot be cut
v0.1.0 is published, with both installers, from a tag whose CI was green on Windows and Linux.
- RG154 · 101b30ethe update check has only met answers written by hand, never GitHub's own for a published release
The check is held against GitHub's own payload for v0.1.0, and a run that cannot reach it says so (design recorded in
packages/shell/src/updates-live.test.ts). - RG147 · ebead45the palette says it finds a line in every backlog and lists only surfaces, so search over all projects reaches no one
The palette offers the lines search returned, from every backlog read, and says what it does not cover (design recorded in
packages/ui/src/useSearchable.ts). - RG128 · dd2dcbba checkout busy when the probe runs is skipped, so the launcher answers from a cache 446 versions old
No engine is named here, the stale clone is gone, and resolution reaches the sibling under development (design recorded in
.claude/settings.json). - RG192 · d26b7d3two screens draw the English a failed bridge call carried, a field whose code no catalogue entry covers
The carrier's refusals carry a code, so a screen says them in the window's language and quotes only the prose nobody translates (design recorded in
packages/core/src/bridge.ts). - RG191 · ce4193da screen drawing a field this app wrote in English passes every run that does not reach the state showing it
One pass over the renderer fails on any read of a field tagged
@notForScreen, naming what to draw instead (design recorded inpackages/shell/src/screen-prose.ts). - RG189 · 0536202a cache entry refreshed against a new stamp keeps its old place, so eviction takes the entries being used most
A refreshed entry moves to the end, so eviction takes what nobody has asked for since (design recorded in
packages/core/src/cache.ts). - RG188 · 6ba53a1a payload key spelled __proto__ is dropped by the dictionary reader, so a count vanishes and the read still answers ok
A dictionary is read into a table with no prototype, so no key is swallowed and none is inherited (design recorded in
packages/core/src/reading.ts). - RG187 · 47d649dthe carrier gates every project as it opens, so a cold start over seventeen starts seventeen lints at once
A launch gates one project at a time, so the rest of the machine goes to what the reader is looking at (design recorded in
packages/shell/src/carrier.ts). - RG186 · 1006995the duplicates gate matches on export, so a screen redeclaring a design-system name for its own use passes it
A name the design system publishes is refused here whether or not anything exports it (design recorded in
packages/ui/src/duplicates.test.ts). - RG185 · 0eb8c66the gate surface runs lint every time it opens, though the ledger already holds a verdict the files have not moved under
The gate surface opens on the verdict the ledger holds, and runs where one would say something new (design recorded in
packages/ui/src/useGate.ts). - RG184 · 3c5cfc2a source file carrying control characters passes every gate, so an invisible byte reaches a commit
No file this repository owns carries an invisible byte (design superseded: it is a fast test, since reading bytes starts nothing) (design recorded in
packages/shell/src/bytes.test.ts). - RG183 · 76613a6a catalogue key no screen says is never reported, so a string both locales declare can be dead
A key the catalogue declares and no screen says is reported, and the five that were dead now draw (design recorded in
packages/ui/src/keys.test.ts). - RG182 · 3a287c8the filing form asks nobody what the block already delivered, so the window spends an id the terminal would question
The filing form ranks what the block already has against the symptom, and each line opens (design recorded in
packages/ui/src/useFiling.ts). - RG181 · 451c28ethe door keep holds every batch a session offered, since only a file moving drops one
The keep holds one batch per project, which is the only one a screen still has a button for (design recorded in
packages/shell/src/door-keep.ts). - RG180 · 7ee5f00nothing says when the walk behind the remembered record landed, so a project found or lost shows on the next ask
The window hears the walk behind the record land, where the fold moved something, and reads again (design recorded in
packages/core/src/bridge.ts). - RG179 · a86f1acan amend that changes deps or requires reads as unreadable, though the file was already written
An amend that changes a list field reads, since the was of a list field is a list (design recorded in
packages/core/src/reading.ts). - RG178 · 99056a9the sessions list asks once when it opens, so one that ends while it stands still reads as running
The sessions list hears every session through one key meaning all of them, and reads again when one speaks (design recorded in
packages/ui/src/Sessions.tsx). - RG177 · 2c77107a time is written in the desktop's locale and not the window's, so a Portuguese window dates a file in English
A time is written in the language the window speaks, from the one place that turns a stamp into a string (design recorded in
packages/core/src/wording.ts). - RG176 · 7bf4964the pseudo-locale run draws the portfolio alone, so three of this window's four surfaces are never read for a literal
Every surface the route table names is read under the pseudo-locale, not the portfolio alone (design recorded in
packages/ui/src/wording.test.tsx). - RG175 · dd3625fa line this window handed over is offered to a second session, since the claim it took names nobody
A line this window has a session running on is not offered a second one; the way back to it is (design recorded in
packages/core/src/handover.ts). - RG174 · e188dd3a line's own criteria never reach its task screen, so what the ship must check reads as the block's finish line alone
A line's own criteria reach its screen as their own group, each folded lead naming where it came from (design recorded in
packages/core/src/payloads.ts). - RG173 · ffb0dc9a dep or a chain hop on the task screen is text, so reaching the line it names means going back through the project
A dep or a hop the brief calls a task here opens its own line, and one this window cannot reach stays text (design recorded in
packages/core/src/graph.ts). - RG172 · a07c08da listing narrower than its file, and a failed update check, are explained in English whatever the window speaks
A narrowed listing and a failed check say why in the window's language, and five helpers that said it in English are gone (design recorded in
packages/core/src/backlog.ts). - RG171 · b4fc344the improvements tab names each design by its pointer and not its heading, so two designs look alike until opened
A design is named by its own heading (design superseded: section show declares no --no-body, so the body arrives unasked) (design recorded in
packages/ui/src/ProjectTabs.tsx). - RG169 · bd2b7d9a root is added two levels deep and no control changes it, so worktrees three levels down still need the settings file
A root's depth moves from its own chip, bounded at both ends by the rule that would refuse it (design recorded in
packages/ui/src/useRoots.ts). - RG168 · 642418ean unreadable row's reason is composed in English in core, so a Portuguese window shows it untranslated
A row says why it could not be read in the window's language, and the engine's own prose untranslated (design recorded in
packages/core/src/limits.ts). - RG167 · 6ff860ea row is read once, so a line shipped in a terminal leaves the portfolio stale until the window reopens
A read row follows its own project and reads itself again where it stands when the files move (design recorded in
packages/ui/src/usePortfolio.ts). - RG166 · 29fe22cevery row's gate reads unknown, since the ledger RG18 built is fed by nothing a window runs
A row's gate is the verdict the carrier ran, heard as it lands (design superseded: the health rides a gate topic, not the opening) (design recorded in
packages/shell/src/carrier.ts). - RG165 · 62a31a6a door the engine offers cannot run from a window, since the bridge refuses a verb or option its tables never compose
The carrier keeps the doors an answer carried and runs the one a caller names, filling only the blanks the engine left (design recorded in
packages/shell/src/door-keep.ts). - RG164 · 4da641fthe carrier keeps its catalogue in memory, so RG14's record is never written and every launch walks every root first
The carrier reads catalogue.json beside the settings and writes each fold, so a launch draws what it found last time (design recorded in
packages/shell/src/catalogue-file.ts). - RG163 · 82a461cthree live tests need this backlog to hold a quoted lead, an idea and a prose-only design, and it holds none
The three tests make or find what they read: a fixture design quotes its lead, the marker comes off the list, filled lines hold the column (design recorded in
packages/shell/src/live.ts). - RG161 · 272b5a3the signing procedure breaks the Windows CI job on one route and leaves the app exe unsigned on another
The Certum subject name is a local command line, SignPath signs the app before the installer, and four sentences beside them are true now (design recorded in
docs/SIGNING.md). - RG160 · 65a4518openHere's own unheld wiring is never run by a test, since RG137's live case rebuilds it by hand
openHere takes a seam for the surface it builds, so the live case runs its own unheld wiring rather than one the test rebuilt (design recorded in
packages/shell/src/open-here.ts). - RG159 · f98f740the empty-brief contract asserts lacking on a fixture that never has any, so no lacking line is ever read
A fixture whose only open line waits on a requirement makes brief answer with a lacking entry, and the case reads it.
- RG158 · 44bf2c5two live assertions pass unchecked: a picked line with no tier, and a combined filter that selects nothing
A pick with no tier and a filter pair that selects nothing each fail a test now, instead of passing it.
- RG157 · 7ce7337the tag-against-manifest check is tested by its text, so an inverted condition or a lost exit still passes
The step's script is lifted out of ci.yml and run against a manifest, so an inverted condition or a lost exit fails a test (design superseded: the fast suite's own guard refuses a spawn).
- RG156 · 4a98a57the update check tells a build ahead of every release it is the newest, and hides why a check failed
A build ahead of every release is told so and both versions are named, a failed check says what the network did, and only bad JSON reads as bad JSON.
- RG155 · b01a28ethe release-page guard compares a string prefix, so a release URL with dot segments opens another repository
The release page is parsed and compared as a URL — scheme, host, no credentials, normalised path — so a dot segment opens nothing (design recorded in
packages/shell/src/updates.ts). - RG153 · 1787b2enothing in the window hands a task to Claude Code or shows the session, so block F's acts and landings reach no one
The session says when each governed file changed, names a claim held elsewhere, and the rail lists what is running (design recorded in
packages/ui/src/Session.tsx). - RG152 · ef37653Run the gate is a button with nothing behind it, so a finding and the doors it names are still read in a terminal
The gate is a surface: findings as rows with what closes each, and its verdict where the portfolio reads it (design recorded in
packages/ui/src/Gate.tsx). - RG151 · b710ba2no screen composes a write, so a line is still filed in a terminal though its budget, argv and doors are built
A line is filed from the window, priced and refused by the engine (design superseded: Save runs the drawn argv, not applyWrite) (design recorded in
packages/ui/src/Filing.tsx). - RG150 · 618f5caa task opens nowhere in the window, so brief's join of deps, design and binding lists is read by nobody
A row's Open leads to the line as one brief: its design as the file stores it, readiness in the engine's words, the claim, and what binds it (design recorded in
packages/ui/src/Task.tsx). - RG149 · 3bba9c9the changelog, decisions, improvements and deferred tabs are drawn as labels with nothing behind them
The changelog, decisions, deferred and improvements tabs each read their own file; an undone entry says so, reasoning opens as the file has it (design recorded in
packages/ui/src/ProjectTabs.tsx). - RG148 · e2ff1b6a project cannot be opened in the window, so its lines, blocks and filters exist only as readers in core
A portfolio row opens its backlog as rows, every chip an argument to list, readiness from deps, a started unheld line said so (design recorded in
packages/ui/src/Project.tsx). - RG146 · 7a3f05droots are read and never written, so Add a root and Rescan roots are buttons nothing can honour
A root is added from the shell's dialog and removed by name, a missing one kept and marked, and Rescan walks again; a typed folder is refused (design recorded in
packages/core/src/bridge.ts). - RG145 · 2deaf1fthe window opens on a scaffold naming three packages, so the portfolio core already computes is drawn nowhere
The window opens on the portfolio: a row per project filled as reads land, pending never zero, engine beside counts, chips counting rows (design recorded in
packages/ui/src/Portfolio.tsx). - RG144 · d340786the bridge only answers when asked, so a session's stream and a governed file changing have no way to reach a screen
A screen hears its project's files move over IPC; main watches while anyone listens, and unmounting gives the watch back (design recorded in
packages/core/src/bridge.ts). - RG143 · c6a705bthe bridge carries no roadkeep call, so no screen can ask a project anything and every reader in core runs only in tests
A window lists its projects, opens one where main holds the engine, and runs tabled calls over IPC; the rest is refused unrun (design recorded in
packages/core/src/serving.ts). - RG77 · cacf4f9a non-goal arrives as a lead alone, so the sentence that argues it stays in the file
Each non-goal carries the sentence that argues it, off non_goals_why; an engine that publishes none answers null, not a blank reason (design recorded in
packages/core/src/binding.ts). - RG28 · 280d392the --stale payload carries each pause's age and reason and the reader drops both, so the store draws in file order
A pause carries how long it has stood, and the store draws in the order the engine named (design recorded in
packages/core/src/pauses.ts). - RG142 · ac08801a brief with no id on a backlog with nothing ready answers empty, and the reader calls that this app being behind
A brief with nothing to hand over reads as its own shape with the engine's reason, and the contract now holds that and the null-tier pick live.
- RG141 · 9b831fca backlog with nothing ready answers pick with a null tier, so the portfolio draws a waiting project as unreadable
A waiting backlog reads as a row with no next line; the live files take their subject off the listing and two fixtures, so they hold when nothing here is ready.
- RG140 · 21f6923the pseudo-locale run reads the text on screen and never a name, so an aria-label typed into a component passes it
The run reads every name a screen reader speaks beside the text; it found the notice region named in English, now from the catalogue, and lists Back to top with Close.
- RG139 · 7831201the executable names GitHub, Inc. as its company, because the manifest names no author to replace Electron's
The manifest names Alexandre Oliveira as author, so the unpacked roadkeep.exe says that as its company, and a test holds the name there without an address.
- RG138 · e19d2f1the packaged app wears Electron's icon in the taskbar and installer, though roadkeep's mark now leads its header
The packaged app wears roadkeep's mark on a dark tile, rendered from an SVG by npm run icon, and the edit that writes it into the .exe is on while it stays unsigned.
- RG137 · fd44031an open project does not carry why its engine could not be held, so a row cannot say why it reads slowly
An open project answers why its engine could not be held, asked when read, so the slow row has a sentence; drawing it is left to RG145.
- RG136 · cdabce3the artboards draw a brand mark beside the wordmark that the window does not render, and nothing says which is right
The header leads with roadkeep's own mark, drawn alike in the artboards, above the rail that hid its start since RG63 (design superseded: the mark is roadkeep's own, from its site).
- RG135 · 7e152f7a project whose engine cannot hold a session reads at spawn speed, and nothing says the held surface was refused
The held transport keeps why each root could not be held, with the engine's last stderr line, and drains that stream so a chatty server never blocks.
- RG134 · 3c05365the contract reads this repository's own lint for a finding, so a clean gate leaves it nothing to assert
The contract builds a fixture of its own, writes one line into it by hand, and reads the remedy lint answers for that line.
- RG133 · ea62913the renderer ships three icon API endpoints, and one prop on a nav item is what starts fetching from them
A fast check fails any UI file that hands an entity tile or shell an icon name, the one prop that reaches Iconify (design superseded: nav icons are Tabler by type; only tiles take a name).
- RG132 · e61c048a dialog says Close in English in every language, and the run that found it can only name it
The package puts Close and Back to top in its bundle since 2026.3.9, so the pseudo-locale run lists no exception and a bare word from it is a finding.
- RG131 · 1511ce9a read cancelled after it reaches the held engine runs to the end, and only the transport that spawns kills one
A cancelled held read rejects as aborted at once and its late answer is dropped; the cancel notice is sent too, though this build ignores it.
- RG130 · 61b9028the live gate runs one file at a time because every read in it spawns a python, and that is most of ten minutes
Suite reads go through a held engine and files run one per four cores: 433s became 87s here, and CI stays serial (design recorded in
packages/shell/vitest.live.config.ts). - RG129 · 6de1648the verb table is declared with string keys, so the file owning it asserts its own key type and nothing checks the pair
CALLED is declared by CalledName, keysOf answers its names, tableOf builds the report, and capabilities.ts is off RG121's exempt list with no assertion left.
- RG127 · 738b58ethe artboards draw a header the window no longer has, and they are what the next screen is designed against
Main and Shell draw the window's header and footer control for control, and a test holds their marked controls to the rendered window (design recorded in
docs/design/README.md). - RG126 · c9583b0the provider stack is spelled twice, so one added to the window is missing from every test that renders it
main and the harness both mount ProviderStack and RoutedSurfaces, and differ only in StrictMode and the router, each passed in as a child.
- RG125 · c8afd98the i18next half of the wording is two hand-written objects, so a key added to one and missed in the other is silent
Every language in AREA_WORDING is walked against en for a missing, stale or copied path, by the same bundleGaps rule core holds for the catalogue.
- RG124 · 9da89dea design system control draws its flags from a CDN, so a screen adopting one shows the image the policy refused
A live test reads the built renderer for an absolute image source and every host (design superseded: the page reference it would note this in is vendored and rewritten on refresh).
- RG123 · ee77661a sentence shown in a toast is English whatever the window is speaking, and the run that would catch it looks elsewhere
Both halves of a notice are catalogue values, and the run reads the whole document (design superseded: the toast it placed in a portal renders in place; the run never raised one).
- RG122 · 09fa03fthe transport that reads in 6ms is proven by a test and reached by nothing a person would run
The app's open path keeps one roadkeep mcp per project, reads at six milliseconds instead of seven hundred, and hands back a close that ends it (design recorded in
packages/shell/src/open-here.ts). - RG121 · 3b70841the one type-aware rule left off covers the whole tree, so an unsafe assertion outside a reader is unreported too
On everywhere but thirteen named readers and the tests, with two shared narrowings replacing twelve written by hand (design recorded in
.oxlintrc.json). - RG90 · 43c551emuted text on a muted panel is 4.33 to 1, which no screen renders yet and one will
The package darkened muted text to 0.52 in 2026.3.9, so the pair is 5.05 to 1, and the contrast test now holds it to AA in both grounds.
- RG50 · 3f1de91nothing updates, so a fix reaches a person only if they go and look for one
Help, Check for updates names the version it is on and the newest published, opens only this project's release page and installs nothing.
- RG13 · da7dbada candidate is judged governed by a read that fails, so rejecting a folder costs the work of a whole lint
A folder nothing governs opens as ungoverned off the engine's own config, before commands is asked, and its null source no longer reads as a failure.
- RG9 · 5e1737aprose a person typed goes out through argv, which is where RK1474 recorded bytes arriving as different bytes
Every prose field of an add round-trips byte for byte through argv, shell syntax included, held by a live test (design superseded: the shell-less spawn never changed a byte).
- RG120 · 48cb922the wired skill and hook are behind the engine answering here, and only a command somebody remembers fixes it
The copied surfaces are refreshed, and a CI step holds them against the engine answering: install --check writes nothing and exits non-zero (design recorded in
.github/workflows/ci.yml). - RG118 · 2973758no screen names the build, so a defect report cannot say which one it came from
Every page carries a footer naming the build: the product, the version, the commit, packaged or source, and whether it was signed (design recorded in
packages/ui/src/Shell.tsx). - RG117 · 866d124the route table is spelled three times, so a surface can be routed and still be missing from the map
Every route is one array: main mounts it, the harness mounts the same one, and the test that checks the rail against it reads its paths (design recorded in
packages/ui/src/routes.tsx). - RG116 · 1a55638there is no control for the language, so choosing one means editing the settings file by hand
The header has a language menu: choosing one moves both translation systems and reaches the settings file, so the next launch opens in it (design recorded in
packages/core/src/bridge.ts). - RG115 · 0111705the sentences a bad settings file composes cross the bridge and no screen shows one
A launch that lost a field says so in the chrome's own notice surface, one sentence per loss, and a ground that could not be saved says so too (design recorded in
packages/ui/src/Shell.tsx). - RG114 · a03f91fthe built app never starts on the Linux runner, and the harness reports the wait without what it printed
The refusal now carries what the app printed, and the Linux runner lets Chromium enter its sandbox — the second is a hypothesis CI tests (design recorded in
packages/shell/src/running-app.ts). - RG113 · 1afaa62the live tests find an engine on the developer's PATH, so a fixture is unresolved on a runner
CI installs the checked-out engine with pip, so a fixture resolves the same command a developer has — verified against a venv holding only that (design recorded in
.github/workflows/ci.yml). - RG112 · e19744dnothing pins the line endings, so a Windows runner checks out CRLF and Prettier reports every text file
* text=auto eol=lfmakes every checkout LF, so the gate reads the same bytes on a runner as locally — proven on a clone with the runner'score.autocrlf(design recorded in.gitattributes). - RG111 · 5798d54the lint gate reads the engine CI checks out beside the packages and fails on code this repo did not write
Both halves of the lint step skip the engine CI checks out, so the gate judges this repository's files alone — verified with a checkout in place (design recorded in
.github/workflows/ci.yml). - RG110 · 433f418the vendored page reference is checked by nothing, so a copy that drifts is read with the same trust as a current one
npm run lint ends in viglet-ds-page-reference --check against 2026.3.8, so a vendored copy that drifts or an artboard the package dropped fails the gate here.
- RG109 · a4c20aethe five screens drawn here miss four things the shell's set requires, one of which stopped being true at RG86
The five screens carry a back-to-top, a locale control, a ground control and one reading column set by the shell, which the vendored set requires of each.
- RG108 · 24891b6the design system's page contract reaches this repository only if somebody goes and reads it in another checkout
The contract, the boundary and nine artboards are vendored under .claude/skills/viglet-ds-pages and docs/design; this project's own canvas entries were preserved.
- RG107 · 207fda4the dark focus ring is the light accent, because this app's :root wins over the package's dark block
The dark ring is the dark accent again, and the contrast test reads the cascade in source order so another override reaching both grounds is caught (design recorded in
packages/ui/src/index.css). - RG106 · cf9aa5fthe window mounts nothing until the bridge answers, so a call that never returns leaves it blank
The launch read has a two-second deadline and mounts in English past it, so a shell that never answers costs a locale rather than the window (design recorded in
packages/ui/src/launch.ts). - RG105 · ce7cd4bthe rail marks where you are in the package's neutral, so the shell reads as another product's console
This app claims --primary through the four inputs, so the mark, the button, the progress bar and the tile glow are amber on both grounds (design recorded in
packages/ui/src/index.css). - RG104 · f32a92aremoving a fixture directory throws EPERM on Windows, so a file whose tests all passed reports as a failed suite
One removal waits out a lock Windows has not dropped, and a live test holds it against a child standing in the directory (design recorded in
packages/shell/src/scratch.ts). - RG102 · 1d32addthe walk yields now and the three reads around it do not, over the same paths a person named
The three reads around the walk are asynchronous under one bound on the disk, so a sleeping drive no longer holds the process the window talks to (design recorded in
packages/shell/src/probing.ts). - RG101 · ee41d46every call spends a second and a half starting Python, and the engine publishes a mode that starts once
A third transport holds one roadkeep mcp per project: 6ms a read against 738ms spawned, same payload, spawning for what it cannot serve (design recorded in
packages/shell/src/mcp-transport.ts). - RG100 · 7124046an id in a project whose listing was bounded reads as one nothing in that project ever carried
An id in none of the listings reads as unfiled only where all three were read whole, and as unknown otherwise, which is a sentence about the read (design recorded in
packages/core/src/pauses.ts). - RG99 · 348f81ba read has two doors and the one a screen has to use is the one that raises rather than answering
client.call answers with the same three states a write gets and raises for none, so a screen has one door and no caller wraps a read in a try (design recorded in
packages/core/src/client.ts). - RG98 · da84516core's boundary test holds an import and nothing else, so a path rule written as string work passes it
core's boundary test now fails on a separator fold nobody wrote a reason for, and on a reason that no longer matches anything (design recorded in
packages/core/src/boundaries.test.ts). - RG97 · 78d1dd4nothing declares which Node this repo needs, so a wrong one fails inside a dependency and not at the door
Node 26 is declared in package.json, .nvmrc, the CI pin and the gate table, and engine-strict makes npm refuse rather than warn (design recorded in
CLAUDE.md). - RG96 · 62ffe0cthe suite now tests a bundle it did not build, so a green run can be about yesterday's code
A live run refuses to start against a build older than the tree, naming the file that was edited and the command that fixes it (design recorded in
packages/shell/src/freshness.ts). - RG95 · 41945eano gate reads an advisory, so the next one is found by whoever happens to install something
CI reads npm audit against a written list of the advisories answered here, and fails on anything else and on an exception nothing reports (design recorded in
packages/shell/src/advisories.ts). - RG94 · 655200dno type-aware rule runs, so a floating promise is still nobody's finding
The lint gate runs the type-aware half, and the findings were read rather than silenced: one rule off with a reason, and the rest fixed (design recorded in
.oxlintrc.json). - RG93 · f4e7e3bthe dev loop reaches into the compiler's own layout, and only a hand run would notice it moving
The path into TypeScript's layout is one function two callers name, and a live test starts it, so an upgrade that moves the file reds a run (design recorded in
packages/shell/src/compiler.ts). - RG92 · a8f4312the project skill states counts and a priority that stopped being true, and nothing checks it
Every count and queue the skill restated is now the read that answers it, and the file is under a budget the gate holds (design recorded in
.claude/skills/roadkeep-gui-roadmap-docs/SKILL.md). - RG91 · 0e81052the packaged build is proven on one machine, and CI never makes one
CI runs the stamp and its posture refusal on every change, and builds a Windows and a Linux installer on a tag or on demand, keeping both (design recorded in
.github/workflows/ci.yml). - RG89 · 3848967two readings derive the marker set from one config, and only a test keeps them agreeing
openMarkers is a filter over markersOf, so one config is read one way and a project that left its open set to the default is offered it (design recorded in
packages/core/src/marking.ts). - RG88 · ba108ffone screen has two translation systems, and only one of them was chosen
i18next holds the one locale this window has, the shell's tag sets it, and the catalogue reads it back from there (design recorded in
packages/ui/src/speaking.ts). - RG87 · 4f8d382the ground setting has two homes, and the file one is not the one that wins
The settings file is the source of the ground and storage is a cache: the file paints the first frame, and a change goes back over the bridge (design recorded in
packages/ui/src/ground.tsx). - RG86 · ea4d0a6the locale setting reaches no screen, so choosing one changes nothing
Choosing pt-BR draws the whole window in Portuguese, the shell resolving the tag and handing it over the bridge before the first frame (design recorded in
packages/core/src/locales.ts). - RG85 · 1c50ba3the handler proving the seam runs any argv against any root, which a real service cannot
The refusals a service transport owes are written down before one exists: DECISIONS names four, and the test handler's own comment points at them.
- RG84 · 5446417every live file resolves the engine itself, so one being rebuilt mid-run reds the suite four ways
The suite asks the engine what it is once per run, so a rebuild underneath it arrives as one named sentence and not thirty-one renamed keys (design recorded in
packages/shell/src/live.ts). - RG83 · f5b94c9one verb answers in two shapes under a flag, and nothing names the second until it breaks
Six second shapes are declared and each is covered, so naming one without a case reds a guard rather than waiting to break (design recorded in
packages/shell/src/contract-live.test.ts). - RG82 · c6a5440the contract test asserts one engine version across three reads, so a rebuilt engine reds a suite nothing touched
The version is named once and carried into every failure printed, and nothing compares two reads of a tree under edit (design recorded in
packages/shell/src/contract-live.test.ts). - RG81 · 2b51b0dthe read and write paths each spell the same argv wrapper, and the two have already drifted apart
Both paths wrap their own table's spelling with one composer, and the write path now says why it takes no cancel signal (design recorded in
packages/core/src/client.ts). - RG80 · 9748f13opening a paused task is a refusal whose typed fields are all empty, leaving the screen only English
A refused task read now asks the three listings where the id went, so a paused line draws its store entry and the way back (design recorded in
packages/core/src/pauses.ts). - RG78 · 9b88524every live test file now carries its own call-and-unwrap, and the sentence a moved key prints is written in each
Thirty-one live files open on one module, and the sentence a moved key prints is composed once instead of in each (design recorded in
packages/shell/src/live.ts). - RG76 · 9b5809dbrief already sends the chains and the shape drops them, so opening one task pays for a second call to deps
A brief's chains are declared on its shape and laid out by the same code, so a task draws its routes off the read that opened it (design recorded in
packages/core/src/graph.ts). - RG75 · a8321b3two live tests still name RG9, so the commit that ships it fails a suite nothing changed to break
Both tests now find their line by the state they are about — a dep resolved, one no ship here can clear — so shipping an id changes which line answers, not whether they pass.
- RG63 · e1352e9there is no page chrome, so the first real screen will invent a shape the design system already has
The rail, the header, the palette, the shortcuts sheet and the back-to-top are mounted once, and a page sets no column of its own (design recorded in
packages/ui/src/Shell.tsx). - RG103 · 3b8c050every caller assembles the engine, the pool, the cache and the reader itself, and no two assemble it alike
One call resolves the engine, bounds the calls, reads what the project governs, keys the cache on it, and hands back a client (design recorded in
packages/core/src/opening.ts). - RG74 · f4a556ca marker says in progress and the claim registry says nobody holds it, and nothing tells the two apart
Both facts are reported and the disagreement is drawn rather than resolved, against the working marker the config names (design recorded in
packages/core/src/detail.ts). - RG73 · aa78400a row is built by four separate reads, so a project costs four interpreter starts to show once
A scannable row is one call and the next line is a second, because resolution already answered the engine and the gate comes off the ledger (design recorded in
packages/core/src/rows.ts). - RG72 · 23d9f67a family is drawn in the order it was found, so a version list can read newest last or newest first by luck
The member the stable name points at reads first, then the rest by path with digit runs read as numbers, newest first (design recorded in
packages/core/src/families.ts). - RG71 · d3fcc2ea walk of every root blocks the thread it runs on, so a slow drive freezes the window
A level is read together under a bound and consumed in the order it was listed, so a slow drive costs the scan and not the process (design recorded in
packages/core/src/scanning.ts). - RG68 · 2810b81the contract costs a minute of process starts, because every read rebuilds nothing but pays a fresh engine
A fixture is built once per shape per run and copied after that, taking the live suite from 599 seconds to 415 (design recorded in
packages/shell/src/fixture-cache.ts). - RG67 · 971fd56a project declaring a read bound answers in a shape nothing here has ever seen, and the reader refuses it
A listing past the project's read bound arrives as the blocks, the counts and the narrower call, read off a fixture that declares one (design recorded in
packages/core/src/backlog.ts). - RG66 · 3cbb601a verb can be called with no shape declared for its answer, so the boundary has a hole per verb
A verb declares its reader beside its argv, so a call answers with the payload, the refusal or the field it could not read (design recorded in
packages/core/src/answers.ts). - RG65 · 3d39b03resolving an engine costs two interpreter starts on Windows, where the same file is spelled two ways
Whoever has a filesystem says what makes two spellings one file, so a Windows resolution starts one interpreter rather than two (design recorded in
packages/core/src/engine-resolution.ts). - RG64 · 4088356the fast suite and the one that spawns a real engine are one command, so every run pays for both
npm testis 854 tests in eight seconds andtest:livethe 307 that spawn, split by a filename that a guard reading every test file keeps honest, with CI paying for both. - RG61 · eeb041ethe app ships a high-severity advisory it did not choose, reached through the design system
The advisory reaches the install tree and not the executable, measured twice and held by tests that fail when the package moves (design recorded in
packages/ui/src/advisory-live.test.ts). - RG60 · cb44477no test ever starts the app, so the isolation the window configures is checked by reading it
The built app is started and asked what the page actually has, so a dropped isolation flag turns the suite red instead of shipping (design recorded in
packages/shell/src/running-app.ts). - RG59 · d3e08f0the renderer has no content policy, so a script tag that reaches the page runs beside the bridge
The packaged build refuses a remote script, proven by putting one in the page and watching it be blocked by name (design recorded in
packages/core/src/policy.ts). - RG58 · 384423anothing checks style or dead code, so three packages drift apart file by file with the gate silent
One command holds the package split, the dead code and the formatting, and every rule it silences says why (design recorded in
.oxlintrc.json). - RG57 · 8c6d28ca main-process change is invisible until the dev run is killed, because only the renderer is watched
A main-process edit now rebuilds and replaces the Electron child, and a failed build leaves the running app alone (design recorded in
packages/core/src/reloading.ts). - RG56 · 403d5cean agent working this backlog has no instruction file, so every session rediscovers the rules by reading code
A session is told which package may know what and where the rest lives, in a file the gate holds to a budget in lines and bytes (design recorded in
CLAUDE.md). - RG55 · dddd6c7there is no CI, so every assertion this plan rests on runs only where somebody remembers to run it
One workflow runs the typecheck, the suite and the build on two platforms, and the gate through roadkeep's own action (design recorded in
.github/workflows/ci.yml). - RG54 · 5ad867bcontrast and keyboard reach are asserted by nobody, so an accessibility defect ships looking like a style
Contrast is computed over the real tokens in both grounds and keyboard reach is asserted on the screen; the light ring failed and is fixed (design recorded in
packages/core/src/contrast.ts). - RG53 · 9a47e77a marker is an emoji drawn by whatever font the platform picked, so one status looks like three
Markers and their labels are read out of the config, drawn in a face chosen for coverage, and always carry a word somebody can read (design recorded in
packages/core/src/markers.ts). - RG52 · 03e443athere is one ground, so somebody who works in dark reads this app in light
Both grounds paint from the same tokens, the setting resolves against the desktop, and the words on screen do not move with it (design recorded in
packages/core/src/ground.ts). - RG51 · 218c91astrings are written into the components, so a second locale means reopening every screen
Every string a person reads now comes from one catalogue, and a pseudo-locale test fails the run a literal is typed into a screen (design recorded in
packages/core/src/wording.ts). - RG48 · bb7f3b3the claim that a service is a transport swap is asserted by nothing, so it is an intention
A second real transport carries every read over HTTP and the answers are compared, so the swap is exercised on every run (design recorded in
packages/shell/src/http-transport.ts). - RG47 · bfeab30settings have nowhere to live, so roots and preferences are gone when the window closes
The roots, the skip list, the pool width, the theme and the locale have a versioned file that resets field by field (design recorded in
packages/core/src/settings.ts). - RG46 · e1be774there is no executable, so the app runs only where its source tree and toolchain already are
An installer builds, opens a window, and names its version, commit and signing from inside itself (design recorded in
packages/core/src/build.ts). - RG45 · 6db85a2nothing watches the governed files, so a write by an agent or a terminal leaves the screen stale
The governed files a project declares are watched while somebody holds it, and a burst of writes tells the screen once (design recorded in
packages/core/src/watching.ts). - RG43 · 2d571aathe claude binary is assumed to exist, so a machine without it fails at the moment work starts
The command that runs a session is resolved and named like the engine, and a machine without one is a stated condition (design recorded in
packages/core/src/agent.ts). - RG42 · 8d2800bwhat a session wrote to the governed files is not watched, so the screen shows the backlog from before it ran
What a session did is read off the files it changed: the marker, the design and the ledger, beside what it said (design recorded in
packages/core/src/landing.ts). - RG41 · e89f6c6a line is handed over without being taken, so two sessions can be started on the same task
Handing a task to a session takes it: brief and claim are one call, and a held line is named instead of offered (design recorded in
packages/core/src/handover.ts). - RG40 · 9f1c4b4a session's output is a stream nothing renders, so what the agent is doing is invisible while it does it
A session reads as acts: which tool on what, the roadkeep calls marked, and every raw line still reachable (design recorded in
packages/core/src/acts.ts). - RG38 · 601ad2bnothing starts Claude Code, so a task and the session that does it are two windows and a copied prompt
A session starts from the brief payload itself, owned and killable, with no claude on the machine its own state (design recorded in
packages/core/src/session.ts). - RG36 · 8ab0809an input has no budget, so a field is typed to whatever length and refused after the sentence exists
Every field is priced before a word is typed, counted against what the line allows rather than what the limit says (design recorded in
packages/core/src/budgeting.ts). - RG79 · 763a294an unreadable answer reports not JSON and drops stderr, where the engine explained itself in full
An answer this app cannot read now carries what the engine wrote, so the sentence naming the cause reaches the person (design recorded in
packages/core/src/limits.ts). - RG69 · 356a6e1a subcommand is a verb with a space in it, and the verb table has no way to spell one
A verb's key is an identifier and its spelling is an array, so a two-word verb is looked up and sent under the name commands publishes (design recorded in
packages/core/src/verbs.ts). - RG44 · 8095500the renderer holds node powers, so the half a service would serve to a browser can delete a file
The renderer has a browser's powers and one frozen typed object, and every navigation off the bundle is refused or sent to the system browser (design recorded in
packages/core/src/bridge.ts). - RG39 · a7cfd3cthere is no design system, so every screen decides its own type, spacing and colour on the spot
Every colour, radius and face comes from the design system Turing, Shio and Dumont render with, and a test fails any component that names one.
- RG37 · fda8d8fthere is no application at all: no window, no build and no way to run any of this
A window opens over three packages, with one typecheck spanning them and a headless suite over both halves (design recorded in
CLAUDE.md). - RG35 · f198eb6amend, restate and renumber have no door, so the corrections that keep an id are terminal-only
The three corrections that keep an id are doors, each offered with the sentence the engine publishes for it (design recorded in
packages/core/src/correcting.ts). - RG34 · 824aa66the argv the app composed is never shown, so a write cannot be read before it runs or repeated after it
The argv is a line a person can read before it runs and paste after it, and a transcript keeps what ran with its exit code (design recorded in
packages/core/src/transcript.ts). - RG33 · 37a7d36a lint finding is a line of text, so a report naming its own doors arrives as something to read and not to run
A finding is offered as the door that closes it: run where complete, a form where not, and the repair pass dry first (design recorded in
packages/core/src/repairing.ts). - RG32 · 91bf10aa rationale section cannot be written, so a line filed here points at nothing until a terminal is opened
A rationale is written where the pointer points, and corrected as a fragment the verb matches rather than the caller (design recorded in
packages/core/src/sections.ts). - RG31 · a0d9736there is no door for ship, retire, defer or resume, so a task is read here and closed elsewhere
Ship, retire, defer and resume are doors, each answering with the edits it made across the files it touched (design recorded in
packages/core/src/leaving.ts). - RG30 · 10d8d44a marker cannot be moved, so starting work is a shell command run beside the window that shows it
A marker moves through the verb: the open set comes from config, and the answer says whether the claim was taken or given back (design recorded in
packages/core/src/marking.ts). - RG29 · dfa7df0the app reads and never writes, so a correction is typed in the terminal this app exists to replace
A write is a composed argv this app never runs against a file: applied, refused with its fields, or unreadable (design recorded in
packages/core/src/writing.ts). - RG27 · 702ed88the ledger and the decisions file are unreachable, so what shipped and what was weighed live outside this app
The ledger and the reversals are reads: what a block delivered, the five nearest a sentence, and what the ledger undid (design recorded in
packages/core/src/memory.ts). - RG26 · ced72ccthe non-goals and the criteria are off screen, so the two lists that bind a proposal are the two nobody reads
Both binding lists are reads: the non-goals with the designs answering each, and criteria grouped whole, three empties apart (design recorded in
packages/core/src/binding.ts). - RG25 · 087a72edeps and what a ship unblocks are a list of ids, so following a chain means reading ids one at a time
A line's deps open as the graph the engine resolved: blockers, chains drawn whole, the cascade a ship frees, and a dep outside told apart (design recorded in
packages/core/src/graph.ts). - RG24 · ce24e1bthe rationale section is not shown, so the half of a task that explains it stays invisible
A task's rationale opens with it: the prose byte for byte, where it lives, and what it has left of the word budget the gate will use (design recorded in
packages/core/src/design.ts). - RG23 · 35ff03aa task has no detail, so the why, the deps and the design are read in the file this app exists to replace
One brief read carries the line, its resolved deps, the design whole, what a ship unblocks and the lists that bind it, composed by nothing here (design recorded in
packages/core/src/detail.ts). - RG22 · 7dfee30a list of eight hundred lines has no filter, so a block or a marker is found by scrolling to it
Every filter is an argument the read already takes, so a narrowed list is the command's own answer and the choices are read from the project (design recorded in
packages/core/src/filters.ts). - RG21 · 66aa524opening a project shows counts and no lines, so the backlog it governs is still only in the file
A project opens into its blocks in heading order, with the lines the grammar refused drawn beside the ones it accepted (design recorded in
packages/core/src/backlog.ts). - RG20 · 36e2269finding a line by its words means opening each project and reading its list in turn
Search runs over held payloads across every backlog, matches id, symptom and why, and names any project it could not cover (design recorded in
packages/core/src/search.ts). - RG19 · 7672db1what to work on is asked one repository at a time, so there is no answer that ranges over all of them
Every project's candidate is laid out together with the tier that chose it, in the person's own project order and ranked by nothing here (design recorded in
packages/core/src/candidates.ts). - RG18 · febd849whether a project's gate passes is unknown until it is opened, so the list cannot say which one needs attention
A row shows the last verdict with when it was taken, unknown until a run has earned one, and stale the moment the files move (design recorded in
packages/core/src/gate.ts). - RG17 · 369be33twenty projects are read one after another, so the first screen is a wait with nothing drawn on it
Every project goes out at once through the pool, rows stream in as they land in recorded order, and the cheap read fills the screen first (design recorded in
packages/core/src/cold-start.ts). - RG16 · 7d5636enothing shows more than one project, which is the single thing this app exists to do
One row per project holding only numbers a verb printed, pending until read, and nothing added up across them (design recorded in
packages/core/src/portfolio.ts). - RG14 · fd4f257the whole tree is walked again on every launch, so a list the person already approved is rediscovered
The list is a record a rescan diffs rather than rebuilds, and a project it no longer finds is marked missing and kept (design recorded in
packages/core/src/catalogue.ts). - RG12 · 77fbb71a git worktree family reads as unrelated projects, so one backlog appears once per version folder
A junction collapses onto the folder it names and two worktrees group by the git directory they share, read off git's own files (design recorded in
packages/core/src/families.ts). - RG11 · d630923a scan descends into node_modules and .git, so finding seventeen projects reads a hundred thousand folders
The walk looks for one filename, refuses an ignored or hidden directory, stops at the declared depth and never enters a project it found (design recorded in
packages/core/src/scanning.ts). - RG10 · ea1898eno root is named, so there is nowhere to look and the project list can only come back empty
A root is a folder somebody named with a bounded depth, there is no default, and one that stopped existing is kept and marked (design recorded in
packages/core/src/roots.ts). - RG8 · 0fff72fa read has no ceiling, so one project whose engine hangs stops the screen that was drawing it
Calls run through a pool of settable width under a settable deadline, and one that runs out becomes a state on that project (design recorded in
packages/core/src/limits.ts). - RG7 · d274ef1every read costs an interpreter start, so a screen over twenty projects pays twenty of them to redraw
A read is keyed by the project, the argv and a stamp of the files it declares, so an unchanged project is not read twice (design recorded in
packages/core/src/cache.ts). - RG6 · ccde12enothing checks which build answered, so a project on an older roadkeep fails at the first flag it lacks
A project is asked once what its build runs and which flags it takes, so a door is withheld rather than refused later (design recorded in
packages/core/src/capabilities.ts). - RG5 · d29c22ca refusal is prose on stderr, so the field it is about has to be read back out of English
A refused write comes back as its code and field, and the doors that close it read through one shape shared with the gate (design recorded in
packages/core/src/refusals.ts). - RG4 · b827a1cthe client's reading of a payload is asserted by nothing, so a rename upstream breaks a user and not a build
A fixture built by the write verbs is read by every verb this client calls, and two over-strict shapes failed here first (design recorded in
packages/shell/src/contract-live.test.ts). - RG3 · 4d872aea payload arrives as any, so a key renamed upstream is an undefined at run time and never a red build
Each read declares a shape that yields the typed value or names the field that drifted, blaming the version gap rather than the project (design recorded in
packages/core/src/payloads.ts). - RG2 · bd05f41the engine is assumed to be a roadkeep on PATH, which is the one thing engines says it may not be
Each project is asked which copy writes for it, and a modified tree, a disagreement and a machine resolving nothing are answers (design recorded in
packages/core/src/engine-resolution.ts). - RG1 · 857699bnothing here invokes roadkeep, so every payload this design rests on is one no code can fetch
A verb table builds one argv, one transport spawns it with no shell, and four tests fetch real payloads from a live roadkeep (design recorded in
packages/core/src/transport.ts). - RG278a session card moves only under a pointer drag, and an arrangement nobody wants is undone one card at a time
Each session card's title menu moves it across or along without a drag, and Settings puts every card back where it started.
- RG62nothing stops a screen re-declaring a component the design system already exports
The design system's duplicates gate runs in
npm run lint, and a planted component proves it is looking at this app. - RG49the executable is unsigned, so Windows tells a person the app is untrusted before it opens
docs/SIGNING.md says how a certificate is obtained and where it plugs in; SignPath, Certum and a cloud OV are the three a Brazilian individual can take.