Background work

Two scheduled rows carry the assistant’s work on its own library: 25 stages, of which 8 call a model. Capture runs in minutes; consolidation runs once a day, and its cron is the only thing ordering any of them. Everything else that runs unasked — including the upkeep of the machine itself — is on the What runs on its own page.

These are the shipped defaults. What you can change lives in a config file you own once TESSERACT is installed, so your copy may differ, and should, once you tune it.

capture — every 5 minutes

Seals what the last few minutes produced into memory leaves, and recaps any conversation that has gone quiet.

Without it: Turns and terminal work would wait for the nightly pass, anything the machine lost before it would never be captured at all, and a conversation held anywhere would leave nothing behind, so the next one would start from nothing.

#	Stage	What it does	Runs after	Due	Budget
1	leaf_intake	Admits waiting leaves and appends them to their buffer.	—	continuous	2 min
2	leaf_seal	Compresses a buffer that crossed its size or age threshold into one seal, and marks its leaves sealed.	leaf_intake	continuous	2 min
3	conversation_reflect	Writes one recap for every conversation that has gone quiet, whichever entry point it arrived through, tagged with that entry point.	leaf_seal	continuous	2 min

consolidate — 17:00 every day

Settles the day into the library: digest, distil, lint, scrub, re-index. It sweeps the agenda on the way.

Without it: The library would grow by accretion: duplicates never merged, broken links never repaired, indexes drifting from the files they describe.

It consumes leaf_seals from the other row — declared, so nothing reads across rows by accident.

#	Stage	What it does	Runs after	Due	Budget
1	agenda_reap	Abandons the items on the agenda that have sat unfinished past their horizon, so a backlog nobody can finish never crowds out new work.	—	daily	1 min
2	conscience_heartbeat	Scrapes the day’s failures, idle jobs and open breakers into a drift report.	—	daily	2 min
3	daily_writer	Rolls the day’s scheduled runs into the daily log layer.	—	daily	2 min
4	leaf_digest_daily	Recomputes one digest across every seal written that day.	leaf_seal†	daily	5 min
5	leaf_topic_route	Files each seal’s sections under the topics its entities earned.	leaf_seal†	daily	5 min
6	work_index_sweep	Drops index rows pointing at sessions and files that no longer exist.	—	daily	3 min
7	chat_digest (model)	Reads yesterday’s conversations and writes down what mattered.	—	daily	10 min
8	retention	Ages everything the retention table names — old sessions to the archive, spent logs away, and the permission ledger’s old rows to a dated file beside it.	chat_digest	daily	5 min
9	feedback_consolidator (model)	Reviews every active directive and proposes merges, archives, demotions, and conflicts for the operator to settle.	—	daily	10 min
10	feedback_sweep (model)	Looks for standing instructions you gave in passing and proposes them; it never writes one itself.	—	daily	10 min
11	librarian_heartbeat (model)	Consolidates the raw daily layer into canonical memory and refreshes the index.	chat_digest	daily	10 min
12	dream_cycle	Promotes what you keep recalling into longer-lived memory.	librarian_heartbeat	daily	10 min
13	memory_lint	Scans the memory store for broken links, stale paths and empty stubs.	dream_cycle, librarian_heartbeat	daily	5 min
14	memory_scrub	Repairs the findings it safely can, and leaves the ones needing your decision.	memory_lint*	daily	5 min
15	path_heal	Points written paths at the folders they moved to, and asks about the ones the mode keeps for you.	memory_scrub	daily	5 min
16	vault_raw_watch (model)	Ingests what you dropped in the vault’s raw folder; anything that fails a safety filter is held for you.	—	daily	15 min
17	vault_lint (model)	Checks the vault wiki for orphans, stale pages, contradictions and missing hubs.	vault_raw_watch	daily	10 min
18	index_rebuild	Rebuilds the keyword and vector indexes over the settled store.	memory_scrub, path_heal, vault_lint, vault_raw_watch	daily	15 min
19	atlas_build	Redraws the map of how everything you have saved connects — memories, wiki pages, sources and the names in them.	index_rebuild, memory_scrub, path_heal	daily	10 min
20	atlas_verify	Weekly. Redraws the map a second time and checks it matches the one on disk, so the map can never quietly become the thing it describes.	atlas_build*	weekly	10 min
21	memory_relink (model)	Looks up the memories the map says nothing connects to, and tries to find them relatives.	atlas_build*, atlas_verify	daily	10 min
22	brief_render (model)	Writes tomorrow morning’s brief, last, so it knows what the night actually did — delivery is a separate service that sends it at the hour you set.	memory_relink, retention, vault_lint	daily	10 min

Order is declared, not timed

A stage names what must run before it, and the runner derives the order above from those names — it is not the order they are written in. Three kinds of edge, and the difference matters when something breaks: a data dependency (marked * in the table) means the stage consumes what the other one produced, so it is skipped when that one did not succeed. A plain ordering edge only places it later; the stage still runs. And † marks a stage waiting on the OTHER row’s output — the two rows fire apart, so it reads what the last capture left rather than waiting for one.

That distinction is why an unreachable model cannot cost you the day’s maintenance. The deterministic stages commit before anything waits on a provider, and nothing downstream of a model stage is skipped unless it actually reads what that stage writes.

The daily row’s own cadence — 0 17 * * *, 17:00 every day — is the only clock in the whole arrangement. Move that one line and every stage moves with it, keeping its order.

Missing a day costs one run, not the work

Each stage remembers how far it got. Come back after a week away and a stage is handed the whole week as one window rather than being run seven times — and the few stages that can only think in single days walk the days they missed, oldest first, bounded so a month away cannot become a month of model calls in one run.

What a stage reports

Every stage says what came of it, plus how much it changed and how much it declined to touch. There is no state for ran, produced nothing, called it a win.

Outcome	Means
succeeded	It ran and produced something.
skipped_no_work	It ran and there was nothing to do. Healthy, and it says so rather than reporting a success.
refused	It deliberately did not start — you turned it off, a breaker was open, or something it needs was missing.
degraded	It produced less than it promises. A rebuild without embeddings is the usual one.
truncated	It ran out of its time budget; the rest resumes next run from where it stopped.
failed	It tried and errored.
caller_error	It worked, and it was asked for something it cannot do: a file that is not there, a setting of the wrong shape, work that was already finished. Being asked wrong is not the same as being broken, so it is counted separately.
unverified	It acted, nothing went wrong, and it left no mark anyone can go and check. Neither a success nor a failure, and it is counted in its own column rather than folded into either.
skipped_upstream_failed	Something it consumes did not succeed, so running it would work from stale input.