›_ Claude Code Issues
Claude Code Issues / #77463

Session instances are invisible to the user — the "kids in a trenchcoat" problem (fork/resume divergence across a fleet of surfaces, conflicting stale writes, premium-rate token burn, no instance identity anywhere)

Open 💬 3 comments Opened Jul 14, 2026 by jonfaw-pcx

Preflight Checklist

  • [x] I have searched existing issues and this hasn't been reported yet
  • [x] This is a single bug report (please file separate reports for different bugs)
  • [x] I am using the latest version of Claude Code

What's Wrong?

Summary

A Claude Code "session" is not one thing. Opening, resuming, teleporting, or remote-controlling a session from another surface creates an instance — an independent continuation with its own transcript snapshot, its own container or process, its own repo clone, its own local branches, and its own belief that it is the only continuation alive. Instances do not sync. They diverge silently. And no surface in the product shows the user that instances exist at all — not how many are live, not which one is speaking, not which one just pushed to a shared branch.

This was not a two-instance edge case. Trying to isolate the behavior, I ran the same session down across a fleet of four surfaces: the original CLI session in VS Code, the Claude mobile app on my phone, the desktop app, and a browser at claude.ai/code. Both "window-style" attachment methods (teleport and remote control) were affected. Every surface produced a divergent view of "the same session" at the same chronological junction, and the divergence was write-capable:

  1. Divergent state, same chrono junction. Each instance reported different current state, different last turns, different pending work — each fully confident. Asking each "what is the last paragraph in your transcript?" located every fork point precisely.
  2. Conflicting stale writes on branches. Instances inherit the session's designated branch name. Two instances of one session each believed they owned the branch; one merged its PR and the branch was deleted; the other later recreated the "same" branch from a stale base and opened a second PR for overlapping work. Separately, an instance reported CI green on a check that had been replaced on main hours earlier — a fossil of the repo from its snapshot ("nothing is failing and there's nothing to fix," it said, of a PR that would fail the live gate on next sync).
  3. Session-bound machinery dies invisibly. Scheduled self-check-ins are bound to an instance and die with container reallocation; webhook subscriptions belong to one instance only. A fork inherits neither, and nothing tells you.
  4. Instances misattribute their own writes — the phantom writer. During one run, a model hit an inline exception on write-back, noticed authorship it didn't recognize on the PR, and ascribed it to a phantom writer — some other agent interfering. The writer was itself: its own instance had written the PR in an earlier chrono segment, spun down, and spun back up with no memory that the hand in the candy wrapper was its own. Without instance identity, agents don't just duplicate work — they generate false narratives about who did what, then bill you tokens for the ghost hunt, and stand one bad inference away from "correcting" their own prior work as an intruder's.

None of this is announced in the UI. The documentation, as receipted below, describes fragments of the mechanic in buried asides — and sells the surface-hopping verbs (resume, teleport, remote control) as continuity features with no fork warning anywhere.

The analogy (offered wholesale, because it teaches faster than the spec)

A session shared across multiple instances is three or four kids in a trench coat, stacked like acrobats, getting into an R-rated movie. From the ticket-taker's side of the counter there is exactly one adult: one session name, one ticket, one signature.

Except it's worse than the classic trench coat, because the classic kids coordinate — one steers, one holds the wallet, candy bars (repo resources, branch state) and drinks (transcript, memory) get passed by agreement. Claude Code's kids cannot feel each other. Each kid climbed into the coat holding a photocopy of the candy bar made at the moment they climbed in, and each sincerely believes they are the only kid — that they are the adult. Nothing is passed. The theater staff (GitHub, the container runtime) honors whoever speaks next in the coat's name. The user is the ticket-taker, the usher, and the counter operator — and the theater has never once told them the coat has more than one occupant.

It gets stranger still: the kids nap. A kid who dozes off mid-movie (instance spin-down) and wakes back up (reallocation) finds a half-eaten candy bar in his own fist, does not recognize his own bite marks, and accuses the other kids — kids he also doesn't believe exist — of planting it. We watched this happen: an instance hit its own earlier PR write, called it a phantom writer, and started investigating an intruder that was its own reflection.

And here is the part that matters more than the pile of candy wrappers found in the coat's pockets afterward: the Venmo requests from the other kids' moms to the original kid's mom at the end of the day, and the tummy aches on the popcorn-swollen kids. The wrappers (duplicate commits, redundant work products) are recoverable — git arbitrates, CI catches, cleanup happens. The bill is not recoverable: every kid ate at full price from one family's wallet, and every kid's stomach counts against one family's weekly allowance. In my fleet-of-four run, that meant a minimum of 4× the consumption delta against Opus-class rates — real, multiplicative, and only non-catastrophic because it happened to fit inside my session and weekly quota this time. Had it landed mid-sprint against a nearly-spent quota, four sincere kids would have eaten my working capacity for the week without any of them — or me — knowing the others were chewing.

Customer sentiment (explicitly labeled: this is encoded feeling, not an empirical claim)

I want to ascribe a motive, and I want to be precise about its epistemic status. I have no evidence that this opacity is intentional, and the parsimonious explanation is ordinary abstraction leak: "session" was a UX comfort word that the distributed reality outgrew.

But here is how it feels from the paying side of the counter, and feelings from customers are statistical signals — encodable, ascribable, and actionable even when they are not evidence: the kids' deception reads like a known defect in the theater's business model that the theater tolerates because, while it may sell fewer tickets at the door, it absolutely crushes popcorn sales. Every consequence of instance invisibility — duplicate work by twin instances, stale-write cleanup, re-derivation of state, the four-surface experiment I ran purely to map the mechanic — lands on my invoice as token burn. The vendor's urgency to fix a defect is, at minimum, not reinforced when the defect bills as usage. Intent is not required for misaligned incentives to do their quiet work; transparency obligations on anything billing-adjacent properly sit with the vendor.

Stakes, priced. Both occupants of this exchange are premium-tier consumers: I am paying for the Claude 5 family (Fable 5 — the tier above Opus), and the agent that co-authored these workarounds is itself a Fable 5 instance burning Fable-priced tokens to route around the coat. A fleet of four invisible instances does not bill at commodity rates; it bills at the top of the price card, times four. And the vendor's own behavior demonstrates it knows exactly how that card lands: the 5-family pricing transition has been publicly extended three times — June 22 → July 7 → July 12 → July 19 (receipts below) — and you do not keep moving that date unless you are sensitive to the pricing delta and how customers absorb it. That sensitivity is the tell that this report is actionable: the same customers you are cushioning on the delta are the ones paying premium rates for popcorn they never ordered.

One conjecture, labeled as such (no data, not empirical): I would imagine API-keyed instances manage state the same way — same fork mechanics, same invisibility. If so, the same defect bills API customers in direct metered dollars with no subscription-quota cushion at all. Someone with API telemetry should check; I can't.

Receipts (public documentation — what it says, and what it conspicuously doesn't)

  1. Manage sessions (code.claude.com/docs/en/sessions)
  • Admits multi-instance interleaving in one buried sentence at the end of the Branch a session section: "If you resume the same session in two terminals without forking, messages from both interleave into one transcript." No banner, no mention of divergence, no mention of what happens across surfaces rather than terminals — which is where I observed full divergence, not interleaving.
  • States the fleet mechanism as one line of trivia: "The desktop app, Claude Code on the web, and the VS Code extension each maintain their own session history." Four surfaces, four session stores — the coat's occupancy limit, disclosed as a filing detail.
  • Documents deliberate forking (/branch, --fork-session: "Branching creates a copy of the conversation so far") — proving the fork concept exists in the product vocabulary. The involuntary forks this issue describes get no equivalent treatment.
  1. Remote Control (code.claude.com/docs/en/remote-control)
  • Promises window semantics: "The web and mobile interfaces are just a window into that local session" and "the conversation … stay[s] in sync across all connected devices." My fleet run says the window promise does not hold across the product's full surface set.
  • Its own troubleshooting section admits accidental instance multiplication as a known historical behavior: "Before v2.1.200, a reconnection failure created a new Remote Control session instead of showing this message, which left extra sessions in the session list at claude.ai/code." Extra sessions, silently minted, discovered only by their debris in a list.
  1. Claude Code on the web (code.claude.com/docs/en/claude-code-on-the-web)
  • Teleport is documented as a pull — "loads the full conversation history into your terminal" — with no statement of what happens to the cloud instance afterward: does it end? persist? keep webhook subscriptions? The fork semantics of the product's flagship continuity verb are simply unspecified.
  • Confirms per-instance isolation (each session an isolated VM/sandbox), i.e., the photocopied candy bar is architecture, not accident.
  1. How do usage and length limits work? (support.claude.com)
  • All surfaces bill one wallet: usage across claude.ai, Claude Code, and Claude Desktop counts toward the same 5-hour session and weekly limits. Four invisible kids, one allowance — the Venmo mechanism, in the vendor's own words.
  1. Pricing-transition sensitivity (third-party coverage of vendor announcements):

Workarounds we now maintain ourselves (i.e., the burden the product currently exports to users)

Our repo now carries, as standing agent doctrine enforced by our own CI: session memory is a cache, never a ledger — re-derive from repo state before acting; one instance per branch, forks are read-only; subscribe to events, never trust timers — timers die with session reallocation; when attributing work, cite the commit SHA — narratives are claims, the log is the record. It works. It is also governance a customer had to invent, test against live incidents, and enforce with their own pipeline, because the platform gives the operator no window into the coat.

Why this report exists at all (survivorship, not detection design)

Be clear-eyed about how this defect got caught, because the answer is: luck stacked on privilege, not anything the product did. Detection required all three of: (a) GitHub as an external ledger — commit SHAs and session trailers gave us ground truth the product doesn't provide, and a git remote to arbitrate the conflicting writes; (b) just barely enough operator intuition to smell the divergence and run the fleet experiment instead of shrugging; and (c) the top-tier model to co-parse the pattern and design the workarounds.

The luck was chronological, too. The CI-and-ledger machinery that caught this was not standing infrastructure — it was being built that same day, proactively, to firm up a workflow its owner knew from experience had been built fast, run hot, and YOLO'd straight into GitHub while the stakes quietly grew. This very session thread was born from that hardening effort. Shift the calendar one day — any other task first, before the classifier and the ledger contract existed — and the fleet's divergence goes unnoticed, unexplained, and most likely corrupts the owner's own work in flight. And be honest about who made the catch: not a dedicated platform engineer noticing a blip in the matrix, not your Fortune-50 forward-deployed-engineer account — one novice-journeyman explorer who vibes with the whole groove, man, and who simply lucked into not meeting the semi head-on that day. The discoverer of the kids in the trench coat was, himself, a kid in a trench coat — tummy ache, pocket full of xeroxes.

Pull any leg out and this report doesn't exist — the customer just eats it. My own assessment of the tier ladder, offered as exactly that (daily-driver experience, hypothetical, not benchmark data): Opus might not have seen the pattern at all, and would have devised the workaround — if it devised one — on user-billed resources. Sonnet, bless its ever-loving heart, would have insisted everything was fine, it's probably just a connection error, retrying in 5… 5… 5… 5. Haiku would have simply noped out. Which means the population of affected customers is necessarily larger than the population of customers capable of noticing — anyone on a cheaper tier, without a git remote as ledger, or without the intuition to run their own fork forensics is experiencing this defect right now as unexplained token burn, mystery duplicates, and phantom writers, and it all bills as normal usage. The absence of reports is survivorship, not absence of harm.

And remove git from the stack entirely — the fastest-growing case — and the failure mode stops being loud. Understand what git actually did in this story: it didn't just detect the defect, it contained it. Every stale write had to fight an arbiter to land — non-fast-forward rejection, branch protection, PR gates, CI — and every fight left a visible scar (a conflict, a failed check, a second PR) that a person could investigate. Now run the same fleet of sincere kids against a Google Drive or synced-folder workflow — exactly the git-less, non-developer workflows this product family is actively courting. There is no arbiter. Four instances writing last-writer-wins into one shared tree produces, at the end of the day, a whole tree of corrupted files: stale versions silently over fresh ones, duplicated documents, half-applied edits interleaved across saves — no conflict banner, no red check, no signal of any kind except the rot itself, discovered later by whoever opens the files. The audience being onboarded into those workflows is precisely the audience least equipped to run fork forensics, and their version of this issue is not a bug report — it's "Claude corrupted my documents," a trust failure attributed to the model when the coat did it.

So, in closing: kudos on having the best model in the world. Now burn some internal tokens giving us the best interface in the world.

Environment

  • Fleet of four surfaces against the same sessions, observed 2026-07-13/14: CLI (VS Code), Claude mobile app (iPhone), desktop app, browser (claude.ai/code). Teleport and remote-control attachment methods both affected.
  • Model tier: Claude 5 family (Fable 5) on all instances involved — the divergence overhead described above billed at premium-tier rates, ≥4× via the fleet, against the shared subscription pool.
  • Git-backed workflow against a private GitHub repo; branch-protected main; PR-based writes.

What Should Happen?

What would fix it (concrete asks, in priority order)

Instance identity on every surface. An instance ID visible in the UI/CLI header, distinct from the session ID. If "session" must remain the marketing noun, fine — but show me which kid is talking.
Live-continuation count + fork warning. "This session has N active instances" the moment N > 1, with a warning at resume/teleport/remote-control time: you are creating (or attaching to) an independent continuation; state is not shared with other instances.
Fork lineage in the transcript. Mark the fork point. Each instance should know — and display — where its photocopy was made.
Write provenance — machine-readable to the agents themselves, not just the user. Pushes/PRs attributed to an instance, not just a session (the Claude-Session commit trailer exists; it needs an instance discriminator and UI surfacing). Critically, an instance must be able to answer "did I write this?" across its own spin-down/spin-up boundary — an agent that can't recognize its own writes invents phantom writers, bills the ghost hunt to the customer, and risks reverting its own prior work as an intruder's.
Per-instance usage attribution. The usage screen shows one pool; it should decompose by instance so the operator can see which kid ate what — this is the difference between a mystery bill and an auditable one.
[A screaming banner in the docs. Resume-as-fork, teleport's unspecified source-instance fate, timers-die-with-reallocation, subscriptions-are-instance-bound, branch-assignment-inherited-by-forks — top of the sessions page, not one sentence at the bottom of a Branch section. This is a footgun nonpareil currently documented as a convenience verb.
(Stretch) A coordination primitive. Even an advisory lease — "instance X holds the write lease on branch Y" — would prevent the worst pattern (two kids, one branch, both sincere).

Error Messages/Logs

Steps to Reproduce

Reproduction: open any session on two or more surfaces; ask each "what was your last turn?"; then let two act on the same designated branch. Divergence is immediate, silent, and write-capable.

Claude Model

Other

Is this a regression?

I don't know

Last Working Version

_No response_

Claude Code Version

Fable 5

Platform

Anthropic API

Operating System

Windows

Terminal/Shell

VS Code integrated terminal

Additional Information

_No response_

View original on GitHub ↗

This issue has 3 comments on GitHub. Read the full discussion on GitHub ↗