# The Unwired Switch

Part I: The World, Misreported

## You are here if

You changed it and nothing changed. The setting is in the file, documented, spelled correctly, and the behavior is exactly what it was before you touched it. The removal command exited clean and the thing it removed is still registered. You rebuilt and restarted, and the service is serving last week's code. You archived it and it loads anyway, every session. You pass the parameter on every call and something else decides, every call.

And nothing failed. That is what brought you here: not an error but the absence of one. No red, no warning, no rejected write. You acted, the system accepted the action, and the world is proceeding as if you had done nothing, because as far as the part of it that matters is concerned, you did.

You are in the wrong chapter if something positively told you it worked and the claim was false: a green check wired to the wrong sensor is chapter 1. If your change demonstrably took effect and only stopped being true later, that is chapter 2, which owns time. This chapter is for the write that drew no complaint and had no effect. The switch flips smoothly. It clicks. It is connected to nothing.

## The mechanism

Every configurable system has two parts: the surface you write to and the mechanism that reads it. They are built by different people, at different times, against different versions, and the surface is almost always wider than the mechanism. Config parsers skip unknown keys instead of rejecting them. A field that binds in one version, one mode, or one scope parses identically in all the others. A documented setting can describe wiring that shipped later, or shipped elsewhere, or never shipped. The interface accepts your intent whether or not anything downstream subscribes to it, because accepting is the interface's whole job.

And the thing you touch is rarely the thing that acts. Between your hand and the effect sits a stack: a settings file in front of a live registry, a proxy in front of a daemon, a directory name in front of a catalog, a per-call parameter underneath an environment override, a registry read once at session start and never read again. A write into that stack can land, durably and correctly, in a layer the mechanism does not read, or reads at lower precedence than something you forgot, or read an hour ago and will not read again until tomorrow.

No error comes back, because nothing erred. The parser parsed. The file saved. The removal command matched nothing in its scope and correctly did nothing about it. A write into a dead field is a successful write. Every layer performs its documented function; the failure exists only in the seam between your intent and the mechanism, and no single layer can see the seam, so no single layer can report it. Silence is what this failure class emits, and silence is all it emits, which is why its instances run longer undetected than almost anything else in this manual.

The type specimen. For two months in 2026, a fleet routed its models per call. Every dispatch carried a model parameter: the cheap model for search, the expensive one for judgment. Every log recorded the choice, the decisions varied, the records varied. And one environment variable, set once and forgotten, pinned every subagent to a single model the entire time. The parameter was accepted on every call, recorded on every call, and honored on none, because the pin sat at higher precedence and the routing layer had no reason to mention it. Nothing was broken; both features worked as documented. What ended it was not an error but an implausibility: a cross-model comparison that came back too uniform to believe, and then a look at the transcript's own model field, a channel the routing layer does not write, which had been quietly recording the same model, call after call, since April.

Book One spends its whole arc earning the verification loop, the operator's standing discipline of auditing the environment instead of trusting it; this chapter inherits that loop and aims it at the narrowest aperture it has, the single write, at the moment your hand leaves the switch. Chapters 1 and 2 are about reports: signals that were never true, records that were true once. This chapter is about the writes themselves, the ones that never landed. It owns the seam between intent and mechanism, and its entire content is one question, asked before you walk away: what, other than my intention, says this connected?

## The discipline

Confirm the effect through an independent channel; the absence of an error is not evidence that anything happened.

The ritual:

1. **Name the mechanism, not the interface.** Before the write, say which component must behave differently if it lands: the daemon, the live registry, the catalog the next session loads, the model that actually runs. Pass: you can point at where the effect will be observable, and it is not the surface you are about to touch.

2. **Choose a channel the write path does not own.** The registry's own listing command, the daemon's health endpoint, the transcript's model field, the consuming view, the real diff on disk. The test of a channel is that it can disagree with you: if it would read the same whether or not the write connected, it is decoration. Pass: you can say what the channel would show if the write silently failed, and it differs from what it shows on success.

3. **Read the before.** Through that channel, before writing. A read-back with no baseline proves presence, not effect, and plenty of dead fields hold plausible values. Pass: the current state is in your hand, so success can appear as a difference rather than as a value that merely looks right.

4. **Write once, then read the after through the same channel.** Not the interface's echo, not the exit code, not the absence of a complaint. Pass: before and after differ, in the direction you intended, in the channel the write path cannot edit.

5. **Exercise the effect once.** State can change and behavior still not: a server can be registered and not serve, a skill can leave the catalog and still sit loaded in a running session. Dispatch one call, invoke it once, trigger the interaction, fire one entry into the view that consumes it. Pass: the downstream behavior differs, not merely the upstream state.

6. **When the read-back fails, hunt the second writer instead of repeating the first.** Somewhere a layer outranks you: an environment pin, a scope shadow, a snapshotted registry, a write-time normalizer. Re-running the same write louder loses to all of them. Pass: you can name the layer that swallowed the write, because that layer will swallow the next one too.

## The case ledger

**[E002] settings.json mcpServers field is inert** (2026-05-18)
Receipt: registering two MCP servers via the settings file's documented server block never made them appear in the live registry, through a reload and a full restart, with no error at any point.
Rule: register MCP servers via the CLI's own registration command, which writes the real registry file, then list the live registry and see the entry; the documented settings field parses cleanly and does nothing.

**[E003] MCP removal scope mismatch** (2026-06-07 / 2026-06-21)
Receipt: removing a per-project MCP server with the wrong scope flag silently no-op'd; the actual registration lived under a different scope, and the same server could end up registered twice.
Rule: run the removal from that project's directory with the matching scope flag, clear each registration scope separately, and confirm against the live listing that zero registrations remain.

**[E010] Proxy restart doesn't reload the daemon** (undated)
Receipt: after rebuilding a local service, restarting its stdio proxy kept serving stale code, because the proxy restart never touches the daemon process underneath it.
Rule: restart the underlying daemon directly, then confirm through its health endpoint that what is running is the rebuild, not the memory of one.

**[E016] Time-ordered log entries need a full timestamp** (2026-06-28)
Receipt: a logged event defaulted to a date-only timestamp and sank below other same-day entries in the recent-activity view it was meant to surface in.
Rule: pass a full timestamp when logging anything for a time-ordered view, then read the consuming view once and see the entry where you intended it.

**[E020] Package-manager stand-in values silently ignored** (2026-06-07)
Receipt: scaffolded repos shipped stand-in strings in a package manager's build-approval field instead of real booleans, so several packages' build scripts were silently ignored.
Rule: set build-approval fields to real booleans and pin the tool version in the manifest, so local and CI resolve the same behavior and a stand-in cannot pass for a setting.

**[E036] CSS fill-mode silently blocks a later hover state** (2026-06-19)
Receipt: an entrance animation holding its end state pinned a transform, so the same property's hover transform never fired, and nothing anywhere reported the shadowing.
Rule: drive the entrance animation and the interaction state off one shared custom property, and exercise the interaction once to confirm it actually fires.

**[E063] Bot review comments need explicit thread resolution** (undated)
Receipt: an automated reviewer's inline PR comments required both a code fix and an explicit thread-resolution step; fixing the code alone left every thread open, and each fix-push triggered a fresh review.
Rule: fix forward, then resolve each review thread explicitly through the API, and confirm the open-thread count is zero rather than inferring closure from the fix.

**[E068] Symbol-editing tool writes to the wrong tree** (2026-07-03)
Receipt: a symbolic code-navigation tool kept writing to its originally activated project path while the intended work sat in a sibling workspace, with no cross-check to catch the mismatch.
Rule: re-activate the tool on the exact workspace path before any symbolic write there, then verify with that workspace's own status that the edit landed in the intended tree.

**[E075] Mid-session agent registration doesn't work** (2026-05-17)
Receipt: dispatching a newly created agent definition mid-session failed immediately, because the dispatch tool validates against a registry snapshotted at session startup.
Rule: treat mid-session registration of a new agent type as unwired by design; inject the definition's instructions into an existing general-purpose type and accept the fidelity trade.

**[E137] An environment pin silently overrode per-call model routing** (2026-04-16 / 2026-06-12)
Receipt: an environment variable pinned every subagent to one model regardless of the per-call model parameter, for roughly two months, so every routing decision in the window was a no-op recorded as if it varied.
Rule: never trust the parameter or a self-reported model line; read which model ran from the transcript's own model field, and hunt for stray environment pins after any suspiciously uniform cross-model result.

**[E146] Renaming a skill's directory doesn't archive it** (2026-06-10)
Receipt: renaming a skill's directory to mark it archived left it in the active catalog, so several skills thought retired were still loading and costing context every session.
Rule: to exclude a skill from the catalog, rename its definition file itself, not its containing directory, then confirm against the live catalog that it no longer loads.

**[E148] Skill and command name collisions on invocation** (2026-05-31)
Receipt: a slash invocation whose name collided with a differently defined command wired to the skill instead, and invoking it on a large resumed session re-injected the whole skill catalog and tripped a context-size gate.
Rule: check what a collided name actually connects to before invoking it, and recover from a tripped context gate with a session-narrowing command rather than a full restart.

**[E150] A write-time normalizer overrides a manual format conversion** (2026-05-30)
Receipt: a consolidation pass recommended converting a memory library's frontmatter to one format, but a write-time normalizer silently reconverts every edited file to the opposite format, so the manual conversion could never persist.
Rule: treat the normalizer-enforced format as canonical; before any bulk manual conversion, convert one file and re-read it to learn which writer has the last word.

## Adjacent doors

**If something positively asserted success and the assertion was false**, a green check, a done message, a passing gate, that is chapter 1. The dividing line is what the system handed you: chapter 1's failure hands you a signal that lies, this chapter's hands you nothing at all. A false green has to be disproved. A silence only has to be noticed.

**If the read-back shows your write landed and a later read shows it gone**, and the tree you are in has more writers than you, that is chapter 5. The end state looks identical, a change that is not there, but the cause is a peer rather than a dead field, and the correct first move is to yield, not to rewire. The machine-owned cousin of that case lives in this chapter's ledger, the normalizer of E150, which rewrites behind your every write and always wins; when the second writer moves on its own schedule instead, it is chapter 5's problem.

**If you ran the ritual and the independent channel is what you now doubt**, the registry listing, the health endpoint, the consuming view, that is chapter 4. Everything in this chapter rests on there being one channel the write path cannot edit; the two-month pin in this ledger was ended by exactly one such field, written by a layer the routing stack could not reach. The day you cannot name a channel like that, you are out of this chapter's jurisdiction and into the instruments.
