Progress you can't fake.

Derive progress. Never maintain it.

There is no status document anywhere. Status lives in one place, the record's own frontmatter, and the board is a read of those files. A hand-kept board and the frontmatter it copies will eventually disagree, and nothing tells you which one is lying.

The useful consequence: you cannot make the board look better than the work. Moving a card means changing a record, and changing a record means the work actually moved. An empty column stays visibly empty, because "two ideas captured and nothing tested" is the honest picture of where you are.

The status list is closed, and that's the feature

A small fixed set of words, not free text. That's what makes the board renderable at all, and what lets the record checker catch a typo before it becomes an invisible card sitting in no column.

If you find yourself wanting a new status, the work has usually outgrown its record type rather than its vocabulary, which is a different and more useful thing to discover.

Parked is decided. It is not queued.

Most backlogs are a graveyard that looks like a plan: things nobody rejected and nobody will do. BOSS splits that pile in two and makes you say which:

• Deferred: you named a condition that would bring it back. A decision with a trigger, and the trigger is written down.
• Dropped: decided against on the merits, reasoning kept so you don't re-litigate it in four months.

Neither is a queue, and the board says so where it lists them. Paused work also can't simply walk back in: three questions first (still relevant, still aligned, anything changed) so nobody builds a feature the world moved past while it sat there.

A kanban whose columns you can't drag things into

Captured → Taking shape → Building → Shipped, plus Parked. It looks like every board you've used and behaves like none of them, because there is nothing to drag: a card sits in a column because of what its record says, and the only way to move it is to change the work. The venture itself sits above the columns, on its own line.

One column has proved harder than the rest, and it's an honest problem rather than a feature: Building is the only state nothing can verify. A shipped claim can be checked against disk. An index can be checked against the records. But nothing can check whether a card claiming to be in flight has anyone in flight on it, which is why BOSS also watches how long things sit there and asks.

Ending a session is a thing you do, not a thing that happens

Work doesn't stop at a natural boundary; it stops when you do. So there's a verb for closing out: it updates where the project stands, appends a log entry for what landed and what surprised you, and lets the conscience update its own read. You run it before stepping away, so the next session starts with context instead of archaeology.

Coming back is the other half. boss status opens with where you are and the one thing to pick up; boss recap reads the week back out of records you already wrote (landed, learned, decided, in flight) and prints empty sections as empty, because a summary that can only go up is a comfort device.

The tasks you spot mid-build

"This also needs a rollback." "The adjacent rule is probably wrong too." Found work lives in the conversation until something durable holds it, and a long session loses it silently. BOSS notices when the list in the chat has outrun anything written down and says so, once, and there's a file for exactly this: found tasks, the scope that turned out to be new, and the questions that should stay questions.

It fires on time elapsed, not on reading your mind, so it's a reminder rather than a referee. Re-reading what you built tells you what you did; nothing can recover what you meant to do next unless you wrote it down.

And the part that isn't a file

The conscience keeps a persistent read on the venture in plain English: its point of view, not a log. You can ask what it currently thinks, see how that read changed over time, or see what it said and what you actually did with it. You can also make it forget things before a date, because a memory you can't evict isn't memory, it's an accumulation.

That last view is the uncomfortable one and the most useful: it's the record of advice given versus advice taken, and it belongs to you rather than to BOSS.

Typed records, and a promotion you can read from both ends

An idea is IDEA-NNN, and it comes in two kinds: the one venture you walked in with, which gets pressure-tested and is validated or killed, and the capabilities you add to it. A capability that earns a build contract becomes FEAT-NNN, and the link is written at both ends, so you can stand at a feature and find the thinking that produced it, or stand at an idea and find what became of it. A promotion legible from only one side is how work gets rebuilt.

There's a checker for the record set itself: duplicate ids, statuses outside the closed vocabulary, and promotions that broke. The failure it exists for is the quiet one: a record that looks fine, sits in no column, and is therefore invisible rather than wrong.

Six record types, and you get the few you need on day one rather than the whole filing system. Ideas, evidence and decisions at the first rung; specs when there's something to build. The record system in full

Process as a predicate, not a checklist

The thing that watches your project isn't a list of steps you tick. Each loop declares an entry condition and an exit condition, both evaluated against your actual files, three or more captured ideas and no canvas naming a riskiest assumption, or styling spread across several files and no token system.

Two things follow, and they're the reason it's built this way:

• A loop can close by itself. You do the work, the exit condition becomes true, it stops watching. Nobody marks anything done.
• It can be wrong in a checkable way. A predicate that fires when it shouldn't is a bug with a reproduction, not a matter of taste, which is how a false-positive class got found and fixed rather than tolerated.

And the loops that end work are first-class: a gate before paused work re-enters, and a verb for ending something at whatever size it actually is. How a loop decides to speak

A decision record with a falsifier and a signature

Context, the call, the reasoning, the consequences, plus two fields most decision logs don't carry:

• A falsifier. What would prove this wrong, and by when, with a number and a date. Written before the answer is known, which is what makes it cost something.
• Who decided: you, you ratifying the AI's suggestion, or the AI on its own. That distinction gets more useful every year, and nobody remembers it unstated.

And the rule that keeps the log honest: supersede, don't edit. A decision that turns out wrong gets a new record pointing at the old one, which stays exactly as written. A log you can revise is a log that agrees with you.

Work in progress is a number, and BOSS watches it

When too much is open at once it says so and asks which one is actually moving. It won't reorganise your work or rank it for you; naming the pile is usually enough, and a tool that reprioritises on your behalf is a tool you stop trusting.

Coming back is handled the same way: boss status opens with where you are and the one thing to pick up, and boss recap reads the week back out of records you already wrote: landed, learned, decided, in flight. Empty sections print as empty, because a summary that can only go up is a comfort device. What BOSS writes down, and the product positions.