Take a quick tangent with /side

The categoriser’s in and you’re partway through wiring it into the import flow when a small question lands: which of last month’s transactions did the new regex table leave as other? It’s worth knowing - a big other bucket means the rules have gaps - but it’s a side errand. You don’t want to abandon the wiring you’re mid-thought on, and you really don’t want the answer’s exploration - file reads, a quick query, some sample rows - piling into the main thread and shoving the wiring context further down the window.

Last lesson’s /fork is too heavy for this, and for a reason you can now put a number on: forking pays for a second copy of the shared history, because both threads are meant to live and grow. This detour isn’t going to live anywhere. The right tool doesn’t copy anything.

Stepping aside and back

/side opens a brief side thread off your current session - you ask your tangential question there, get the answer, and return to the main thread with its context undisturbed by the detour:

> [mid-wiring; the main thread is full of import-flow context]

> /side

  ⎿ Side thread. The main conversation is parked, untouched.

> run the categoriser over last month's import and list every transaction
  that came back "other"

  [reads the import, runs the categoriser, prints the unmatched rows]
  6 of 214 landed in "other": 3 are a new merchant (BLINKIT), 2 are ATM
  withdrawals, 1 is a refund. The regex table has no pattern for any of them.

> [you note it - add a groceries pattern for BLINKIT later - and step back]

  ⎿ Returned to the main thread. The side exploration didn't enter this context.

The win is precise: you got the answer, and the main thread is exactly as it was - still holding the import-flow wiring you were mid-thought on, not one token heavier for the detour. Unlike a fork, none of the side thread’s reads or output ever rejoin the main thread, not even as a summary - they simply don’t come home.

When it’s a tangent, and when it isn’t

The judgment call is honest scope. /side earns its keep when the detour is genuinely disposable - a question you want answered without keeping the trail. The moment the “quick tangent” turns into real work you’ll want to continue - you start actually adding those missing patterns, not just noting that they’re missing - it has outgrown a side thread, and you’re better off treating it as its own task with its own session.

So the three moves now sort cleanly by weight, and it’s worth holding them apart:

• /side - a disposable detour, paid for once and never carried forward.
• /fork - two parallel lines of work you mean to develop and compare, paid for twice on purpose.
• A fresh session - unrelated work that deserves its own clean window from the start.

Pick the heavy tool for a light job and you carry clutter you didn’t need; pick the light tool for heavy work and you’ll lose the trail right when you wanted to keep it.

This lesson is short because the move is small - one command, one honest question about scope, nothing else to teach.

Back to the main thread

You’re back where you left off, the wiring still warm in context, plus one note for later: teach the regex table about BLINKIT. You finish the wiring and keep going - and this is where the day starts to bite. The money-handling refactor sprawls across the importer, the models, and the reports endpoint, and you’ve been feeding Codex file after file for an hour. The window is filling. You’re not done and you’re not switching away - you’re just running out of room. That’s a specific problem with a specific fix: reclaim the window in place.