Check it.

What each number counts

The repository is private, because it holds my calendar, my grades and my notes. That is a real limit on what you can verify here and I am not going to pretend otherwise. What follows is the method behind each figure and the artifacts behind the claims, which is the strongest thing I can publish without publishing my own life.

One figure is not counted from the repository, so its method belongs here. A single working session, metered through the tool's own usage report, cost $138.40. At about twenty sessions a month that is $2,768. Measured the other way, the same session used about 24 percent of a weekly limit, which puts the month near $2,508. The two agree within ten percent, so the range is $2,500 to $2,800 a month of metered usage against a $20 subscription. The second figure assumes a usage limit tracks dollar cost proportionally, which is an assumption and not a measurement. None of it is a claim about what the work is worth. It is what the same work costs at list price.

The test suite, actually running

Not a screenshot of a number. This is the tail of pytest -q on the repository as of 05 August 2026, every test passing.

============================== warnings summary ===============================
.venv\Lib\site-packages\fastapi\testclient.py:1
  C:\Users\ryan0\OneDriveNew\OneDrive\My Second Brain\.venv\Lib\site-packages\fastapi\testclient.py:1: StarletteDeprecationWarning: Using `httpx` with `starlette.testclient` is deprecated; install `httpx2` instead.
    from starlette.testclient import TestClient as TestClient  # noqa
-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
1408 passed, 1 warning in 119.09s (0:01:59)

The suite covers the scheduling engine, the calendar gateway, the study reflow, the capture listener and the build tooling. Tests are written against behavior rather than internals, so a module can be rewritten without rewriting its tests.

How a phase closes

Every phase states, in one sentence, what has to be true before it can be called done. The sentence is written before any code exists, and it does not get edited afterwards. That last part is the whole point: an acceptance test you are allowed to rewrite once you have seen the result is not a test, it is a description of whatever you happened to build.

The clearest evidence that the rule is real is the phase that failed it. Phase 35's acceptance depended on a hook that a later architectural decision removed, so its sentence could never be true again. The tempting move was to reword the criterion so it passed. It is marked superseded instead, with a note naming the phase that absorbed the remaining work, and it stays visible in the table.

67 rows in total, 61 done, 1 superseded. Eight shown.

Proving it against scenarios, not vibes

Before a component takes over anything live, it runs against a batch of written scenarios whose expected outcomes were recorded first. If a run disagrees with an expectation, the assumption is that the code is wrong, not the expectation. The batches are never deleted afterwards; they are the regression suite. There are 15 of them.

• behavior
• capture
• character
• digest
• energy
• evening_tick
• feasibility
• focus
• mistakes
• multi_course
• schedule
• sleep_pull
• study
• ta
• weekly_review

One decision, in full

Hard-to-reverse decisions get written down with their reasoning and the alternatives that were rejected, so that a choice made for a specific reason is not quietly undone six months later by someone who cannot see the reason. There are 129. This is the one that shaped everything else, reproduced exactly as it appears in the repository.

One module, and its test

Everything above is about process, and process is easy to claim. This is a real module from the engine. It decides how a long-polling listener should respond to a failure: wait it out, or stop. It is pure, with no file access, no network and no clock of its own, which is what makes it testable at all.

"""Poll failure policy for long-poll daemons (Phase 45.5, Decision 123).

Behavioral spec: prompts/capture.md v1.4 §7.1.

A long-poll listener fails two ways that demand opposite responses, and
conflating them is how a daemon dies silently while still running: a
*recoverable* failure (unreachable, timed out, temporary server error) is worth
waiting out, while a *permanent* one (credentials rejected) never heals. This
module owns that judgment and everything downstream of it — the back-off
arithmetic, the Poll-incident bookkeeping, the sustained-outage threshold, and
the halt decision — behind two methods.

Deliberately pure: no file access, no network, no clock of its own. The caller
supplies the time and carries out the returned PollAction.

Named for the general concept rather than the Capture inbox because Run record
and Poll incident are daemon-wide terms (UBIQUITOUS_LANGUAGE.md). The *logic* is
general; the two user-facing strings in `_halt_action` are Capture-shaped, and
should be parameterised the day a second poller adopts this — not before.
"""

The judgment that matters is in the middle. Elapsed time is measured on a monotonic counter rather than the wall clock, because this machine resyncs its clock by hours around sleep, and a three-hour jump must not be recorded as a three-hour outage.

class PollPolicy:
    """Tracks one Poll incident at a time and decides the response to each poll."""

    def __init__(self, *, monotonic_fn=time.monotonic) -> None:
        # Elapsed time is measured on a monotonic counter, never on the wall
        # clock: this machine resyncs its clock by hours around sleep (System
        # log 2026-07-17/18), and a three-hour jump must not read as a
        # three-hour outage. Wall-clock `now` survives only for stamping.
        self._monotonic = monotonic_fn
        self._clear()

    def _clear(self) -> None:
        """Back to no-incident-in-flight: the state a healthy listener sits in."""
        self._wait = _BASE_WAIT
        self._opened_at: datetime | None = None
        self._attempts = 0
        self._kinds: tuple[str, ...] = ()
        self._notified = False
        self._down_for = 0.0
        self._last_tick: float | None = None
        self._last_wait = 0.0

    def _accrue(self) -> float:
        """Add the gap since the previous poll, capped at what we actually asked
        for plus one poll's worth of slack.

        A larger gap means the listener was not polling and failing through it —
        the machine was suspended, or the clock moved underneath us. Counting it
        would surface a night of sleep as a nine-hour outage and buzz the phone
        the moment the lid opens.
        """
        tick = self._monotonic()
        if self._last_tick is not None:
            gap = tick - self._last_tick
            self._down_for += max(0.0, min(gap, self._last_wait + _POLL_ALLOWANCE))
        self._last_tick = tick
        return self._down_for

And the test that holds it in place:

def test_first_recoverable_failure_opens_an_incident_and_waits_five_seconds():
    line = _Timeline()

    action = _policy(line).on_failure(
        TimeoutError("The read operation timed out"), line.now
    )

    assert action.wait_seconds == 5
    assert action.halt is None
    assert action.notify is None
    assert len(action.events) == 1
    assert "timed out" in action.events[0]


# --- backing off ------------------------------------------------------------


def test_consecutive_failures_double_the_wait_up_to_a_five_minute_ceiling():
    line = _Timeline()
    policy = _policy(line)

    waits = [_fail(policy, line).wait_seconds for _ in range(9)]

    assert waits == [5, 10, 20, 40, 80, 160, 300, 300, 300]

The repository stays private while it holds my own life in it, so the public piece is the machinery with none of my data in it: bindery is the build that turns the calculus workbook into something sellable, extracted, ported to Python and MIT licensed. It refuses to produce a file when the author's own notes survive into it, which is the only part of it worth copying. If you want to see anything else here in more depth, email me and I will walk you through it.