What roadkeep shipped.

section amend --check runs every refusal and prints the prose as it would read, writing nothing, on the CLI and the served tool (design recorded in plugin/src/roadkeep/sections.py).

show joins a paused line from the deferred store with its reason and the resume door, alone or among other ids; brief still refuses one (design recorded in plugin/src/roadkeep/showing.py).

An id project's prose takes a non-id top-level anchor before the first block, so a scaffolded strategy file opens (design recorded in plugin/src/roadkeep/sections.py).

non-goal list --all prints every entry, --json always carries every lead and reason, and the elided count names the flag (design recorded in plugin/src/roadkeep/briefing.py).

anchors names each numbering's free top-level with its family count where they differ, and a trailing colon no longer reads as a namespace (design recorded in plugin/src/roadkeep/history.py).

record amend --line <n> --body - rewrites a ledger line whose id the grammar refuses, and the finding on such a line now prints that door instead of one that refuses.

code.renamed runs only where the project's pyproject.toml names the engine's package, so a vendored .roadkeep/ no longer fails an adopter's gate on renames that never happened.

amend --drop-requires takes a met need off a line, over the CLI and the tools alike, and dropping the last word clears the group so pick offers the line again.

A launcher committed before RK1699 finds the engine again through a shim at the old path, and a SessionStart that reaches no engine now says the governed files are unguarded.

The reader's pages build into roadkeep's site at dist/gui/ and deploy with it, served at alegauss.github.io/roadkeep/gui/.

A release's tag now builds the Windows and Linux installers from its own commit and attaches them to that release, under the CLI's version.

A project no engine answered for says so as a missing Python 3.11 where the machine has none, asked only once an opening fails.

An AppImage or dmg offers the plugin on its first launch where claude answers, once, running the same two commands the Windows installer does.

An install copies plugin/ alone, 4.1 MB with the engine, hooks, skills and commands, and leaves gui/, the tests and the site behind.

A session under gui/ is told its rules are gui/CLAUDE.md, the dev skill names what crosses the line, and the gui suite runs only on a change the reader depends on.

CI lints gui/ as its own project, and the guard names a nested project's file and its directory instead of offering tools that would write the root backlog.

The web-UI non-goal now allows a desktop reader that only spawns the CLI or MCP server, and still refuses a service, a database or a second line writer.

A Continuation refusal reaches the caller as one: its count is given, and _retrying takes only a string as a retry's address (design recorded in src/roadkeep/kernel/document.py).

validate failed --files writes the verdict and an open line in the entry's block, --saw its why, as one; other verdicts refuse the flag (design recorded in src/roadkeep/validating.py).

record amend keeps a verdict line without --lines, and lint reports a bad token or sentence, a second verdict, and one under an open line (design recorded in src/roadkeep/validating.py).

[validation] asks the question from the ship after it was declared, or from its from entry, so adopting never hands a project its whole history (design recorded in src/roadkeep/validating.py).

Every shipped entry with no verdict is one read: unvalidated lists each with its commit, --block narrows it, and stats carries the two counts (design recorded in src/roadkeep/validating.py).

An entry carries what a person saw: validate writes one line under it, a second verdict rewrites it in place, and a token outside the set is refused (design recorded in src/roadkeep/validating.py).

Git staging or reading a governed file passes the guard in silence; any other command naming one, or chained with it, is still asked about (design recorded in src/roadkeep/guarding.py).

a quoted name with no directory is a path where exactly one tracked file carries it, so a section naming five sprites names five artefacts (design recorded in src/roadkeep/showing.py).

an evidence clause may end on a comparison, so a task whose proof is a number the project already writes down declares a criterion that runs (design recorded in src/roadkeep/remaining.py).

weight leaves out what [history] incidental accounts for, so a project is sized by what it wrote and not by its generator (design recorded in src/roadkeep/history.py).

show takes one id or several, so a fan-out joins every design in one read, bounded by [reads] show and with the git walks behind the distance made once (design recorded in src/roadkeep/showing.py).

One reader holds both path keys: absolute is refused on either flavour and not on this one, and a climb out of the root is refused at all (design recorded in src/roadkeep/config.py).

project.logo names a mark as a repository-relative path, refused for a climb, a backslash or a scheme, and never for a missing file (design recorded in src/roadkeep/config.py).

declare project opens [project], whose name, description and icon rows are each held to a [limits] width the gate reports (design recorded in src/roadkeep/config.py).

A body refusal's preventive read now names the file that refused, so a draft over the decisions limit is priced against 150 and not against the improvements 250.

Every roadmap row of the list payload carries its readiness, and --startable narrows to the lines no dep and no absent requirement is holding up.

Every source file parses under the floor the manifest promises, checked without needing that interpreter (design recorded in tests/test_packaging.py).

ROADKEEP_HOME is the only engine tried where set: absent or failing its probe, it is refused by name with what the probe said (design recorded in hooks/roadkeep-launch.py).

list --stale --json gives each pause its since and reason, oldest first under an order key, and both registers age one selection (design recorded in src/roadkeep/counting.py).

non-goal list --json now publishes non_goals_why, each carried lead's reason keyed by that lead and bounded like it, and every key it already had keeps its name and type.

declare writes a declared role's missing file at the path its key names, so file.missing names a door repair runs and the gate closes.

One composer names declare at all five role refusals and only where it lands, which also closes a typo RK1670 was offering declare for.

govern reads and writes both opt-in tables, measured as their validators measure, so the door declare names runs and the help is true.

The retry row replaces a token no shell delivers and names the field to retype, one rule with the capture offer; the payload keeps it verbatim.

A census of the thirty-one tests reading this backlog says what a drain does to each, measured by running the suite against a drained copy.

The undeclared-role refusal names declare, and defer's own store refusal stops reading out the hand edit it copied its rule from.

A served refusal offers the subjects that transport exposes, subtracted off a slot the surface records per verb.

Thirteen bare doors carry the invocation, twelve new census sites run them, and running two found commands that had never existed.

The door replaces a token no shell delivers with a placeholder and names the flag, so the line it prints arrives intact in every shell on the machine.

The argument takes the two character rules every other composed field does, refused before the reading, and no field is left to the round-trip alone.

The scan resolves a module-level name and raises on one it cannot, so the six codes named as constants are inside the closure and four gained the rows they had none of.

The rows are over both files' labels and account for both totals, so Turing reads as 105 blocks and not 3 and Shio's 668 delivered all land in a row.

A dep on a dismissal resolves unresolvable with the premise in its sentence, and the finding that names it stopped asserting a departure that did not happen.

reopen --section writes the design in the transaction that files the line, and a reopen without one reports the anchor nothing answers.

The census is declared and total, and the five that write both streams in one run go through beneath: every answer with a note had its note above it down a pipe.

The exemption is keyed by the receiver and held total against the suite, so three whole modules are swept again and a called notes() is not a list.

declare --move puts a misplaced key under the table this build declares it in, and it is the one write that runs while the config does not parse.

The two scans read one _shown_at, so they are complements by construction, and a property over surface.modules holds that they tile every non-prose string.

The rule is one sentence in verbs/refusing.py with its two grounds, held over asking.QUESTIONS against a project that declared only the scaffold.

One rule on both surfaces: a declaration says one subject is required and the dispatcher refuses a call that named none, where two handlers each raised their own.

The read runs with -B, so asking a tree its version leaves it as written and the reported count is the rule's.

One scope walk in surface.py answers both questions, and the third walker's shorter address is gone.

The sweep reads the suite as well as the package, and the two sites that predated the fold are folded.

One table with a row per list, and the population read off the payloads — which found a second list nothing promised.

Five guards whose subject was a code shape now read the syntax, and the population that reads characters is empty.

Each page carries its own figure beside the orientation's, and a page past it is a page to split.

The read goes out under doors, which is where a payload publishes a command a caller has not yet chosen.

One instrument, three fixtures, and the reach stated as seven of eighty-five instead of described as one.

The 27 spans carrying a placeholder are read one by one, and the answer is not the design's: thirteen are doors.

One reading over four closed sets, with a row per table saying whether its prose is a caller's or an author's.

Both spans are read off the binding the comment sits above, and the three readings that used to be empty strings refuse.

The trigger is declared beside the flag that reads it, so the population is a table and the bare form prints it.

The dead-import scan gained the one binding it read as live, and it found a second instance standing in installing.

One door now runs through every shell on the machine, so the quoting is read by a shell instead of by the parser that mis-quoted it.

The drop names the heading and the size it takes, and a shipment that opened none of the three doors is told so.

The write moved onto Namespaced.save, so the config's writers are one layer again and the ordering is a property a test holds.

add --symptom reads the pipe on a dash, as restate --symptom has since RK1187, and the parser's own declaration is what two registers now hold it by.

config states governed and the roles [files] declares, so the probe is one call: with RK1630's root and version already on it, a client meeting a path before a project has all four.

One helper on the two readers of a payload leads every mapping with the absolute root and the build that answered, keeping the two verbs that already name one, and hands a list back untouched.

Document.written_end is the third of the three end readers and the one about the whole file, so the two modules that append a section ask it instead of walking back twice.

show and brief carry the distance, off one derivation: how many entries landed under the block since the commit that proposed the line, which pick at 2 ms does not pay for.

composed.FIELDS classifies every value-taking argument a write verb takes as schema, round-trip, address or path, and its first run found govern --because writing prose no validator reads.

The sweep reads every corpus that is present and requires none, so this repository's own 2,324 fields are asserted on a machine with neither — which is what CI is.

The flag and the open count pass from the walk that knows them, so a tree with no git says it read no history and how many lines it cannot speak for.

delivered --near --open ranks the corpus an add ranks, at this verb's wider window, so the order a write volunteered once can be asked for again and each row says which half it came from.

Neighbours is the block's corpus as a value, with the boundary and the ranking on it, so the three readings measure what add ranks instead of a rebuilt list of that shape.

corpora.shape reads each pin through the package's own census, totals and per block, and the drift advisory says it: turing holds 3 open against 901 delivered, which is what a design can now cite.

The summary earns its count on three grounds the fold does not reach: it counts across both codes, it is there where a run of one folds to nothing, and the missing-entirely split is one no fold makes.

The census prices the blocks the report prints, off the fold lifted out of the gate, and names the runs it charged once so a smaller total is not read as a note that stopped firing.

The note is the interpolation after the blank line, exact in both directions; a site spelling none falls back to the first call, so an undeclared kind fails by name instead of passing in silence.

A dismissed role on the deferred store's shape: dismiss files a subject, a reason and a required premise, and reopen files it as work when that premise breaks.

The two streams are ordered by one function both callers go through, with the reason written down and a run that reproduces the reversal without it.

The un-wiring says the approval it wrote goes with it, so a foreign server left declared and unapproved is a state the caller was told about rather than met.

A key this build declares under another table is reported as misplaced and names which, read from the map config prints, and RK1064's sentence stays for the key nothing declares.

The three scans share one reading of a composed command, so a span crossing an f-string's parts re-forms and the scan that reads a name reads ids and governed files too.

A narrowing flag with nothing to narrow now says so on its own row, and a --have word outside a vocabulary the project did declare is refused as add --requires already refuses it.

The four pairs are declared with answers(), so the dispatcher refuses them before a handler runs and the served schema carries the rule instead of only the exit code.

A vendored engine is the directories its declared surfaces live in, derived from CARRIED — 3.89 MiB across 90 files where it was 22.46 across 973.

The census says it covers only the sites composing through the prefix, and beyond() is the 398 spans outside it, asserted non-empty so the sentence cannot go false in silence.

has says which of three questions it takes, and on_disk is the one forty-one call sites were spelling out with a path lookup and an is_file beside it.

The harvested sentence is sent once per table and joined on a field each key row already carries, taking config --json from 34,172 code units to 23,640.

The parenthesised supersession is read by shipping.replacement beside the writer that composes it, and the guard that missed a regex now reads calls rather than lines.

Every served argument is now shown in a call the shipped pages spell, and a test holds it: 2,437 code units on the turns that open a page, against 9,939 of schema every session pays at connect.

A refusal that derived an address now publishes the retry as an argv list with that address beside it, so the one part a caller executes is read rather than parsed out of the sentence.

A row may now name what has to be edited first, in a file this tool does not own: the precondition prints above its door and repair leaves it alone instead of dispatching a refusal.

A message that spells one door with the invocation and another verb without it is now red: the pair is the tell, so prose naming a flag family stays legal.

Two withholding reasons quoted figures that had gone stale and now name the reads that take them, and a sweep over that closed set refuses a measured number where an address belongs.

The prose beside a table is a declared population with a holder each, the extraction shared and the claim per table: two are decidable here and two already have closures of their own.

A pause reports what the rendered line came to against the limit that bound it, closing at the accepting end the sentence govern limits.why opens at the choosing one.

The rows an add volunteers are priced per write off the composer they moved out of Insertion.stated into, bounded by ranking.VOLUNTEERED and withheld from the served surface as its two siblings are.

install asks config which file governs a tree, so a pyproject-configured root is no longer offered init and a subtree is told what governs it rather than offered a second backlog.

Every composed door is quoted with a double quote, which cmd, PowerShell and a POSIX shell all read as one token: the line report prints was measured broken in cmd and now runs in all three.

Every writer of roadkeep.toml renders, parses and refuses before the bytes land, the check being config.readable and the population an AST sweep that named a sixth writer the count had missed.

The first non-goal opens the list, as criterion add and priority add open theirs: the heading lands where init writes it and the answer says it appeared, so the table declare opens is usable.

A handler may answer with a Result carrying both registers and its code, dispatch renders it, and the eighty-seven still printing are named in a list RK1615 empties.

The sweep asks the parser what is registered as a handler instead of asking the source what one looks like, so the shape is refused where a verb is declared.

The served surface takes a handler's Result instead of the stdout it printed for a terminal, and the nine still answering in a code are named, unserved, and each for a stated reason.

The three shapes seventy of ninety-two builders answer in are declared as data, and a sweep refuses a twenty-first nobody named, the forty-five one-offs being rows that leave as they conform.

A refusal publishes its fields on both surfaces: the register asked for is its own slot beside the argv that says what the caller typed, and the payload is the served answer where there is one.

The capture path is quoted so its door runs, the transport rewrite is a decision, and no site is a work-list item.

The three reads run, engines survives the config it is offered for, and the two false clauses say what the tool does.

The dependent's line and the uncounted read both run, and the audit door is backticked so a scan can take it.

The three ledger reads run, and the restate door now carries the invocation, so both alternatives an inherited claim names are findable.

The two govern refusals run against a scaffolded project and a bare tree, and a help door is executed rather than treated as a failure.

Both branches of the malformed-anchor read run, and the move refusal is deliberate: the branch composing its command is one no fixture can reach.

The two deferring sites run against a store and a queue, and the reconciling refusal names the resume that has to happen before the status it named.

The three linting sites run against fixtures of their own, and the flag export.unmarked names now follows the finding rather than a literal.

The three states of the .gitattributes row run against a repository, and the door two of them name is spelled with the invocation, which is what makes it findable.

no record is both built by two modules and reached by position, so the sweep is declined and the intersection is held as the gate that catches the next one.

the record three subjects share is keyword-only, so a field inserted above another is a compile-time question rather than a published figure moving in silence.

A refused call under --json publishes the violations, the two clauses above them and the sentence, in the record's own names.

the capture dump's filing door is backticked and found, and the handoff row is reclassified as the pipeline into another tool it always was.

two more composed doors are executed against an outline with two families, which found a narrowing door whose placeholder any shell splits and two row states that overstated the fixture.

three more composed doors are executed against a scaffold and one write past it, which found declare non_goals naming a command that refuses on every project it was written for.

three composed doors of the partial-ship family are executed against two lines of ledger, which found one door no backtick scan could see and one that refused as printed.

A block title takes the section title's three rules at both doors; 136 titles across the three corpora refused the fourth the design asked for, Turing writing bold and backticks in real ones.

The prose half warns with the count per source instead of failing, this file's own advisory register, so a reworded Shio sentence no longer reds a build about a rule it says nothing about.

unclosed counts what the filter set aside on the walk it already pays for and names the entries accounting for none, silent where every one of them worked.

The two reads differ on half the insertions and 15 of 18 show a row no width of --near reaches, so the row keeps that verb's phrases and stops claiming to be its rows.

Read per block across three backlogs, the open half takes 9.5% to 20.8% of the rows as its share of a block goes 3.8% to 38.1%, so three holds; Turing is not the inverted corpus.

Five stale surfaces printed 1,149 characters of which 791 was one sentence repeated; the run folds to that sentence once and its addresses, and an absent page naming a verb keeps its row.

The note sweep takes the first call in an answer's f-string, so a clause beside the note is no longer read as a fifth kind.

The census names both acts a mismatch can take instead of asserting one, and the sentence is a function this suite reads back.

the widest served note is composed against Engine.every_module, so the list it prices is the one a real note carries and in the spelling every other reader uses.

The declaration --invoke fell through is now said on stderr and as a payload key, so the one-line answer is unchanged and no longer silent.

A server declaration this command did not write is left where it is and named in the report, and uninstall keeps it for the same reason.

Every note code now has a state that produces it, so the seventeen are 2741 characters measured against the 282 this project trips.

The exemption for a shown word ends at a backtick, so a help string may illustrate a project value and may not build a command round one.

the gate reads a marker constant under both spellings, imported and reached through its module, and holds the pair as a pair so a third arrives as a red.

The seventh key narrows the open set, so the half-shipped state is a marker a project can name and a shipment that cannot says so.

The narrowing is declared at the parser, and the one rule no declaration can spell is measured as the only instance of its shape.

One of the fixture's two commits carries a body and the sweep asks origin about the id that shipped, so a flag printing a message is readable.

Measured: 2 of 119 declare choices and both separate, and the wider signature calls budget --block inert where a block is not part of a line.

The departures read the deletion's own record, so the constraints a dropped design quoted are read once by the function that deletes it.

A clean gate says how many lines a constraint reaches whose own design answered it, so the suppression is visible where the gate is read.

A backticked module.name in governed prose is resolved against the package, so a design naming a renamed symbol is a finding.

uninstall --engine weighs the vendored copy and removes it, refusing a tree that carries a .git, and the kept row names it.

A backticked command holding an unquoted placeholder with a space is a red, read off what the package composes rather than off its prose.

The store lists oldest pause first with its age in commits and the reason beside it, behind a flag a caller takes once.

A brief names the id a folded criterion came from, joined out of the two files it already opens, so no bullet grows a field.

Taken on both pinned corpora the axis reads the same as here, and this repository has the longest span, so the shape is the reading's.

The row says the figure is a floor where no dep resolves and no design is quoted, measured at 1359 against 3235 on this backlog.

The table sentence a listing prints says a version names the commit that wrote it, which is what pinning here holds.

The id a retirement names is read by a function beside the one that writes it, and a second site taking the head off by hand is refused.

An exposed argument the shipped guidance never spells a call for is named beside its price, which is the reading the surface had never had.

a page's row says what of it is the declaration, measured at a fifth of a percent to half a percent, so the frontmatter stays where the page states its own claim.

the guard's comment names the one collision the enumeration finds, and a test holds the prose against the table so a word called a command here has to be one.

The bound reaches a caller as a field of the refusal payload, which is the half the remedy table had already taken.

govern names the door a limit does not reach, so an author choosing limits.why is told a pause is charged against the rendered line instead of finding out by a long reason landing.

sixty of sixty decisions were filed by a departure, so the role keeps no door of its own and the measurement that says why is held as a test.

the reading an add volunteers carries the id and rank a later retirement joins on, so the population that could score the query half is published and no log of readings is stored.

the orientation leads with what an ungoverned tree still owes, so the first command it names is the one that makes the other four answerable, and the sweep runs it.

govern reads back the file it would write and refuses with the parser's own sentence, so a number two keys forbid no longer lands and closes every verb behind it.

every unreached row of the composer work-list names the state its fixture wants instead of one shared constant, and no two share a reason.

a section title, a non-goal's lead and a criterion's are held to the mangled rule their own line's fields are, through one shared function, and a section body is still the prose it does not read.

the split that decided the mangled rule is re-taken over the pinned corpora on every run, so a field growing a run or prose losing every one is a red rather than a docstring gone stale.

an incidental path this tree does not hold is a note naming the report it stopped filtering, so a filter that quietly does less is said rather than read as a louder backlog.

the near row names the listing for each half it counts, so a reader who suspects the fourth-nearest can open the open lines as well as the deliveries.

the window stays three and the reason is now measured: the open half takes one slot of thirty-three and widening reaches no pair three does not, both held as tests.

the read that lets a reader choose between the four rows is said once on whichever fires first, taking the note's worst case from 893 to 692 code units with every move still on its own row.

the kinds table is held against the sites that append a note rather than the guard three of them call, so the per-call kind is covered and a second one is a red.

cost --notes prices the four notes this server appends, composed at their widest from the functions the answers use, and says which one is paid on every call.

engines carries a fifth row for the command the harness runs, so a declaration naming a program this tool did not write is reported as unreadable rather than as none.

Part's docstring states the three subjects that share it and a table holds the callers total, so a record used three ways says so and a fourth is a red.

the note codes are declared beside the remedy table and held total against the emitter, so cost --notes says how many of them fired here and how many this project never meets.

a composed command carrying a marker constant is now a red, so the repair the codepoint scan rewarded is caught by the shape a backticked span makes it.

markers.working is the sixth key, so every door that takes, reads or releases a claim uses the marker this project declares and a backlog spelling its own can be worked.

adopt declares --ledger and --sections two answers, so the dispatcher refuses the pair before a handler runs and the served schema, the sweep and both surfaces read the same rule.

every served boolean is now run with the flag and without through the argv the server composes, so a flag this transport makes inert is a red rather than an answer nobody can tell apart.

Every one of the thirty-six sites is run or deliberate, and running them found eleven defects no reading of the same messages had.

section drop now names the constraints the deleted prose quoted, so the fourth door that removes a design reports what the three departure doors already did.

every register now states the quotation it measured rather than a settlement it cannot see, so a design citing somebody else's answer no longer reads as having made one.

uninstall now names the vendored engine among what it keeps, with the version where the tree states one, so the copy nothing points at is reported rather than left silent.

brief now says a line carries no criteria and names the command that writes one, so the absence is read before the first edit rather than at the partial marker.

pick counts the deferred store beside ready and blocked, and names the read that opens it.

retire --folds-into moves a line's own claim into another task's criteria and ends the line, in one write.

weight reports what each comparable filed behind it and the span it arrived over, bounded by the next ship.

adopt prices this backlog's widest brief beside what the surface costs, at the moment a ceiling is chosen.

install --check dates the committed bridge from its bytes where no record does, over this engine's own history.

one function composes a carried line and one beside it decides whether a line is one, round-tripped by a test.

budget --ship --decides prices the decision line beside the ledger one, and the exemption naming it is gone.

each reference page declares the one verb it saves a reader, and the absent-page note quotes it.

a table names every served name that is also a verb of a different act, held total against both enumerations.

a length violation carries which ceiling refused it, and a line-bound refusal says the field is legal and cites the line's key.

a sweep over the prose fields the parsers declare refuses each one over its limit, with nothing written.

brief says a design answers a constraint and names the ship flag that carries it, before the ship deletes the design.

a test holds why the query half cannot be scored: all eleven known answers are written into the field a query would join.

a test holds refuses against what lint does with each governed key, and the two that no gate reads say so in the field.

char.mangled refuses a field whose bytes came through the wrong codec: 0 false positives over 3,962 fields, 18 over prose, so it reads fields only.

[history] incidental names what a hook writes every commit, and the projections join the paths this tool writes.

the near rows rank the block's open lines beside its deliveries, counted apart and marked apart.

engine.disagreement files one row per differing copy, each carrying the move that closes it: 893 units against 643 joined, which RK1491 made readable.

serving.NOTES declares every note kind with the rule it is under, held total against the literals the module passes.

the declaration reader recognises the launcher this command writes, and answers nothing where it finds neither spelling.

cost --notes prices the sixth cadence: 282 per run here, 643 for the widest note composed, and no ceiling — small beside every other cadence.

the absence a requirement produces now carries the line's symptom and the two commands that take it.

the pairs fixture is a repository with a shipped section, and what it still cannot reach is named — which found origin --why --json swallowed.

ship, retire and close now name the constraint whose answer went with the design they deleted.

install now says what landed when a vendor copies an engine and the surfaces then refuse.

The reading is taken at the pins and it falsifies the premise: Shio's widest brief is 3354 against 3300, and the graph rows are a tenth of it, which cost --brief now splits.

install --check names the absent record and the gate says the direction is unestablished, so a project wired before RK1462 is told rather than guessed about.

record amend asks no count where every continuation is one this tool wrote, so a checked entry is corrected in one call and a hand-wrapped one still costs the span.

A table pairs each budget subject with the write it prices and holds the option spellings both ways, and the two words retire and defer use are taken here.

The gate tells a surface behind this engine from a page the project never had, and the summary line a skimming reader sees carries the count and the door.

The CLI takes the MCP spelling of a verb and of a field, saying which one it used, and never respells a verb it has of its own, RK353's refusal becoming an acceptance.

amend --add-dep and --drop-dep name what changed and derive the group, and an addition the line cannot hold is refused naming that dep rather than the sentence that never moved.

budget --defer prices it: Budget.carried is prose the field keeps and the caller does not retype, and reason_room is what the line leaves, which defer now refuses past.

non-goal list now carries a settled row per constraint, naming the open lines whose design quotes its lead, so the gate's silence is readable from the rule as well.

The corpus is both prose fields now, the why being where two authors of one defect agree: nine of the eleven known pairs land inside the five, worst rank three.

A ceiling declared as [reads] list, held by the verb on the answer it composes: over it list prints that selection's blocks and counts, and the largest --block that fits.

the ship withdraws the block drop it would be refused for and states the ending instead, so a sweep is never handed the command that write just blocked.

the claim two files copied is respellable and never rewordable, so a correction folding to the one on record lands and a rewording is refused by name.

unclosed drops a commit that touched only governed files, so a corrected why or rationale no longer reads as work that landed and the report is code again.

the gate names a verdict that came from code no disk holds, and the write is not refused: the only remedy is a restart, which is a door neither a gate nor an agent can open.

a home stating another version replaces the mtime inventory with the two numbers and one remedy, because the code that answered is on no disk and no module decided that.

engines --invoke answers the command this project declares rather than restating the launcher's resolution order, of which it knew two of four entries.

the gate note carries a third clause for the engine vendored here, so a project running two local pens at two versions is told once per commit and not only on demand.

requirements declared may be a table of what each word is, and the refusal that withholds a line quotes it, so a caller weighs the gate instead of believing it.

the wide anchors listing carries the live rows and counts the retired behind --retired, so an id project is not handed 175 KB of addresses nothing prunes.

the launcher stops probing before the server on Windows, where nothing is replaced, and connecting costs 58 ms over the engine instead of 328.

install --vendor pins the engine before it writes the surfaces and wires from what it pinned, so one run leaves a tree its own check passes.

brief publishes the design revision once instead of under every settled dep, which on a six-dep task was half of a deps block that was 46% of the answer.

install records the engine that wrote each surface, so a project whose copies came from a later one is refused and named the direction instead of downgraded.

budget takes --requires, repeatable, so the 21 characters of structure an add writes for a requirement come off the number before the sentence is composed.

ship --checked names a criterion this task carries and moves its own sentence under the ledger entry, so a verified claim no longer reads like an ignored one.

budget answers to --section-body and --section-body-file too, so the flag a caller priced a design with is the flag the add that files it takes.

budget --ship prices the sentence the ledger will hold rather than the line the id is on, which is the number brief already quoted and this read contradicted.

non-goal.reaches falls silent where the line's design quotes the constraint's lead, so a decision made once is recorded where it ages out with the work.

block list rows carry what the ledger records, and the block filter that cannot enumerate labels names it, so a caller placing work never reads the file.

block drop names what became of the block in the refusal, in the words block list already uses, so a sweep told to run it last gets an ending instead of a dead end.

revise corrects a decision sentence where it stands, keeping the entry, its marker and the superseded clause it did not author, so a typo no longer outlives the decision.

engines reads what the running home states now, so a copy swapped in place under a live server is a swapped row and a refused verdict instead of agreed.

engines reads a fifth copy, the engine vendored under .roadkeep/, so two local versions get a row each, a differ line naming both pens, and exit 1 instead of two clean reads.

The family register summarises the rows the wide read withholds, and a project numbering by id has no families — so the listing stated a count and no narrowing reached it.

The handshake's provenance line cost three git calls at twenty seconds each, outlasting the client's thirty; the placement now shares one three-second deadline and degrades to unplaced.

A sweep refuses the whole note list unpacked, compared or indexed, following one binding, and the suite's own module set is declared once (design recorded in tests/test_advisories.py).

Both registers come off one method: the payload publishes the same sentences the report prints, and carries an empty list under --check.

On Windows the launcher runs the server as a child with this process's stdio, so the process the harness spawned is the one still serving.

Every alternative in a joint span counts, and the two verbs nothing serves are a declared exemption the skill pays for by naming the keys (design recorded in tests/test_skill.py).

The session page renders cost --skill as a third cadence — the orientation and a row per reference page — and the build reruns when the skill moves.

The process-scoped notes fire once per server, name the modules that moved, and lead with the CLI remedy a session can actually run.

list --json carries a startable key over the lines its own filter selected, so the split reaches the served surface without a forty-fifth tool at connect.

Four sites now spell the slot the parser reads, and a test holds every backticked group in this repository to the template that declares them (design recorded in tests/test_quoting.py).

A wired project's gate note says when the engine answering is a modified checkout at no commit, so a moving version stops reading like a release.

brief and pick name the shipped entries whose sentences cite an open id, so the eighth caller reads what the previous seven learned.

A write ends with five lines saying what the surfaces let a session do — the daily verbs, the gate, the two reads that save a refusal, and the check CI runs.

The skill is an orientation of 11k units, the write path and the query surface being two pages install carries beside it, and cost --skill prices each (design recorded in tests/test_skill.py).

amend's usage names restate where it declines the symptom, and a declared registry holds every verb that turns a field down to naming the verb that owns it.

a length refusal carries a foresee row naming the budget read that measures the same draft and writes nothing, so the preventive verb is discoverable where the write failed.

lint says non-goal.reaches where a non-goal lead and an open symptom share a word the ledger rarely uses, as a note with the two reads that settle it.

lint reports a partial line with no criteria as criterion.absent, and ship --part names the criterion add that closes it in the same answer, so the gate is the backstop.

stats splits the open count where a project declares [requirements]: how many nothing absent is holding up, and the rest under what each waits for, a line naming two counted once.

Every generated section is in the contents list, stated once in headings.ts and merged into the route by a Starlight middleware.

The walkthrough's command blocks wrap like their output, so a command carrying a whole sentence stays inside the page.

The argument is quoted like the path beside it, and a sweep over every expanded block refuses a bare variable in any of the four files.

cost --deny prices a refused write off a real Refusal, beside the notice that already had a ceiling, and names the shell half without judging it.

The hook and the release are read back against the bumper's TRACKED, and the test fixture derives from it, so a fourth versioned file is a red (design superseded: it is stated four times).

One reading anchors the diagnostic and keys the remedy, so every finding filed against roadkeep.toml reaches its doors in the panel.

A sequence is one action naming its steps in order, or none where the first is prose, and roadkeep.run takes a list of argvs so both shapes compose the same way.

cost --skill prices the write path beside the served schema and says which sections it went to, served over MCP and with no ceiling declared.

The schema row names the held figure its room was taken against, so the line reconciles without the one below it (design superseded: the held figure belongs in the clause, not in the cost column).

All nine verdict addresses are now measured, each in the file that owns its verb, and each assertion was proved to redden with the suppression off (design superseded: each site had a test at it).

Two tables in cli.py name all thirteen returns with their argument, and a sweep holds them to be what it found (design recorded in tests/test_invariants.py).

Both --check verbs state the verdict from the run, so the offer is gone from every EXIT_GATE that was already an answer and replay is asserted silent.

A parser declares whether its exit 1 is a verdict, so lint --fix and repair close on the finding alone and a repair whose own step failed still offers.

Under an id scheme ref.missing names the section that closes it, and --fix writes the pointer where that section is already there (design superseded: deriving it unconditionally reddens --baseline).

The site is two builds under site/ — a Vite pitch whose copy is one module and the Astro area under site/docs/ — publishing site/dist/, so docs/ is the store alone.

explain --json publishes cause and no decision, so no finding page can print one sentence under two headings.

init --existing declares the governed files already there and scaffolds only the rest, reading the prefix off the ids and the blocks off the headings (design superseded: it left the shape open).

No reference page declares an order: the sidebar is listed from the payload's family walk order (design superseded: it proposed generated frontmatter, not a config reading the payload).

Every one of the 119 finding codes now carries a hand-written situation, and a test holds the join so a code added to the gate arrives with its sentence.

The site build now runs on src/** and roadkeep.toml, so a renamed verb, flag or config key rebuilds the generated reference on the commit that changed it.

Path.home() raises rather than answering, and three readers on the path lint takes through engines called it unguarded; no home now means no plugin is installed, which is an answer.

Every page keeps a plain-text twin converted from the same render, at its own address plus index.md, and the area publishes a generated index that llms.txt names.

A word budget per page declared with its argument above the key, refused by the build, with generated pages counted apart and a page that states a count failing too.

The laws are harvested from agents.md and the non-goals asked of the verb that owns them, and a test refuses any page in the area that carries its own copy of either.

One page for the system the verbs act on — the roles, a line's fields, the pointer, blocks, the two other bullets, and the four doors with what each leaves behind.

A throwaway repository with a drifted roadmap, the adoption run against it, and every command with the output it actually produced — captured by a script the suite executes.

The five surfaces a session receives, with what connecting costs and which tools are withheld generated from cost and the served schema, under the prose no read answers.

The whole of roadkeep.toml rendered from the read that owns it, with this repository's own file as the worked example, under what a person writes: what a number is for, and adopting one.

One page per finding code, generated from the table explain reads, under a hand-written sentence naming the ordinary act that put the reader there — the half no read derives.

One page per verb family, its table rendered at build time from the parser the tool emits as data, under prose written once, with the suite holding pages and component against that payload.

The area's own workflow builds it on every push and pull request and deploys the bytes that build produced when asked, so nothing generated is committed and no publish is unreviewed.

The source sits outside the store and the build owns one reserved subtree of it, docs/guide, with the base, the output and discovery asserted against what declares each elsewhere.

An Astro and Starlight area with its own sidebar, per-page contents and build-time search index, sourced from site/ and built into a reserved subtree of the store, with the entry page as its first.

One read prints the parser as data — every verb, its arguments, defaults and the sentence the parser carries — so a reference generated from it cannot describe a flag that was renamed.

The two lists are declared constants and a census holds them against what the module puts on the parser, so a verb added to either half is a named failure and not a stale sentence.

A capture is a file of the project, so the three verbs that take one resolve it against the root -C named; a body file is not, and stays the caller's.

Both readers now print the argv that closes the row, composed once and complete wherever the capture recorded where it was aimed.

capture sweep deletes a capture whose filed id the ledger records as shipped, and names the three states it cannot prove spent rather than guessing at them.

Both surfaces a caller meets before calling name what this build fixes and no project declares, and neither copies the reading (design recorded in skills/roadkeep/SKILL.md).

Every sentence about engines says which question its count is for: four copies are read and three are judged (design recorded in src/roadkeep/installing.py).

The frozen root's directories are confronted with the rows that declare them, so an undeclared fixture is a red (design recorded in tests/test_backlog.py).

The doubled anchor an open line points at is read off Turing's own bytes at the revision that carried it (design recorded in tests/corpora.py).

The check names the other copy beside its repairs, off the one sentence the register report already prints (design recorded in src/roadkeep/merging.py).

Each row names the half of the wiring it read and defers to the verb that labels both, so the three reads reconcile (design recorded in src/roadkeep/installing.py).

The row reads the attribute half back, so a tree whose files already route is told that rather than offered the flag (design recorded in src/roadkeep/installing.py).

Where a machine holds two copies the report names both, so the caller chooses knowing there is a choice (design recorded in src/roadkeep/rendering.py).

engines names the driver git would run beside the tree writing here, and never reads its version, which would mean running it (design recorded in src/roadkeep/installing.py).

Git sends all four of this repository's governed files to the driver it ships, so its own merges are decided the way it claims (design recorded in .gitattributes).

Every pair that imports itself back is named — thirteen with what the boundary does, eight as work nobody has looked at (design recorded in tests/test_cycles.py).

The record sits with the reading that builds it, so the presenter imports it once at the top and the reading names its return (design recorded in src/roadkeep/budgeting.py).

config states what this build fixes from its own corpus with the reading beside it, so the conversion is a command not a script (design recorded in src/roadkeep/budgeting.py).

A law cited from any governed sentence resolves against the table that declares them, and is law.unknown where it does not (design recorded in src/roadkeep/linting.py).

All eight blocks state what finishes them, two criteria each, read off what that block's ledger actually delivered (design recorded in docs/ROADMAP.md).

The refusal states the free address, and the retry it earns replaces the destination rather than the source (design recorded in src/roadkeep/verbs/refusing.py).

A second project sweeps the four writes the first could not reach, and the two exclusions left are about what the verb answers with (design recorded in tests/test_answers.py).

Every write's rows are swept for one outside the shared column, and the three that had one — criterion add, declare, govern — no longer do (design recorded in tests/test_answers.py).

A brief's three allowance rows state their figure the same way, so the comparison they exist for is one reading (design recorded in src/roadkeep/briefing.py).

The volunteered rows say how many of how many, and name the listing that holds the rest (design recorded in src/roadkeep/authoring.py).

A role whose path names a directory is read as the absent file it is, so a report cannot fail a write already on disk (design recorded in src/roadkeep/authoring.py).

Every row of an add's answer begins at one column, and the printer it shares has no default indent left to fall back to (design recorded in src/roadkeep/rendering.py).

A caller passing a withheld argument is told it is withheld and why, in the sentence declared beside it (design recorded in src/roadkeep/serving.py).

Every add names the three delivered here nearest the symptom it just filed, at the moment nothing is spent but an id (design recorded in src/roadkeep/ranking.py).

Every served tool answers for what it does not offer, so claim now takes --have and git's five carry the sentence that explains them (design recorded in tests/test_serving.py).

A successful write over MCP says when the code that validated it had moved on disk, and names the gate that judges what landed (design recorded in src/roadkeep/serving.py).

govern --instead replaces the argument above a key rather than stacking on it, and names every line it took out (design recorded in src/roadkeep/governing.py).

budget aims an amend at the sentence it writes and not at the one it deletes, the remainder on a replaced field being the whole allowance (design recorded in src/roadkeep/budgeting.py).

A brief's shipping and deciding allowances are the whole field, that sentence replacing the line's rather than extending it (design recorded in src/roadkeep/briefing.py).

The session ceiling is this checkout's own served surface, re-taken from its reading and argued where govern puts it (design recorded in roadkeep.toml).

A ship names where its decision keeps a body, so an outline project files one the same way an id project does.

The spec brief composes is a document export writes, bounded by a file rather than by a tool result (design recorded in src/roadkeep/exporting.py).

A decision keeps a body in the decisions file, addressed by its id and deleted by nothing.

The tool list is composed per project, so a verb that is one role's whole grammar reaches only a project declaring that role (design recorded in src/roadkeep/serving.py).

The install report heads with the project it wrote to, and names the engine only where that is a different tree (design recorded in src/roadkeep/installing.py).

A finish with no criteria says so and names the verb, where a project uses them elsewhere and this block was not one (design recorded in src/roadkeep/rendering.py).

The queue's finding keeps the arbitration its verbs already kept, and the unread row that names a line it could not take stays (design recorded in src/roadkeep/linting.py).

The criteria reader keeps the arbitration its sibling got, so no drop is offered for a line carrying an id (design recorded in src/roadkeep/criteria.py).

A bullet the task grammar already read is that reader's, so no door offers to drop a line carrying an id (design recorded in src/roadkeep/scoping.py).

The backlog question asks all four kinds, so a cycle well-formed on both sides and present only in the merged file is refused (design recorded in src/roadkeep/linting.py).

The driver asks the backlog what one file cannot answer, so a dep on a line the other side removed is refused by the id it wrote (design recorded in src/roadkeep/linting.py).

The driver refuses the findings no version already carried, so a branch is not blocked by a line it never wrote (design recorded in src/roadkeep/merging.py).

The estimate asks for the byte-level walk by name, so a mark the fixer closes is counted in what adoption costs (design recorded in src/roadkeep/linting.py).

A file that does not decode is refused by name with the door its ownership decides, rather than by the decoder's own sentence (design recorded in src/roadkeep/adopting.py).

A field the ledger declaration removes is not measured, so no row counts against a slot the shape has not got (design recorded in src/roadkeep/adopting.py).

The fill width is read and never counted against, so an estimate stops naming edits nothing would ask for (design recorded in src/roadkeep/adopting.py).

The reread tries both other roles and the header names all three, so a rationale file is priced as prose rather than as nothing (design recorded in src/roadkeep/verbs/adopting.py).

A file nothing parsed is read again under the other role, and every estimate names the grammar that answered it (design recorded in src/roadkeep/verbs/adopting.py).

A field nothing parsed is reported unread in both registers, where a zero longest beside a zero over read as a measurement that fitted (design recorded in src/roadkeep/rendering.py).

The gains column is padded to the widest label of the rendering, so a label reaching the old constant no longer runs into its sentence (design recorded in src/roadkeep/rendering.py).

An undeclared key is told the number that holds it, or that nothing does and which gate is off until one is written (design recorded in src/roadkeep/governing.py).

The second spelling is deleted, so deps refuses through the class whose three answers include the pause and its door (design recorded in src/roadkeep/verbs/querying.py).

A paused id is told which store holds it and the two verbs that read and undo it, instead of two guesses that are both false (design recorded in src/roadkeep/showing.py).

A door carrying the id its finding holds names it, and its sentence says what the command it names actually reports (design recorded in src/roadkeep/remedying.py).

A blank the sweep cannot fill fails loudly wherever it sits, and the caller that may have a continuation is the one that says so (design recorded in tests/composing.py).

Five rows have their doors run against the state that produced each finding, and the loop ends where the gate is clean, not where a call parsed (design recorded in tests/test_composing.py).

A duplicate anchor is closed by the verbs the project's own scheme has, an id-addressed section being one no move re-addresses (design recorded in src/roadkeep/remedying.py).

The session budget names the ranking first and the total second, a read having gained the ordered several a choice already had (design recorded in src/roadkeep/remedying.py).

The ranking states what the gate refuses and the ceiling it refuses it against, on the read somebody runs to decide a cut (design recorded in src/roadkeep/serving.py).

What names the checkout is counted into what a session pays and subtracted from what the ceiling holds, so the verdict stops moving (design recorded in src/roadkeep/serving.py).

The schema row derives its room from the ceiling the gate refuses it against, in one spelling both once-rows now share (design recorded in src/roadkeep/budgeting.py).

The anchor is spelled only where it is not the id the entry already opens with, which returns 8 characters per clause under an id scheme (design recorded in src/roadkeep/shipping.py).

The room is taken off the composition before it is attributed to the field the message names, so the retry it invites lands (design §RK1331 recorded in src/roadkeep/shipping.py).

A refusal naming nothing to shorten to reads as do not say it, so both crowded messages name where the note goes (design §RK1330 recorded in src/roadkeep/shipping.py).

a title equal to the anchor the write just derived is refused, and the refusal says what the argument is for (design §RK1329 recorded in src/roadkeep/sections.py).

declare opens an opt-in table as well as a role, and both refusals name that command instead of a hand edit (design §RK1328 recorded in src/roadkeep/adopting.py).

each pass declares the words it produces and REPAIRS is derived from them, so a repair with no word is a red (design §RK1327 recorded in src/roadkeep/fixing.py).

the plugin answers only for the project this process is in, so a root it was pointed at publishes no call (design §RK1325 recorded in src/roadkeep/provenance.py).

doors is the one name and always a list wherever a payload offers a command, and the costs that were not calls say so (design §RK1324 recorded in src/roadkeep/remedying.py).

the fixture declares [criteria] and every live block states what would finish it, so the table is proven by the artefact (design §RK1323 recorded in roadkeep.toml).

the working copies are one terminator again, and an invariant refuses a tree that is both (design §RK1322 recorded in tests/test_invariants.py).

the surface subjects moved to cost, so budget is third-largest and each verb answers one tense (design §RK1321 recorded in src/roadkeep/verbs/querying.py).

whose prose a number is about is said by the caller that composed it, so one payload no longer answers two ways (design §RK1320 recorded in src/roadkeep/budgeting.py).

lint reports criterion.orphan at a Done when heading no block or open line answers, and --fix takes the empty one (design §RK1318 recorded in src/roadkeep/linting.py).

the event carries the door its stage makes available, composed once and rendered by neither register (design §RK1319 recorded in src/roadkeep/rendering.py).

a task's criteria heading is re-addressed in the transaction that moves the line, and the move is named (design §RK1317 recorded in src/roadkeep/criteria.py).

a block's criteria leave inside the transaction that withdraws its label, and the leads that went are named (design §RK1316 recorded in src/roadkeep/blocking.py).

the commit list leaves on stdin, so the read is bounded by history and not by the operating system's argv (design §RK1315 recorded in src/roadkeep/history.py).

each table's sentence is read where that table is documented, so a shared key set no longer lends its words (design §RK1314 recorded in src/roadkeep/describing.py).

init writes [criteria] empty and the requirement vocabulary as a commented stanza, so both verbs work on day one (design §RK1313 recorded in src/roadkeep/adopting.py).

--replace matches the prose with its wrapping collapsed, so a sentence copied from section show is the sentence it finds (design §RK1312 recorded in src/roadkeep/sections.py).

the guard counts --requires, the confirmation names it among the fields that moved, and show prints the group (design §RK1311 recorded in src/roadkeep/authoring.py).

section find names the anchors whose prose carries a string, with a count each, and the failing --replace names them too (design §RK1310 recorded in src/roadkeep/sections.py).

an add that leaves a follow-up now says what that body may weigh, in both registers, before the paragraph exists (design §RK1309 recorded in src/roadkeep/authoring.py).

a stale wired surface is a note, so the exit code says whether the governed lines drifted and nothing else (design §RK1308 recorded in src/roadkeep/linting.py).

which empty a listing is and the door that fills it reach the payload, and a test holds the class (design §RK1307 recorded in tests/test_doors_in_both_registers.py).

brief's payload names what each optional clause spends out of the ledger sentence, so a ship carrying both composes from it (design §RK1306 recorded in src/roadkeep/briefing.py).

budget answers for a retirement too, on the ledger line retire writes and less the prefix it derives into the reason (design §RK1305 recorded in src/roadkeep/budgeting.py).

pick and brief name what the declared priority waits on and the ids that would release it, beside the fall-through (design §RK1304 recorded in src/roadkeep/picking.py).

ship --part names the door its open half leaves, so amend --dep is read off the answer, not by being handed the line twice (design §RK1302 recorded in src/roadkeep/shipping.py).

brief keeps the count whole and cuts the roster to the lowest four with the remainder named, the walk now ordering by id (design §RK1301 recorded in src/roadkeep/briefing.py).

The ship that empties a block answers with that block's criteria, each with its why, so the reading arrives at the one moment it is owed (design §RK1300 recorded in src/roadkeep/rendering.py).

A collective token's expansion is one note naming the lines that wait on it, so a clean run states each fact once instead of once per line (design §RK1299 recorded in src/roadkeep/linting.py).

brief publishes one budget table and names the other two as their difference from it, so no unchanged row costs the payload twice (design §RK1298 recorded in src/roadkeep/budgeting.py).

A line states what must be present with (requires: …) from a declared vocabulary, and pick offers it only to a caller that passed --have, naming the rest.

The reading carries the comment run standing above the key, verbatim and a line at a time, so the argument the write kept is what the read hands back.

The answer reads the comment lines that were placed rather than the flag that was passed, so an argument that wrapped to nothing is told which flag writes one.

An argument byte-for-byte identical to the bottom of the stack already above the key is not written again, and the answer says the reason already stands.

govern --because "…" wraps the author's sentence into comments above the key, stacked on whatever argued the number before, so a governed number carries its reason where its reader is.

A count of what exceeds a ceiling says what it was taken over, so no verdict covers a line nobody measured.

The named read keeps the rule the unnamed one states, so a line with no brief is said and not priced.

The note about a bounded reading fires where the shortfall is news, not on every clean run.

The reading carries how many open lines there are, so no report reconstructs it from a subtraction.

A brief the ranking cannot compose is named, so the widest is never one that went unmeasured.

The gate prices the briefs pick offers next and names how many open lines that left out.

A brief is measured in the unit a tool result is paid in, and [reads] brief is the ceiling the gate holds (design §RK1286 recorded in src/roadkeep/budgeting.py).

A refusal drops the door the schema appends where that door is false for the call being made.

The reading behind a decisions limit counts the claims a ship would carry into that file.

The barrier reads the project once per call, so an allowed write costs one config parse.

A table declared at several addresses reports how many, so one of them is never printed as the value.

A decision refused over its inherited claim names the two real doors, and brief prices it first.

A hand edit to the config is allowed and told which of its numbers have a verb, deciding nothing (design §RK1280 recorded in src/roadkeep/guarding.py).

The roles a limit is measured over are derived from the declared set, so a role added is a role read.

The shape says what this project declared beside what this build defaults to, so a set key states its value.

The shape is cached on the clock of what moves it, and the config has a watcher of its own.

A criteria address refused for an id names where that line went, so a pause reads as a pause.

A brief prices every clause and every file a ship composes, not the ledger sentence alone (design §RK1275 recorded in src/roadkeep/briefing.py).

A verb marks one decision replaced by another, writing the forward pointer and the marker in one call (design §RK1274 recorded in src/roadkeep/shipping.py).

A served description states each rule once, and the note gives way to the flag's own help (design §RK1273 recorded in src/roadkeep/serving.py).

A verb takes the reading and declares the number in one call, refusing one this corpus already breaks (design §RK1272 recorded in src/roadkeep/governing.py).

Completion and hover in the config file offer the keys the package printed, and the panel compiles none of them (design §RK1271 recorded in editor/extension.js).

A config verb prints every table, key, type and default this build accepts, and what this project declared (design §RK1270 recorded in src/roadkeep/describing.py).

A decisions role files an ADR as the line-and-section pair this format already writes.

A criterion is addressed to a task as well as to a block, and brief prints both.

A ship now names the file the deleted design's durable half moved to (design §RK1267 recorded in src/roadkeep/shipping.py).

The scrape sees a code whose head carries a hyphen and reads the module that declares one, so all four non-goal codes name the command that closes them.

A block states what must be true for it to be finished, as a list per block the ship never deletes, and brief prints it before the first edit.

A configured project declares a role it turns out to want, getting the file with its block headings and one inserted key, so no retrofit is a hand edit.

A one-clause correction names the two strings and edits the prose on disk, so a table or a fence the call never names is never retyped.

A refused remainder is reported under the flag that carried it, with one sentence saying which of the call's two sentences the rule is about.

A ship refused for length names what each of the two arguments took and which has room, and the shipping allowance quotes what a supersession will spend.

The three verbs that write a body take a path over MCP too, so a rationale refused at 257 words costs an edit and a path instead of the other 250 characters again.

init --deferred scaffolds the store and its key together, so the pause door a project opts into is written by the command that writes every other governed file.

add --ref <family>.1 --section opens the family in the same write, titled from the block, so a block's first design is a child exactly like every later one.

An undeclared block is named beside the fields that are wrong, where the block is answerable regardless of the prose.

A refusal for a missing terminator states what ending the sentence costs where there is no room for it.

An unrecognised flag that names a positional says so, and every verb's refusal lists what it takes by order.

Every section carries what a model is charged for it, as a column beside the two ceilings and never as the order.

The section breakdown is ranked by the limit about to refuse, and the reading sits under it rather than over it.

A resident row has three states, so a file that is not there says so and states no room.

The read consulted before an edit states what a model is charged, as a reading beside the limits and never as one.

The summary row states the conversion and stops, leaving which unit refuses to the gate and the per-file row.

Every resident row states what its own declared limit has left, in the unit that limit is written in.

The refusal defaults to naming no route, so the four messages that block a turn say one thing.

A census holds every record carrying the served prefix against the site that fills it from the one reader.

Both cadences are reported in code units, with the bytes the gate refuses on named rather than converted away.

The declared case is the prefix itself, so the second field RK1242 added is deleted rather than validated.

budget --session prices the SessionStart notice beside the schema, in the unit its ceiling is now held in.

The session-start note names what else answers where a project declares the server and its tools never arrive.

The description split names its own unaccounted bytes, so both levels of the breakdown balance exactly.

The refusal and the note read [install] enforced, so quieting a stale surface no longer buys a guard on every write.

The description row is split by where each clause is written, so a tool's always-passed flag names its own help.

lint carries a gate.behind note beside its verdict on a pinned project, so a clean report says whose clean it is.

The guard asks the version first and pays for git only where two copies claim one, which is 2 ms against 45.

budget --tools takes a tool and ranks its own fields, naming the module each help string is written in.

A governed write is refused where the project pinned a version and this copy is behind it, naming the copy to run it through.

lint --since reads the block: every open line's source moved and none shipped is said once, and replaces the per-line notes.

A partial shipment states what is left, as a field on the open line rather than a subtraction the next reader performs.

auto answers half the cores, so a full run leaves the machine to the session that started it and two sessions in one checkout stop asking for 56 workers on 28 threads.

renumber rewrites the trailing (<id>) the tool itself wrote, leaving an outline anchor where it is, and the report names that anchor rather than the new id.

engines --invoke prints on one line the command that reaches the copy wired to this project, so composing a shell call needs no listing of a plugins cache.

A dep whose rendered group does not read back, or carrying the pointer arrow, is refused at input — so the line the tool could write and no verb could reach is not written.

lint --since notes task.worked where this change touches a path an open task's section names, which is the mirror of the check that prose moved without its line.

section add and section amend resolve every anchor the body cites and refuse ref.dangling with the addresses named, which is the code the gate reports for the same defect.

brief names every qualifier the ledger records for an open line, so resuming a partial no longer means reading the design to recover what is left.

budget names the sentence and terminator rules beside the widths, read off the role's own schema — which the line half was not using, so its numbers were the base's too.

budget --body no longer needs an anchor, so one call prices the line and the body add validates as one unit — the retry no longer carries the rationale again.

A label declared elsewhere and missing from a file that would take it is a heading to open: the refusal names that file and the --organise flag that reaches it.

remaining.unmatched fires on a pathspec with no metacharacter naming a directory that exists, which is the typo and never the migration whose sites were deleted.

Every field the caller states now wins over the line on file, as --ref already did, and the answer names which came from the call rather than from the roadmap.

The walk finds its steps as backticked spans through composing.runs, so the preamble is no longer read as one and the suite stops depending on whether a console script is installed.

The one-call form has existed since RK93 and nothing named it: every add that omits --section now offers it beside the follow-up it would have avoided.

A ledger path absent from HEAD that some commit once held is history and not drift; one still in HEAD is a deletion the gate keeps reporting.

The launcher asks a candidate to run before trusting it: guard falls through on any failure, and the two modes that may write or execv probe first.

A census holds every invocation() site to a state, and one instrument fills the placeholders and runs what a message composed — six sites executed, the rest named as work.

The pointer finding carries the anchor as its subject, so the door names the address that failed instead of the task id, and a sweep over an outline fixture holds the class.

The path.missing door names record amend, which reaches the ledger the finding is always about, and a test runs it end to end rather than matching its argv.

A payload the guard could not read says so on stderr, naming the bytes that arrived and that this is the gate failing rather than a write allowed; stdout and exit 0 are untouched.

The launcher expands ${VAR} and $VAR in ROADKEEP_HOME, answering CLAUDE_PROJECT_DIR itself, and a vendored copy is a candidate ahead of the sibling — the second half shipped with RK1193.

install --vendor copies the highest-versioned engine this machine reaches into .roadkeep/, verifies it, and the launcher resolves it before any sibling — one installer instead of one per repo.

The dead copy of Share.payload is gone, and tests/test_shadowing.py sweeps every module and class of the package for a name its own body binds twice.

A pathspec that reached no file is named on the headline and beside its clause, and published as unmatched, so a query that never ran no longer reads like a migration that finished.

defer and resume take a line whose ledger entry is a half, and the gate reads that qualifier off the changelog rather than off whichever file is second.

Where carries the paused state, so a refusal about a line the store holds names the store and resume instead of reading as a typo.

The id-reuse refusal names the flag the verb it fired at declares, so renumber and record renumber say --to where add says --id.

The empty-outline sentence names both I.1 and 1.1 and says the first address decides the system, so the one message that guessed no longer walks a decimal project into RK1210.

Two numbering systems among a file's top levels is two numberings, so next_family answers None there — the address no longer depends on which string a set iterated first.

section add refuses an anchor whose immediate parent is missing, naming every generation between the prefix it found and the address typed.

The refusal for a child whose family is missing names every section add that opens one, in the order they run.

add names the family a pointer's anchor extends before the design that extends it, so every call it hands over is one that runs.

block amend <label> --title gives a declared heading new words in every file that declares it, keeping the label, the placement and the work.

brief prices the ledger line through as_recorded, the function ship renders from, so the pointer's ten characters are gone from the figure and a --part is named as structure it cannot know.

The ref.missing refusal on a block whose prose has not started prints the whole path, ordered and with its arguments filled in.

restate names the why and the design as the two other places the claim it replaced is written, as the doors that reach them.

The gate reports install.stale for a vendored launcher, hook or skill behind the engine answering here, naming install; [install] pinned is how a project that chose its version says so.

Every prose argument budget takes is a draft it measures — --why, --symptom and --body answer with the overrun and exit 1, and the served schema publishes no ceiling to refuse one.

block list prints every declared block with its title, open count and state in file order, naming the labels only the ledger declares — the read add --block assumes, served over MCP.

restate --symptom reads stdin like every other prose argument, so a bare - is the pipe and never the claim it lands as.

init --strategy writes the fourth file and declares its key in one transaction, and the path is beside DEFAULT_PATHS rather than in it: that table is the layout a project has.

unclosed sweeps the open lines for commits naming them, dropping the one that filed each — the oldest, since add mints the id and nothing can name one before the line exists.

the porcelain is read once into a record that keeps both columns, and a loose path the index already carries says so — on the row and as its own key in both payloads.

the sweep is over the declared surface and this suite's own files, reading the AST so a multi-line decorator is where its definition starts — and the six instances it found are closed.

the scan is a hybrid — the AST for annotations, which have no scope under PEP 563, and symtable for everything else — and five dead imports that were live behind the old reading are gone.

the dead local is gone and STDIN with it — _one_body was the only reader left, and no other handler kept a copy of the condition RK1176 moved.

The mcp mode serves wherever it is started and names a missing engine on stderr, the deferral being the guard's rule alone.

the criterion rides with the brief as its clauses and what each matches now, so the claim the work is measured against arrives before the first edit rather than at the ship.

a roadkeep-evidence block is the same grammar with the sign flipped, counted by the same reader — and this task's own criterion answered 4 of 4 before the line was closed.

the reach is a floor the closure publishes with what is out of it, and ranking against the why is unsound because that field names the partner.

a mark inside a Markdown link naming a path is a reference outward, which the corpus already writes and the gate now leaves alone.

a label listed in blocks.standing is caught up rather than finished, so no sweep fires and no heading is offered for withdrawal.

the engine says which checkout does not parse and where, and the hook still degrades to unenforced.

the address is read off the pointer that left with the shipped line, which no prose diff witnesses.

add asks the same history section add reads, so a pointer at a retired address is refused where it is written.

which arguments read the pipe is the parser's claim, resolved once in dispatch, where the two-into-one refusal is asked for every verb.

the rules are a declared domain keyed by what each reads, the reporting phase is a second list, and a test holds both — a rule _examine calls by name is a red.

build_parser is a 39-line index over six declare functions, one per verb module, and the command surface fell from 32% of the package to 21% while the package grew.

every verb answers with one result and derives both registers from it, beside the verb that computed it — the door left composing JSON is the guard, whose three shapes are the harness's.

the withheld reasons moved to the arguments they explain, and each table that stayed now carries the measured reason it did — TOOLS' being the guard's own 44.6 ms.

the search reads the qualifier a partial entry carries inside its bold id, so the commit that ships half accounts for it.

brief prints the ledger line's allowance beside the roadmap line's, where the two differ, so the ceiling a ship enforces arrives before the write.

one command declares the namespace and re-addresses that file's own citations, which is knowable only in that transaction.

the row that answers is the newest whose install is still on disk, so a pruned version stops being what engines reports.

a row only stands the launcher down where the install it names is still on disk, and a row naming none still binds.

a contiguous run of never-carried ids is one row with its count, so the ids a reader can act on are visible.

every event carries the block's standing and the two verbs a block is driven with print it, so the follow-up list is one call fewer.

a dep whose ship is a descendant of the design's last revision is named beside it, as an ordering and never a claim.

the counts separate a stamp this project resolved from one it can only take somebody's word for, and name the repository.

the capture records where it was aimed, so a bare id becomes the delivery it was without the repository being typed again.

a stamp qualified by the repository holding the id is read as filed, because this project cannot open that backlog.

one command applies every difference the gate has that this machine can, and names the two it cannot.

a closure reads the floor pyproject declares and refuses the calls above it, over the package and the suite alike.

the half is named for the condition it is one side of, and a closure declares the two readers that cannot ask a project.

every variable the launcher reads is pointed inside the fixture, and a closure holds that set against the launcher's own source.

one predicate says what the three meant — a line spelling the engine followed by a verb, which a tool name never is.

every fixture git call goes through the runner that carries the identity, and the three that cannot say why in a table a closure reads.

the refusal leads with whose line overflowed and the amend that closes it, and names every line the write would break.

four spaces are a code block after a blank line and a list item's continuation after a bullet, so the state is a block and not an indent.

an unknown key names both readings once per refusal, and every config refusal now ends with the build that read it.

the refusal that computed the free address now hands back the caller's own call with it filled in, quoted, at the surface that made one.

the clause is derived from the revision each pin replaced, so a skip says which of three things happened instead of asserting one.

the rows that say a reading is unread now carry the door that reads it, published in the one shape a door already has.

neither door: both pins hold zero offenders under Shio's own declaration, so the disagreement is declared instead — their bytes under this repository's schema.

The two dep kinds a re-pin retired are frozen as their own bytes beside a config that parses them, and the skip that replaced each names where the shape went.

Both pins moved and every number under them was re-measured, and two shapes that shipped out of the live trees are an absent input rather than a weakened claim.

The capture row prints where one is unfiled and carries the total there, and the payload keeps the state a report stops saying.

capture filed stamps a capture already on disk, refusing an id no governed file holds and a path this project did not write.

A capture carries the id it was filed as, stamped by the add that files it, so the count reads the artefact and a reworded symptom no longer leaves a row nothing can clear.

A free top-level says it is an address and not yet a section and names the section add that declares it, on stderr and in the payload, where a free child says nothing.

report says the kept file is not a backlog line and prints the add that files it, and stats counts every capture and names the unfiled ones.

The refusal names ship --why as the exit whose sentence records the abandonment, the three shapes for a second record each being blocked by a rule the format keeps.

Either side of the comparison may be the directory, and the trailing slash git spells a collapsed tree with is what keeps the third case exact.

Building and committing moved to a trigger-loaded project skill, so the every-turn file dropped to 104 of 125 lines and the pointer is what stays.

A per-sentence pass reclaimed two lines and 124 bytes with every rule and measurement kept, and measured the prose and the index both at their density floor.

The index closure reads what is tracked and what is written but not yet added, so a surface reaches it on the turn that wrote it and both directions read one set.

The amend payload carries what each changed field said before, deps spelled the way the line spells them and nothing for a field that did not move.

A committed .gitattributes decides the checkout and a test refuses any file that mixes the two, so a scripted edit cannot silently match nothing.

A table per record binds every field to the key it becomes or to the reason it becomes none, asserted in both directions and executed against the verb that answers.

Every write command prints the git add line for what it wrote or is exempted with a reason, and a closure over the parser holds the two sets total.

add prints the git add line for every path it wrote, projections included, off the save's own return.

A --lines beside a --part is refused for the rule rather than for the ledger, and names the call with no --part as the completion a count belongs to.

A moved section is labelled by the task that owns it, so this id's own subsection is excluded and prose belonging to nobody keeps its anchor.

A prose file edited inside a section this id owns is read by its span, additions against the file now and removals against the file at the revision.

A rationale file is compared by the sections it holds, labelled by the id each heading names, so another session's design is named inside the file being staged.

The revision is resolved once per command and passed down, and a tree with nothing to compare asks git nothing: 123.8ms to 90.8ms here.

A rename table per payload is asserted against the fields of Scope in both directions, so a sixth field cannot reach one reader only.

sharing is one function both readers of the commit contract call, so claim <id> names the ids that moved in a file it is about to stage.

A project declares once with [headings] permanent that its headings outlive the work, and the offer to withdraw one is then absent rather than hedged.

A departure names the other ids whose line arrived in or left a governed file it stages, read as two parses so an annotation refresh moves nobody.

The entry-point sentence has a variant per wiring, so a committed project reads that its launcher finds an engine rather than that one was wired.

An empty own body says which of the two silences it is and names the subsections that carry the prose, on stderr so the body stays a body.

The subtraction of what an id already explains happens in split, so a departure reports a governed file it wrote that another session had changed.

Anything that is not guard or mcp is forwarded to the engine the launcher resolved, so the entry point the installed skill names runs every verb.

The why limit charges the author's sentence and not the prefix a pause derives, so a line written to its budget can be set aside.

A ledger entry naming a half is the one pair no marker write refuses, so the line pick offers is the line a claim takes.

install reads the committed launcher off the project's own declarations, so a --committed tree reports its real drift and the plain install keeps its wiring.

section show --own prints the extent section amend --body replaces, and a body carrying a subsection's heading is refused as the wrong extent.

A citation is read to the end of its address, so a namespaced or sentence-final one resolves and a dead one is still reported.

export --contents derives a prose file's contents from its own headings, so a ship that drops a section rewrites the list in one write (design §RK1110 superseded: one level, not every heading).

An unchanged amend says the prose was never read and the JSON carries it as a field, so a piped body with a --title is not a confirmation (design §RK1109 superseded: stdin is never a tty over MCP).

install --committed writes a launcher the repository carries, so the guard reaches a session with no plugin and no checkout, and defers on the harness's own registry.

An address that is not an anchor reads as a heading text, so a file's opening and its contents answer to section show and amend (design §RK1107 superseded: no positional name had to be declared).

A citation in a section's body resolves like a pointer, so ref.dangling names prose arguing from a deleted design (design §RK1106 superseded: Shio's four are quoted anchors the scan excludes).

A file budget counts CRLF as the LF the repository stores, so one commit has one ceiling on every machine, and lint and budget both name what this checkout pays over it.

every reader of this repository's own corpus is declared with why it is prose, which the measurement made feasible at six functions rather than thirty modules.

PATH_ARGUMENTS classifies every path this CLI takes as the project's, the caller's or repo-relative text, held against the parser.

conftest's docstring states ask the parser, never the line, and a scan holds that the shared fixtures read no file as text but the one declared.

a path naming a file of the project resolves against the project root, and the refusal names the file beside the caller when there is one.

the estimate prints what the served surface costs a session at connect, beside the doors it names and with no verdict on the trade.

WITHHELD names every argument a served verb does not offer and why, held equal to the parsers so a new flag is a red test rather than a silent omission.

the two tests that read this repo's docs take a populated root, which is docs/ while it has an open line and a stand-in when it does not.

[tools] session holds the whole served surface, measured at 52 tools in all three projects and so a fact about the package rather than the project.

budget --tools and --session now read one serving.surface(), so the ranking and the session total cannot disagree.

budget --session names the schema paid once at the handshake and the resident files paid on every turn, and never adds them, because the cadences differ.

The index drops its task numbers, which origin answers better, and the config records that re-measuring reversed the advice: the index is 36 percent and the cheap cut, not the prose.

GAINS declares each door as a name, a predicate over what the project declared and the sentence saying what it has instead, so a fifth is a row and a test can ask whether all four are named.

budget --file ranks a resident file's sections the way --tools ranks the surface, and the first reading says the Layout index is 37 percent of agents.md rather than the 23 RK203 recorded.

agents.md forbids editing source through a shell heredoc, beside the commit rule, paid for by compressing two paragraphs the file already had room to lose.

The queue joins the category, read off the Priority heading rather than its entries, and says the project picks by lowest ready id instead of naming a gap.

The doors a project has not declared are a named category under one heading, with the store joined by a prose file and the non-goals, so the next member has somewhere to land.

The closure's document is named for what it is and the printer and payload read removed_in, so the file a closure wrote is answered rather than assumed to be the roadmap.

Neither corpus declares a store or carries one retired entry, so adopt now names the missing pause door in its estimate instead of leaving it to the first defer to refuse.

Resumption carries the document and the line it placed or None, and Closure names the file it removed from, so an act that writes no line is expressible rather than faked.

The pairwise check reads the three carriers off the Backlog the run already loaded, which took it from 0.70ms to 0.18ms and stops a fourth carrier costing a fourth parse.

The third pair is read and filed against the changelog, with two reads for a door: measuring found neither corpus declares a store, so no verb was built for a state nobody can reach.

A reconciling resume prints reconciled and says the roadmap was untouched, carries the line's own marker, and refuses a --marker that could mark nothing.

referring.PAIRS declares the three pairs of files that can hold one id, the gate walks it instead of a loop per pair, and the unread third says why it has no rule.

The gate reports id.paused-and-open, resume removes the store's stale copy without placing a line, and a departure is refused while the contradiction stands.

Task.in_halves is the one predicate both the gate and the verb read, on the record that carries the qualifier, so the next narrowing is one edit rather than two that agree by hand.

The store is the table's third axis: resume closes a paused id, and sweeping it found the first cell with no door, which is an id both files carry.

A replay reads the version off the engine every capture stamps and says, on a negative verdict only, that work shipped since is work the report could not have seen.

A table pairs every reachable marker and ledger shape with the verb that leaves it, run against a file in that state, and measuring found no cell without one.

The gate reads a live partial off the entry's qualifier, so a partial marker beside an entry recording the whole is reported as id.two-files and repair closes it in one run.

The entry's qualifier decides a live partial and the roadmap's marker no longer does, so a line beside an entry recording the whole is closed by ship and the refusals name it.

surface.address() answers where a module lives now, the five surveys the move broke ask it, and an invariant refuses any literal naming a subpackage address the census does not have.

One named() spells a module for both halves of the note, and a test asserts they agree against the census, which is the property that was false from RK494 and that nothing read.

The meter counted codepoint as dep and read four too many; measured properly it is sixty, and forty-one are the kernel's public surface rather than rules in the wrong file.

budget prints one line under the table naming the table and the line each declared limit sits on, and the payload carries the origin per field so a served read answers why is it 200.

EXPLAINS declares which code explains which and at what scope, both suppressors read it, and the grammar finding carries the file it covers apart from the one it is filed against.

The two mechanism modules are src/roadkeep/kernel/, so reaching past the boundary is an import that reads wrong rather than a test somebody has to know exists.

A role whose every bullet fails the round-trip is reported once against the declaration that broke them, on either failure shape, instead of once per line against the corpus.

A refused limit prints where it was set, roadkeep.toml:34 [limits].why or a role's own line, and says this tool's default where the project declared none rather than inventing a citation.

referring.py declares the three relations, the machine each resolves through and every code each answers, held total by a test that found the pointer family answers five and not four.

A test names the two kernel modules, the two places they reach above themselves and why each is allowed, and holds the backlog vocabulary they speak as a ceiling that may only fall.

A role's shape is a [grammar.<role>] of extends, markers and drop, applied by Schema.under, with the two the tool ships as declarations rather than as methods.

TEMPLATE states the bullet once as slots with a read face and a write face, and both render and the parser derive from it, so a renderer emitting what the grammar refuses is unstatable.

The read counts the handshake beside the tool list and names both halves under one session total, so text moved from one to the other no longer measures as a saving.

Measured again, warm: the check is 1.4ms and the 121ms was one-time import cost misattributed by an in-process comparison, so nothing is cached and the numbers are recorded.

The counting caveat moved to the handshake, which a client is given once, taking 3159 code units off the tool list while each field keeps the number and the aim that vary.

[tools] characters declares what one served tool may cost, lint refuses one over naming the tool and the ranking, and budget --tools prints the room beside each figure.

The skill states the count's second permission once, where the correction is introduced, and the completion says it carries the same pair, so the span is reachable from the text that decides.

The ledger's refusal now names both permissions the count carries, and the roadmap's still names the one it has, so neither offers a shape its file does not hold.

The count is withdrawn from the served tool, saving 221 code units on every session, and kept on the CLI so a script that spells it is answered by NoSpan rather than by argparse.

ship and record amend publish no why ceiling and state the per-line limit and the span in the note, so the client stops refusing a call this server takes.

That branch rewrote the entry instead of placing one, so it bypassed the only door that checks: a why carrying a newline landed as a two-line entry no field held.

The completion writes the span back when --lines authorises it, and the --supersedes pointer takes the first line alone, so neither deletes a paragraph the parse never held.

The clause is read off the ledger before the write that can remove the mark, and printed with the corrected entry, so the amend and the listing state one fact again.

record add --id now refuses only an id a line carries and reports the sentence that names one, so an id cited but never recorded can be given the entry it lacks.

record add, record and retire now lead with the job rather than the case that produced them, in the CLI help, the docstring the MCP surface prints and the skill.

--lines above one now lets --why carry the whole span: the first line is the sentence, the rest is written back verbatim and checked by re-parsing rather than collapsed.

The refusal asks history where the parse has no answer, so an id a ledger entry delivers without leading with it says which commit wrote it.

The row offers the reservation as a fourth reading, so the state RK1031 built a declaration for is not answered with a rewording.

record amend writes the qualifier where the roadmap still carries a live partial, so the cycle terminates and the completion path closes the line.

The door is named only where the closure path takes the line, and a test runs the command it names against the state that raised it.

The refusal carries the command that closes the line where the closure path takes it (design superseded: the doors it called shut are open for a 📋 line, shut for a ⏳ one).

Every command line the four files spell is the launcher the plugin already used, so none depends on a console script a marketplace install does not make.

A superseded entry is named as one in the listing, under --near and in the payload, so the duplicate check stops answering yes-shipped about work that did not hold.

A pointer nobody named is kept wide for the line and dropped for the section, so a new task is budgeted for the anchor it will create rather than another task's.

The scaffold declares an empty [non_goals] beside the heading it writes, so the verb that fills the list works on a project init created; adopt writes no config.

A target the flag named and nothing created is refused with the two lines that make a file one, at the path relative to the root.

defer and retire accept --why beside --reason, so the field the other nine verbs write is reachable by the name a caller has.

The prose is compressed to 120 of 125 lines with the Layout index byte-identical, so the next module added has somewhere to be named.

A body budget reports the smaller of its declared limit, what its own subsections spend and what a binding ancestor leaves, and the aim comes off that.

The ancestor row discounts what this section already contributes and names the verb that follows, so the figure is what the next write accepts.

The overage is one number at both doors and the ways out are not: an amend is told to shorten or to move, and neither door names one the caller cannot take.

An amend is charged its ancestors too, as a delta: a write that makes an over-limit parent worse is refused, and one that shortens it lands.

No parser accepts an abbreviation, so every prefix that reached a write is the refusal this tool composes — and which surface answers is where the flag was typed.

A project declares reserved_ids: the deriver skips them, the gate stops calling them spent, a typo still fails, and a reservation written as a line is reported.

A config opening with a byte-order mark is answered with the byte, the original refusal beside it, and the way to remove it; a marked pyproject is found rather than walked past.

The pre-add read carries the ancestor that binds and what it leaves, beside the field own limit rather than instead of it.

A body read from a path loses the mark its editor wrote, and one in a file is red and fixable (design §RK1028 superseded: only the mark is swept; a lookalike a design quotes is prose).

An id just past everything a line carries is named as the sibling not filed yet, with the ordering as the advice; far past it is still an illustration and below it still a hole.

An unrecognised flag is refused by this tool now: the verb that was reached, the option token alone, and that verb's own surface rather than the whole tool's.

An argument that addresses a section is answered with the verb that prints one, and a declared address replaces the absence rather than arguing with it.

A child is charged to the address that owns it before the write, and the listing that offers one says where its parent has no room left.

A field read on stdin loses the one mark its encoder opened with, so the escape hatch works on the shell that most needs it; the same codepoint further in is still refused.

Every command a message spells carries the flags the parser declares (design §RK1022 superseded: --family is an anchors flag and --ref is not; the command beside it was missing).

The questions this project wrote down are a declared set, each one an argv the CLI parses and only reads, and every read-only verb answers one or says why it answers none.

A survey over the declared source set reddens every import nothing spells, past the __all__ re-exports and the __future__ directive; the six it found are gone.

The harness compares the home engines derived against this checkout exactly, so a run that answered from another tree fails instead of reporting on it.

The tree opens with the total and each declared marker beside it, every number rendered from the payload stats already answers and none computed here.

Which copy answered is asked once per window and again when somebody presses refresh, so a save runs the reads about the file and not the one about the tool.

Every tracked top-level entry is named in the Layout index or exempted there with a reason, and the two surfaces that shipped without one are named.

A door says whether running it writes, derived from the verb the CLI already declares read-only and the flag that makes one a write, and the payload carries it.

priority add opens the section above the blocks where a project has none and says so, so no queue needs the hand edit the guard denies.

python scripts/build_vsix.py writes the archive from the files this tree holds, with zipfile and no toolchain, and it installs.

The gate reports a pointer resolving to a heading with no prose or no title, under the two codes the door already refuses, and a container is still silent.

A manifest and one plain JavaScript file, activating on the config file and carrying no rule: every fact it shows was read from a payload a verb printed.

A job gates the client against this repository's own docs, pinning node and asserting it answered before the harness runs, so a skip cannot read as proof.

The view calls the roadkeep a workspace declares and refuses to guess one, and names above every row which copy answered and whether the copies agree.

A prompt counts down what budget says each field has left before a word exists, and add still decides — the refusal reaching the editor verbatim.

Findings become diagnostics anchored at the column the report gives, and a door the tool called complete becomes the action that runs it.

A tree grouped by the block the payload gave, ready before blocked and the blocker named, with every row read from a verb and no Markdown parsed.

A test reads the four payloads by key over this repository's own docs, so a promised key that is renamed goes red here before a client outside the process meets it.

Every code a write refuses says what the gate reports about a file already in that state, and two of the forty-three turn out to be reported by nothing.

The gate reports a design naming an id no line carries, under the code the door raises, so an imported or hand-edited file is no longer silent about it.

A design naming an id no line carries is refused where the prose is composed, naming the two ways out, so an illustration no longer spends an address.

A design declares the rule it instantiates in a fenced block, and the row it names carries the id — so a recurrence is a count and the holder is where the fix goes.

A scan over the package refuses a marker, an id or a governed filename written outside the two modules that declare a default, and L6's row now names it.

A write refuses a dep in neither file and one whose blockers walk back to the line, so the id is no longer spent by a token nothing carries.

Every prose door refuses a tab, an invisible codepoint and a space that is not one, under the code the gate reports and from the one rule both surfaces read.

Every code the gate emits has a row saying whether a write refuses it, measured by a probe wherever one claims so — and probing 30 of 84 found five open, not two.

ship, retire and both record verbs refuse prose naming a file the repository lacks, so the gate's path rule is asked where the sentence is composed.

Seven surveys quantify over one declared set, tests/surface.py, and a test refuses any that derives a second — so a module in a new directory is covered or red, never quietly missed.

Every list a scope splits the tree into asks one predicate, so a declared directory speaks for the files under it in the loose list and in another session's as it already did in the staging line.

Each verb family is a module under verbs/ its own docstring is the authority on, and cli.py is the parser and dispatch alone — 8,489 lines to 2,551.

Every printer and payload builder is in rendering.py, so cli.py is the parser and its handlers alone — 8,489 lines to 7,186.

A design declares its own query in a fenced block and remaining runs it, so what a migration has left is a read taken now rather than a number somebody maintains.

The rules this package states are one declared set naming each surface and holder, closed against the six laws, and it found L4 held by five listed codes.

A finding answers one declared set of fields and a row names them, so what a door says about its finding is a property over the table instead of a defect per row.

A verb declares its subjects and narrowing flags at add_parser and one dispatcher refuses two answers, so the sweep now checks a table and found claim --porcelain --json.

Every message that offers a call states a Door and one renderer spells it, held by a property no module outside it composes one, so a new surface is one change.

a bar in a block title stays inside its own cell, so the readme table keeps its columns.

The sweep takes one entry per rendering, and a field that never leaves its default in any of them fails rather than leaving quietly.

A prefix nothing declared and no id produced is reported as the default it is, in the printed line and in the payload.

Where the argv names git's temporaries the offer asks for the two revisions instead, and a hand-run merge keeps the line it can take.

A prose file is merged by anchor the way a roadmap is merged by id, so two branches that each dropped their own section merge.

A line one branch removed and the other edited is its own category, with the decision it actually asks for.

report says which of the two captures it wrote and names --embed where it wrote the smaller, and replay asks for one that carries the files.

Each message is rendered in both spellings and every verb the shell form offers the served form must name, with two exceptions that carry a reason.

Unattested carries the served prefix the hook reads, so the message shown once names a route the session can take.

Each finding is followed by the door remedy() answers, grouped as the report groups and spelled as the session that will run it.

The closing sentence is composed per table, so a session with tools is offered the three reads as tools and one without keeps the shell line.

The printed line carries the invocation like every other route, and the payload's needs field names the tool that serves it.

A refusal shown over the tool surface names the tool that serves it and its fields, rendered through the subcommand's own parser at the print rather than at the raise.

Every complete door is parsed by the CLI it names, which caught section move offered without the --to it requires — a code neither corpus carries and repair would have dispatched.

The pinned corpora hold that every remedy repair dispatches runs and that a second pass finds nothing, which caught a fold refused on Shio's ledger on its first run.

A drop blocked by a claimed nested section is a decision naming the blocker instead of a command repair dispatches, so nothing is attempted and refused run after run.

The summary counts what ran and names what was refused, so the number a reader acts on agrees with the FAILED lines above it and the exit code is untouched.

A section remedy carries the role of the file its finding is about where the project declares two, so on Turing one that opened the wrong file now closes its own finding.

A run of findings sharing one fact is printed as the pair once with its addresses under it, taking Turing's report from 15,894 characters to 4,044 with the payload untouched.

The message and the remedy ask one reader whether dropping closes this finding, so repair runs the verb the sentence names and the verb it names closes the finding.

Every boolean pair a read takes is swept for the byte-identical answer a swallowed flag leaves, which found two more and left the exception table empty.

The two pairs that are two subjects are refused naming both, and the two destinations that compose still write together, so no flag is dropped in silence.

A narrowing flag is checked against the subject that answered rather than the absence of one, so passing it beside another is refused naming both instead of changing nothing.

budget --tools states what the surface costs a session, in characters and by tool, so adding a tool or a sentence to a description stops looking free at the point of writing.

The eight reads the shipped skill names are served as read-only tools, so an install with no console script can make every read it is told to, and a test holds the two in step.

The worker count is one per thing named and capped at the cores, so six files take 4.8s instead of 12.7s and one file still spawns nobody.

A heading naming no task that no line claims is counted as a standing memo instead of listed, so the audit's rows are only the two states a command closes.

A run that named one file or one test is not spread over every core, so the narrow run is back to 0.93s from 43.2s and the full one keeps its 41s.

anchors --claims lists only the addresses whose ownership is not the ordinary one, over every family at once, so the audit is one call on a corpus of any size.

The coupling was the wall clock and not an order: eleven assertions spelled an elapsed duration, and matching its shape instead took ten parallel runs from four failures to none.

The suite runs parallel by default at 41s against 5m07s, with the worker count derived and the plugin declared beside pytest in the extra CI installs.

One runner in conftest builds every test repository in three processes and a hermetic environment, so nine private copies are gone and no assertion moved.

A stream that refuses hardening is recorded instead of raising, so every verb runs over a used stdin and only a prose read is refused, naming what it could not apply.

A NUL is read as a lost write and not a character, so a partly-lost file is one finding naming the restore instead of 400 whose fix claimed them and wrote nothing.

anchors says per address which task its heading binds and which live lines claim it, so an unbound heading and prose whose task has left are both one call away.

A line whose --ref names an outline section binding nobody renders the binding into that heading in the same transaction, so both write orders reach the same file.

A governed file whose every byte is NUL is one finding naming the restore, checked before the line reader, so 3,301 findings and a --fix that would empty it are both gone.

A staged file is flushed and fsynced before the rename that places it, so a crash between the two leaves the previous whole file instead of the new size filled with NUL.

Every door is published as a call beside its argv where the session serves it, derived from the subcommand's own parser, so lint --fix stays a shell command by rule.

The repair route inside the deny and the Stop gate both name the served tool where this session has one, leaving the invocation only on lint --fix, which says why it stays.

A session with no server for the tools is offered none, so the denial leads with the shell command it can run; served_as is gone and serving is the one reader of which engine answers.

The flag fell through to the unbounded listing, so a read asked for five entries came back with 103 and nothing in the answer or the exit code said which question it answered.

The estimate lists a block once per region through the reader RK439 narrowed, so a ledger grouped by sub-headings reports one label and two genuine regions still report two.

The SessionStart notice names the served prefix where this session has the tools and the invocation where it does not, so the one guaranteed message points at the engine that answers.

replay states, from the exit every capture already carries, that a re-run refused before the verb repeats that refusal and not the symptom — beside the verdict, never folded into it.

delivered --near ranks the block against the sentence being proposed and prints the five nearest, which held every pair this ledger knows the answer to, with no score and no index.

All three copies argue from the score instead of a rank the ledger contradicts, and a test holds them there: the ranking is fine and the absolute score is not comparable.

A capture whose re-run exited 2 carries stopped: usage in the report and on the session's own stderr, so a reader knows the output is evidence about the command and not the symptom.

A heading inside another's subtree is read as the region's own, so a block grouped by sub-headings takes writes again and only two headings neither inside the other are refused.

Every write's event names the block's stage from the four-state reader every query uses, so finished and empty stop sharing a word and a paused block is offered no drop.

Every measure adopt reports names the unit its two figures are in, so a table of three units stops implying one — and the non-goal rows are counted the way the gate counts them.

Every maxLength the MCP schema publishes now names UTF-16 code units beside it, and the code points JSON Schema counts instead, so a client reads the bound that will refuse it.

A queued block whose heading precedes its lines offers filing the first line beside dropping the entry, instead of one door arguing the block was never declared.

A queued block's state comes from the backlog's one reader, so a block with nothing open is reported as paused wherever the store holds a line under it rather than as finished or unstarted.

delivered resolves the block label before it filters the ledger: a letter nothing declares is refused at exit 2, and every answer names which of the four states the block is in.

A block dep resolves against the block's own stage, so a heading opened before its first line no longer reads as shipped and pick stops offering the task waiting on it.

next-id and add report the id below the derived one when only prose names it, so a sentence that promised a number learns it was spent at the moment of spending rather than never.

every character limit is measured in UTF-16 code units, the unit each payload declares and each refusal names where it differs from an editor's count, so this gate agrees with the one a project runs.

brief, pick and list name which of finished, paused, empty or unknown a block with nothing open is, and --json carries that word beside the sentence, so a loop branches on the state and not English.

the totality read crosses the suffixes the schema composes with the fields it validates, both scraped from the source, and the six codes that were invisible now have doors.

priority migrate moves the config's order into the roadmap, and both write verbs refuse by naming it, so the queue defect the gate reports has a door that opens.

add validates the line and a re-readable section body together and raises once, so a call breaching both is corrected in one resubmission instead of two.

the finding names block merge instead of an edit the guard denies, and says how many lines under the later heading it moves, counted to the next heading of any level.

the denial names repair, its dry run and explain before the table it shortcuts, so an agent repairing a reported line reads one route instead of picking from fourteen.

explain <code> answers the class, what produces it and which doors close it in three lines, and with no argument lists every code the gate can report.

repair runs the mechanical pass and then every finding whose remedy is a complete command, re-reading the report between writes, and prints what needs a sentence or a choice.

the codes are scraped from the modules that emit them and every one must resolve to a door, so a check added without stating its repair is a red here instead of a dead end on someone's backlog.

every finding carries the command that closes it — a complete argv where one exists, the doors and what separates them where a decision does, and the blank where L4 forbids the tool the sentence.

the add and the gate ask the ledger only where it is organised by blocks, so neither names a remedy that refuses.

engines compares the commit as well as the version and answers agreed, behind or unpinnable, the last being one version and a modified checkout, which is no commit to match.

reversals reads the forward pointer back with the reversing entry's sentence, so what was tried and undone is a read an author makes before spending an id rather than after.

restate --typo declares a slip of the pen, so the answer and the payload say which of the two acts it was and every other restatement still means a premise that turned out false.

anchors --next prints the free address alone in both surfaces, so the read an add --ref makes every time is one line instead of the last of twenty-eight.

the finished branch answers on stdout in the shape it was asked for, carrying empty, the block and the reason, so a loop reads a payload instead of matching English on stderr.

the empty event names block drop for the label it just finished, so the state the answer computes and the command it makes available arrive together.

a control character that is not a line break is refused as its own code, naming the codepoint, its position and the backtick escape that writes it.

a tree declaring the guard in its own plugin manifest is skipped for the settings surface with a reason, as its two siblings already were, so the check reports clean here.

status, amend and restate validate against the schema the file was loaded under, so a role that [rules] excused a field for is corrected by the grammar the gate reads it with.

the ship names the parent its drop left with no subsections, beside the citation it already named, so an introduction to work that shipped is an edit in the same commit.

add, budget, list and resume each accept --marker and --status for the one declared field, so the name learned on any verb is the name the others answer to.

delivered <block> states every claim a block already made good on, named in the guard's table beside non-goal list, because a duplicate is a read and never a refusal.

the body is re-wrapped at 90 with no word changed and a test holds it there, which is the answer the section argued for over a config width or a fixer that rewrites prose.

the finding names block drop where that verb would remove the empty heading, and says it is a hand merge where it would not.

engines reads the running copy, the plugin the harness wired and every workflow ref, and lint notes a pen and judge apart.

the first block heading goes before the file's next section at that level, and only takes the end where there is none.

place takes the role and derives the path and the organise remedy from it, so defer names its own file too.

the add asks a flat ledger again, and the gate reports it once about the file rather than once per block.

the path flag refuses the dash by name and says where the body comes from, at both doors that take one.

block add --organise <role> writes the first heading into a file organised by nothing, and the refusal names it.

the refusal names the file the line was going into, where that is not the file its labels came from.

block merge folds a label's duplicate headings into the first, moving the entries and including the ledger, so the doubled heading only a hand-edit could repair has a verb at last.

the hook asks whether the difference is the number, against the index, so its own unstaged bump is still its own.

A list marker is the character and the space after it, so a line opening with a bold span is prose the writer fills and the estimate measures.

a dep on a task shipped in halves is annotated with the line's own marker and resolves as open, naming which half the ledger holds.

record add --supersedes writes the revert entry and appends the forward pointer to the entry it replaces, so the ledger's two records of one decision name each other.

The driver's own file is checked with the surfaces and a target that is a directory is in its own way, so the flag refuses instead of landing four.

The wiring refuses a directory a file is standing in before it writes, and the gate reports that apart from a difference it can close.

A directory a file is standing in is refused with the rest, and the directories are made before the config, so a failing write leaves nothing that looks configured.

lint reports block.repeated at the second heading, and every write through place refuses instead of picking one.

A block value must be one heading and no two may share a label, so the scaffold refuses what it would otherwise write out unasked.

a dep that names this project's ids inside free text is refused at the write, naming them, instead of resolving as work nothing can satisfy.

A body-only amend leaves the heading line's bytes alone, so a sigil the reader accepts and the writer would not reproduce survives a write to the prose beneath it.

Both runs count what they read and one test holds the pair across them, so a rationale file of prose no longer answers a blank one's words.

The three argument refusals are one parametrised table, so the untested one is held and a fourth arrives with its row empty.

A prefix named beside --sections is refused, so the combination that reads nothing cannot look like one that read it.

both accounts of the free top-level say it is per namespace, and a test holds the skill and the help against what the command computes.

The rationale is fetched below every refusal the line can raise, and --section-body-file/--body-file name it by path so a retry re-reads it.

add asks the ledger for the block's heading too, and lint reports a block whose open lines nothing there can receive.

amend, restate, status and renumber name the block's family and the free address under it when a line has no pointer (design §RK379 superseded: add had been enriched by RK312 the day before).

A section's address moves with its subtree and every pointer at it, and a pointer follows only where nothing else answers it or the heading names its task.

non-goal amend rewrites the reason where the bullet already sits, so a reworded constraint is a word changing rather than a deletion and an append.

The estimate counts what it read against what the file holds, so a zero over prose is told apart from a zero over an empty backlog.

Both doors into this format ask one reader whether a file declares it, so the refusal reaches the pyproject that does.

A path naming this format's own declaration is refused with the files it declares, so the comment that cited that refusal is now true.

The unread sentence is derived from the files the across-files read opened, so a set the caller narrowed is not covered for.

One reader answers what role a path holds and the field says only how the file was named, so neither sentence is a claim the other denies.

Each file in the payload sits under the key that says what its name is, and which of them the run treated as outside the project is its own field.

Every path is checked before the first is opened, so a run over a set refuses whole and names the argument that carried each one.

A named file is read through its role where it has one, so a declared namespace answers the same whichever way the run reached it.

The two ranges are restated as the comparison they were for — median to p90, lines 2.7× against files 1.4× — which is scale-free, so a test holds it and weight prints it.

The estimate takes the other prose files as arguments, so the doubled address is reachable where no configuration names them.

The fixture takes in-progress as a second right answer, so the tier no longer asserts nobody is working.

The number is gated by nothing, deliberately; the cost was checked decided at five points, now one — and the rule that an unnamed file sorts last is stated and held.

The floor is 100 and far from the reading on purpose — by quarters the median falls 349 to 154, so the tasks got smaller under one-task-one-commit and the shape carries the claim.

A malformed address whose leading segment names a live family is answered with that family next free child, and only the rest with a top-level.

Every near-twin verb is run bare by the same property that enumerates it, so a sentence declared but never printed is a failing test.

A merged line the schema refuses names the id it belongs to and the file being merged, so the count is about a line the reviewer can find.

A section written at an address no live task owns is told the free top-level and the command that lists what is taken, per namespace.

A removal reports gone where a rewrite reports fixed, --json carries removed on the one list, and the run says once that those addresses are the file as it was read.

A drift job asks the channel where the answer cannot gate — continue-on-error and an annotation, never a red — so a newer reader refusing this payload is named before an adopter meets it.

fixing.REPAIRS is the list and a test holds all six statements against it, one direction; the three RK328 missed — the hook's copy among them — now name the dead queue entry.

checked is now what the gate judged: roadkeep.toml joins it where it carries a queue and stays out where it declares none, so every finding's file is in the count.

A refused argv whose verb is a name this tool publishes over MCP is answered with the CLI's own spelling of that act, read from the tool table, which is what publishes the other one.

the replay fixture reads its codec and locale against this process and records values it does not hold, so the drift assertion is about the comparison and not about the shell.

the staleness baseline is pinned to each test's setup, so a suite that edits source while it runs cannot append a note about the checkout to a refusal under test.

The survey RK339 ran once by hand is a test over the parsers, so a verb added tomorrow that shadows a report is named by a failure and not by whoever types it wrong.

defer, resume and section add end their refusal with the same clause add has, so a caller who met the good one once never reads a bare rule as there being no answer.

A refusal caused by a dependent's re-derived annotation names that line's id and address, so the author is not sent to shorten the sentence they just typed.

adopt --sections opens every prose file the project declares and names the address two of them answer to, before the gate files one finding per collision.

anchors --json answers the free top-level per namespace and nothing else, so the row states which namespace its address is for instead of a bare field meaning one of several.

budget --file reports what an every-turn file costs in lines and bytes and what is left, off the same count the gate holds, so an edit to agents.md is composed against a number.

--embed carries every governed file the config declares, and a replay reads a capture in either spelling so the reports already on disk still run.

A replay checks the governed files the staged config declares before it runs, so a capture carrying fewer than the command reads answers nothing.

A claim's read-back names the governed files its own transactions wrote, so a scope carries only the code.

A capture carries the text-handling variables and the codecs the three streams had before main hardened them, read at import, and replay names which of those this process does not share.

A prose file declares its own namespace in [refs], so its addresses are written §<prefix>:<x.y> and two outlines that each start at I are two sets of addresses rather than one read twice.

status with no arguments says it writes and names stats, and claim says the same about claims.

The three subprocess readers name UTF-8 instead of inheriting the locale codec, so the check RK334 stopped from skipping now runs on the machine that ships the plugin.

tests/test_encoding.py runs the CLI under ascii, cp1252 and utf-8:surrogateescape reading bytes: UTF-8 on both output paths, strict in, a surrogate escaped, the pre-main window stated.

The workflow declares contents: read, the reader gating a merge is a version this file names rather than a channel, and the step proving the install happened proves it produced that version.

A third gate job installs the CLI and proves it answers before running the payload test, so the check cannot skip where it matters — and validate needs no login, so a fork runs it too.

The refusal names the prefix this project's own files decide: bare where a .mcp.json declares the server, and the plugin's own spelling where the tree the engine runs out of is one.

A test runs claude plugin validate --strict over a copy of the whole payload, with one surface broken as the control that proves it read them, and skips where the CLI is absent.

Both descriptions are quoted and one reader refuses what YAML refuses, so the skill's name and /ship's allowed-tools reach the loader and the payload validates strict and clean.

Claim dates, declared scopes and write digests share one TOML store beside the lock, so a fourth feature extends a grammar whose round-trip is a property test instead of writing a fourth.

Every prose argument reads stdin on '-', so a sentence carrying a backtick or an apostrophe never meets a shell.

--fix drops the queue entry whose id the ledger holds as shipped or retired, naming each one at the line it was read from, and leaves the order and every live entry alone.

Every door a line leaves by drops the entry that named it, in the same transaction, and says so.

The gate resolves every queue entry as it resolves a dep, so a token naming shipped, retired, set-aside or unknown work fails at its own line and column.

The queue is a governed Priority section of the roadmap with an insert, a drop and a read, and it wins over the config.

brief answers shipped for an id the ledger holds, and quotes no unblocks count for it, so the command a session starts work with never describes finished work as startable.

The context file moved to .claude/CLAUDE.md, read the same way in the checkout and no plugin surface in the payload, so the validator's one warning is gone and its output is signal again.

Which of the payload's two declarations launches is measured: the manifest's wins, the root file answers only where nothing declares, and a test holds the line that decides it.

The duplicate reference is gone and the convention is what finds the file, so the three hooks, the five skills and the server load on a marketplace install instead of failing together.

The hook reads the working tree before it bumps, and where either versioned file carries an unstaged edit it writes the number and stages neither, so a commit carries only what somebody staged.

the command declares which argument its json is the form of, and a test holds every served tool against that declaration.

the note spells the verb plus the always flags that make the tool that act, resolved through the parser as argv does.

the branches that cannot structure an answer refuse the flag by name, before anything is written.

the divergent verbs are a declared table whose every key a test holds against the commands the CLI accepts.

a test asserting about this repository's docs reads one coherent copy taken at collection, so a concurrent session's ship changes the tree and not the fixture.

one bound serves both dests that mean the open set, and the filter that reads any governed file publishes the union.

the staleness note closes with the verb through the CLI, which is the one remedy available inside the session that reads it.

The refusal names the block's family and the free address under it, and anchors --block is the read it points at.

A refused body names what each paragraph costs and which is longest, so the second draft is composed once (design §RK311 superseded: the add --check it ranked cheapest costs a send twice).

A shipment records what the design it deleted had been wrong about, in the ledger's own sentence, so the reader who found out is not the last one who ever knows.

a departure prints the governed files it wrote itself, so a scope declares only what the author chose.

the verb that declares a scope is served as the tool scope, both writing flags exposed and the read left to ship.

adopt names the other scheme only where the declared one left an address unread, so a file it reads whole is never told to switch however the ratio falls.

role publishes the declared files of the kind its own command means, narrowed per project and empty on none.

budget refuses an anchor two prose files declare, as every other reader of one does; --role names which, and a line's own budget keeps its fields and says why its section half is empty.

merge --check is served as the tool merge_check, read-only and answering both halves of the wiring as fields.

the note names the modules that both moved and decided the refusal, and says nothing when the sets are disjoint.

claim --add-path names a path the work turned up without restating the scope, and the row is still replaced with the whole of it.

The closure path reconciles the registry as its sibling does, so a line closed against an entry already on disk releases the claim and the scope it carried.

section add asks the project's declarations rather than the file's, so an anchor a sibling prose file already holds is refused before the write.

budget carries a section row for the body add --section writes in the same transaction: the role's word limit, what that anchor spends, and an aim that sits under the limit.

Document.holds is the one reader both the event line and the gate's note call, and a source test says those two are the only callers.

Both summary lines end with (in <root>) and --json leads with the root key install already uses, so every relative path in a report resolves.

A departure prints the git add -- line for the scope it releases, so the answer is in the output the committer is already reading.

anchors reads every declared prose file, so the free address is the project's and not the first file's, and any address two files both declare is named before a write can double it.

An undeclared-block refusal names the file and the verb and stops listing every label, which shading already answers by name in the one case it mattered.

A declared path that is in neither the dirty set nor the index is marked where it stands, so a typo reads as one instead of as a complete scope.

ship and retire name what the tree holds that no claim of theirs does, read while the claim is still live.

anchors now prints the next free top-level above the rows and orders every family by the number its numeral spells, so the address a reused block needs is derived rather than read off a tail.

The scope line asks whether the target is declared here, so a file no project owns names no siblings and states the narrower limit instead of offering files nobody can hand over.

The report names the governed files it did not open, so the one class the estimate cannot decide is stated as a term of the measurement instead of being resolved from a file that cannot settle it.

adopt counts what within finds — the half of the gate one file decides — so a duplicated id is priced instead of read as conforming, and the two disagree only across files.

Estimate, Plan and Removal are each held to their payload by a test over their fields, with the two renames declared beside it so the boundary that names them stays.

A prose file's own heading anchors are a second source for the scheme, so --sections names --ref-scheme too — and only where the other scheme accounts for more of the file than the declared one.

every verb that prints a section's size now states its own prose and its subtree where they differ, with the role's limit beside them, so no figure stands next to a limit it is not measured against.

The reject names every slot a line needs, and adopt re-reads the file under each [ledger] declaration to report what it recovers — whole hypotheses, the slots not being independent.

schemes counts what the pointers spell and names --ref-scheme the way the prefix half is named, and the round-trip line says which reading produced its number.

removal reads the workflow off the disk instead of a constant, so a project with no CI is told nothing was kept rather than told to delete a path that is not there.

budget --anchor answers a section body in words and budget --non-goal the list's two limits, so the two largest prose ceilings are read before a word rather than met as a refusal.

The would-overwrite refusal names adopt <file> for the backlog it found, spelled relative to the project, so the branch reached by a repository that never adopted gets the door too.

unanchored reads headings that carry prose and no sigil, so an unadopted rationale file prices its sections, while a level-1 title and a container heading stay out of the count.

A claim now carries the paths its commit owns, so claim <id> names what the tree holds that another live claim says is its own.

Document.listed counts top-level bullets and ordered items under a declared block, so a checklist prices like a table, and the preamble, non-goals and nested detail stay out of it.

A Wiring value joins both halves once and every caller renders from it, so the verb withholds the advice the check withholds and no surface can reach for a fact the other has.

The config half is demanded only where a governed file routes here now or once registered, which spares an all-claimed repository without withdrawing the repair from an unregistered one.

One registration_report renders both surfaces, differing by the indent column that pushed them apart, and a test over the dataclass fields fails where the next one reaches only the JSON.

register skips a governed file another driver is named for and reports the skip, and --check treats it as settled — so the repair no longer overrides what it reported, nor fails forever.

attributed asks check-attr, so a rule set in a subdirectory or .git/info/attributes counts, a file wired to another driver is named rather than read as unset, and no git is unknown.

merge --check names the repair of each half it found broken — the verb for the attributes, the git config line for the driver — so following the advice ends the check instead of repeating it.

A read-only command's own exit 1 is a verdict and closes with nothing; a crash in the same command still offers, because main carries that as a flag.

merge --check reports both halves and exits on their conjunction, register is written on top of the same read so the check cannot drift from the write, and a partly-sent file is its own state.

lint --since notes every block this change emptied or reopened, which is what the shipped pre-commit hook runs and what the console-only event never reached.

An autouse fixture clears the two caches a monkeypatch can poison, and an inventory of all six names why the other four are cleared for nothing.

merge --check reads merge.roadkeep.driver back and exits 1 where git has no driver it can run, keeping a command that merely moved apart from one this machine no longer has.

budget takes --ref and counts the pointer as structure; unnamed under an outline it assumes the widest anchor on file and names that, so the answer is never more room than add allows.

The answer is the distribution plus what was elided from it — 23.7k characters down to 1.6k — and the sample it summarises is --records, a count and never a cap.

A session checkout fixture skips the five checkout-reading tests with a warning naming the file that moved, so -W error still fails them.

A heading written for a task now carries its id, appended by the writer that holds it, so the section binds to the line and ship deletes it instead of keeping it.

Document and LockBusy are reached inside the one method and the one function that use them, so a denial loads 5 modules at 44.6 ms rather than 7 at 50.1, and no command pays more.

Each hook event imports in the branch that uses it and words comes from schema, so a denial loads 7 modules rather than 25, measured at 50.1 ms against 84.5 with a test holding the set.

The note names only the prose roles config.has declares, taking its default from prose_role, and falls back to the base number where a project declares no prose file at all.

The three prose bodies publish their word budget in the unit it is declared in, per role and with no maxLength, so the number reaches the author before the paragraph is composed.

The refusal now names the file whose labels it listed and spells block add <label> --title, the one verb that declares the heading wherever it is missing.

Sixteen sites in seven modules print provenance.invocation(), and a test over the package's own constants holds the inventory, so a new message naming an underived command fails there.

register derives the driver from persisted() — console script, launcher or module path, absolute and quoted for the shell git runs — and prints what would end it.

provenance.invocation derives the shell prefix from a PATH lookup, the shipped launcher and the module path, and the guard's denial, gate and session notice all print that instead of a literal.

A closed field is reported as declared by the CLI and shut by this project's config, over its own names, so only a name nothing declares still reads as no such argument.

One Conditional record per dest carries the predicate that opens a field and the sentence a refusal gives, so the two cannot be edited apart and _withheld indexes without a guard.

_withheld reads its reason with a fallback, so a field missing one drops a sentence instead of raising inside the answer, and a test holds both tables against every Tool.conditional dest.

The checkout branch states the fact its directory relation establishes and the remedy that follows, naming no launcher, so a venv or a local marketplace under the root reads nothing it has not got.

add --json reports ref beside id, so both derived addresses are read as fields — including where --section answered the pointer and needs is null.

The remedy reads the project root the call already discovered, so a server started in a subdirectory still names the restart a checkout needs, and only a broken config falls back to the launch path.

anchors [--family <x>] reads live and retired addresses out of the file and its diffs with the next free child, and section add refuses a reused outline anchor by name.

The drift note names the remedy that restarts the server reading it, Engine.carried_by deciding from where the code lives whether a patch bump reloads it or only a restart does.

Share.room floors the remainder into words, budget and brief aim at what is left instead of at the whole field, and --json carries it beside the characters that refuse.

retire resolves the replacement through Backlog, so a paused id is a supersession the tool accepts, and the answer names which of the three files holds it.

The word figure is now the caller's prose= switch, so line.too-long names the surplus and no edit, and the field refusals a shorter sentence does answer keep the hint.

The drift note states a fact about the process beside a refusal that stands as the running code's answer, so a correct constraint no longer arrives pre-doubted and no call is spent disproving it.

The MCP add exposes ref where roadkeep.toml sets ref_scheme = "outline", so an outline project writes a line over the protocol, and the refusal names that table per field.

Whereabouts in backlog is the one composer of where an id is, so resume and both section refusals read one sentence — and record amend is offered off the marker, not off a non-empty string.

section.ambiguous fires at each of the two headings, so Turing's 13 doubled anchors are 26 findings where the pointer-end check reported none.

The refusal names where the id is and the doors that open — record amend or an outline anchor — instead of the add that refuse_reuse forbids for an id the ledger carries.

block drop --prose takes a heading's loose prose with it, refused still over anything a task or a section owns, and the refusal names the flag where prose is all that stands there.

A departure deletes only the section it owns, by lint's own reading of ownership, so a line pointing into a standing memo leaves it and the reason names who it belongs to.

One reader: read returns every bullet with the lead leads prints, shaped or not, so a printed constraint has the door the gate's shape finding asks for.

The count came back thirteen, one of them pointed at, so _pointed_at takes the gate's last condition: an anchor two prose roles declare is charged its own prose by both readers.

_task_for reads both live roles, so a paused task's design is amendable and a section can still be written for it — the refusal is left with the anchors no live line names.

add --section derives the prose role instead of naming improvements, so the one-write door reaches the only file a strategy-only project declares — and the report names the file it wrote.

defer resolves the anchor across the declared prose roles and carries the role, so the report names the file holding the design — a strategy-only project got a KeyError after both writes.

A character overrun now names its surplus in words too — delete 29 characters — about 5 words, ceiled off the aim's own constant, so the retry is a deletion and not a re-guess.

writes reads the digest record against the files — attested, unattested or unrecorded, per role, with the record's path — and moves no baseline, so the fact survives being asked for.

At the plugin's own root the two copies are named as unwritten, not computed, so --check there reports drift and not a category error — and uninstall refuses, those entries being the tree's own.

The SessionStart notice names a vendored copy that drifted from the checkout answering, before the session loads it — 0.86ms wired, 0.07ms where there is no copy, and never the gate.

The root is normalised once and a token is spelled once per base, so the path check costs 81 ms of a 306 ms gate instead of 270 of 529.

The check asks which codepoints occur before asking where, so a clean file is cleared in 6 ms instead of 148 and the whole gate costs 517 ms.

A path token is normalised to forward slashes before anything asks, so one spelling reaches the disk, git and the report whichever platform wrote the line.

A revision run asks the tree it is judging and spells paths lexically, so Turing's check costs 270 ms and no filesystem call instead of 559 ms and 34070.

The check gathers candidates and findings in one pass, so Turing's ledger costs 559 ms of the gate instead of 2.9 s and every entry is read once.

The directory listing is a callable resolved on first need, so a task whose paths all resolve asks git nothing and show is back to 1.0 ms here.

The directory set is read from the index by default, so show and lint give the same answer about an artefact the working tree no longer has.

A spelling that climbs above the root is left out of the ignore batch, so one such path no longer disables the check for every other path in the file.

The ignore answer is stored per token, so a second caller is answered about what it asked, and a repeat costs no second subprocess.

A run naming a revision asks git for both a file and a directory and never asks this disk, so an untracked file created since the ref stops silencing the revision's own finding.

A path claim is decided against the directories the repository tracks rather than against this disk, so deleting a directory reports what deleting one file already did.

A refusal naming a label that shares a prefix with a declared one says so and warns against the second heading, at the write and at both reads that compose the same sentence.

section amend charges the subtree only where a line points at the anchor, which is what the gate charges, so an unpointed container's intro is amendable on its own prose.

The refusal stands and the surprise does not: lint names the closed door every run and the generated declaration says so where the choice is made.

The gate asks git check-ignore before reporting a path, so a build output the repository declared untracked answers the same on every machine.

origin takes an anchor, so a citation of a shipped design resolves to the commit that wrote it and the one that took it, and a typo answers that nobody ever wrote it.

A parse is memoised by the bytes it came from, so the refresh re-reads nothing the command already read: a status write on the largest live backlog went from 94 ms to 46 ms.

A pinned corpus is gated with lint at the revision, which moves the governed files and the tree together, so the three false path findings per corpus are gone.

section drop names the sections left citing what it deleted, from drop's own answer, so all three doors onto a deletion report the same fact once.

project asked the roadmap census for a label it took from both files, so a block whose work all shipped answered KeyError — found the moment every write started projecting.

RK204's write screen restates _PATH_KEYS and the resolve-and-normcase test, and the two are now asserted equal — a key added to the guard alone would skip a write it refuses, silently.

Ship names every section whose prose cited the design it deleted, so the dangling citation is repaired in the commit that creates it.

Answered rather than marked: the import surface is a declared non-goal, so no py.typed ships by decision — and a test holds the absence and the constraint together, neither being honest alone.

An Edit naming no governed file costs 35ms above the interpreter instead of 128ms: the screen resolves the config from the path the payload names, and adds 0.8ms where it must load.

A test holds the Layout index against the package, the two modules it had already lost are named, and the measurement says compress the prose first.

A tool call builds the CLI parser once per process, not once per message: the parser was counted and holds nothing the config declares, so a list call after the first costs 1.3ms.

Importing the package costs 0.6ms instead of 27.7ms: the schema re-exports resolve on first access, so the screen that imports only stdlib no longer loads the format to answer a shell command.

A tool call builds the CLI parser once instead of three times: the argv rendering, the prose lookup and the dispatch all take one index, and a list call costs 5.0ms rather than 12.7ms.

The follow-up asks every declared prose role, so a resolved pointer is silent, and where none answers it names the role it means rather than section add's default.

The drop resolves the anchor across every declared prose role and rewrites the file that has it, reporting that file rather than assuming the improvements one.

The count is now the rule rewrite_entry holds rather than one caller's, and amend and restate take --lines — measured: cursarei wraps 19 of 19.

show prints every source line a wrapped entry owns and its span, so the count record amend --lines asks for is a command's answer rather than a 290-entry ledger opened by hand.

ship completing a partial rewrites the entry's whole span, taking --lines <n> where the ledger arrived wrapped and refusing the count where it replaces no entry.

A corpus config is rooted at a copy of the pinned bytes, so document and lint answer about the revision, and checkout is the named door for the reads that run git.

A second ship --part gets its own refusal, naming the id the delivered step is filed under in the spelling this project's [ids] declares.

budget answers what a line leaves its prose fields — the deps and symptom an add names, or the line an amend holds — and brief prints the why's share of the line it hands over.

Both pins now hold the number the widening was argued from: five silences on Turing, four of them a unique file, none on Shio, and requiring a slash is refuted.

Every governed write re-derives the README's block inside its own transaction, so the gate no longer fails on a file the task did not touch.

The two projections are planned, both targets are asked, and only then are they renamed into place, so a refusal on either leaves neither refreshed.

show and brief look the anchor up in every declared prose role, name the file that declares it, and state the ambiguity where two do — the resolution RK172 gave the gate.

Every budget is published in words as well as characters, from a ratio measured over this repository's own 392 fields, so a first attempt aims at a unit a model can count.

Every length refusal names the field, the surplus and the word delete, so the author subtracts a stated number instead of recomposing a sentence against a total nobody wrote.

The why is held to the smaller of its own limit and what the line has left after its structure and symptom, so no pair obeying the published numbers is refused by a third.

Both pinned ledgers join the round-trip corpus, and a test asserts they still carry the 149 wrapped entries the property is read for, so the widening cannot go vacuous.

Every section refusal names the file through config.relative, the caller rendering the address and passing it in as it already passes claimed, so one file has one spelling.

A subsection is written one level under the section it extends, read off that heading rather than fixed at 3, so it stays inside the subtree its anchor names whatever depth the file nests at.

A correction on a wrapped entry is refused until --lines says how many it replaces, and the whole span is then rewritten, so no tail of the old sentence survives and no paragraph goes silently.

restate <id> --symptom corrects the claim under the id that keeps it, so a false premise costs neither an id nor a section nor a departure that never happened.

A client whose cached tool list aged out is told: the server declares listChanged, holds one digest of what this connection was sent, and notifies when a config edit moves the descriptors.

A shell command waits 77ms for the hook instead of 184ms: a stdlib-only screen answers the payloads naming no governed path before the package is imported, and every other loads and decides as before.

A governed file whose bytes no verb wrote is named as the turn ends: every write records a digest under the lock it already takes, and the Stop hook states one such change once, never asking it back.

tools/list builds the CLI parser once and indexes every subcommand path off it, so 29 descriptors cost 1 build and 3.4ms where 58 builds cost 195ms.

A path is satisfied by any tail of a tracked file, so an entry relative to the module it is about resolves, and a #L35 anchor is stripped before the file is looked for.

A pointer resolves against every governed prose file and each is orphaned and budgeted by the same rules; an anchor two of them declare is ref.ambiguous and is read as neither.

Each parser declares what it takes off a pipe, so all three paths refuse by naming the argument and a pytest over every tool fails on a fourth instead of the session that meets it.

A call gets a stream already at EOF instead of the client's pipe, so a handler that reads prose refuses an empty body rather than swallowing every message queued behind it.

The guard reads the name too, so an address under the anchor is claimed prose whether the file writes it as a heading or as a bullet.

The gate is declared a read and --fix the write in it, so a lint during somebody else's write answers about the format instead of about the lock — and readOnlyHint is derived.

A read that can write declares which flag makes it one, so dispatch decides the lock again — and a test names the three and holds the property no call site could state.

A one-segment outline anchor opens a new top level, placed after the last one at the depth the file writes one at, and a task's section is placed by its anchor.

claims --prune drops the rows that are not claims and keeps every one that is, so the precise remedy no longer means deleting a whole checkout's registry.

The listing joins the ledger and the store as well, so an id that left the roadmap says which door it left by and only the leftover reads as one.

Every write of the registry is a reconciliation against the lines it was given, and follow is the only thing that writes it — so a row no door reported is cleared by the next marker write.

The terminal doors release the claim on the line they take out, so the listing holds what somebody is looking for and not one row per shipped task.

claims lists the registry against the roadmap — held, expired or stale, oldest first, with the window and the file — so the last question about a claim is a command like every other.

The marker write is where a taken line is refused, so status <id> on the in-progress marker cannot re-date somebody's claim — and nothing re-dates a live one at all.

The marker write is the only writer of a claim: take and hold read the registry and no longer date it, and one test states that all three doors leave the same thing behind.

A marker write now moves the claim with it: the in-progress one dates a claim and any other drops it, which is the rule the read already assumed of every door but this one.

Entry carries the span the parser already knew, so an insertion lands after the whole last entry and a removal takes the whole one.

A refusal names the build that read the config and which modules moved after the process imported them, so a stale server states the cause instead of describing a file that is correct.

install names the merge driver among the surfaces it does not write, and --register-merge writes the .gitattributes half during adoption while the git config line is printed.

section add and amend are held to the schema the document was loaded under, so a [limits.improvements] declaration binds the write that creates the text and not only the gate.

A tab in the indentation is the nesting RK49 keeps and is reported by nothing; past it, char.tab names the separator and --fix writes the space the format meant.

block add --after <label> opens a block beside a named neighbour, resolved per file, and refuses where a file that wants the heading declares no such block.

block drop <label> withdraws the heading from every file where its subtree is blank, and names what is filed under it where anything is.

record move <id> --to-block <x> re-files a ledger entry under another heading, reporting both positions and refusing one no heading declares.

install runs the gate while it writes the workflow: a clean project gets the strict one, a backlog with debt gets the baseline plus the count it defers and when to drop the line.

adopt reports the non-goals too — parsed, unread, over, and the longest lead and reason against their limits, declared or not — and counts them in the headline only where the project opted in.

uninstall takes out this project's server entry, the guard's three hook entries and the copied skill — keeping every entry that is not ours, and the CI gate, which calls the published action.

The copied skill names python "<launcher>" — the path install already wrote into the server and the hook — and a shipped skill that stopped spelling the sentence is a refusal, not a copy.

A table row, a fenced block and a blockquote cost the section budget nothing, so the limit charges the argument an agent has to read and a list stays charged.

A section whose title names a live task no pointer reaches — its own or another's, directly or through a parent anchor — is reported as section.unreachable.

The ownership check reads the same pointer index section drop refuses from, so a section open lines still point at is silent and the finding names only remedies the tool allows.

The bytes read from the README are compared against the file before the rename, so a splice landing on top of somebody else's write is refused at the gate instead of applied.

A transaction renders every file to a scratch name, then checks all of its targets, then renames them, so a writer landing between the check and the last write is caught before anything has landed.

Bash is matched and answered with ask: a governed path mentioned in a command is the decidable half, and what the command does with it is the user's call, so silence is no longer the answer.

A retirement is the one line a markerless ledger marks — a departure being the status such a file does not state about itself — so retire is a door on every project and 🗑 is never read as ✅.

A ⏳ line or an entry naming a half is read as a live partial and passes, so the gate stays loud only for the shape it was written for — a line shipped and not deleted.

A sub-anchor is owned by its first segment, so §RK34.1 belongs to RK34 and a subtree a renumber left behind is reported stale or orphaned instead of exempt.

A project declaring [ids] suffix gets task_id on add, bounded to require the letter, so the split the skill prescribes is a call and not only a terminal, and a bare number is still derived.

adopt names each leading-zero width and the split letter as an [ids] key with a count, so nine findings read as one unwritten declaration — and whether to write it stays the reader's call.

Dumont runs the plain gate green — [ids] pad = 2 made its nine ids legal and rewrote no line — beside Turing's baselined one, so four projects declaring the format is two that cannot drift from it.

Every assertion about a foreign corpus reads a pinned revision, so an edit next door cannot turn this suite red, and the live tree is read as an advisory that warns rather than fails.

lint splices the derived block into every file carrying the markers and compares, so a projection nobody re-derived fails the commit rather than a pytest fixture an adopting project never installs.

A bullet putting GitHub's [ ], [x] or [] where the status goes, with a bold id after, is a named reject — counted by adopt, inside what would change, and never offered as a marker to declare.

A renumber carries the claim to the new address with its age intact, and a defer drops it — the two doors that change a claim without the marker it is read against moving.

A brief carries the pick's own answer instead of its reason sentence, so the door a session starts a task with names the held ids — and so does the absence where a claim is what emptied it.

.githooks/pre-commit runs the release's own bumper on every commit and never blocks, so a plugin loaded from this checkout is re-read after each one.

A stalled line now reports the live claim on it, so started and stuck reads apart from somebody is on this — while held stays the candidates the ranking stepped around.

[claims] held declares the window in minutes, bounded at both ends where it is read, so a project states how long its work takes and held = 3600 is refused instead of becoming a lock.

The claiming flag is its own tool, claim, whose argv and description are still brief --claim's own — so brief and pick carry readOnlyHint again and a client has nothing to ask about.

brief --claim takes the line it describes inside one lock, and brief <id> --claim takes a named one — refused, not re-dated, where another worker already holds it.

ship refuses at input where it would write an entry without an outcome, so the ledger's sentence is the author's rather than the roadmap's problem statement inherited by omission.

block add <label> --title declares the heading in every file already organised by blocks, at that file's own level and separator, after the last block's subtree.

ship reads the ledger side too, so an entry for a still-open line closes it — unless the files say the work is in halves, or the two describe different work.

The completion path is a ship's alone: a retirement against a task whose half the ledger records is refused, so the sentence about what landed is not deleted silently.

record drop refuses two entries that do not say the same thing, and record renumber --line gives one of two deliveries its own address without moving it.