A dashboard over the memory
Six chapters of machinery and no way to see it running.
By August the memory store held 2,525 rows across five projects and two machines, and issues were being promoted out of it into four repositories. All of that was observable only by asking questions of it one at a time. So I built a small dashboard, called TaskDash, on the boring end of the stack: a Hono server with SQLite and Drizzle on port 3200, a React front end, one poller pulling memories out of fragRag into a local memory_inbox table with a cursor, another polling GitHub for issue state.
It does three things. It shows what each project has been doing, it surfaces memories tagged actionable that never became issues, and it lets me turn one into an issue with a click.
For a few months it felt vaguely inert, the way a dashboard does when you stop believing it. In late August I sat down to find out why, and the answer was longer than expected.
57 sessions in a week I barely worked
The number that started it was on the activity chart. AgentCRM, 57 sessions this week.
I had worked on AgentCRM maybe two days that week. Nothing about 57 was plausible, and the shape of the error was the interesting part, because a dashboard that overstates your output by 7x is a dashboard you will keep looking at.
The count was of memories with memory_type set to session_summary. Three completely different things were being stored under that type.
The first is the handoff my /stop routine writes at the end of a session, with structured sections for what got done, what's blocked, and what's next. The second is the marker my /start routine writes when a session opens, which is a record that work began and can never contain a next step. The third, and by volume the largest, is every ad-hoc note taken mid-session: a debugging finding, a deploy note, a decision, typed as a summary because a session produced it.
Of the 57, eight were real handoffs. Three were session-start markers. Forty-seven were notes.
Before changing anything I measured which writer produced what, over 60 days of production data. Memories following the /stop format parsed into usable sections 84% of the time, 57 out of 68. Free-form titles parsed 1 time out of 368, which rounds to zero. The component I'd assumed was the weak link was the only one working correctly, and the 16% of handoffs that didn't parse were sessions that genuinely had nothing pending.
The fix was to stop treating the type as the identity. Handoffs are now identified by their session-end tag or their title prefix, and only those are counted as sessions. Session-start markers are excluded entirely, and I changed /start to write them as fact, which is what they are. Notes are still read for the items they contain and counted separately.
AgentCRM then read 10 sessions for the week, on an eight-week series of 0, 2, 2, 2, 14, 11, 3, 10. Two quiet weeks, a fortnight of heavy work, a break, a return. That is a work cadence. The old chart was measuring how often the system wrote to itself.
Three integrations that failed by going quiet
Fixing the number meant reading the sync path, and the sync path had been dead for a while.
The memory inbox had not advanced since 19 April. Two independent causes were stacked on top of each other, which is why neither got noticed. Nothing scheduled the sync at all: the only caller was a Sync button in the UI, so the data was as fresh as the last time a human clicked. And underneath that, the server could not reach fragRag anyway. Node's fetch rejected the HTTPS endpoint with "unable to get local issuer certificate", a missing intermediate in the chain that curl accepts and Node does not, so every one of my manual checks with curl had reported the service healthy.
A 15-minute poller and an internal address instead of the public one fixed both. The first run added 1,937 memories and took the inbox to 2,295 rows. Four months of memory arrived at once.
The second failure was worse. All five GitHub connections had been sitting at status='error' since 28 May, left over from a migration off a single shared token onto per-account ones. The poller skips connections in the error state, by design, so it can keep working when one repository is misconfigured. With all five errored it did nothing at all, cleanly, every cycle, for three months.
Every token was valid when tested. Re-enabling them imported 222 issues from AgentCRM on the first cycle, 99 of which were new to the dashboard.
That is the same shape as the 403 in the previous chapter, and by this point I'd hit it three times: an integration whose failure mode is silence, sitting next to a dashboard that renders silence and idleness identically. I don't have a general fix. What I have is a habit of asking, for any poller, what it looks like when it's broken, and refusing "the same" as an answer.
The bridge was in an unmerged pull request
The third discovery is the one I'd rather not write down.
The memory-to-issue bridge from the previous chapter, the one I'd been describing as how my system works, existed in a pull request. Twenty-one commits, opened 21 April, untouched since. Only the branch's first commit had ever landed on main, back on 3 April.
Half of it had genuinely shipped, which is how I missed it. The fragRag side was deployed and live: the promotion tools, the issue-URL columns, the extended session routines. The dashboard side, the source-memory links on issues, the per-account tokens, the memory cards showing issue state, the unpromoted tile, all of it was on a branch. My laptop died and got rebuilt in June, which is the most likely reason the thread was dropped, though that's inference rather than something I can prove.
Merging it four months late was not a merge. The August work had rewritten the entire sync layer to fix 14 separate bugs, and the branch predated all of them, so it carried the old sync bugs plus its own new hooks. A test merge conflicted across more than 16 files. The direction that worked was keeping the fixed sync core from main and grafting the branch's bridge hooks and per-account token support onto it, taking the branch's UI wholesale only where it didn't overlap. Fifteen of fifteen regression tests, both workspaces type-checked, and a live smoke test of the create-issue path before it went anywhere near main.
Fixing the metric instead of the data
One tile read "48 unpromoted actionable memories" and had read something like it for months. The obvious response is to promote 48 memories.
Twenty-one of the 48 were session summaries. They carried the actionable tag because the session had actionable work in it, which is true and useful for search, and it does not make the summary itself a task. Promoting them would have created 21 GitHub issues whose bodies were entire session handoffs.
Excluding session summaries from the metric took the count from 48 to 27 on one account and 8 to 6 on the other, and those numbers are now real: 27 memories that describe a specific piece of work and never became an issue. The tile went from an alarm nobody could act on to a queue.
I've come to treat this as the default suspicion. When a count has been wrong for months and nobody has acted on it, the count is usually the bug.
The conditions nobody files
The last piece is the one that changed how I start every session, and it came out of a category error I'd been making all along.
An issue is work somebody decided to do and wrote down. There is a second kind of thing that is nothing like that: a pull request that's open, a branch that exists on one machine and nowhere else, a migration applied to staging and not production, a token that needs rotating. Nobody files those, because they aren't decisions. They're conditions that are quietly still true, and precisely because no one filed them they can sit for months without appearing on any list.
Pull request 17 had been open for 124 days. That's the whole argument in one row.
So they got their own model. An open_loops table keyed on account and loop key, where the first sighting starts a clock, and the age is the signal rather than a priority somebody assigned. Amber at 7 days, red at 30, and anything past 30 escalates into exactly one issue, tracked by id so it can't escalate twice. Snoozing one requires a reason, which then shows up next to it, because a loop hidden without a reason is just a loop you'll rediscover.
Two detectors feed it today. One reads open pull requests from each GitHub connection. The other fires at session close, recording unpushed branches, pending deploys, and stated blockers. On its first live run it found the two genuinely open pull requests on AgentCRM. A third detector, sweeping blocked sections out of session summaries, is specified and not built.
They surface at the top of every session start, oldest first. Right now mine tells me the fragRag bearer token still hasn't been rotated, which it has been telling me since 28 August, in amber, correctly.
The loop, closed
The whole thing now runs as a cycle, and it's worth stating plainly because it took six chapters to get here.
A session stores context as memory, addressed by meaning rather than by path. Context marked actionable is promoted into a GitHub issue, deduplicated against what's already filed. The issue is the state of the work, readable by any model on any machine. When it closes, the state syncs back onto the memory and tags it resolved, so a future session searching that topic finds the outcome recorded next to the intention. Conditions that never become issues get tracked as loops with a clock on them.
I verified the promotion path end to end with a disposable probe rather than by reasoning about it: wrote a memory, promoted it to an issue, closed the issue, watched the state sync land on both the fragRag row and the local inbox, confirmed the resolved tag, then deleted the probe and closed the test issues.
Plenty is still open. The third loop detector isn't built. The token rotation this system reminds me about weekly remains undone. Twenty-seven unpromoted actionable memories are sitting in a queue waiting for me to work through them.
What changed over these seven chapters is where that list lives. When I open a laptop I haven't touched in a fortnight, the machine hands me those three items in the first thirty seconds, and I no longer have to remember that they exist.