All seven step goalposts are now proven. G1 (net-negative production) is NOT met
at +83 and is reported as a miss with a per-step breakdown rather than reframed.
Also records the near-miss G5 caught: S4's reader guard showed no mutation
response because the load fold had already erased the divergent state at boot.
It was correct and would have shipped unproven. An added clause pins it.
For a disconnected pane, `recoverTerminalPane` consulted a recently-expired SSH
lease and, on a match, spawned a replacement shell. It could never match: leases
store a relay-native pty id (`pty-7`, normalized on every write) while the
runtime registers the app-form id (`ssh:<conn>@@pty-7`), and the comparison was
a raw `===`. The branch was also unreachable for a local pane, which has no SSH
lease. Goalposts S6 and S8.
A characterisation oracle lands FIRST and proves it, rather than assuming it:
ssh-pane-recovery-grant-reachability.test.ts mints BOTH id forms from the
production helpers — never as two hand-typed literals — so it tracks the real
namespace split instead of restating it, and seeds a lease that qualifies on
every other predicate (state, worktree, tab, leaf, grace window). Anti-vacuity
assertions pin that control actually reaches the gate rather than bailing early.
Mutation proof, run before the deletion: normalizing the comparison at the
`lease.ptyId === ptyId` site makes the grant fire and reddens the oracle. That
is the exact "fix" someone would reach for, so the oracle is pinned to
unreachability rather than to the throw.
Deleted: the grant tail, the `terminalPaneRecoveryByIdentity` dedup map (whose
only consumer was the grant), and the dead `ptyId` parameter.
NOT deleted, and worth naming because over-deleting here would break users:
`getRecentExpiredSshLease` itself, `hasRecentExpiredSshLeasePane` and
`SSH_PANE_RECOVERY_GRACE_MS` all stay. Their other two callers pass `ptyId`
undefined, which short-circuits the broken comparison — those are live today and
feed headless-mobile terminal-tab visibility.
Also NOT done: deleting only the gate while keeping the spawn. That would have
granted a respawn to every disconnected pane — a behaviour change in the
dangerous direction. The refusal is what stays.
Four tests pinned the grant. All were seeded through a helper that stores the
lease id as the same literal it registers as the runtime pty, with a null
connectionId — a shape production cannot mint. Three are INVERTED, keeping their
scenarios; the fourth is now tautological and carries a comment saying so rather
than being left silently hollow. The oracle's own counterfactual control is
inverted by this deletion too, which is recorded in the file: its flip from
grant to refusal is what "inert" means here.
Honest limit, stated in the oracle rather than smoothed over: unreachable BY
CONSTRUCTION for SSH panes; for a local pane, unreachable only up to a random
UUID collision.
Net production: -32 lines.
Ships with S3. Collapsing the fabricated exit removed a lie, but it left the
pane frozen: `restoreRequired` never crosses to the renderer, so a relay-driven
reattach failure had no user-visible signal at all, and the renderer's own
reattach arms showed a raw error toast with no way to act.
An unproven failure now renders the pane as disconnected with exactly two
explicit actions — "Try again" (remount against the same shell via
requestTerminalPaneRecovery) and "Start a new terminal" (retire the binding,
then spawn fresh). Nothing infers death and nothing auto-spawns; the user
decides, because at that point no one knows whether the shell is alive.
The two actions are the same two things the code already did, moved behind a
click: the retry is the existing pane-recovery request, and "start a new
terminal" is the existing clearExitedPanePtyLayoutBinding + clearTabPtyId +
startFreshColdRestoreAgentResume sequence that used to run automatically on a
"proven gone" error. No new IPC channel: the silent-respawn decision was always
renderer-local.
Copy constraint, enforced by an oracle rather than a review note: the banner may
never assert the shell exited. STYLEGUIDE.md:236 already forbids result verbs
without result data, and a failed attach is not result data. A test asserts the
rendered text matches no death verb and shows no wire token.
`TerminalRemoteRuntimeReconnectBanner` is renamed `TerminalPaneDisconnectedBanner`
— it now serves any transport, and per AGENTS.md the name must say what it holds.
Existing i18n key strings are kept verbatim so no shipped translation breaks;
the SSH copy is additive (4 new en.json keys).
`describeReattachFailure` is deleted with its last caller. Its two cases were
not dropped: "keeps the wire token out of the pane" is re-asserted against the
new copy, which is a stronger place for it.
Renderer production (excluding the pure rename): +28 lines.
The superseded-PTY fence refuses a keystroke queued for a shell whose pane has
since bound a different one. It reads `ptyPaneKey` disagreeing with
`paneKeyPtyId` — and only spawn ever wrote those maps. Reattach bound the pane
through `runtime.registerPty` instead, so the maps never learned the successor,
`isSupersededPtyId` returned false by construction, and the fence was inert on
the one path it was built for. Goalpost S5; a defect in already-shipped work.
Collapse to one `bindPaneShell` producer that writes the durable record and the
fence maps together. All three binding paths call it: the relay reattach and
both spawn handlers. Error policy stays at the call sites because it genuinely
differs — a caller that just created a shell must clean it up on a failed
durable write, a caller that merely reattached must not detach anything.
The paneKey is composed from the tab that holds the leaf *now*, resolved from
the live layout, not from the tabId frozen in the lease. Only the leaf half of
a pane key is remint-stable; `detachTerminalPaneToTab` moves a live pane and its
PTY into a new tab, so a stored tabId names the tab the pane left.
Mutation proof, both sub-guards isolated:
- drop the `rememberPaneKeyForPty` call -> 3 clauses redden
- prefer `args.tabId` over the live layout -> 1 clause reddens
The second clause is new in this commit. Every pre-existing clause in the fence
oracle used one tabId on both sides, so a producer that simply forwarded
`lease.tabId` would have gone green and shipped the tab bug unnoticed.
Two source-text clauses are STRENGTHENED, not relaxed. They previously required
the relay to hold a `persistPtyBinding` call of its own and merely forbade an
ssh-partition argument on it. The relay now has none, so they assert ZERO direct
binding writes there plus a `bindPaneShell` call — a second bind producer is
exactly the defect this removes.
Also repairs a latent false green: the "persistence fails" case in
ssh-relay-session-reconnect-incarnation was passing because a missing mock made
the call throw a TypeError that happened to emit the console.error it asserted.
The failure is now injected at the producer, so it is a real oracle for "a
thrown durable write must not detach the PTY".
Net production: +60 lines. This is the one step in the program that grows;
the shrink arrives with S8's deletion. Reported rather than smoothed over.
Co-authored-by: Orca <help@stably.ai>
An SSH pane's durable binding lived in two persisted partitions. Main's spawn
wrote `ssh:<target>`; the relay's reattach write passed no hostId and landed in
`local`; the renderer has always published SSH pane membership to `local` on
purpose. So `durablyBoundPtyIdForPane` hedged ssh-first-then-local, read a
partition no live writer maintained, saw the arriving lease disagree with a
stale pty id, and bailed — supersession silently no-opped and both leases stayed
live. That is the STA-3077 2 -> 19 -> 20 mechanism.
`local` wins: it is the only publisher of pane membership and where
`mayCreate:false` is evaluated. Every reader and writer now names it.
- resolvePersistedStablePaneOwner / retirePersistedStablePaneOwner drop their
connectionId parameter and read the default partition.
- the CAS write and both spawn upserts drop the hostId argument (each was an
if/else that collapses to one call).
- durablyBoundPtyIdForPane stops hedging.
- a one-time load fold moves any legacy `ssh:<target>` ptyIdsByLeafId into
`local`, preferring `local` on conflict, sequenced after the leaf remap so
every folded binding keys on a UUID.
Side effect worth naming: the renderer never hydrated the `ssh:*` partition
(listKnownRuntimeHostIds filters to `runtime:*`), so the Issue #217 force-quit
binding protection had never worked for SSH panes. It does now.
Mutation proof, run as a 2x2 because the two edits can mask each other:
- fold disabled, reader local-only -> 1 clause reddens (the fold is live)
- fold disabled, hedge restored -> 3 more redden (the reader is live)
- fold enabled, hedge restored -> ALL GREEN
That last row is why this commit adds an eighth clause: with the fold shipping,
the fold erases the divergent copy at boot, so the reader guard would have
shipped unproven — the exact failure mode G5 exists to catch. The new clause
rewrites `ssh:<target>` mid-session (orphan adoption still writes there) and
reddens when the hedge is restored, pinning the reader on its own.
Five clauses in ipc/pty.test.ts pinned the two-partition shape and are INVERTED
to the single home, each keeping an explicit arity check so a re-added partition
argument fails loudly rather than silently.
Net production: +9 lines (the fold is new state repair; the call sites shrank).
Co-authored-by: Orca <help@stably.ai>
A failed attach never proves the shell exited. The relay answers not-found for
a pane-identity mismatch and for any id it merely cannot hand back, so treating
it as death sent the pane a synthetic `pty:exit { code: -1 }`, cleared provider
state, deleted ownership and expired the lease — four claims about a process we
know nothing about, on a shell that is usually still running.
Collapse every failure into the non-destructive branch that already existed a
few lines above (`restoreRequired = 'reattachAttemptsExhausted'` + wakeRecovery).
A branch collapse, not a new mechanism: goalpost S3.
Two tests pinned the deleted premise and are INVERTED rather than patched, so
the new intent stays covered:
- ssh-relay-orphan-abandon-paths: "retires the lease without a kill when the
relay proves the PTY is gone" -> "leaves the shell running when the relay only
reports the PTY as not found". Its comment claimed attach verifies liveness
before answering not-found; it does not.
- ssh-relay-session: "invalidates and broadcasts remote PTYs that cannot
reattach" -> "leaves an unreattachable remote PTY alone while its sibling
reattaches".
Also repairs two clauses left red by c51be8072b (step A), which dropped the
expected-identity parameter and the expectedIdentityByPtyId map.
Mutation proof: restoring the destructive block reddens 6 of the 8 oracle
clauses in ssh-relay-reattach-exit-proof.test.ts; the 2 producer pins stay
green. Verified the mutation landed before believing the result.
Net production: -21 lines.
Co-authored-by: Orca <help@stably.ai>
Intentionally RED: 14 clauses that fail against current behaviour and go green
under the changes named in new-design-goalposts.md. The branch is held unmerged,
so red here means unimplemented, not broken.
Each was verified to fail for the right reason and to flip green under the
identified fix, which was then reverted. Each pins the producer as well as the
consumer, so no clause can pass vacuously if its route is ever severed — the
failure mode that let three earlier guards ship inert.
Co-authored-by: Orca <help@stably.ai>
Points at the goalposts as the contract, names the three goalposts whose oracles
are already written and red, and carries the process rules that were learned the
expensive way — prove guards reachable, verify mutations land, commit per step,
and never let a subagent write production files in a shared worktree.
Co-authored-by: Orca <help@stably.ai>
It only existed in an ephemeral job directory, so the plain-English explainer
had no durable source for its specifics — record shape, death rule, reattach
algorithm, migration order and the 25 oracles.
Co-authored-by: Orca <help@stably.ai>
The lease stores a relay-native pty id and the caller passes the app form, with
a raw equality comparison between them, so the 30s grant cannot fire for a real
SSH pane. The death rule that existed to referee it is deleted rather than
built, and the dead path itself becomes a removal.
Co-authored-by: Orca <help@stably.ai>
Each goalpost is a behaviour with an oracle and the mutation that must redden
it, so 'proven' cannot be claimed from a green test. Records the anti-inert rule
as a first-class goalpost, since three guards in this program passed their tests
while sitting off the route production takes.
Co-authored-by: Orca <help@stably.ai>
The relay froze pane identity at spawn, so moving a pane to another tab made it
refuse a live shell — and refuse by saying 'not found'. The comparison is
presence-guarded, so not sending the fields disarms it on every relay version
including ones already installed on hosts: no wire change, no redeploy.
Nothing is lost. It existed to catch a relay restart recycling pty-N for a new
shell, and in exactly that case pane and tab both still match, so it accepted
the wrong shell anyway. The incarnation the attach returns is what distinguishes
those, and it already crosses the wire.
Removes the whole client-side apparatus: the expected-identity type, its
per-lease derivation, its map, and the parameter threaded through four layers.
Co-authored-by: Orca <help@stably.ai>
The relay reports a pane-identity mismatch by saying the pty was not found,
but it found it — comparing identity is how it noticed. Publishing that as
expiry made the renderer clear the binding and cold-restore with agent resume,
so a live shell gained a second agent on one transcript. Reachable today by
detaching a pane into a new tab, which changes the tab the relay froze at spawn.
Mismatch now carries its own token and the classifier refuses it as proof.
Genuine absence still expires, so a shell that really went away is not stranded.
The three failure tokens move to src/shared: main published them and the
renderer decided respawn on them, from two copies that had drifted apart.
Co-authored-by: Orca <help@stably.ai>
The first version assumed the reader knew the codebase. Reframed around two
bugs, two fixes and one decision, with the jargon replaced by pane / program /
note / helper and a five-word glossary for what could not be avoided.
Co-authored-by: Orca <help@stably.ai>
One leaf-keyed ownership record, orphans computed at connect, and replacement
shells only on positive proof — with the shipping order and the one product
trade the design asks the owner to accept.
Co-authored-by: Orca <help@stably.ai>
A final review traced every auto-respawn route. The primary one converts the
reattach failure into a boolean before any classifier sees it, so the shipped
proof gate never runs there. Records that two of the six shipped changes are
narrower than claimed, and why their tests could not have caught it.
Co-authored-by: Orca <help@stably.ai>
Three review rounds across two models replaced the two-record split with one
leaf-keyed record, deleted attach-time pane identity, and made orphans a
connect-time projection. Records that a shipped gesture still turns a healthy
remote shell into a duplicate agent resume, and that the renderer classifier in
that chain treats an error-message shape as proof of death.
Co-authored-by: Orca <help@stably.ai>
Separates verified code facts from unverified leads so reviewers attack the
design rather than a reconstruction of it, and records which simpler
alternatives were already refuted and why.
Co-authored-by: Orca <help@stably.ai>
Adopts the data-plane proposal and adds the control-plane track it does not
cover: re-key ownership by pane, split orphan inventory out, then delete the
compensating code. Records that the host-authority alternative was refuted and
that the shipped keystroke fence is inert on the reattach path.
Co-authored-by: Orca <help@stably.ai>
Pre-renders every diagram to inline SVG in both themes so the report opens
offline and stays sharp when zoomed. States the gate/journey score and the
retractions alongside the fixes, so the unproven half is as visible as the
proven half.
Co-authored-by: Orca <help@stably.ai>
Two reviewable documents with diagrams, written so someone with no prior
context can follow what breaks, why, and what changed.
The design overview explains the five things stacked behind one terminal
rectangle, the 2 -> 19 -> 20 report, the three root causes, and the rule
underneath all of them: unknown is not dead.
The test overview explains why a green test proves nothing on its own,
the four-step mutation proof we adopted, and — the part worth reviewing
hardest — an honest account of what could not be proven and why, including
the properties that are true by construction and therefore have no guard
to remove.
Co-authored-by: Orca <help@stably.ai>
Checked what the build emits rather than reasoning from file paths. None
of the 32 test-only fixtures appears in `out/` — Rollup drops them because
no production entrypoint reaches them. On "compiles into the shipped
product", this clause holds today.
On the other reading it cannot be closed by moving files at all: both
production tsconfigs use bare `include` globs with no `exclude`, so a
`__tests__/` directory matches exactly like any other path, as does every
`*.test.ts` in the repo. Relocating 32 fixtures would remove nothing from
typecheck scope.
A sweep was started and stopped once this was verified, rather than
landing 32 moves across areas this program does not own for no gain. If
the intent is that typecheck scope should exclude test code, that is a
repo-wide tsconfig change with a different owner.
Co-authored-by: Orca <help@stably.ai>
`xterm-bypass-event-fixture.ts` and `__fixtures__/xterm-bypass-event.ts`
were byte-identical apart from an import path. The `__fixtures__` copy had
zero importers and the live copy compiled as production — someone started
the move and left both. Dead copy deleted, live one moved, its three test
importers updated.
Audited the wider G6 clause by importer rather than filename: 32 test-only
files, roughly 3,300 LOC, currently compile as production; 4 of the 36
candidates have real production importers and are correctly placed. The
list is recorded in the goalposts.
Those 32 are almost all older than this program and outside the terminal
surface, so sweeping them belongs in its own change rather than inside a
terminal PR. The clause stays failing, with the remaining files named.
Co-authored-by: Orca <help@stably.ai>
G6 requires one identity comparison; five implementations existed across
two concepts.
Worktree-namespace identity had two: `runtimeWorktreeIdsEqual` and
`runtimeWorktreeIdentityKey` independently re-derived repoId plus
normalized path. Equality now derives from the key, so the comparison and
the sleep / mutation-queue keying cannot drift into two different rules —
which is exactly how the suffix-stripping bug reached production once.
Pane identity had three byte-identical leaf-UUID comparisons, in
orchestration `db.ts`, `lifecycle-reconciliation.ts`, and
`orchestration-legacy-process-identity.ts`. One copy moved to
`stable-pane-id.ts`, which already owns `PaneKey`, `parsePaneKey` and
`makePaneKey` and which all three already imported. No new module, no
branded type, no parallel comparison.
Net -14 production lines. The namespace oracle still bites: restoring the
filesystem parser inside the identity key reddens exactly its five cases.
The raw counts are not the actionable set, and the classification is
worth recording: of 409 non-test `worktreeId` comparisons, 71 are typeof
guards and 81 are sentinel tag checks. Most of the remainder are renderer
predicates over store rows where both operands are the same main-minted
id, so normalizing there would widen equality rather than correct it.
Co-authored-by: Orca <help@stably.ai>
G6 lists "no superseded quarantine remains reachable" and this module was
assumed to be one. Disabling its single call site reproduces the hazard
it exists for — `cho hi; rm -rf x` reaching the shell — so deleting it
without a replacement re-opens command execution.
The replacement was costed by building it rather than estimated: +26
production LOC to thread the incarnation, ~+33 complete, and the
cross-remount state it needs outlives the destroyed pane so it becomes a
module about the size of the one deleted. Floor is roughly +140 to delete
88, and it would add a second identity comparison to a gate already
failing for having more than one.
The decisive part is that the route is not uniformly available: remote
runtime results carry no incarnation, old hosts cannot be made to publish
one, and mixed versions are the normal state. A paired client reads
unknown, which this program's own rule says is not proof — so either
every remote reattach surfaces unresolved, or a fallback is needed and
the only correct fallback is this module.
Whether to amend the clause or accept something weaker on remote hosts is
a user decision, so the clause verdict is left as failing rather than
quietly reclassified.
Co-authored-by: Orca <help@stably.ai>
G6's body still demanded strictly-negative production LOC after the user
relaxed it to minimise-and-justify, so the gate had two conflicting pass
conditions and no single truth value. Its body now points at that
decision.
Assessed the remaining clauses against the branch rather than assuming.
Two fail structurally: more than one identity comparison and mutation
admission path still exist, and `terminal-input-quarantine.ts` is still
reachable from two production files.
Records why the quarantine is not subsumed by the superseded-PTY fence,
which I had assumed and checked. The fence refuses writes aimed at a
stale ptyId; the quarantine guards the user's next keystrokes landing on
the successor under its current, correct id — a case the fence never
sees. Removing it needs the recovery path to surface a different shell as
unresolved, not a deletion.
Co-authored-by: Orca <help@stably.ai>
I recommended adding a typed end-reason so a user quit stops looking like
a resume candidate, then went to implement it and stopped.
`SleepingAgentSessionRecord` already carries three fields that each exist
to stop something resuming that should not have — `origin`,
`restoreOnTabOpenOnly`, and `automaticResumeBlockedBy` — each traceable
to its own incident, consulted at 22 non-test sites. A fourth predicate,
however well typed, is the fifth containment cycle.
The designs without this bug do not have a better flag; they resume only
on an explicit action, into a new terminal id, and make two agents in one
terminal unrepresentable in the schema. The first of those is a product
decision about whether automatic resume stays a feature, so it is the
user's call rather than mine.
Co-authored-by: Orca <help@stably.ai>
Three journeys attempted; none promoted, and the reasons are recorded in
the ledger rather than rounded up.
MaxSessions=1 against real OpenSSH, with the cap read back from `sshd -T`
rather than assumed, and remote pids read on the container two
independent ways that must agree, each carrying its kernel start time.
Two disjoint mutations discriminate — one reddens only the reconnect
clause, the other only the two restart clauses. But the disconnect clause
is a forward guard: four separate guard removals left it green, so
nothing shipped is load-bearing for it.
Lazy discovery samples sshd's own accept log and live session census
across a 22s window with the in-use host as a positive control. No
mutation reddens its third clause alone — the real cross-host lease
scoping is load-bearing, but removing it breaks the sibling host during
setup, so the failure carries no clause information.
The paired-runtime skew spec pairs two real processes at different
versions and refuses to run rather than degrade into a same-version
pairing that would look green and prove nothing.
No production code changes.
Co-authored-by: Orca <help@stably.ai>
These five reproduced a defect that was live on main: folder-workspace
ids were compared with the instance suffix stripped, so two workspaces
sharing a directory read as the same namespace. They were committed
skipped, pointing at the PR that fixes it.
That PR is merged, and they pass. Verified they still bite: restoring the
suffix-stripping comparison reddens exactly these five and leaves the
other four green.
An oracle written before its fix, held skipped, and confirmed against the
fix after the merge — rather than deleted and rewritten from the answer.
Co-authored-by: Orca <help@stably.ai>
The WSL run blamed bash 5.3.9 for the unrelated
`local-pty-shell-ready` failure. macOS runs the same bash version and
passes 67/67, so the version is not the cause — the trigger is
environmental to that distro, and the underlying defect is that the spec
asserts an absolute count of OSC markers it does not own.
Co-authored-by: Orca <help@stably.ai>
The oracle runs on every environment the journey names, and is
clause-selective on all three: reverting three-valued `hasPty` reddens
only the unknown-not-dead clause, and widening the sole-provider fallback
reddens only the stale-generation clause.
Selectivity in WSL was established rather than assumed. The spec runs
serially, so a red first test reports the others as "did not run" — they
were re-run alone under the same mutation and stayed green.
Also records that an Orca WSL-mode terminal now starts on that host at
all, which it could not before: the distro had no provisioned default
Unix user, so every interactive launch blocked on first-run setup.
One diagnosis from the WSL run is corrected here rather than repeated:
the unrelated `local-pty-shell-ready` failure was attributed to bash
5.3.9, but macOS runs the same bash version and passes 67/67. The trigger
is environmental to that distro, and the underlying defect is that the
spec pins an absolute count of OSC markers it does not own.
Co-authored-by: Orca <help@stably.ai>
Four journeys now have discriminating oracles but none meets its full
stated scope, and each shortfall is named rather than rounded up.
Journey 2 is one WSL run from promotion. Journey 12's tests are
in-process, so they do not close the live-skew gap the original ledger
named. Journey 4's cross-host clause cannot be proven by mutation at all
— a mux is per target, so its dispose cannot cross hosts, and the
cross-host test stayed green under the mutation that reddens siblings.
Journey 13 measured one dimension of ten, on lifted predicates rather
than through real IPC.
Co-authored-by: Orca <help@stably.ai>
Daemon: replaces a spec that modelled only a client restart and never
crossed the daemon boundary, whose successor generation owned nothing so
"the live successor is neither killed nor replaced" was vacuous. The PTY
leader is now a real login shell reporting `$$` back through the
production write path, resolved to a kernel start time. Two mutations
each redden exactly one of the three clauses, on macOS and Linux:
reverting three-valued `hasPty` reddens only the unknown-not-dead
clause; widening the sole-provider fallback reddens only the stale
generation clause.
Skew: reverting the restore-required publication to expiry reddens 4 of
5 new tests while the legacy control stays green — the regression this
branch fixed is now caught if reintroduced.
Multi-host: restoring `mux.dispose('connection_lost')` reddens sibling
isolation on one host. It does NOT redden across hosts, and that is
recorded rather than glossed: a mux belongs to one relay session per
target, so its dispose cannot cross a host boundary. Journey 4's
cross-host clause rests on isolation-by-construction, not on a mutation.
No production code changes.
Co-authored-by: Orca <help@stably.ai>
The oracle now runs natively on macOS, Linux and Windows, and its
discrimination was watched on each: a mutation reddens it, a restore
greens it. On Linux and Windows both mutations were run, and the second
reddens only the stale-operation test — so the journey's two clauses are
proved independently rather than jointly.
Windows is the new evidence. The PowerShell branches added blind at
ebffb85a848 executed correctly on their first run: `$PID` expanded to
real integers, which also proves the pane shell there is PowerShell-family
rather than Git Bash, and `Get-Process StartTime` returned kernel start
times 5.4s apart — so a recycled pid could not have passed as a survivor.
First journey promoted in this program. The other twelve are unchanged,
and the residual limit on "every stale exact operation" is recorded
rather than glossed.
Co-authored-by: Orca <help@stably.ai>
Marks the client-constructed binding proposal as rejected with the three
false claims that sank it, and records what shipped instead.
States the shipped fence's actual limitation rather than leaving it
implied: it compares a binding, not an incarnation, so a respawn under a
reused ptyId passes. The obvious remedy is wrong here — the agent-create
id is deterministic by design so a replayed create stays idempotent, and
randomising it would trade this narrow gap for a duplicate-spawn bug.
Also records the ranked lessons from four comparable agent IDEs, chiefly
that a typed end-reason at end time is what stops a user quit from
looking like a resume candidate.
Co-authored-by: Orca <help@stably.ai>
Both probes were POSIX-only and unconditional: `echo ...=\$\$` for the
shell's own pid, and `ps -o lstart=` for its start time. Running the spec
on a real Windows host proved it dies before reaching either guard, so
Journey 1's Windows half was unprovable rather than merely unproven.
PowerShell exposes the same two facts as `$PID` and `Get-Process`
StartTime. The start time still matters on both platforms for the same
reason: a PID alone cannot separate a survivor from a reused number.
Still green on macOS. The Windows path is written from the host probe and
has not itself been executed end to end — that is the next thing to run
there, not a claim being made here.
Co-authored-by: Orca <help@stably.ai>
`readPaneBinding` took a single unpolled read of a DOM dataset attribute
immediately after a renderer reload, while its sibling helper polls the
same data for 15s. On a native Linux host both tests failed every run
with 'No bound terminal pane is mounted' while the app was demonstrably
healthy — the screenshot showed the terminal restored with a live prompt
and the boot PID echoed.
The assertion is unchanged; it is only awaited. Nothing is weakened.
Found by running this spec on native Linux rather than assuming macOS
behaviour generalises.
Co-authored-by: Orca <help@stably.ai>
A signal means "interrupt my pane", so delivering one to a PTY the pane
has already replaced is a misdirected interrupt. Fence it with the same
lock-step proof used for write and resize.
`pty:kill` stays deliberately unfenced and a test now pins that: a
superseded PTY is orphaned, and reclaiming it is exactly what the
orphan-cleanup callers ask for. Refusing there would break the operation
that reclaims leaked shells — the opposite of the intent.
The fence sits at the IPC boundary, above `tryGetProviderForPty`, so it
covers local, daemon and SSH rather than the local path alone.
Co-authored-by: Orca <help@stably.ai>
`pty:write`, `pty:writeAccepted` and `pty:resize` accepted any id. The
renderer queues input, so a keystroke buffered before a reattach landed
on whatever PTY had since taken the pane — and a resize reshaped the
successor's shell.
Main already tracks `ptyPaneKey` and `paneKeyPtyId` in lock-step, so
their disagreement is proof the caller's id was superseded. No wire
change, no renderer change, nothing added to the input payload.
An id with no recorded pane stays permitted: unowned and orphaned PTYs
are unknown, not stale, and unknown never authorizes refusing an explicit
operation. That is also what keeps orphan cleanup working — those ids
have no pane by construction.
The tests pin the CALL SITES, not the predicate. A capability that exists
and is never called is indistinguishable from no capability, which is
exactly how `mayCreate` sat inert here for several commits with every
test green.
Co-authored-by: Orca <help@stably.ai>
Every defect this program has touched is the same defect: identity
compared with the wrong key, or not compared at all. Lease keyed without
the pane, reattach using a creating write, folder-workspace ids compared
with the instance suffix stripped, local mutating IPC carrying only an
id, a live shell classified as expired, liveness unable to say unknown.
Proposal: one branded binding type built from fields that already exist
and are already persisted, constructible only from an authoritative
source, carried by mutating operations, compared by one shared function.
Makes a wrong-key comparison a type error rather than the next incident.
Under adversarial review, including against the open issue corpus.
Not accepted.
Co-authored-by: Orca <help@stably.ai>
The previous induction closed a pane while the transport was severed and
relied on `pty:kill` FAILING so the lease outlived the pane record. It
does not fail: with the provider already torn down, `pty:kill` takes its
tombstone branch and marks the lease terminated, and `reattachKnownPtys`
filters terminated leases out of the fan-out — so the reconnect never
visited the PTY the test was about. It passed on both trees.
Seed the precondition instead. Spawn a real remote PTY on a leaf that
never becomes a pane, then roll the host partition back to its pre-spawn
snapshot, leaving a live lease and a live remote shell that no durable
pane owns. No failure races a success.
Adds a vacuity guard that is independent of the tree under test: the
lease's own `lastAttachedAt` must advance, proving the fan-out actually
visited this lease before the pane census is trusted.
Verified on this machine under an isolated TMPDIR, since the e2e
harness keys its seeded-repo pointer on a machine-global tmpdir path:
guard present passes, guard removed fails with the phantom leaf grafted
into the local partition, guard restored passes.
Co-authored-by: Orca <help@stably.ai>
Six parallel streams, each required to fail with its guard removed rather
than merely pass.
Local restart proves the OS process itself survives, by reading
`ps -o lstart=` for the shell's own pid. That matters: with the quit path
made destructive, the tab, leaf and pty ids all came back byte-identical
while the shell underneath was a new process — every existing restart
spec would have stayed green. Two separate guards were removed to redden
it, and the second reddens only the stale-operation case.
Daemon restart discriminates by reverting three-valued `hasPty`; version
skew now covers publication semantics and confirms the new
`SSH_SOURCE_RESTORE_REQUIRED` token mutates nothing on an old client;
two-host isolation censuses both containers.
Deletes `src/relay/pty-source-replay-index.ts` — 201 production lines
with no importer outside its own test, verified against an
entrypoint-rooted import graph rather than a name grep.
Five namespace tests are skipped, not passing: they reproduce a defect
still live on main where folder-workspace ids compare equal with the
instance suffix stripped. PR #12474 fixes it; they are its oracle.
Co-authored-by: Orca <help@stably.ai>
G6 becomes minimise-and-justify rather than strictly net-negative. The
deletion budget the plan assumed does not exist: an entrypoint-rooted
import graph found 51 of 53 candidate files reachable and instantiated
on live paths, leaving 263 deletable LOC against roughly +1,021 to
offset. Correctness may still not be traded for line count.
Co-authored-by: Orca <help@stably.ai>
Adds a second reconnect scenario and a helper that reads pane records
from the local partition as well as the ssh host partition. That split
matters: the reattach binding call passes no hostId, so a grafted pane
lands in the LOCAL partition and an oracle reading only the host
partition passes whether or not the guard is present.
Both tests remain forward guards. The second one was reported as
discriminating and did not reproduce: with `mayCreate: false` removed
from the call site and the app rebuilt, both still passed. Its induction
races `pty:kill` against a severed transport, so when the kill lands the
lease is cleaned up and there is nothing left to graft. The handoff
README is corrected to say so rather than claim a journey.
Co-authored-by: Orca <help@stably.ai>
The settle poll reused a matcher the assertion 15 lines above had already
satisfied, and Playwright's poll engine probes immediately and returns as
soon as the matcher passes — so it observed the same state twice and
elapsed 0ms. A shell grafted a second or two after reattach reported
ready slipped through into the next cycle.
Reviewer was right on #13111. Test-only; no production change.
Co-authored-by: Orca <help@stably.ai>
The package was untracked under a gitignored `docs/**`, with the
un-ignore rules living only in an uncommitted .gitignore edit — a single
`git clean -xdf` would have destroyed the authoritative plan.
The 814-path construction snapshot is now pushed as
`nwparker/react185-authority-snapshot` too; it had no remote ref.
Co-authored-by: Orca <help@stably.ai>
`IPtyProvider.hasPty` returned a boolean, so a provider whose inventory
was empty for reasons that have nothing to do with the session — socket
down, cache never hydrated, provider generation just constructed — had no
way to say so and answered "absent". Its own siblings already knew
better: `probePtyLiveness` and the runtime's `PtyController.hasPty` were
both already `boolean | null`, with consumers branching on null
correctly. The lie was injected at exactly one interface.
Now three-valued, and each provider answers unknown where it cannot
prove absence: the daemon adapter off-socket, the SSH provider before a
completed listing, the router when any adapter cannot answer, and the
degraded provider rather than fabricating a verdict. `terminal_gone`
requires unanimous proven absence.
Also fixes a real cold-start bug this surfaced: `pty:hasPty` never
awaited the daemon-swap startup promise, though the sibling
`probePtyLiveness` bridge already did, so before the swap the local
provider answered an authoritative false for every daemon-owned id.
Net +27 production lines. The plan behind this predicted -92 on the
strength of deleting the renderer's dead-session reconcile path; that
code is live (`pty-connection.ts` imports it), so nothing was deleted.
Expressing a third value where there were two costs lines, and a
deletion that is not real is not worth manufacturing.
Co-authored-by: Orca <help@stably.ai>
A per-PTY recovery budget running out disposed the whole relay channel,
so one PTY that could not re-prove its delivery aborted every in-flight
filesystem and git request on that host and stalled every sibling pane.
A retry count is not proof of anything, and it certainly is not proof
about the other sessions sharing the channel.
Exhaustion now parks that PTY's delivery. The remote shell keeps
running, its lease stands, and the next relay open reattaches it with a
fresh delivery generation — the parked state is cleared on teardown and
the generation changes on reconnect, so a reconnect recovers it.
The consecutive-attempt ceiling goes away entirely; the per-generation
one is what bounds the retry cost, and the second ceiling only existed
to reach the channel drop sooner.
Tradeoff worth stating: the failing pane used to self-heal within
seconds because the forced reconnect wiped all rejection state, and it
now stays frozen until the next relay open. That is a worse outcome for
that one pane and a much better one for every other session on the host,
and reconnecting is user-reachable.
Co-authored-by: Orca <help@stably.ai>
A refusal that exists and is never passed is indistinguishable from no
refusal, and store-level tests cannot tell the difference — they call the
store directly. Learned from `mayCreate`, which was correct and had no
production caller for several commits.
Co-authored-by: Orca <help@stably.ai>
It was run against an unfixed tree and passed, so it does not prove the
STA-3077 fixes and should not be read as if it does. A clean severed
transport does not reproduce the field conditions — accumulated duplicate
leases, or a source returning needing re-establishment.
It keeps its place as a forward guard: it counts the shells the relay
actually hosts and pins their PIDs, so a later change that grafts a pane
or respawns a shell fails here.
Co-authored-by: Orca <help@stably.ai>
Neil
