Plain-language guide to 114 verified findings from two independent automated code reviews of Farhelm, grouped by real-world impact.
Exclusive starting point (previous checkpoint)
df6199142d6495a95b2d008400ba2686efb775c6
First included commit
06af3b27a0adf6c357a9def88dbf6bced5fee027 (chore: reject unsupported revisions in deflake, #4550)
Inclusive ending point (tip)
66ad3aaa95ef03a2130e2d0194d58353912ae9da
226 commits on main.
Overview
Two separate automated trailing reviews inspected the same range of Farhelm's main branch (above): review A (PR #4650), run by GPT-6.2 Sol at high effort, recorded 17 findings, and review B (PR #4649), run by Gemini 4 Neon at high effort, recorded 99 findings (three of which added new evidence to items already in the queue, alongside one modified item in review A). Two independent verifiers—GPT-6.2 Sol and Claude Opus—then checked every finding against the source code and rated its impact. A reconciliation pass settled every disagreement between the two verifiers and matched the two findings that both reviews caught, producing 114 unique entries.
Most, if not all, of the code in this range was written by GPT-6.2 Sol in the first place. That likely puts review A at a disadvantage: a reviewer tends to share blind spots with the model that wrote the code, while review B brings a different model's eye to it. Keep this in mind when comparing how much each review found.
Two of the models had more than one role. GPT-6.2 Sol wrote review A and was also one of the two verifiers, and Gemini 4 Neon wrote review B and also wrote the explanations on this page. Claude Opus, the other verifier, wrote neither review. The session that settled every disagreement between the verifiers, by reading both write-ups against the code, was also Claude Opus.
Each finding is placed into one of four impact buckets:
Bucket 1: security or data loss
A real security weakness or loss of user data or work, reachable in a plausible scenario. An adversary in a realistic position counts, including a misbehaving coding agent, because Farhelm's approval cards exist to guard against one.
Bucket 2: severe UX
The person running Farhelm gets stuck, silently gets a different action from the one they confirmed, or is misled into making the wrong decision.
Bucket 3: latent security or data loss
A real security weakness or data-loss defect whose path needs an improbable coincidence, such as a key press in the one frame where a menu changed meaning, two consecutive local database failures, or a deliberate mid-operation SSH config edit that points Farhelm at a hostile account. The defect is in the code and would matter if it happened, but nobody should expect to hit it in ordinary use. These are worth fixing, after buckets 1 and 2. Entries are tagged LATENT.
Bucket 4: other
Everything else: minor UX glitches, misleading wording, test coverage gaps, stale docs, and developer tooling.
Each entry also carries a verification verdict:
CORRECT
The claim and its stated impact held up against the source code.
PARTIALLY CORRECT
The underlying defect is real, but at least one sub-claim or the stated impact did not hold; each entry notes what failed to hold.
DISPUTED
The two verifiers disagreed on whether the defect is real; both positions are given.
UNDETERMINED
The issue cannot be settled from source code alone; the entry explains what would settle it.
Summary
Verdicts per review. Each review is counted on its own findings, so the 2 findings both reviews reported count once for each. Latent counts findings in bucket 3, whatever their verdict.
Review
Findings
Correct
Partly correct
Disputed
Undetermined
Incorrect
Latent
A (GPT-6.2 Sol, PR #4650)
17
15
2
0
0
0
1
B (Gemini 4 Neon, PR #4649)
99
65
32
1
1
0
9
No finding was judged wrong by both verifiers, so the incorrect column is empty. The one disputed finding is wrong according to GPT-6.2 Sol and correct according to Opus.
Unique findings per bucket and by who found them.
Bucket
Both A & B
Only A (GPT-6.2 Sol)
Only B (Gemini 4 Neon)
Total
Bucket 1: security or data loss
0
0
3
3
Bucket 2: severe UX
0
0
7
7
Bucket 3: latent security or data loss
0
1
9
10
Bucket 4: other
2
14
78
94
Total unique findings
2
15
97
114
The two reviews barely overlapped: of 114 unique findings, only 2 appeared in both, and both are minor wording problems in bucket 4. Review B (Gemini 4 Neon) was much wider. It found all 10 findings in buckets 1 and 2 and 9 of the 10 latent ones, plus 62 user-facing UX items (2 of them shared with A) and 18 test, doc or tooling items in bucket 4. Review A (GPT-6.2 Sol) found nothing in buckets 1 or 2. Its 17 findings are mostly test quality and tooling (10), plus 6 minor UX items and 1 latent data-loss gap. Review A was more precise: 2 of its 17 findings were partly wrong, against 32 of B's 99.
Bucket 1: security or data loss
Found by both reviews
None.
Found only by A (GPT-6.2 Sol)
None.
Found only by B (Gemini 4 Neon) (3)
Agent-requested Antigravity launches do not resolve symlinks before the approval card
CORRECT
When you turn on Antigravity's automatic workspace-trust switch in Settings and a running agent asks Farhelm to create, spawn, or clone an Antigravity session in a folder given through a symbolic link, the approval card displays the symlink path as supplied instead of resolving it to its real destination first. Farhelm only resolves the symlink later, on the target host, right as Antigravity starts, and then passes the resolved real folder to Antigravity as a trusted workspace for that process. Claude, Codex, Muse, and Pi all resolve and pin the canonical folder before showing the approval card; Antigravity was left out because a code comment assumed supervisor-side resolution at launch time was already enough, even though Codex does the exact same launch-time resolution and still pins before approval.
What this costs you is a gap in the approval card's trust boundary. A misbehaving agent on another host can point to an existing symlink on the target machine to hide which real repository will receive workspace trust, or repoint a symlink while the approval card waits so Antigravity trusts a different folder than the one you inspected and approved. Once trusted, that folder's hooks, settings, and commands run without Antigravity asking. The trust grant is scoped to that single Antigravity process rather than written permanently to Antigravity's saved configuration.
This requires Antigravity's automatic trust switch to be enabled (it is off by default), a misbehaving agent making the request, and a symlink on the target host. That adversarial setup is narrow, but guarding against a misbehaving agent is the reason approval cards exist.
Claude's automatic trust guard skips your home folder and root, but still trusts parents of home and fails open
CORRECT
Farhelm deliberately refuses to mark your home directory or the filesystem root trusted in Claude Code's settings file when Claude's automatic trust switch is on. Claude treats any trusted directory as covering every directory underneath it, so marking either one would silently trust everything inside your home folder. The guard in the supervisor, however, only checks whether the launch directory is the filesystem root or equals your canonical home directory. Any parent directory of your home folder—such as the top-level users directory on Linux or macOS—slips past the check.
When that happens, either from your own launch or from an approved agent request, Farhelm writes that parent directory as trusted into Claude's settings file with no cleanup record. Because Claude applies trust to all subdirectories, that single write permanently trusts your entire home directory and every repository inside it (as well as sibling user folders), both inside and outside Farhelm, even after you turn the Farhelm setting back off. Separately, if the launch shell's home path cannot be resolved—for example a broken symlink or an empty value—while Claude's custom config-directory variable points to a valid settings file, the guard fails open and lets the trust edit run unguarded.
Starting Claude in a parent of your home directory is uncommon, but it needs no timing race or special setup—one ordinary launch with Claude auto-trust enabled is enough. The unresolvable-home fail-open path is much rarer because it requires an unusual shell configuration.
Predictable Tailscale SSH socket directory lets another local account block Tailscale hosts
PARTIALLY CORRECT
Every time the helm prepares a Tailscale SSH connection—whether for the supervisor, interactive sign-in, host setup, or Podman containers over Tailscale—it puts its shared SSH control sockets in a deterministically named folder inside the system temporary directory. The folder name is derived from three values another user on the same machine can read or guess: your numeric user ID, your canonical Farhelm state directory path, and the Tailscale destination name.
If another local account pre-creates a file, folder, or symlink at that exact path in the shared temporary directory before your Farhelm creates it, Farhelm's ownership and permission checks rightly refuse to use it—so there is no connection hijacking or credential theft. Because there is no fallback path, however, every Tailscale SSH operation for that destination fails closed. On a sticky shared temporary directory you cannot delete another user's entry, so restarting the helm or reconnecting does not recover service until the other user or an administrator removes the entry, the machine reboots, or you move your state directory.
This only affects multi-user machines where another local user account is hostile; single-user desktops and laptops are unaffected, and the error message names the obstructed path so the cause is visible.
Verdict — PARTIALLY CORRECT: The denial lasts while the squatted entry remains rather than being strictly permanent—an administrator, system cleanup, reboot, moving the state directory, or changing the destination spelling clears it—and once Farhelm creates its own private directory first, another unprivileged user cannot displace it.
Saving hook setup during Replace with can act on a newer source warning or silently drop the launch
PARTIALLY CORRECT
This finding adds new evidence to an existing queue item. When you use Replace with (or Restart with) and confirm "Set up and launch" on the inline hook-setup question, Farhelm first saves the hook-setup preference to the helm and only then continues the launch. While that preference write is in flight, the helm now continues pushing live session updates to the desktop app (a recent change removed the pause on pushes during an in-flight command). Unlike the YOLO confirmation prompt, the hook-setup prompt does not freeze or invalidate itself when the source session's warning changes.
Because the post-save continuation reads whatever source-session consent was most recently rendered rather than what was shown when you clicked "Set up and launch", two things can go wrong. If the old session becomes active while the save is in flight and a redraw presents the stronger warning before the save finishes, Farhelm can send a looser stop-or-delete guard than you agreed to—stopping and deleting a source session whose agent just started working. In the narrower case where the source state changed right before the save settled and the new warning has not yet been presented on screen, Farhelm saves the hook setting and then quietly skips the launch altogether without telling you, leaving you to press Launch again.
Both outcomes require the source session's liveness to change during the preference write to the local helm, which is normally only a few milliseconds. The silent no-launch case is the more likely symptom when the race is hit.
Verdict — PARTIALLY CORRECT: Review B's added evidence correctly identified that live session pushes now arrive while the hook-setup save is in flight and that the continuation can either widen the deletion guard or silently drop the launch, but overstated one point: activating "Set up and launch" still goes through the inline prompt's answer guard—that guard just covers only the hook question's wording rather than the separate source-session warning.
Queue item: hook-save-uses-newer-replace-warning
Agent-approved managed checkouts re-read the Claude trust switch after you approve the card
PARTIALLY CORRECT
When an agent asks to start a session in a new managed checkout—either on an installed host or inside a brand-new disposable environment—Farhelm freezes the launch's trust choice before showing you the approval card so that the launch matches what you reviewed. After you approve, however, the checkout preparation path reads the current Claude trust setting from the database a second time. Because toggling that switch does not invalidate checkout previews, the stale preview still passes and the two trust inputs diverge.
Flipping Claude's automatic trust switch in either direction while the approval card is waiting—or while a new disposable environment is being built—produces a mismatch. Switching it from off to on causes Farhelm to mark the newly cloned repository trusted in Claude's settings file even though the approval card never showed workspace trust (including when the checkout was cloned for another agent). Switching it from on to off skips the managed-checkout preparation edit and its archive-cleanup record, after which the frozen Claude launch flag still marks the folder trusted through the ordinary-folder path—leaving a permanent trust entry in Claude's settings that is never cleaned up when the checkout is archived or deleted.
This cannot be triggered by an agent because agents cannot change Settings. It requires you to toggle Claude's trust switch yourself while an agent's checkout approval card is open or its disposable environment is starting, though environment builds can take long enough to make that window plausible.
Verdict — PARTIALLY CORRECT: When Claude auto-trust is off, the approval card omits the workspace-trust chip rather than showing an explicit "Not trusted" chip.
A failed container recipe rebuild on a later-removed host makes the recipe permanently undeletable
CORRECT
When you run Rebuild on a Podman container recipe—or when a lazy recipe preparation fails before any image is committed, such as a failed base image pull—Farhelm clears the recipe's last failure text for that container host before checking whether the host is online and usable. Updating that field inserts a per-host state entry for that host into the recipe's database record even if no images or helper containers were ever created there, and the failure handler writes the error message back into that same entry.
Later, if you remove that container host from Farhelm, the host-removal guard checks whether any recipe needs cleanup on that host. Because a failure-only entry has no images or helper containers, the guard allows the host to be removed without stripping its entry from the recipe. When you eventually try to delete the recipe, recipe cleanup loops over every host recorded in the recipe's state and insists that each host still exist in the registry before clearing its record. It fails with an error about the removed container host and aborts deletion.
Because host IDs are auto-incrementing and never reused, re-adding the same SSH host gets a new ID and cannot unblock deletion. Once hit, the recipe cannot be deleted through Farhelm at all without a code fix or manually editing the helm database. Anyone who tries rebuilding a recipe against a broken or offline container host and later removes that host will run straight into this.
A host reconnect while fetching folder history can permanently wedge the launcher
CORRECT
When a launch runs with the launcher dialog hidden—either a quick launch that relies on the host's last used folder, or a launch that just woke a suspended host and is now waiting to read that host's recent folder history—the desktop app sends a background history request keyed to the host's current connection generation and verification state. If the host reconnects with a newer connection generation (or drops out during a plain hidden quick launch) before that history request replies, the reply handler sees that the key no longer matches and returns immediately.
That early return skips the callback that would normally retry the read or reopen the launcher. Because the launcher dialog is hidden, it never redraws to issue a new request, and once a wake reaches its ready phase its timeout alarm is already cleared. The launcher stays stuck in its preparing state with the "Resuming…" pill on screen and no cancel button, blocking New, Clone, Replace with, Restart with, quick-launch shortcuts, host-registry edits, and Suspend or Resume on that host.
The timing window is short—the duration of a single history request—so it is uncommon in normal use. In the post-wake variant, a later full host disconnect will unstick it; in the plain hidden quick-launch variant, nothing clears the wedged state until the desktop app reconnects to the helm or resets its UI session.
Pressing Enter in Replace with's folder field can bypass the safety guard when a template shrinks the list
PARTIALLY CORRECT
In Replace with, Farhelm guards the Folder dropdown so that pressing Enter when a folder suggestion was just un-highlighted cannot accidentally retire and delete the source session before you have seen the un-highlighted state on screen. That guard only runs when the highlighted item is cleared (None). However, the dropdown tracks its highlight as a raw numeric row index, and applying a launch template that changes the folder text does not clear that index or reset filtering.
If you type a filter in the Folder field, arrow down to a second suggestion, and a template shortcut or a delayed template batch changes the folder so the filtered list shrinks to fewer entries, the stored index now points past the end of the list. If you press Enter before the shrunk list has been painted on screen, the guard sees a non-empty highlight and steps aside, the lookup finds no row at that index, the dropdown closes, and Enter falls straight through to submit Replace with—stopping and deleting the source session when the last frame you saw meant "pick this folder".
Your files on disk are untouched, so what you lose is the source session itself. Because the bug requires a filtered, highlighted folder choice and a template edit landing in the sub-second window between pressing an arrow key and pressing Enter, it is narrow, with a delayed template batch being the most plausible path.
Verdict — PARTIALLY CORRECT: Once a redraw after the template change has actually been presented on screen with no row highlighted, pressing Enter to submit Replace with is the intended behavior; the bug only breaks the presentation guard when Enter arrives before that frame is shown (and the secondary claim about index 0 silently picking Home likewise applies only before that frame is presented).
Picking a recent repo setup in Replace with on a suspended host skips the fresh-clone warning
CORRECT
When you open Replace with on a session that lives in a managed checkout, the form starts in Folder mode and tells you explicitly that the replacement will keep working in that checkout with all of its changes. If the host is a sandbox or container that gets suspended while the dialog is open, Farhelm still keeps that installation's recent managed-checkout setups in the empty command pane. Pressing Down and Enter on one of those recent repository rows switches the destination to Managed checkout and immediately invokes Replace in the same key handler, before any redraw occurs.
On a connected host, that immediate submit is blocked because Farhelm has to fetch a checkout preview first, giving the dialog a chance to redraw and display the warning that a managed checkout starts from a fresh clone without your existing changes and moves the old checkout to trash if it was the last session. A recent change bypassed the preview wait for hosts that can wake on launch, so on a suspended host the press succeeds immediately using the previous frame's consent. Farhelm hides the dialog, wakes the host, clones a fresh copy without your changes, and deletes the source session—while the last promise you read on screen said your changes would be kept.
This requires the host to be suspended while Replace with is already open (for instance from another client or tool) and requires using keyboard Down and Enter on a retained repository setup. The old checkout is moved to the trash inside the environment rather than immediately destroyed, so your work is recoverable until the trash or environment is deleted.
Launching New on a suspended host silently replaces displayed ~ with a remembered folder
CORRECT
When you open New manually and pick a suspended sandbox or stopped container that has no open sessions, the Folder field shows ~ with no indication that the path is still pending. Because the host is offline, Farhelm cannot read its recent launch history while the dialog is open, and a recent wake-on-launch change exempted resumable hosts from waiting on the default folder before enabling Launch. Pressing Launch hides the dialog and wakes the host.
Once the host connects, Farhelm routes the manual launch through the same post-wake folder lookup designed for unseen quick launches. If the host's history has a previously used plain folder, Farhelm quietly overwrites ~ with that remembered directory and launches the session there without ever showing it to you. If reading the host's history fails, Farhelm reopens New with a "Couldn't prepare quick launch" error message even though you started a manual launch from the dialog.
This happens on an ordinary, everyday workflow whenever you open New against a suspended sandbox or stopped container and leave the folder untouched at ~. The substituted directory is always your own most recent plain folder on that host rather than an arbitrary path, though if Claude's automatic trust setting is enabled the switch from ~ to a project folder also means Claude auto-trust applies where ~ would have been skipped.
Real security or data-loss defects whose path needs an improbable coincidence. Each entry says what that coincidence is. Entries expand on click.
Found by both reviews
None.
Found only by A (GPT-6.2 Sol) (1)
Tailscale uninstall re-resolves the tailnet name on each step instead of pinning the verified nodeLATENTPARTIALLY CORRECT
During a confirmed uninstall over Tailscale, the sub-claim in review A (PR #4650) that Farhelm's saved destination name could change mid-run does not hold, because the host provisioning lock blocks retargeting and mode changes until execution finishes. What does hold is that the uninstall plan stores only the destination string rather than the verified node's Tailscale address and host keys, so every remote step re-queries the local Tailscale daemon and trusts whichever peer currently owns that name. Under the very unlikely precondition that a tailnet node is removed or renamed and another node takes over its exact name in the brief window between verification and execution, the uninstall steps could stop the wrong machine's Farhelm supervisor, terminate its running terminal hosts, and delete its library directory (leaving state directories intact) if the login and paths match.
Host menu Retry can resume a failed deletion when the menu still showed a connection retryLATENTCORRECT
In the Hosts action menu, Retry handles both reconnecting a host and resuming a failed sandbox or container deletion under the same menu entry, choosing which action to send from live host state rather than what the menu showed. Because the desktop framework can redraw a changed menu on the same key-press frame before the user sees it, pressing Enter on what still looked like a connection retry can resume a failed deletion instead (review B (PR #4649) confirmed this live-state binding at the reviewed tip, updating an existing queue item). Hitting it requires pressing Enter in the single frame where the menu's meaning flipped, and the helm only allows the delete retry when the environment was already sealed for deletion earlier, so it cannot destroy an unsealed machine.
Agent session creation drops the approved host connection check during one post-approval database readLATENTPARTIALLY CORRECT
When an agent requests a session on a named host whose folder is not pre-checked for workspace trust (such as a custom Command, trust-off, or agent-wrapper launch), Farhelm verifies that the host's connection did not change while the approval card waited, then runs a local host-policy database read before dispatching without carrying that connection pin forward. If the host were retargeted and reconnected to a different machine during that single local database read—and the replacement host's policy allowed the launch—the approved session could start on the replacement machine instead of failing. That precondition is practically unreachable because it requires a user retarget in a sub-millisecond window that no agent controls, and the finding's claim that this violates the card-wait rule did not strictly hold since the wait itself is checked before the database read.
Hosts menu Remove checks the live skip-confirmation preference instead of the drawn stateLATENTPARTIALLY CORRECT
Choosing Remove from a host's actions menu reads the live "Remove hosts without asking" setting at click or Enter time instead of locking in the state shown when the menu was presented. In a narrow race where that preference finishes saving just before activation, or where a keyboard Enter hits a disabled Remove item as it becomes enabled before redraw, Farhelm immediately forgets the SSH host without confirming—discarding its helm-side settings, permissions, and session organization while leaving the remote supervisor and sessions running. The finding overstated the surprise: the Remove item looks identical whether the preference is on or off, only the user's own preference save can flip that setting so the result matches their chosen setting, and managed environment hosts (sandboxes and containers) always ask before deleting a machine.
Refused container host checks still cache the wrong machine's Podman path and proxy mapLATENTPARTIALLY CORRECT
If a container host's SSH alias temporarily points to another Linux machine running Podman and Farhelm checks it, Farhelm refuses new work on that host but still caches the other machine's Podman binary path and proxy settings. After you restore the alias back to the original machine without triggering another check, existing container operations (status, resume, delete) keep executing the cached Podman path (failing if the two machines install Podman at different paths), and recovering an unfinished container creation passes the other machine's cached proxy settings into one setup script's environment. Two claims in review B (PR #4649) do not hold: the proxy file actually installed inside the container is read live from the current host rather than from the cache, and opening the launcher or triggering a quick launch also re-checks container hosts rather than requiring a manual Refresh or restart.
Container setup scripts and creation proxy reads skip machine-and-account verification over SSHLATENTPARTIALLY CORRECT
Container build and setup scripts stream proxy environment exports (which can contain proxy passwords) over SSH stdin as soon as the SSH process spawns, without verifying the remote machine and account first, and container creation reads proxy settings from the current route without that check either. Because OpenSSH connection sharing keys on the resolved host, port, and user, editing your SSH config mid-build to change the account opens a fresh connection without a host-key warning; separately, image preparation re-reads the cached place observation instead of keeping the one it already verified. Review B (PR #4649) overstated the practical risk: on a benign endpoint, Podman exits on the missing container ID without reading stdin, so leaking proxy credentials requires deliberately editing your SSH config mid-build to point at an authenticated account that is actively hostile and captures stdin, while committing wrong proxies into a prepared image requires an alias flip, intervening probe, and flip-back inside a brief preparation window.
Container host place verification accepts a plaintext nonce that a hostile SSH endpoint can echoLATENTCORRECT
When verifying a container host's machine and account over SSH, Farhelm passes the expected proof nonce in plaintext in the remote command's arguments and accepts output starting with that nonce as proof that the guard matched. That protects against accidental drift to an ordinary machine or account running the shell check as written, but a hostile SSH endpoint can simply echo the nonce from its arguments without knowing the original machine ID. Reaching such an endpoint requires the host's SSH alias to resolve to a hostile account or machine that passes SSH host-key checks and knows Farhelm's check format, and the worst outcome is a confirmed container Delete forgetting a container that is still running on the real host (or recording a pending container create against the wrong host).
Tailscale mode toggle unparks host connections even if registry refresh failsLATENTPARTIALLY CORRECT
When toggling Tailscale mode on an SSH host, if saving the new mode succeeds but the immediate registry refresh hits a local database read error, the helm still unparks the host connection before returning the error. If the host's own follow-up database read also fails—requiring two consecutive local read failures right after a successful commit—it can briefly dial using the previous SSH mode, and a retry switches the active connection to the new mode without explicitly closing any lingering old-mode shared SSH socket. The original finding's security-downgrade claim did not hold because the fallback is ordinary host-key-verified SSH in batch mode (the trust policy the host was already using moments earlier), so no unverified trust is granted. The practical cost is at most a failed toggle error followed by a brief dial on the old route and an idle shared connection until timeout.
SSH setup Re-run omits Tailscale mode and can fall back to ordinary SSH in a raceLATENTPARTIALLY CORRECT
When you re-run a failed setup on a Tailscale SSH host, the desktop app sends the destination without the host's Tailscale flag or entry identity, leaving the helm to look up the mode from the registry. If an external API client or agent-approved action removes or retargets that host in the narrow window before the probe reads the registry (including during a pending sign-in), the helm finds no row and falls back to ordinary SSH—potentially re-adding the host without Tailscale or starting setup automatically when "Set up new hosts without asking" is enabled. The original finding's claim of a silent host-key-pinning bypass did not hold because ordinary SSH still verifies host keys against the user's known_hosts in batch mode (and prompts during sign-in), so an untrusted key is rejected rather than accepted. Even so, the missing mode lets a raced rerun recreate a deleted Tailscale host under the wrong SSH mode when ordinary SSH can already reach it.
Upgrading after an unrecorded legacy Claude settings write skips cleaning up the old endpoint URLLATENTCORRECT
Before Farhelm moved Claude credentials into a private launch-environment file, it wrote Claude endpoint settings into the host's Claude settings file before recording the local delivery stamp. On upgrade, Farhelm cleans up those legacy keys only on hosts that carry a local stamp so fresh images keep their own settings, meaning a host whose last pre-upgrade write succeeded remotely but lost its reply or crashed before stamping—and never reconnected to retry before the upgrade—skips cleanup permanently. If that happens and Claude gives its settings file precedence over the launch environment, a newly delivered Claude token could be sent to the stale endpoint URL from the earlier recipe. The precondition is narrow and the stale URL is one the user previously configured rather than an attacker's, making this a latent exposure risk.
Each item below expands on click. Within each subsection, user-facing UX issues come first, then test gaps, docs and developer tooling.
Found by both reviews (2)
User-facing UX issues (2)
Claude workspace-trust help in Settings does not mention that home and root are skippedCORRECT
The Claude Code page in Settings tells you that turning on automatic folder trust marks any folder you choose as trusted before Claude starts, without noting that Farhelm deliberately skips your home directory (the launcher's default folder) and the filesystem root. Because the supervisor enforces that exclusion anyway, someone who enables the switch expecting sessions in their home folder to stop prompting still sees Claude's trust question, with only a note in the terminal explaining why. This is easy to hit since home is the default launch folder, though the behavior itself is the safer one.
New container or sandbox shows "Cloned inside the new environment" before a repository is pickedCORRECT
When you choose New container or New sandbox in the launcher and switch Destination to Managed checkout without picking a repository yet—or after clearing the Repository box—the Folder line immediately says "Cloned inside the new environment once it starts" instead of "Select a repository". The Folder detail helper checks whether a new environment is targeted before checking whether a repository has been selected, unlike the footer summary and Launch validation which still require a repository. Anyone setting up a managed checkout in a new environment hits this wording glitch, though Launch remains properly blocked until you pick a repository.
Launcher hides known container host refusals until the first Podman check finishesCORRECT
When a container host is already refused because of a duplicate, changed, or unverified installation, the helm includes that specific reason in the host status even before the first Podman check completes. The launcher ignores the reason whenever no check timestamp is present yet and shows a generic "needs a Podman check" message instead. This occurs briefly right after the helm starts (typically for a few seconds until the background check finishes); launches are still properly blocked, and the actionable refusal wording appears once the check completes.
Launcher checkout preview path can no longer be selected or copiedCORRECT
After the launcher's managed-checkout layout switched the previewed folder from a read-only text input to a static label, the exact destination path can no longer be selected or copied before launching. Every user launching a managed checkout hits this if they want to copy the planned folder path into another tool or message. The full path is still visible in the row, so this is a lost convenience rather than a functional block.
Deleting an orphan Tensorlake sandbox can promise ongoing cleanup before admission if local store reads stallPARTIALLY CORRECT
When you delete a leftover Tensorlake sandbox in Settings, the helm gives the request a 20-second reply limit and answers with a timeout saying cleanup carries on in the background, assuming admission (a 10-second Tensorlake lookup plus local database checks) finishes well before that. Because those local database reads share a single mutex-guarded SQLite connection with a 5-second busy timeout and have no outer bound, heavy database contention combined with a slow or timed-out vendor lookup can push an admission failure past the 20-second mark, leaving no failure record when Settings refreshes. The sub-claim in review A (PR #4650) that an unanswered vendor lookup alone can cause this does not hold, since the lookup times out after 10 seconds, well inside the 20-second reply limit. In the rare case where both database contention and vendor slowness combine, the sandbox simply reappears in the list with no error and can be deleted again.
Terminal selection highlights the unused padding cell at a wide-character wrapCORRECT
When a terminal line soft-wraps because a double-width character will not fit in the last column, Farhelm omits that unused trailing padding cell when copying text. The selection overlay, however, highlights through the full row width without consulting the wide-wrap padding flag, so dragging across such a wrap tints one extra empty cell at the end of the upper row. The copied text is still right, making this a minor cosmetic mismatch whenever selections cross wrapped wide characters.
Deflake base-refusal tests do not verify that start avoids writing run stateCORRECT
The deflake driver currently rejects unsupported base revisions before creating a run directory or updating the checkout's current-run pointer, as required. Its tests only call the revision-checking helper directly and never exercise the start command itself, so a call-order regression that writes run state before refusing would still pass. This only affects maintainer deflake tooling; if it regressed, a refused run could leave a stray directory and repoint later status or wait commands at a run that never started.
Deflake sweep-base test fixtures inherit the developer's Git hooksCORRECT
The deflake sweep-base test fixture overrides Git user identity and commit signing, but leaves the rest of the developer's Git configuration intact, including global hook paths and template directories. On a machine with a global commit or checkout hook that rejects the synthetic fixture commits, all four tests fail during setup before reaching their assertions. This only affects contributors running the deflake tests locally; it causes a loud setup error rather than a false pass and has no impact on Farhelm users.
Environment launch-history test bypasses request-level origin handoffsCORRECT
Farhelm keeps agent-created environment sessions from updating the desktop's recent setups and default container host, and both the ordinary and fresh-checkout launch paths currently preserve the agent origin. However, the regression test injects the agent origin directly into the post-creation acceptance step instead of driving a create request through either route. Nothing is broken today, but if a future refactor dropped the agent origin in either request path, agent launches could start overwriting desktop launch defaults without tripping this test.
Host lifecycle test checks the other host's availability via a helper instead of its menuCORRECT
When a session launch is in progress on one host, Farhelm disables Suspend and Resume only for that host while leaving other hosts' lifecycle controls usable. The regression test verifies the other listed host by calling the internal refusal helper directly and only opens the busy host's menu, leaving the rendered menu state on the second host unchecked. Production code disables each host's menu item per host today, so this is a test-coverage gap: a future UI change that disabled every host's lifecycle controls during any launch could slip past the test and force users to wait for unrelated launches to finish.
Inline Resume test does not verify the button's disabled stateCORRECT
While a launch is in progress on a suspended host, Farhelm disables the host row's inline Resume button and also blocks the request in its click handler. The regression test only asserts the button's tooltip text and that clicking sends no resume request, without inspecting whether the rendered button is actually marked disabled for visual and accessibility consumers. Because the click handler independently refuses the request, dropping the disabled flag on the button would leave the test passing while showing users an apparently clickable Resume button that silently does nothing during a launch.
Remote probe absence test never verifies that its stand-in binary actually ranCORRECT
The remote probe regression test checks that Farhelm reports an absent installation both when no remote binary exists and when a stand-in binary exits with code 75 while SSH reports status zero. Because the probe script's own missing-binary fallback also exits with code 75 and the absence result does not expose whether a binary was resolved, the test never observes whether the stand-in actually ran. The production probe script does execute the binary today, so this is a test-strength gap: a future path-resolution regression could slip past the test and cause setup to misclassify an installed remote supervisor.
SQLite startup maintenance test only checks missing statistics, not refreshing stale onesCORRECT
On startup, Farhelm runs SQLite planner maintenance (PRAGMA optimize=0x10002) so both new and long-lived databases keep current query statistics. The unit test starts from a fresh database with no SQLite statistics table (sqlite_stat1) and never covers a table whose existing statistics have gone stale. Nothing is broken today and SQLite itself decides when stale tables need re-analysis, so this is a low-risk coverage gap that would only matter if a future pragma or SQLite change stopped refreshing stale statistics and gradually slowed queries on older stores.
Tensorlake prepared-host test misses snapshot guard retention while the sandbox is still startingCORRECT
When adding a Tensorlake host from a prepared snapshot, Farhelm holds a per-recipe snapshot lock until the new sandbox reaches the Running state, then releases it before waiting for SSH so concurrent recipe rebuilds do not retire the snapshot prematurely. Production follows this lifecycle today, but the Add-host test only checks that the lock is free once the SSH wait begins and never verifies that it stays held while the sandbox is still Pending. If a future change released the lock right after creation, a concurrent recipe rebuild could delete the source snapshot mid-startup and break host creation without failing this test.
Terminal link oracle generator drops the wide-wrap padding flag from regenerated fixturesCORRECT
The checked-in terminal link test oracle includes the wide-wrap padding marker on its two emoji-wrap test cases, because those rows were hand-edited without updating the fixture generator script. Running the documented generator produces those rows with only the wrap flag, omitting the padding bit that the grid model uses to distinguish wide-character wrap padding from a printed trailing space. No Farhelm user is affected; a developer regenerating the oracle would either hit an unexpected test mismatch or quietly lose coverage of links crossing a wide-character wrap seam.
Failed remote test-worker staging leaves the evidence directory stamped as in progressCORRECT
Before uploading scripts and working-copy files to a remote test worker, the test-worker driver writes outcome: staging to the evidence directory's invocation.txt stamp (and preparing earlier before collecting the file list). If the file-list check or either upload fails, the script exits with code 2 and cleans up the remote stage without replacing that stamp, contrary to the documented rule that refused requests record their own terminal outcome. This affects only maintainer test tooling; the live command still prints a clear error, but anyone inspecting the evidence directory afterward may think staging is still running.
When you review an agent's host-add request in the Add host dialog, any change to the background approvals list triggers a brief 700 ms arming pause that disables the Tailscale checkbox while leaving the destination and alias text fields editable. Because a disabled checkbox stops tracking focus, keyboard focus is evicted from it and Tab skips over it until the pause ends; the same focus drop also happens while a destination check is in flight. The finding's other claim—that pressing Enter on the focused Tailscale checkbox starts a destination check and evicts focus—did not hold, because that checkbox has no Enter handler and the dialog only submits on Enter when the dialog container itself has focus.
Adopting a new host identity leaves cached Podman readiness and unused machine claims stalePARTIALLY CORRECT
When you wipe or replace a container host and click Adopt in Hosts, Farhelm replaces the host's ordinary installation identity without clearing its cached Podman check or releasing an unused machine claim. If the old check is still within five minutes, new container launches or recipe builds can fail with a misleading error telling you to restore the original SSH destination, and another host entry pointing at the vacated machine can be rejected as a duplicate even across restarts. The finding overstated both persistence and scope: opening the launcher or container settings automatically re-checks container hosts and clears both conditions (as does a manual Refresh), the five-minute window governs launch admission rather than the readiness display, and reinstalling only the supervisor on the same machine does not cause the mismatch.
Unused container host keeps its old machine claim after being rejected as a duplicateCORRECT
If an unused SSH container host is repointed outside Farhelm to a machine already claimed by a second host entry, refreshing it rightly refuses it as a duplicate, but Farhelm rolls back the update without releasing the moved entry's stale claim on its original machine. A third host entry pointing at that vacated machine can then be rejected as a duplicate of the moved entry—persisting across restarts—with a message saying they still reach the same machine. Hitting this takes three host entries and an outside SSH alias change, no data is lost, and removing or retargeting the moved entry clears the block.
Empty or relative HOME causes Claude workspace trust to edit files inside the working directoryCORRECT
When Claude automatic folder trust is enabled, Farhelm enters the session's working directory before reading HOME and does not reject an empty or relative value. If a host's login shell leaves HOME empty or relative with no custom Claude config directory set, Farhelm resolves .claude.json relative to the working directory and will write a trust entry into any existing .claude.json file (or symlink target) sitting inside that folder; if a custom Claude config directory is set, an empty HOME also defeats the guard that stops Farhelm from trusting the real home directory. Nothing in Farhelm produces an empty or relative HOME, so this only affects misconfigured shell environments and is a defensive hardening gap rather than an everyday failure.
Claude folder-trust banner appears on custom Command and legacy launches where the setting has no effectCORRECT
When you start Claude in an ordinary folder using a custom Command or legacy launch and Claude asks whether to trust the folder, Farhelm displays the hint banner telling you that turning on Claude's folder-trust switch in Settings can answer it automatically. Unlike the hints for Codex, Muse, and Antigravity, the Claude hint does not check whether the session used a structured Claude launch—the only kind for which that Settings switch applies in ordinary folders. Turning the switch on leaves those Command and legacy launches asking anyway, though you can still answer Claude's prompt directly in the terminal.
Unreachable container host errors embed up to 64 KiB of raw remote stderrCORRECT
When SSH or the remote shell fails before Farhelm's container-host identity check can run, Farhelm copies the command's error output directly into the failure message instead of passing it through the trimmer and character filter used by other Podman errors. Up to 64 KiB of unfiltered text—including control characters—can then end up in container host status errors, lifecycle failures, HTTP error bodies, and helm logs, repeated across every container on that host. The desktop app already escapes host-supplied text before drawing it and normal SSH errors are short, so this mainly risks cluttered diagnostics rather than UI spoofing.
Deleting the right half of a wide terminal character swallows an adjacent spaceCORRECT
If a terminal program deletes only the right-hand cell of a double-width character and shifts an ordinary space with the same background color into that column, Farhelm's terminal grid encoder absorbs that space as the wide character's second column. Because the underlying terminal cell representation cannot tell a shifted plain space apart from an erased right half of the same color, copying text, selecting words, or detecting URLs and paths drops the space between the wide character and the text after it. This requires a rare cell-level delete targeting the middle of a wide glyph, and no content beyond that single separator space is affected.
Repeated interrupted uploads in the same session are silently ignored while an older banner stays openPARTIALLY CORRECT
Interrupted-upload banners are deduplicated purely by session, title, filenames, and whether the upload was sent, and every newly opened terminal restarts its pasted-image numbering at pasted-1. If you leave a session mid-upload, leave its banner undismissed, return, paste another screenshot (or retry the same filename), and leave mid-upload again, Farhelm drops the second notice and does not scroll the existing banner back into view, so you can miss the second failure. This requires two mid-upload departures from the same session without dismissing the first banner, and local files are unaffected. The sub-claim that two tabs of the same session uploading pasted-1 at once lose the second notice on normal departure did not hold: both terminals hand off their uploads before the notice check runs, so they merge into one banner listing the file twice.
Failed or superseded post-wake checkout launch reopens without a Not launched alertCORRECT
When you launch a managed checkout on a suspended or stopped host and the folder check fails after the host wakes (for example, a typed checkout name is already taken or the host has no checkout folder configured) or is superseded by a newer connection, the launcher reopens without recording a launch refusal. No bordered "Not launched." alert appears beside the Launch button and screen readers receive no alert announcement: a failed check shows only a polite status line on the Folder row, while a superseded check reopens with no explanation of why nothing started. No wrong session is created, and you can adjust the form and press Launch again.
Hidden per-host Trash confirmation keeps other hosts' delete buttons locked and eats the first CloseCORRECT
If you open a host's "Delete all on" confirmation inside the Trash dialog and that host is then removed or its archived checkouts are cleared elsewhere so its section disappears, the confirmation remains open invisibly. While it sits hidden, every individual Delete and Retry button on other hosts stays disabled with nothing on screen explaining why, the first Close click or Escape press silently cancels the invisible confirmation instead of closing Trash, and if a new archived checkout arrives on that host before dismissal the stale confirmation reappears. A second Close or Escape closes Trash normally, and nothing is deleted unintentionally.
Host settings Tailscale switch shows an unprefixed launch refusal, stacks old errors, and can leave the error stuckCORRECT
Toggling the Tailscale host switch in Host settings while a session launch is in progress displays a bare lowercase sentence fragment without naming the Tailscale setting, keeps any previous Tailscale save error visible above it, and clears any other control's busy notice in the dialog even though no save started. If a Tailscale toggle save was already in flight when the launch began and you click the switch again, the red launch-refused message stays on screen even after the earlier save succeeds. The glitches are cosmetic and confusing, but nothing wrong is saved and later saves still work.
Hosts menu Re-run dispatches from live host state instead of the drawn setup or update actionCORRECT
In a host's actions menu, the Re-run item renders its wording for either a failed setup or a failed update, but its click handler ignores that drawn choice and re-reads live host state instead. If a failed update supersedes an earlier failed setup while the menu stays open and you click in the stale frame before redraw, clicking Re-run on what looked like a failed setup immediately starts an unconfirmed remote host update rather than probing setup. The race window is very narrow because an entire update must start and fail while the menu is open before the click lands, and nothing is destroyed, though it runs a different action than the one shown.
Interrupted-upload banner mangles empty session titles and can drop a later-learned title in a batchCORRECT
Farhelm allows empty session titles, but an interrupted upload in a session with an empty title still inserts the title clause and produces a broken banner sentence ("Attaching <file> to was interrupted...") both on screen and for screen readers. Separately, when multiple interrupted uploads are grouped into one banner, Farhelm takes the session title only from the first upload in the group; in the rare case where an early upload queued before the session's metadata arrived and a later upload captured the title, the banner omits that title. In both cases the filenames and upload outcome still come through.
Interrupted uploads stay hidden when the selected session switches to a recovery or unavailable cardPARTIALLY CORRECT
If an open session loses its terminal while remaining selected—for instance, when a host reboot or update puts it on its recovery card, or a reconnect lands on an unreachable host—Farhelm drops the terminal and holds the interrupted upload in memory without showing either a terminal strip message or a window banner. The interruption stays invisible until you switch to another session or the terminal returns, and quitting first loses the report completely, though local files are untouched and no false success is shown. The sub-claim about an old-style retired container session losing a live mid-upload transfer did not hold in normal operation because both the helm and supervisor already refuse terminals and file uploads on retired container sessions, and a font-measurement failure leaves no mounted pane at all rather than a card.
A later Codex or GitHub delivery failure hides a pending legacy Claude cleanup warningCORRECT
On an upgraded host where cleaning up legacy Claude settings fails, Farhelm withholds the new Claude launch environment and continues delivering Codex and GitHub credentials so those independent slots can still finish. Because any failure in those later slots (such as a malformed Codex config or a missing gh CLI needed for private GitHub clones) returns early, it overwrites and drops the pending Claude cleanup warning. The host warning then mentions only Codex or GitHub, and replacing the host's Claude credential blames that unrelated failure until you fix it and retry, though the new Claude credential stays safely withheld throughout.
Erasing or deleting the left half of a colored wide character drops the remaining cell's background colorCORRECT
When a terminal program erases or deletes only the left half of a double-width character with a colored background, or inserts a blank at its right half, the terminal grid keeps an orphaned right-half spacer cell carrying the original background color. When the supervisor encodes that row for the desktop client, it skips every wide-character spacer cell unconditionally without emitting a styled blank, leaving that column to paint in the terminal's default background. This is a rare one-cell cosmetic glitch with no effect on terminal state or data.
New container with Managed checkout adds a ~300 px blank gap in the launcherCORRECT
In the session launcher, selecting New container with Managed checkout places the Container host block directly inside a vertical column while keeping a 370-pixel flex basis meant for horizontal rows in Folder mode. Because a vertical flex container applies flex basis to height, the Container host section stretches to roughly 370 pixels tall and inserts around 300 pixels of empty space above the Repository field. This happens on every New container launch using Managed checkout, pushing Repository and the agent choices down the dialog and forcing extra scrolling, though every control still works.
Overflowing notice banner stack jumps back to the oldest banner after reconnectCORRECT
When the desktop window disconnects or is displaced, the notice banner stack is not drawn, so the UI framework discards its scroll position while the window still remembers which banners were already shown. On reconnect or Take back, if the latest banner was already present before the outage (such as an undismissed connection-lost notice), the stack does not scroll back to the bottom and instead opens at the oldest notice at the top. A user with enough undismissed notices to scroll the stack can find the newest banners hidden below the fold until they scroll down, though nothing is lost and every notice remains reachable.
Stuck restart cleanups can starve later pending cleanups on Linux supervisor startupCORRECT
When a Linux supervisor restarts, it retries pending process cleanups from failed delete-during-restart operations one at a time in a fixed order under a single 60-second startup budget. Any entry that stays slow or unconfirmable remains at the front of that order, so two or three stuck entries can consume the entire budget on every restart and prevent later, cleanable entries from ever running. Reaching this state requires multiple failed restart cleanups accumulating on the same Linux host, and its cost is up to a 60-second startup delay plus orphaned agent processes left running from already-deleted sessions.
Malformed session IDs from the startup cleanup queue are logged without full escapingPARTIALLY CORRECT
When a supervisor discards an invalid session ID from its startup cleanup queue, or fails to retire that entry, it logs the raw ID with plain display formatting instead of escaped debug formatting, allowing line breaks and invisible or direction-changing characters into the log contrary to the logging rules. One sub-claim in the finding did not hold: the configured logging formatter already sanitizes ANSI escape sequences by default, so terminal-escape injection is blocked. Because shipped code only stores freshly minted UUIDs in the private supervisor database, reaching this requires an already corrupted or locally tampered database, leaving the practical impact to log hygiene during startup troubleshooting.
Plain Restart and Replace leave host Suspend enabled on sandbox and container hostsPARTIALLY CORRECT
Starting a plain Restart or Replace from a session menu or header does not disable Suspend in Hosts or on other sessions sharing that sandbox or container host, and the helm's host Suspend path does not block on in-flight session restart or replace requests. Two parts of the finding did not hold as stated: the product specification only requires disabling Suspend for launcher-submitted launches (including Restart with and Replace with), and on a single desktop window a normal Suspend activity check queues behind the ordered Restart or Replace, so direct overlap mainly happens through Stop and suspend or a prior activity check completing mid-request. In that narrow window, explicitly suspending the host can interrupt the Restart or Replace or leave its outcome ambiguous until the host resumes, without data loss.
In-flight container recipe builds skip rechecking host admission before later helper stagesPARTIALLY CORRECT
After a container launch or recipe rebuild passes its initial host check, later image-build and Farhelm-preparation stages obtain Podman capabilities through the existing-container runtime path, which ignores probe staleness and duplicate, changed, or unverified Farhelm installation refusals. The finding's claim of a clear specification violation did not hold: the job was already admitted when the launch or rebuild started, and every later helper still checks the host's recorded claim and verifies the target machine and Unix account before running, so whether continuing an already-admitted job counts as new work is a judgment call. If a container host's ordinary Farhelm connection enters a refused state mid-build (or while a queued launch waits), the build can finish its later stage on the same verified machine and account instead of stopping early, without touching another machine or moving credentials.
Container host claim and recipe state database checks omit the Tailscale flagPARTIALLY CORRECT
While recording a container host's machine-and-account claim fences on the SSH host's Tailscale setting, the companion database checks that verify an existing claim and guard recipe state writes omit that flag. Two sub-claims did not hold or were overstated: claimless recipe state edits re-read the current host row immediately before writing (so they cannot use a stale snapshot), and the claimed-helper race requires toggling Tailscale and completing a full fresh probe reclaiming the same machine and account inside a tiny local-only window before the first helper is recorded (after which further toggles are refused), while the preparation stage also re-reads proxy settings after starting its helper. Even if hit, every command stays pinned to the same verified machine and Unix account, making this a narrow defense-in-depth gap rather than a realistic trust-boundary crossing.
Container leftover listing and deletion run SSH commands outside the host route lockPARTIALLY CORRECT
Scanning observed hosts for leftover containers (such as opening Settings → Containers) or deleting an unregistered leftover on an unused SSH host runs SSH commands without holding the host's SSH route lock, unlike Podman place probes. One detail in the finding did not hold: ordinary host removal stops the host actor and deletes Tailscale host-key snapshots without making the explicit shared-SSH-master shutdown call that toggling Tailscale mode makes. If a leftover listing or deletion overlaps disabling Tailscale mode or removing that unused SSH host, the command can fail once (fixed by Refresh) or recreate a stray Tailscale host-key snapshot or shared SSH connection after cleanup.
Leftover container listing and deletion skip host identity checks and can report false successCORRECT
Listing leftover containers and deleting an unregistered leftover in Settings → Containers run Podman commands without checking the host's recorded machine-and-account identity, even when the host has an active claim. If the host's SSH alias is repointed outside Farhelm to a different machine or account whose Podman store is empty, deleting a leftover reports success and refreshing the list hides all leftovers on that host instead of flagging the changed destination. Nothing is deleted on the wrong machine, so there is no data loss, but the user is told cleanup succeeded while the original container keeps running and consuming resources on the old host.
Container host commands over SSH trust raw exit codes without status-tag wrappingUNDETERMINED
Unlike remote host setup, update, and uninstall commands—which wrap remote scripts in a tagged status record so a lossy SSH server cannot mask failures as exit 0—Podman probes and container lifecycle commands over SSH trust the SSH client's raw exit code directly. On an SSH server that reports exit 0 for failed commands, probe checks and recipe build or lifecycle commands could appear to succeed silently, while container and image deletion would fail closed permanently because absence checks would keep reporting the resource present (host identity verification itself remains protected by its per-command output check). What cannot be settled from source is whether any SSH server fronting a supported Linux container host actually drops exit statuses to zero: the only known example in the codebase is Tailscale SSH on macOS, and macOS cannot host containers. Settling this requires a reproduction or vendor confirmation showing a Linux SSH server, bastion proxy, or forced-command wrapper returning exit 0 after a failed remote command.
Podman probe hides SSH session-limit refusals on its final identity-check stepPARTIALLY CORRECT
When a container host exhausts its SSH session limit (MaxSessions) specifically on the final machine-and-account identity read of a Podman probe, Farhelm discards the session-limit refusal and stores a generic error telling the user to check the SSH destination and press Refresh. Two parts of the finding did not hold completely: not every earlier probe step propagates the session-limit refusal (the best-effort cleanup of the temporary probe scope ignores its result), and an ordinary Farhelm installation refusal can still take precedence over the generic identity message. When capacity runs out on that final step, the launcher and Settings → Containers point the user at the wrong cause until capacity frees up and a Refresh runs.
Container host checks use a stale host snapshot if setup finishes mid-checkPARTIALLY CORRECT
A container host check reads the host's registry entry before probing over SSH and reuses that snapshot afterward to check for identity refusals, settle the container host claim, and format any displaced twin's display name. If Setup or Update updates the host's remote install paths while that check is in flight, the helm treats the host as having no matching connection state, so a refused entry can temporarily claim an unclaimed slot, a newly connected owner can miss taking over an unused twin claim, or a displaced twin's message can show an outdated alias. Review B (PR #4649) overstated the practical impact: subsequent readiness and launch checks re-read the current host row so a refused host still cannot start containers, a legitimate owner can still displace it in most cases, and the next check (opening the launcher or pressing Refresh) clears any wrong readiness state.
Verified container host cannot take over an unused claim held by a duplicate of a third hostCORRECT
When a stale host entry with a recorded installation identity still holds an unused container host claim and now points at a third registered host's Farhelm installation, Farhelm classifies that stale entry as a duplicate of the third host rather than an identity mismatch. During claim settlement, Farhelm only lets a verified host take over an unused claim from a duplicate entry when the duplicate points at the challenger itself, not at a third host. In that narrow three-host topology, the legitimate container host is refused for new containers and image builds until you remove or retarget the stale entry named in the refusal message.
Suspending a container briefly flashes Connecting and can trigger the full reconnect ladderCORRECT
After pausing a container, Farhelm releases its connection hold without first publishing the confirmed Suspended state, so the host briefly flashes Connecting while Farhelm inspects the paused container over SSH before settling to Suspended. In addition, releasing a hold after any Suspend (for containers or Tensorlake sandboxes) leaves the active reconnect flag set, so if that immediate post-suspend check fails transiently, Farhelm runs the full reconnect retry ladder and shows Connecting for up to about a minute instead of a single quiet check. Both behaviors are cosmetic and do not affect the paused container or sandbox.
Post-wake disconnect or launch start failure may reopen the launcher without an explanationDISPUTED
Review B (PR #4649) reports that if a waking host disconnects or changes installation right as its post-wake checkout preview or folder-history read finishes, the launcher can reopen without showing the "Not launched" refusal alert explaining why the session did not start. Verifiers disagreed on whether that race can occur: one confirmed the silent-reveal paths in the launcher and noted that the code's own comment anticipates a stale preview or history callback running before the wake observer reacts, while the other argued that the GUI framework synchronously flushes store observers and their deferred wake-rejection callbacks before a separately scheduled reply task can observe the host update. Either way, the stakes are low: no session is created, and the reopened launcher shows the host as unavailable so you can see what happened and retry.
Probing a duplicate or managed host with Tailscale enabled returns a misleading mode-change refusalCORRECT
When probing a destination over the API with an explicit Tailscale setting, the helm checks for a Tailscale-mode mismatch against any existing host sharing that destination before validating the target or checking whether the host is already registered. Adding an already-registered SSH host with the opposite Tailscale setting therefore tells you to change Tailscale mode in Host settings instead of naming the existing host entry, and probing a managed sandbox or container destination with Tailscale enabled gives the same advice even though managed environments have no Tailscale setting. Because the desktop Add host dialog pre-checks its cached host list before probing, this mostly affects API callers or a brief race with a newly added host, and nothing is contacted or modified.
Direct Update and SSH setup requests are not refused for environments awaiting deletionCORRECT
While a sealed sandbox or container is waiting for a failed deletion to be retried, the helm's Update and ordinary SSH setup checks only refuse stopped, suspended, or state-changing environments and let the Deleting state through. The desktop app hides Update and Re-run for those hosts, so only direct API callers can trigger this path while the environment is still reachable after a failed delete. Doing so wastes time probing or reinstalling into a machine queued for destruction and holds its provisioning lock (blocking a deletion Retry as busy until the run ends), though it cannot unseal the environment or lose data.
Removing or uninstalling an SSH host waits on in-flight checks and open sign-in promptsCORRECT
Removing an ordinary SSH host waits for any active SSH probe, background container check, or interactive SSH sign-in prompt on that host to finish rather than returning a prompt busy refusal as specified. Because an open sign-in prompt can wait up to two minutes (and removing the host does not cancel it), host removal can hit the 20-second reply timeout while leaving the host locked as busy to other operations, and Uninstall's final forget-host step can stall the same way. Nothing stays stuck permanently — the removal finishes on its own once the check or prompt ends — but it creates an unnecessary wait and timeout message.
Replacing a session inside a sandbox or container promises Trash for a new managed checkoutCORRECT
When you choose Replace with on a session inside an existing sandbox or container and switch the destination to Managed checkout, the launcher note says the new checkout moves to the trash when its last session is deleted. That wording only switches to permanent-removal language when launching a brand-new environment, not when launching inside an existing session-owned sandbox or container where deleting a session discards the checkout or destroys the whole environment permanently. Actual deletion still opens a non-skippable confirmation stating the permanent outcome, so there is no unwarned data loss, but the note sets the wrong expectation and contradicts the replacement warning directly above it.
Signaled SSH or Podman client can turn truncated setup output into exit 0CORRECT
When the helm runs remote provisioning or inspection commands over SSH or Podman, it preserves SSH exit 255 as a transport failure but overwrites a missing exit code and clears the signal if the remote status marker already arrived on stderr. Because stdout and stderr drain over separate pipes, an external signal (such as the OOM killer) hitting the local SSH or Podman client in the narrow window after stderr flushes can make a cut-off reply look like a clean exit 0. Structured probes reject incomplete replies, but permissive callers—such as reading a sandbox's home directory, which only checks for an absolute path—could accept a truncated value and pass a bad path or misleading diagnostic into later setup work.
Failed wake in Restart with shows "Not launched." instead of "Restart error."CORRECT
When Restart with tries to wake a suspended or stopped sandbox or container host and fails, the alert beside the Restart button starts with "Not launched." instead of the "Restart error." lead that Restart mode uses for every other refusal. Both wake failure paths hardcode the "Not launched." prefix into the stored refusal, and the launcher renders that message verbatim instead of applying the mode-specific lead. The underlying reason text is still accurate and the user can tell nothing restarted, so the impact is minor wording drift (missed because the wake and launcher request tests no longer cover Restart with on a resumable host).
Erasing the right half of a styled or linked wide character leaves stale attributesCORRECT
If a terminal program erases only the right half of a wide character using the same raw background color, the supervisor merges the erased cell back into the wide character's two-column span with the left cell's full style and hyperlink. Because the check compares only raw background color, a reverse-video wide character paints its inverted foreground color across the erased column, underlines and strikethrough continue across the erased column, and an OSC 8 hyperlink stays clickable there even though the emulator cleared the cell. This requires a rare half-glyph erase sequence and is cosmetic: any link click still goes through Farhelm's normal hover disclosure and explicit-click rules.
Settings → Containers hides loading status and shows a stale error during reloadCORRECT
In Settings → Containers, the leftover-containers section shows "Reading container leftovers…" only when it holds neither cached rows nor a previous listing error, because it does not track whether a read is currently in flight. After a failed listing, clicking Refresh or deleting the last listed leftover starts a new host query (which can take up to 20 seconds) without clearing the prior error, leaving only the old failure message on screen with no indication that a reload is running. A user can easily assume the retry already failed until the reply eventually arrives and replaces the stale error.
Workspace-trust help for Codex, Muse, Pi, and Antigravity omits agent launchesCORRECT
The Settings help text for the Codex, Muse, Pi, and Antigravity workspace-trust switches lists New, Clone, Restart with, and Replace with as the launches covered by the switch, leaving out agent-requested launches (which Claude's help text explicitly mentions). In practice the helm applies those switches to agent-requested launches too, as specified. Someone turning a switch on can assume agent-initiated sessions are excluded, and on a host with Always-allow enabled those sessions will start with workspace trust without showing an approval card.
Deleting characters on a colored wrapped-wide row leaves a one-cell background gapCORRECT
When a terminal program deletes characters on a colored row that ended in a wrapped wide character, the emulator shifts the wide-wrap padding cell inward without clearing its wrap-spacer marker and resets the final column. Because the supervisor's row encoder skips wrap-spacer cells at every column and only paints wrap padding at the row's right edge, the shifted cell is omitted from the screen update. The user sees a one-column default-background hole in the middle of the colored row—a rare, purely visual edge case.
Keyboard shortcuts chord still opens during terminal IME compositionCORRECT
Pressing the Keyboard shortcuts chord (Cmd+/ on macOS or Ctrl+Shift+/ on Linux) while an input method is actively composing in a focused terminal still opens the Keyboard shortcuts dialog, even though the spec says composition should not open it. Session Delete and Rename already check whether the terminal has active composition, but the shortcuts chord handler skips that check—a leftover from an earlier recorded parity gap before the terminal composition query was added. When an input method does not swallow the chord first, the read-only dialog interrupts typing until dismissed with Escape.
SSH host setup checks "Set up new hosts without asking" after probing finishesPARTIALLY CORRECT
When you add an SSH host or re-run a failed SSH setup, the desktop app reads "Set up new hosts without asking" only after the remote probe finishes instead of capturing the setting at the moment you clicked Add or Re-run. Because a probe can span an interactive SSH sign-in, turning that preference on while the check is still in flight causes Farhelm to start installing immediately without showing the setup plan for review. The original finding's claim that another client could flip the setting mid-probe did not hold, since only the user's own GUI saves this preference (either in Settings or via a permanent answer on another host's setup prompt). The impact is a skipped plan review on a host the user already asked to add or re-run, rather than an unwanted action.
Removing a host during a starting SSH or Podman check leaks a small lock entryCORRECT
Three background helm paths—SSH setup sign-in, SSH provisioning plan checks, and Podman host refreshes—read a host from the registry and then look up its per-host SSH route lock without holding the provisioning lock across that gap, and the lookup unconditionally inserts a map entry on a miss. If the host is deleted and its lock entry purged in that window, the racing check recreates an entry for the deleted host ID, sees the host is gone, and leaves the orphaned entry behind for the rest of the helm's lifetime because host IDs are never reused. Each raced deletion leaks only two small lock objects in memory, so users will not notice it in normal operation.
Confirming an SSH-style setup on an existing Tensorlake sandbox writes paths before lockingPARTIALLY CORRECT
Through the provisioning API, confirming an SSH-destination setup plan for an already-initialized Tensorlake sandbox writes the planned Farhelm binary and state paths to the registry and reconciles the host before acquiring the host's provisioning lock or checking whether the sandbox was suspended. The original finding's claim that reconciliation tears down and replaces the host connection task (dropping lifecycle holds) did not hold—reconciliation keeps the existing task and its hold intact—but it does briefly publish a Connecting state before suspension is observed again. That window can let the confirmation's own suspension check pass and probe a suspended sandbox, while leaving uninstalled paths saved for the next connection. The desktop app does not hit this path because sandbox reruns use a dedicated sandbox target and Add host rejects existing destinations; no user data is lost, though an API caller can end up with a failed or hanging setup and stale saved paths.
Suspend and Stop and suspend still stall behind slow hosts during their activity checkCORRECT
Suspending a disposable environment (from a session row, session header, or the Hosts panel) or choosing Stop and suspend from a session menu still waits behind any unrelated slow host for up to about 20 seconds, even though the suspend action itself was moved off the serialized request queue. Before asking for confirmation or sending the suspend, the desktop app fetches the host's session list over the serialized queue even though the helm answers that lookup from its local cache without contacting any host. While that check is stuck waiting, the session's controls stay busy, and from the Hosts panel clicking elsewhere cancels the confirmation and tells you to choose Suspend again once the delayed reply arrives.
Suspend quietly does nothing if a launch starts on that host during the activity checkCORRECT
If you click Suspend (or Stop and suspend from a session menu) and a new session launch starts on that same host before the pre-flight activity check finishes, the suspend request is dropped silently instead of explaining why it was refused. Both the session controls and the Hosts panel bail out without recording a refusal note, whereas an already-open confirmation dialog keeps its button visible and disabled with an explanation. The race window is usually brief, though it stretches up to 20 seconds when the activity check is queued behind an unrelated slow host; nothing is lost and the launch proceeds, but you get no feedback that Suspend did not run.
Tailscale host edits and registration discard format guidance and blame the SSH addressCORRECT
Turning on Tailscale SSH mode for a working SSH host whose address uses a URI, explicit port, bracketed IPv6 literal, or SSH config alias with underscores—or editing or registering a Tailscale host with such an address—fails with a generic message claiming the address is not a usable SSH destination. The Tailscale address validator produces specific guidance explaining that Tailscale mode expects a Tailscale node name or IP with an optional login, and setup probes show that message, but the host store and mode-toggle routes throw it away. The request is refused safely and leaves the host unchanged, yet the user is told a working SSH destination is unusable without being told what format Tailscale mode needs.
Editing a Tailscale host destination bypasses the route lock and skips retiring old shared connectionsPARTIALLY CORRECT
Changing a Tailscale SSH host's destination does not take the host's SSH route lock, park the live connection, or close old shared Tailscale SSH connections, and it skips deleting the old address's pinned host-key files if registry reconciliation fails. When a destination edit overlaps an active probe, container refresh, or update check, the check can hit a transient connection error, leave stale key files on disk, or leave an old shared connection alive until its 60-second idle timeout. Several claimed consequences did not hold as broadly as stated: deleting pinned keys fails closed rather than weakening verification, old shared connections are isolated by destination and cannot be joined by the new route, a split Update plan is refused at confirmation when the destination mismatch is detected, and a racing probe can only re-add the old address as a separate host if the moved row has not learned a matching supervisor identity.
Failed Tailscale host probes can falsely blame state-directory socket lengthCORRECT
When setting up, updating, or checking a Tailscale host fails with an SSH exit status 255 before the remote command starts—such as an offline peer or refused login—on a machine with a long username or custom state-directory path, Farhelm overwrites the primary error detail with a false warning about the state directory's SSH socket path being too long and claims interactive SSH sign-in is unavailable. That check only applies to ordinary SSH hosts that store shared sockets in the helm's state directory, whereas Tailscale hosts use short socket paths in the system temporary directory and do support interactive sign-in. Only users with long local state paths hit this, but when they do, the real SSH error is buried behind misleading advice that shortening the state path cannot fix.
Template approval cards and summaries mislabel unsupported approval modes for non-shell agentsCORRECT
When an agent proposes creating or editing a launch template with an approval mode that the chosen non-shell agent does not support—or an existing template already stores one—the approval card and template list summary show that agent's default mode (such as YOLO or its guarded mode) instead of the mode actually stored. Template shape validation allows unsupported modes through, and the summary formatter resolves non-shell modes through the default-fallback helper instead of printing the saved value as it already does for shell templates. A user reviewing the card can approve a template whose saved permission differs from what they read, though the practical impact is low because the helm rejects unsupported explicit modes when the template is launched and displays custom permission flags separately.
Tensorlake setup reruns skip up-front suspended and deletion-pending refusalsCORRECT
Probing a setup rerun on a suspended or deletion-pending Tensorlake host skips the up-front refusal checks and still returns a confirmation plan instead of rejecting the request immediately. Confirming the plan catches deletion-pending hosts before changing state, but a suspended host is never refused up front: Farhelm temporarily replaces its Suspended status with a setup status, queries Tensorlake, fails the setup run once Tensorlake reports the sandbox is suspended, and triggers a reconnect. The Hosts panel hides Re-run for suspended and deleting hosts, so desktop users only hit this through a race while API callers can trigger it directly; nothing is created or lost, but it produces an avoidable failed run and confusing status flicker.
Pending shell-tab restore hides interrupted-upload notices when a session row is omittedCORRECT
When a reconnect or remount interrupts a file upload in a session that had a remembered shell tab, the visible main agent terminal holds back the interrupted-upload message while waiting for the session's listing row to arrive and settle the tab restore. If the session is absent from the pushed listing—most notably an older open session cut off by a host's 500-session listing cap—that wait never clears even after you start typing in the visible terminal, and the app-wide banner skips it because the session is still selected. This requires an uncommon combination of conditions, and no files or notices are permanently lost: clicking a tab explicitly shows the message in the terminal, and switching away from the session posts it as a notice banner.
Trash can stop showing active cleanup when a failing refresh races with a delete replyPARTIALLY CORRECT
Because Trash refreshes and deletes run concurrently without strict ordering, a refresh issued after a delete starts can fail and settle before the delete reply arrives. When that happens on a host that was previously idle, the delete handler treats the finished refresh as authoritative and skips marking the host as freeing space—and cannot recover the host's cleanup capability across the failed listing—so the Trash button stops showing active removal until the next successful refresh or reconnect. The separate claim that an unordered refresh racing ahead of a delete causes harmful stale listings when the delete does not advance the Trash epoch is overstated, because the helm advances the epoch whenever anything is actually removed, leaving no-epoch cases with an accurate listing and recorded per-item refusals.
Workspace-trust banner keeps an uncloseable save error visible after the hint is dismissedCORRECT
If clicking "Don't show again" on a workspace-trust hint fails or hits a busy preference save, the error line stays visible even after the hint is dismissed in Settings (or after an earlier in-flight dismissal succeeds following a rapid second click). Because dismissing the hint hides the banner's action buttons, including its close button, the red "Not saved" alert remains stuck above the terminal with no way to dismiss it directly. The terminal keeps working normally, and the stale line clears once you switch sessions, answer the trust prompt, or turn trust on.
Trust-hint dismissal click reads live session selection, dropping clicks on deselect and misdirecting the follow-up readPARTIALLY CORRECT
Review B (PR #4649) added three details to an existing finding about "Don't show again" reading live session selection instead of the session that drew the banner. Two hold: if selection clears before the click handler runs, the dismissal is silently dropped without saving the preference, and if selection moves to another session, the corrective trust read targets the newly open session rather than the drawn one. The third claim—that keying the save error only by session can show one agent's error under another agent's trust banner after a Replace—does not hold, because replacing a session creates a new session ID, restarting keeps the same agent type, and a single session cannot switch between different hint-showing agents.
Launcher promises folder allocation on an unverified suspended or stopped host while refusing LaunchCORRECT
On a suspended sandbox or stopped container whose installation identity has not yet been recorded (for example after an incomplete setup), the launcher refuses a managed-checkout launch as unverified before checking whether the host can wake. The folder status line and checkout summary only check whether the host can wake, so they still promise that the folder will be picked or named when the host is ready while Launch stays blocked. Launch remains safely refused so nothing is created, leaving only contradictory copy until the host completes its first verified connection.
Failed restart unwind does not persist Linux scope cleanup if the session row is already gonePARTIALLY CORRECT
When a session restart launches a replacement terminal host that fails after starting a scoped process and the supervisor cannot confirm the process tree is gone, the unwind path does not check whether the session row disappeared or queue a pending scope cleanup for the next supervisor start. If the row is absent, the session is not republished and a later supervisor restart clears the leftover launch record (or skips reclaim when the database has no sessions) without retrying the scope teardown, leaving processes running as a resource leak. The practical reachability is narrower than a normal concurrent delete: ordinary Restart and Delete share the same per-session lock, so reaching this requires an out-of-band database deletion or a lock bypass, and no user data is affected.
Waking a host that paused while YOLO confirmation was open drops the confirmation and asks againCORRECT
When the launcher shows the inline YOLO confirmation prompt and the target sandbox or container suspends or stops before you click "Start YOLO session anyway", submitting starts waking the host without carrying the one-time YOLO approval through the wake. Once the host reconnects, the launcher submits the session without confirmation, so the helm refuses it and reopens the exact same YOLO prompt. The timing window is narrow and fails safe by asking twice rather than launching without consent.
Slow failed wakes on stopped containers or repeating sandbox errors can stall 60 seconds or mislabel the failure as suspendedPARTIALLY CORRECT
When starting a stopped container or resuming a suspended sandbox takes longer than the 20-second reply bound and then fails, the launcher's wake watcher does not record that the host entered its starting or resuming phase and only recognizes a provider failure when the error text changes—which explicit container starts never update and repeated sandbox failures can keep unchanged. Without an observed connecting state, a failed stopped container waits out the full 60-second budget before claiming the host resumed and failed to connect; with a connecting state, both paths claim the host was "suspended again", misdiagnosing the failure and calling a stopped container suspended (direct container start refusals also use "Resuming" wording). Two sub-claims did not hold as stated: once a host actually connects and reaches the ready phase, a later stop reports that the host became unavailable rather than "suspended again", and a late sandbox failure normally publishes a fresh timestamp rather than stalling for 60 seconds.
Missing regression tests for Claude's home-directory trust guard and workspace-trust isolationCORRECT
Three recent workspace-trust checks lack direct test coverage: the guard that refuses to mark the user's home directory trusted for Claude is only tested as a standalone path helper rather than through the real launch wrapper process, the predicate deciding whether an agent launch pins its approval folder has no direct unit test, and the trust-switch independence test never turns on Antigravity's trust switch by itself. Without a wrapper-level test, a refactor that accidentally bypassed or reordered the home-directory guard could pass the suite and quietly mark the entire home directory trusted for Claude. No user-facing bug exists today; this is test-suite hardening.
Credential-delivery failure test still checks an obsolete Claude settings file instead of active outputsCORRECT
The unit test covering transport failures during sandbox credential delivery still asserts that ~/.claude/settings.json was not created, even though Claude credentials are now written to the supervisor's managed credentials file on fresh hosts—making that check pass vacuously. As a result, the test never verifies that Claude's actual credentials file stayed unwritten when Claude delivery failed, nor that Codex's config file stayed unwritten during Codex failures and received the rotated value after retry (since Claude's file was already updated before Codex failed). A regression that leaked partial credential writes or skipped refreshing Codex on retry could pass this test, though there is no product defect today.
Real-harness drift test passes on ignored Stop hooks after Restart for Codex and AntigravityCORRECT
The opt-in maintainer drift suite verifies that Codex and Antigravity keep reporting their conversation identity after a session Restart by checking that the resume command stays unchanged and the hook log records a new acknowledgment for the same conversation ID. Because Restart preserves the Turn-1 capture while clearing the reporting-process pin, an ignored end-of-turn Stop callback—when Codex skips verification on an already-resumable session, or when Antigravity's resumed transcript fails verification—still returns success and logs an acknowledgment carrying the inherited ID. That lets the drift check report a pass even if a Codex or Antigravity update stops firing startup hooks or changes its resumed transcript format, weakening a maintainer compatibility test without affecting normal product behavior.
Ensure-hosts startup file skips Tailscale address checks for already-registered hostsCORRECT
When the helm loads an ensure-hosts startup file (used by agent builds and tests rather than regular desktop runs), it checks basic SSH syntax for every entry up front but checks Tailscale address format only for hosts it is about to insert. Marking an already-registered host as a Tailscale host with an invalid Tailscale address therefore passes startup with no error or warning, only to fail later on a fresh database or after removing that host. When a newly inserted entry does fail the check, the startup error names the destination as an unusable SSH destination while dropping both the entry index and any explanation of the expected Tailscale address format.
Manual real-Mac reboot test helper discards the remote exit-status tagCORRECT
The opt-in real-Mac reboot measurement test builds remote commands with the tagged exit-status wrapper added for lossy SSH servers, but its helper throws away the tag and reads only the raw SSH process exit status. Against an SSH server that drops remote exit codes (such as Tailscale SSH on macOS), a refused passwordless reboot can appear to succeed and stall the test polling for up to 30 minutes, while a failed post-reboot inspection can panic with a misleading malformed-output error and leave the raw status tag in stderr. Production provisioning uses the tagged capture path and is unaffected.
Masked-input test never verifies screen-reader value suppressionCORRECT
The GUI test for masked password fields (such as the ntfy access token) checks painted text and accessible labels, but never checks the separate accessible value field or runs with accessibility active. Farhelm also masks these fields visually without explicitly declaring a password content type, so screen-reader value suppression currently relies solely on an internal mask check in the UI toolkit. Shipped builds do not leak secrets today, but a future toolkit update that changed that guard could expose typed tokens to assistive technology without failing this test.
Internal reply and operation wrappers derive Debug over JSON bodies that can carry the ntfy topicCORRECT
Farhelm deliberately omits debug formatting on its notification settings type so a user's private ntfy topic never enters diagnostic logs, but the generic UI-channel reply and GUI operation outcome wrappers auto-derive debug formatting over raw JSON bodies that carry those settings (never the access token). Unlike the request wrapper, which already uses a custom redacting debug formatter, these response wrappers would print the topic if anyone ever debug-logged them. No shipped production log call currently debug-formats either wrapper, so there is no active leak today — this is a defensive hardening gap against future logging changes.
Session pane module doc still says the helm withholds pushes during a commandCORRECT
The module documentation for the session pane still states that the helm pushes no updates to the window while a host Suspend command is in flight, even though the UI channel was changed to stream fleet updates alongside pending commands. The reconnect-card hold itself is still required because the terminal stream can drop before the pushed session state catches up, and the accompanying test comment already reflects that timing. Users are unaffected, but a contributor reading the stale module comment could misunderstand the channel ordering or mistakenly remove the hold.
Tensorlake Rust test runner reads test counts from a 60-line truncated summaryPARTIALLY CORRECT
The maintainer-only Tensorlake Rust test runner parses each passing shard's completed test count from a summary file capped at 60 sorted lines of summary, failure, and skipped-test output, even though it already copied the full console log locally. If the summary line were pushed past line 60, the runner would falsely fail the passing shard and place the sandbox on an evidence hold. Two claims in the finding did not hold as stated: the trigger is far rarer in practice because under default byte-order sorting nextest's 5-space-indented summary line sorts ahead of ordinary 4-space skipped lines (and the repository has fewer than 60 skipped-test sites across all shards anyway), and a retained sandbox does not stay running indefinitely because named sandboxes suspend after 60 seconds idle, leaving snapshot storage rather than live compute until swept.
Tensorlake test harness creates sandboxes before recording them in its cleanup ledgerCORRECT
The maintainer-only Tensorlake test harness allocates a worker sandbox on the platform before appending its name and ID to the local cleanup ledger. If the script is interrupted between creation and the ledger write, or if the write fails, neither the shard's cleanup handler nor the automatic sweep knows the sandbox exists. In practice this is a narrow failure window—already accepted in prior triage—and because named sandboxes suspend after 60 seconds idle, an untracked sandbox leaves behind billed snapshot storage that must be found by its name prefix and removed manually rather than staying running continuously.
Test-worker collect drops the worker's recorded exit status from collected evidencePARTIALLY CORRECT
When collecting a finished test-worker run's evidence after the fact, the worker script ignores the authoritative exit code saved in its completion marker, excludes that marker from the transfer, and stamps the local invocation record only as collected. As a result, a force-stopped run whose runner exited gracefully on TERM before a stubborn child was force-killed still shows the graceful exit code in its summary, and a run killed before writing a summary leaves no exit code in the collected directory at all. The broader claim that collected evidence cannot distinguish ordinary passes from failures did not hold: normal runs still carry the runner's exit code in their copied summary file.
Passing --checkout . or .. to test-worker breaks remote path and lock isolationPARTIALLY CORRECT
The maintainer-only test-worker script canonicalizes its default checkout path but stores an explicit --checkout argument verbatim before taking its basename for the remote directory. Passing --checkout . places the checkout directory at the worker root and shifts the worker-wide lock files and bootstrap marker up into the worker account's home directory, which bypasses mutual exclusion with other checkouts and forces a full re-bootstrap on every run (potentially altering shared packages while another checkout is mid-test). The sub-claim that --checkout .. also writes source and output directories directly into the worker account's home directory did not hold: worker admission fails when trying to create the shared holders directory in the parent of the home directory before source installation or output creation runs, leaving only the temporary stage (which the exit trap cleans up) and checkout lock touched.
Test-worker status does not show active worker-wide bootstrap locksCORRECT
When a maintainer test-worker run times out after 5 minutes waiting for a worker bootstrap, the error message instructs the caller to run status, yet status never checks the worker-wide bootstrap lock. Because status only inspects the calling checkout's own lock and holder file, it shows no active holder during a standalone bootstrap (which never takes a checkout lock) or during an automatic bootstrap started by a different checkout. Anyone following the timeout message cannot tell whether a slow bootstrap is legitimately running or stuck and has to retry blindly or inspect the worker host manually.
Stopping a remote test-worker run during preparation still syncs files, prunes retained runs, and marks an empty result finishedCORRECT
The remote test-worker controller checks for a stop request only once during admission, before automatic bootstrapping or source syncing. If a maintainer stops a run during bootstrap or file sync, the tests never start, but the worker still overwrites its synced checkout, creates an empty result directory, evicts the oldest of the 20 retained runs, and marks the cancelled run as finished so later collection succeeds with zero logs. This affects only internal test-worker tooling and leaves local working copies untouched, though it can push out the worker's only copy of an older retained run when 20 are already stored.
Test-worker stop reports a run ended just before the remote checkout lock is releasedPARTIALLY CORRECT
When a running remote test-worker job exits, its cleanup removes the lock ID file before deleting the stage directory and only releases the checkout lock when the shell process exits, while the stop command treats the missing lock ID as proof the run has ended. In principle an immediate follow-up run could hit a transient busy error showing an unknown holder and need a retry. Two parts of the original report did not hold: the full staged repository copy is already deleted before a run leaves preparation, so the remaining cleanup window is milliseconds rather than a large tree deletion (far shorter than a new run's upload and staging time), and the cited fixture-cleanup helper in the test suite does not launch a follow-up run.
Managed-checkout wake tests omit Replace with despite claiming full parity coverageCORRECT
The desktop launcher's parity record claims all 13 wake-on-launch cases from the old browser test suite are covered, including replacing an existing session with a managed checkout on a suspended host. In reality, all managed-checkout wake tests only launch new sessions, and the lone Replace with wake test uses an existing folder and stops at a refused resume. That gap leaves source-session locking through post-wake preview, release on preview failure behind Quick Switcher, delete-guard preservation, and the missing fresh-clone replacement warning on a suspended recent checkout uncovered.
Managed-checkout wake tests only exercise verified suspended sandboxesCORRECT
Every managed-checkout wake test in the desktop suite runs against the same verified suspended sandbox fixture, leaving unverified resumable hosts and stopped containers untested on the checkout-wake path. A separate stopped-container wake test exists for plain-folder launches, but it only covers a happy-path start without managed-checkout allocation or preview. As a result, the contradictory folder-allocation notice on unverified hosts shipped undetected, and regressions in waking a stopped container for a managed checkout would pass the suite.
Folder-wake tests omit 60-second timeout expiry, mid-wake host removal or retargeting, and completed Replace withCORRECT
The folder-wake test suite confirms that time spent in a host's resuming phase does not burn the 60-second connection budget, but never drives either the folder connection timeout or the busy-retry timeout to expiry (only the shared checkout test exercises connection expiry). It also has no coverage for a host being removed or retargeted to a different installation mid-wake, or for a Replace with launch finishing after wake with the confirmation captured at press time—its only Replace with wake test ends at a refused resume and checks only that some refusal appeared. Regressions in any of those wake safeguards would pass the suite unnoticed.