I spent nine months calling it a fuel tank

From the very first commit, the unit of this tool was a **tank**. A tank was where an account's configuration lived. You had two subscriptions, so you had two tanks, and the interesting question was which one still had quota — fuel. The vocabulary followed: fuel, dry, burn order, a gauge on the dashboard.

The name was accurate about the thing I had noticed and wrong about the thing I had built.

What was actually in there

A tank holds the engine's **long-term memory** — the accumulated notes about your projects, your preferences, the corrections you have made. It holds the **session history**: every conversation, searchable, resumable. It holds the auth token, which is to say it holds *which person the vendor thinks you are*.

Quota was never the contents. Quota was the thing on the outside of the container that you could read without opening it.

It took nine months to notice, because the misnomer never produced a wrong answer. Everything worked. The gauge was right, the switching was right. A bad abstraction does not announce itself by failing; it announces itself by making the next feature awkward for reasons you cannot name.

What changing the noun did to the tool

Once a tank holds identity rather than fuel, a pile of decisions that had been arbitrary become forced.

**Memory should be shareable across engines.** If the valuable content is what you know rather than what you have left to spend, then it is absurd for the same person's notes to be trapped in one vendor's account. So memory can now point at one shared store that several tanks read and write — including tanks on different engines entirely.

The mechanism matters more than the feature: that store is **plain markdown, in a directory, belonging to nobody in particular.** One engine has a memory directory, so it gets a symlink into the shared store. Two others keep their memory in opaque formats, so instead they get a short pointer note appended to the rules file each of them already reads on startup.

No translation layer. No sync. No format negotiation between vendors. All three are reading *the same file*, which is the only integration strategy that cannot drift, and it is available because the substrate is a text file rather than a product.

**Some identities must never be commingled.** Once a tank is a persona and not a wallet, "put all your tanks in one rotation" stops being obviously correct. So a tank can be marked standalone: out of the rotation, out of the carry-your-session-onward paths, and the memory-sharing command refuses it outright. That exists because a bot persona might live on your own account, where an account-level guard cannot see the difference — the boundary that matters is the *identity*, and the tool had no word for it until the noun changed.

**Sharing is opt-in, seeded by copy, and reversible.** Which was not a policy I reasoned out. It is what you do by default once you accept that the thing you are joining together is somebody's accumulated self rather than their remaining credit.

The feature I deleted in the same release

There was a mechanism that carried one vendor's login between tanks by stashing and restoring a Keychain item. It shipped, it was clever, and I removed it.

It had never been tested against a real Keychain. And its failure mode was that a restore could quietly do nothing — leaving you signed in as the *other* account while the interface said you had switched. You would then spend a different person's quota, under a different identity, with no signal at all.

**A switch that might lie about which account you are on is worse than no switch.** Making someone click through a sign-in is a cost. Being silently wrong about who you are is not a cost, it is a defect with the shape of a working feature. It came back three releases later, with every restore verified against the stash before launch and an integration test driving the real system binary against a disposable keychain — which is what the original should have had.

That is the same lesson as the noun, arriving from the other end. When the container held fuel, a bad switch wasted money. Once it held identity, a bad switch was something else entirely.

The general shape

If you are building anything that holds state for a person, it is worth asking, out loud, once:

**What is actually inside this thing, and is that what I named it after?**

We name containers after the property we first needed to look at. Then the container keeps accumulating, and the name stops describing the contents and starts constraining what we are willing to build. Nine months of features here were subtly organised around "manage your quota" when the honest description was "keep the half of your work that the vendors do not own."

That second sentence is a different product. It is also the one I had already built without noticing.

The boring footnote

clikae — plain bash, MIT, no daemon, no telemetry, every line auditable. The shared memory store is markdown in a folder, on purpose: it is the one format every engine can read today and no vendor can take away tomorrow.