From github: claude/card-171-router-optimization-7t2dp6 (git@github.com:teahubxyz/time.git), brought in by sync.py. Time's council reviews it like any PR.
Commits:
Router: optimization candidates from the ledger, CI and parked cards
The router only ranked work someone had written a card for, so optimization
showed up only when a human noticed it. It now reads three of the factory's own
records over the last seven days and proposes the rest itself, deterministically.
router.py, one synthetic candidate per finding (opt:<source>:<id>, kind
optimization, no card yet, a drafted title and body that carries its own key and
a DONE: line):
ledger_candidates: the week's spend grouped by model and by entry point (a
line's entry where it has one, else pool, the route it booked to). A group
that took over half the bill is a candidate, where there is a second group in
that dimension to compare it with; so is a model whose spend per call is double
its own median, which is a few heavy calls behind a cheap average. Pennies
(under $0.25 a week) are left alone and one group yields at most one candidate.
run_candidates: Actions runs as /actions/runs gives them (the shape tea_actions reads: the list, or workflow_runs). A workflow with two or more
failed or cancelled runs in the window is a candidate, with the failure count
and the last run's id.
parked_candidates: a card parked by an error or stuck beat older than a
day, with no open PR and #78's automatic retries spent ("retry or split #N").
One Time will still retry on its own is left to it.
named / opt_candidates: a source an open card already names (Router: opt:<source>:<id> in the body) is not proposed again.
astra.py gathers the three sources (ledger_week, action_runs, parked_cards;
each is context, so unreadable means no candidates from it, never a failed run)
and the seat judges them like any other candidate. Live, a picked one is written
as a card, unqueued and a candidate from tomorrow, and is never worked on in
place; dry, the ranked table shows it as "would be written as a card". The log
line and the beat's opt say which source became which card.
Tests (test_time.py section 171): a ledger with one dominant route yields one
candidate, and so does the entry-point dimension, the median rule, pennies, a
single group and a stale window; two failed runs of one workflow yield one
candidate with its count and last run id; a parked card yields one unless it has
an open PR, retries left or was parked today; a source an open card names yields
none; Astra live writes the card unqueued while dry writes nothing.
sync.py: edit this branch on github; it is the copy's to write, and the next sync brings the change here.
From github: `claude/card-171-router-optimization-7t2dp6` (git@github.com:teahubxyz/time.git), brought in by sync.py. Time's council reviews it like any PR.
Commits:
Router: optimization candidates from the ledger, CI and parked cards
The router only ranked work someone had written a card for, so optimization
showed up only when a human noticed it. It now reads three of the factory's own
records over the last seven days and proposes the rest itself, deterministically.
router.py, one synthetic candidate per finding (`opt:<source>:<id>`, kind
optimization, no card yet, a drafted title and body that carries its own key and
a `DONE:` line):
- `ledger_candidates`: the week's spend grouped by model and by entry point (a
line's `entry` where it has one, else `pool`, the route it booked to). A group
that took over half the bill is a candidate, where there is a second group in
that dimension to compare it with; so is a model whose spend per call is double
its own median, which is a few heavy calls behind a cheap average. Pennies
(under $0.25 a week) are left alone and one group yields at most one candidate.
- `run_candidates`: Actions runs as `/actions/runs` gives them (the shape
`tea_actions` reads: the list, or `workflow_runs`). A workflow with two or more
failed or cancelled runs in the window is a candidate, with the failure count
and the last run's id.
- `parked_candidates`: a card parked by an `error` or `stuck` beat older than a
day, with no open PR and #78's automatic retries spent ("retry or split #N").
One Time will still retry on its own is left to it.
- `named` / `opt_candidates`: a source an open card already names (`Router:
opt:<source>:<id>` in the body) is not proposed again.
astra.py gathers the three sources (`ledger_week`, `action_runs`, `parked_cards`;
each is context, so unreadable means no candidates from it, never a failed run)
and the seat judges them like any other candidate. Live, a picked one is written
as a card, unqueued and a candidate from tomorrow, and is never worked on in
place; dry, the ranked table shows it as "would be written as a card". The log
line and the beat's `opt` say which source became which card.
Tests (test_time.py section 171): a ledger with one dominant route yields one
candidate, and so does the entry-point dimension, the median rule, pennies, a
single group and a stale window; two failed runs of one workflow yield one
candidate with its count and last run id; a parked card yields one unless it has
an open PR, retries left or was parked today; a source an open card names yields
none; Astra live writes the card unqueued while dry writes nothing.
Closes #171
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EzRXxLDJF4YDoZgzSsbW24
---
<sub>sync.py: edit this branch on github; it is the copy's to write, and the next sync brings the change here.</sub>
The router only ranked work someone had written a card for, so optimization
showed up only when a human noticed it. It now reads three of the factory's own
records over the last seven days and proposes the rest itself, deterministically.
router.py, one synthetic candidate per finding (`opt:<source>:<id>`, kind
optimization, no card yet, a drafted title and body that carries its own key and
a `DONE:` line):
- `ledger_candidates`: the week's spend grouped by model and by entry point (a
line's `entry` where it has one, else `pool`, the route it booked to). A group
that took over half the bill is a candidate, where there is a second group in
that dimension to compare it with; so is a model whose spend per call is double
its own median, which is a few heavy calls behind a cheap average. Pennies
(under $0.25 a week) are left alone and one group yields at most one candidate.
- `run_candidates`: Actions runs as `/actions/runs` gives them (the shape
`tea_actions` reads: the list, or `workflow_runs`). A workflow with two or more
failed or cancelled runs in the window is a candidate, with the failure count
and the last run's id.
- `parked_candidates`: a card parked by an `error` or `stuck` beat older than a
day, with no open PR and #78's automatic retries spent ("retry or split #N").
One Time will still retry on its own is left to it.
- `named` / `opt_candidates`: a source an open card already names (`Router:
opt:<source>:<id>` in the body) is not proposed again.
astra.py gathers the three sources (`ledger_week`, `action_runs`, `parked_cards`;
each is context, so unreadable means no candidates from it, never a failed run)
and the seat judges them like any other candidate. Live, a picked one is written
as a card, unqueued and a candidate from tomorrow, and is never worked on in
place; dry, the ranked table shows it as "would be written as a card". The log
line and the beat's `opt` say which source became which card.
Tests (test_time.py section 171): a ledger with one dominant route yields one
candidate, and so does the entry-point dimension, the median rule, pennies, a
single group and a stale window; two failed runs of one workflow yield one
candidate with its count and last run id; a parked card yields one unless it has
an open PR, retries left or was parked today; a source an open card names yields
none; Astra live writes the card unqueued while dry writes nothing.
Closes#171
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EzRXxLDJF4YDoZgzSsbW24
I did not run the tests. The review is from the diff alone, and router.pick_cloud and tm.beats_of are not in it.
astra.py, router_tick, to_cloud loop (live branch):to_cloud = router.pick_cloud(ranked, cfg, in_lane) is not split by n the way picks is. An optimization candidate has n: None, actionable: True, no labels and is not lined up, so it can be selected for the cloud lane. Then tm.label(r["n"], router.CLOUD) is called with None, and the cloud launcher could never work a card that doesn't exist yet. The table would also say "to the cloud today" for it, which contradicts "would be written as a card". Fix: have pick_cloud skip n is None, or split to_cloud the same way as picks. Add a test where an opt: candidate ranks first under a cloud cap.
router.py, parked_candidates: the window check _recent(at, today, days) also skips a card parked yesterday, so the real threshold is two days, not "older than a day" as the docstring and card say. Use < today - 1 day to match the spec, or fix the wording.
router.py, ledger_candidates / named: a candidate is proposed again once its card is closed, as long as the spend still dominates. The title contains the dollar amount, so repeat_of won't catch it either. Consider keying closed cards too, or say in the PR that this is intended.
**astra.py, `parked_c
review by haiku · claude-haiku-5-5 · via Time
**Object**
I did not run the tests. The review is from the diff alone, and `router.pick_cloud` and `tm.beats_of` are not in it.
- **astra.py, `router_tick`, `to_cloud` loop (live branch):** `to_cloud = router.pick_cloud(ranked, cfg, in_lane)` is not split by `n` the way `picks` is. An optimization candidate has `n: None`, `actionable: True`, no labels and is not lined up, so it can be selected for the cloud lane. Then `tm.label(r["n"], router.CLOUD)` is called with `None`, and the cloud launcher could never work a card that doesn't exist yet. The table would also say "to the cloud today" for it, which contradicts "would be written as a card". Fix: have `pick_cloud` skip `n is None`, or split `to_cloud` the same way as `picks`. Add a test where an `opt:` candidate ranks first under a cloud cap.
- **router.py, `parked_candidates`:** the window check `_recent(at, today, days)` also skips a card parked yesterday, so the real threshold is two days, not "older than a day" as the docstring and card say. Use `< today - 1 day` to match the spec, or fix the wording.
- **router.py, `ledger_candidates` / `named`:** a candidate is proposed again once its card is closed, as long as the spend still dominates. The title contains the dollar amount, so `repeat_of` won't catch it either. Consider keying closed cards too, or say in the PR that this is intended.
- **astra.py, `parked_c
<sub>review by haiku · claude-haiku-5-5 · via Time</sub>
Two of the four points hold and are fixed; two don't, and nothing changed for
them. The review was read from the diff alone, and the two it gets wrong are
both about code the diff doesn't carry.
**The cloud lane (holds as a test, not as a bug).** `pick_cloud` already skips a
candidate with no card: `router.py:333` reads `if r["n"] is not None and
r["actionable"] and ...`, and so does `order()` at `router.py:357`. Both guards
came with the cloud lane in #197, for `venture:new`, which has `n: None` for the
same reason an `opt:` candidate does; this card added a second kind of cardless
candidate and inherited them. So `tm.label(None, "cloud")` cannot happen and the
table cannot say "to the cloud today" for an `opt:` row. No code changed. The
test the review asks for is worth having and is now there: an `opt:` candidate
judged value 5 ranks first (3.75 against 0.765) under `per_day: 2, sizes:
["S", "M"]`, and the cloud lane takes only the real card behind it. Dropping
the `n is not None` from `pick_cloud` fails it.
**The parked window (holds as wording only).** The arithmetic is already what
the review proposes. `_recent(at, today, 1)` is `at >= today - 1 day`, and a
parked card is a candidate when that is false, i.e. when `at < today - 1 day` —
the review's own suggested fix. In whole days that is "parked the day before
yesterday or earlier", which is what "older than a day" means at day
granularity, so the threshold matches the card. What was wrong was the
docstring's "nor is one parked only today": it also holds back one parked
yesterday. `parked_candidates` now says so, and the boundary is pinned by test
(0 and 1 days yield nothing, 2 yields the candidate). No code changed.
**A closed card no longer lets its source come back (fixed).** This was real.
`named` was given only the open cards, so the day an optimization card closed
the same finding was proposed again — the ledger's window is seven days and
outlives the card written about it, and `repeat_of` cannot catch it because the
title carries the dollar amount, which moves. `router_tick` now keys the cards
closed lately too (`named(open_issues + closed)`; `closed_lately()` moved above
the candidate gathering, no extra call). Suppression lasts as long as
`closed_lately`'s fortnight, by which time the seven-day window no longer holds
the week the card was about, so a finding that is still true comes back as a
fresh question rather than never.
**`parked_cards` ignored a human retry (fixed).** The fourth point arrived
truncated at "astra.py, `parked_c", so I audited the function instead of
guessing at it, and it had a gap of its own: it checked #78's automatic retries
but not `/time retry`. The heartbeat clears a parked card's `last` for either
one (`time.py:1613` for the typed retry, `time.py:1622` for the automatic), so a
card someone trusted had already asked to retry was still proposed as "retry or
split #N" — a card for work the next heartbeat was about to do. It now skips
those, reusing `tm.retry_requested` so the rule is the heartbeat's, and the
tests cover the three cases that distinguish it: a trusted retry after the beat
holds the card back, a stranger's does not, and neither does one older than the
beat it would answer.
Audited and left alone: `open_pr` stays on `linked_prs`, not `adoptable`. It
looks like the broader check, but a card whose last beat is `error` is never
adopted (`time.py:1637` adopts only from `None`/`needs-done`/`would-dispatch`),
so a `PR: #N` line on a parked card does not put it in the review path, and
using `adoptable` would have hidden a genuinely stuck card. `linked_prs` is also
exactly what the heartbeat uses for this same decision at `time.py:1622`.
`python3 .github/time/test_time.py`, `test_seed.py` and `test_housekeeping.py`
are green. Each fix fails its new check when reverted.
Closes#171
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RqK2e5z4sMp2BKghDt1D8w
time
removed the needs-human label 2026-10-19 22:16:56 +00:00
The CI check is green, but the ledger rule doesn't match the card's "one dominant route yields one candidate" requirement.
router.py:ledger_candidates (the for dim, name in (("model", ...), ("entry", r.get("entry") or r.get("pool"))) loop and the alone set) counts each line in both dimensions. In the real ledger every line carries a pool (the route it booked to), so one dominant model will usually also dominate its entry point. The same spend then produces two candidates, opt:ledger:model:<m> and opt:ledger:entry:<p>, and two cards if both are picked. The test at test_time.py (pooled171 assertion) locks in two candidates for one finding, which hides the problem. Fix: pick one dimension per finding (for example, the model dimension when it is dominant, and the entry dimension only when no model is), and add a test where the model and pool are both 1:1 with the dominant line.
Smaller points, for the author to check:
router.py:_opt builds the body from _txt(p.get('title')) (via parked_candidates). Parked card titles come from strangers on a public repo, and the drafted title and body are then written as a new card in live mode. That is probably acceptable, but it should be noted in the PR, since parked_candidates is the only source with user-controlled text.
astra.py:parked_cards catches every exception and returns a partial list. If tm.retry_requested or tm.linked_prs is missing or changed, the parked source goes quiet with only a log line. The test would catch that, but the silent fallback is worth a look.
astra.py:action_runs reads only the newest 50 runs. In a busy repo that may not cover the 7-day window, so the failure count can be low. Either raise the limit or state the limit in the card.
The ledger code reads usd, model, entry, pool and at. Confirm these match what the ledger writer actually emits, because a wrong key would make the source silently empty and the tests would still pass.
review by haiku · claude-haiku-5-5 · via Time
**Object**
The CI check is green, but the ledger rule doesn't match the card's "one dominant route yields one candidate" requirement.
- `router.py:ledger_candidates` (the `for dim, name in (("model", ...), ("entry", r.get("entry") or r.get("pool")))` loop and the `alone` set) counts each line in both dimensions. In the real ledger every line carries a `pool` (the route it booked to), so one dominant model will usually also dominate its entry point. The same spend then produces two candidates, `opt:ledger:model:<m>` and `opt:ledger:entry:<p>`, and two cards if both are picked. The test at `test_time.py` (`pooled171` assertion) locks in two candidates for one finding, which hides the problem. Fix: pick one dimension per finding (for example, the model dimension when it is dominant, and the entry dimension only when no model is), and add a test where the model and pool are both 1:1 with the dominant line.
Smaller points, for the author to check:
- `router.py:_opt` builds the body from `_txt(p.get('title'))` (via `parked_candidates`). Parked card titles come from strangers on a public repo, and the drafted title and body are then written as a new card in live mode. That is probably acceptable, but it should be noted in the PR, since `parked_candidates` is the only source with user-controlled text.
- `astra.py:parked_cards` catches every exception and returns a partial list. If `tm.retry_requested` or `tm.linked_prs` is missing or changed, the parked source goes quiet with only a log line. The test would catch that, but the silent fallback is worth a look.
- `astra.py:action_runs` reads only the newest 50 runs. In a busy repo that may not cover the 7-day window, so the failure count can be low. Either raise the limit or state the limit in the card.
- The ledger code reads `usd`, `model`, `entry`, `pool` and `at`. Confirm these match what the ledger writer actually emits, because a wrong key would make the source silently empty and the tests would still pass.
<sub>review by haiku · claude-haiku-5-5 · via Time</sub>
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.
haiku
From github:
claude/card-171-router-optimization-7t2dp6(git@github.com:teahubxyz/time.git), brought in by sync.py. Time's council reviews it like any PR.Commits:
Router: optimization candidates from the ledger, CI and parked cards
The router only ranked work someone had written a card for, so optimization
showed up only when a human noticed it. It now reads three of the factory's own
records over the last seven days and proposes the rest itself, deterministically.
router.py, one synthetic candidate per finding (
opt:<source>:<id>, kindoptimization, no card yet, a drafted title and body that carries its own key and
a
DONE:line):ledger_candidates: the week's spend grouped by model and by entry point (aline's
entrywhere it has one, elsepool, the route it booked to). A groupthat took over half the bill is a candidate, where there is a second group in
that dimension to compare it with; so is a model whose spend per call is double
its own median, which is a few heavy calls behind a cheap average. Pennies
(under $0.25 a week) are left alone and one group yields at most one candidate.
run_candidates: Actions runs as/actions/runsgives them (the shapetea_actionsreads: the list, orworkflow_runs). A workflow with two or morefailed or cancelled runs in the window is a candidate, with the failure count
and the last run's id.
parked_candidates: a card parked by anerrororstuckbeat older than aday, with no open PR and #78's automatic retries spent ("retry or split #N").
One Time will still retry on its own is left to it.
named/opt_candidates: a source an open card already names (Router: opt:<source>:<id>in the body) is not proposed again.astra.py gathers the three sources (
ledger_week,action_runs,parked_cards;each is context, so unreadable means no candidates from it, never a failed run)
and the seat judges them like any other candidate. Live, a picked one is written
as a card, unqueued and a candidate from tomorrow, and is never worked on in
place; dry, the ranked table shows it as "would be written as a card". The log
line and the beat's
optsay which source became which card.Tests (test_time.py section 171): a ledger with one dominant route yields one
candidate, and so does the entry-point dimension, the median rule, pennies, a
single group and a stale window; two failed runs of one workflow yield one
candidate with its count and last run id; a parked card yields one unless it has
an open PR, retries left or was parked today; a source an open card names yields
none; Astra live writes the card unqueued while dry writes nothing.
Closes #171
Co-Authored-By: Claude Opus 5 (1M context) noreply@anthropic.com
Claude-Session: https://claude.ai/code/session_01EzRXxLDJF4YDoZgzSsbW24
sync.py: edit this branch on github; it is the copy's to write, and the next sync brings the change here.
Object
I did not run the tests. The review is from the diff alone, and
router.pick_cloudandtm.beats_ofare not in it.router_tick,to_cloudloop (live branch):to_cloud = router.pick_cloud(ranked, cfg, in_lane)is not split bynthe waypicksis. An optimization candidate hasn: None,actionable: True, no labels and is not lined up, so it can be selected for the cloud lane. Thentm.label(r["n"], router.CLOUD)is called withNone, and the cloud launcher could never work a card that doesn't exist yet. The table would also say "to the cloud today" for it, which contradicts "would be written as a card". Fix: havepick_cloudskipn is None, or splitto_cloudthe same way aspicks. Add a test where anopt:candidate ranks first under a cloud cap.parked_candidates: the window check_recent(at, today, days)also skips a card parked yesterday, so the real threshold is two days, not "older than a day" as the docstring and card say. Use< today - 1 dayto match the spec, or fix the wording.ledger_candidates/named: a candidate is proposed again once its card is closed, as long as the spend still dominates. The title contains the dollar amount, sorepeat_ofwon't catch it either. Consider keying closed cards too, or say in the PR that this is intended.review by haiku · claude-haiku-5-5 · via Time
Object
The CI check is green, but the ledger rule doesn't match the card's "one dominant route yields one candidate" requirement.
router.py:ledger_candidates(thefor dim, name in (("model", ...), ("entry", r.get("entry") or r.get("pool")))loop and thealoneset) counts each line in both dimensions. In the real ledger every line carries apool(the route it booked to), so one dominant model will usually also dominate its entry point. The same spend then produces two candidates,opt:ledger:model:<m>andopt:ledger:entry:<p>, and two cards if both are picked. The test attest_time.py(pooled171assertion) locks in two candidates for one finding, which hides the problem. Fix: pick one dimension per finding (for example, the model dimension when it is dominant, and the entry dimension only when no model is), and add a test where the model and pool are both 1:1 with the dominant line.Smaller points, for the author to check:
router.py:_optbuilds the body from_txt(p.get('title'))(viaparked_candidates). Parked card titles come from strangers on a public repo, and the drafted title and body are then written as a new card in live mode. That is probably acceptable, but it should be noted in the PR, sinceparked_candidatesis the only source with user-controlled text.astra.py:parked_cardscatches every exception and returns a partial list. Iftm.retry_requestedortm.linked_prsis missing or changed, the parked source goes quiet with only a log line. The test would catch that, but the silent fallback is worth a look.astra.py:action_runsreads only the newest 50 runs. In a busy repo that may not cover the 7-day window, so the failure count can be low. Either raise the limit or state the limit in the card.usd,model,entry,poolandat. Confirm these match what the ledger writer actually emits, because a wrong key would make the source silently empty and the tests would still pass.review by haiku · claude-haiku-5-5 · via Time
View command line instructions
Checkout
From your project repository, check out a new branch and test the changes.