@phnx-labs/agents-cli 1.22.52 → 1.22.53

package/CHANGELOG.md

@@ -1,5 +1,151 @@
 # Changelog
 
+## 1.22.53
+
+- **Custom-harness runs launched via a profile now show their real harness name in agents sessions instead of 'claude' (PHNX-2935).**
+
+- **Watchdog un-addressable stalls now include the same recovery command as `agents focus` (PHNX-3070).**
+  Rotate, needs-human declared-block, and nudge-refuse paths append `addressabilityRecoveryHint` so an un-addressable session prints `agents sessions resume <id>` / tmux wrap instead of a reason-only skip. Source: `cli/src/lib/watchdog/runner.ts`.
+
+- **Un-addressable live sessions now surface a clear recovery hint at the point of use** — `agents focus`, `sessions inject`, and the session picker report when a bare interactive session has no addressable terminal rail (not tmux/iTerm/an IDE terminal/a pty sidecar) instead of failing silently, and the hint now names the session's real id in `agents sessions resume <id>` rather than a placeholder (PHNX-3070).
+
+- **Vitest can no longer launch the developer's browser (PHNX-3072).** `tests/setup.ts`
+  sandboxed `HOME` but not desktop-opener binaries, so a test that reached a real
+  `spawn('open' | 'xdg-open')` opened the URL on the developer's machine — green on
+  Linux CI, where `xdg-open` is absent, and disruptive locally. The harness now
+  prepends stub `open` / `xdg-open` / `gnome-open` binaries to `PATH` so a spawn
+  cannot reach the real handler; an unauthorized spawn fails the file. Source:
+  `cli/tests/opener-sandbox.ts`.
+
+- **Feed attention stamps `sourceCursor` at block-write time (PHNX-3073).**
+  `coveredByResolution` conservatively suppresses a candidate with no comparable
+  cursor when a tombstone exists, which is correct for a stale lifecycle re-read
+  but buried a genuinely new open block whenever `session.lastActivityMs` was
+  unresolvable (cloud / remote / index-lag) because neither writer stamped a
+  cursor. `buildDeclaredBlock` and the feed-publish hook now stamp
+  `sourceCursor.lastActivityMs` from the write instant, so a fresh generation
+  compares strictly newer than any prior tombstone. Source:
+  `cli/src/lib/feed/feed.ts`.
+
+- **Cursor auto-titles go through the same skill-scaffolding cleaner as Claude (PHNX-3123).**
+  `readCursorMeta` took `chatMeta.title` verbatim, so a Cursor session whose
+  server-generated title echoed the injected `Base directory for this skill: …`
+  line kept that path as `SessionMeta.label` — the field that wins on every
+  surface for the session's whole life. Claude's `ai-title` was already collapsed
+  to `/<skill>` at label composition (PR #2995); that collapse now lives in one
+  shared helper (`cleanGeneratedSessionLabel`) and Cursor's title takes the same
+  path. An ordinary Cursor title, and one that merely names a `skills/…` path,
+  is unchanged. A Claude `/rename` (`custom-title`) is still never rewritten.
+  Codex / OpenCode / Kimi / Droid put auto-titles on `topic`, not `label`, so
+  they are out of this change. **Not retroactive:** already-indexed labels stay
+  until the transcript next changes (RUSH-3122). Source:
+  `cli/src/lib/session/prompt.ts`, `cli/src/lib/session/discover.ts`.
+
+- **Traces insight engine — cross-session failure clustering + wasted time (PHNX-3141).** `agents traces sync`'s `index.json` now carries `failurePatterns[]` (top-K, ranked by wasted time, not raw occurrence count — a rare 8-hour retry loop still outranks a frequent 2-minute one), `wastedMsTotal`, and `latency` (time-to-first-tool p50/p90/p99/max). Failed `tool_calls` are grouped by `(tool, cause, normalized error)` so near-identical failures (a GitHub rate-limit message with a different countdown each time) fold into one pattern instead of a wall of near-duplicates. Per-session `SessionDetail` also gains `surfacedToolFailures` — every failed step, listed regardless of the run's overall outcome, so a session that ultimately succeeded still shows the tool failures it hit along the way. Source: `cli/src/lib/traces/insights.ts`, `cli/src/lib/traces/sync.ts`.
+
+- **Traces insight group-by dimensions (PHNX-3141).** `cli/src/lib/traces/segments.ts` derives the console bar axes — agent (model × harness), task type, failure timing — and the time-to-first-tool latency insight (`firstToolMs` p50/p90/p99/max). Pure functions; the sync integrator wires them into the shard. Source: `cli/src/lib/traces/segments.ts`.
+
+- **Native-account labels live on the central `accounts.native` rows in agents.yaml (already fleet-synced via `agents repo push/pull`). `remove`/`rename`/`label` operate on every row matching `(agent, identityKey)`, so a post-merge duplicate cannot silently survive (PHNX-3206).**
+
+- **The top-level `agents.yaml` header heals itself instead of freezing (PHNX-3315).**
+  `serializeCentral` parses the committed file to preserve its hand-written body
+  comments, but that also preserved the leading metadata header verbatim — so a
+  top-level `agents.yaml` written before the `agi-cli` rename kept its stale
+  3-line header (repo `agents-cli`, no `$schema:` line) forever while every
+  freshly-written device doc got the current header. The header is now rewritten
+  to the current `META_HEADER` on the next central write, textually (the `yaml`
+  library folds the leading comment onto the first key when that key already
+  carries a comment, so `doc.commentBefore` is unreliable), leaving body comments
+  and every config key intact, and byte-stable once healed so it never re-churns.
+  Source: `cli/src/lib/state.ts`.
+- **The legacy central `browser:` tombstone drains itself on `agents sync` (PHNX-3315).**
+  New browser profiles write the per-device doc, but profiles created before the
+  device-scoped store lingered in the shared top-level `agents.yaml` and churned
+  every fleet pull until someone ran `agents browser profiles claim` by hand.
+  `agents sync` now auto-evicts a lingering central profile into this device's
+  doc and clears it from central — but ONLY for remote (`ssh://`) profiles. An
+  `ssh://` endpoint names a specific host, so the profile is fungible by design:
+  any box resolves it to the same browser, so a concurrent cross-machine
+  double-claim is harmless. A local/`cdp://` profile has no per-machine ownership
+  signal ("that browser is installed here" is not "I hold this profile's
+  credentialed session"), so auto-claiming it would let two boxes with the same
+  common browser each claim the same tombstone and flip a credentialed profile
+  from identity-bearing to fungible fleet-wide — the exact logged-out-browser
+  failure this module exists to prevent. Local/cdp tombstones are left central for
+  an explicit `agents browser profiles claim`. The claim is selected and committed
+  inside a single meta-lock acquisition, and non-throwing (a config conflict or
+  unhostable profile is left central rather than wedging the sync). `profileRegistry` is left as the single source of truth: a
+  claimed profile lives in the device doc alone, never double-counted across two
+  stores. Source: `cli/src/lib/browser/registry.ts`, `cli/src/commands/sync.ts`,
+  `cli/src/lib/state.ts`.
+
+- **`fleet.discovery` / `fleet.ignored` are device-scoped with a union-on-read view (PHNX-3315).**
+  Every box used to rewrite one shared `fleet.discovery`/`fleet.ignored` map in the
+  top-level `agents.yaml` (each dismissal stamped `ignoredOn:<host>`), so two boxes
+  dismissing different peers produced guaranteed git line-conflicts on the next
+  pull. Each box now records ONLY its own discovery decisions and dismissals in its
+  tracked device doc (`devices/<host>/agents.yaml` `fleet:` block), and the
+  effective fleet view is recomputed as a deterministic, order-independent UNION
+  across every device doc at read time — `ignored` beats `approved` for a
+  conflicting name, and the newest `ignoredAt` wins a shared dismissal — so every
+  box computes the identical view and no box ever rewrites another's file. A
+  fold-then-delete migration moves the existing central maps into the owning box's
+  device doc before the central keys are dropped (the device-doc write lands before
+  the central strip, so a crash re-folds idempotently). `agents devices
+  register/ignore/unignore/ignored`, discovery reconcile, the sync pending-diff, and
+  `agents fleet capture` all read the union. Source:
+  `cli/src/lib/devices/{discovery-policy,registry,device-docs,config-migration}.ts`,
+  `cli/src/commands/{ssh,fleet-capture}.ts`, `cli/src/lib/state.ts`.
+- **Agent-host registrations are device-scoped (`deviceHosts`) with a merged read (PHNX-3315).**
+  Locally-discovered SSH hosts and inline registrations landed in one shared
+  `hosts:` map in the top-level `agents.yaml`, so every box that enrolled a host
+  rewrote the fleet-shared file. Registrations now write this box's device doc
+  `hosts:` block; the effective host directory is the cross-box union (newest
+  `addedAt` wins a name collision), and `remove` only edits this box's own doc. A
+  fold-then-delete migration relocates the existing central `hosts:` map into this
+  box's device doc and drops the central key. Source:
+  `cli/src/lib/hosts/{providers/local,registry,remote-os}.ts`,
+  `cli/src/lib/devices/{device-docs,config-migration}.ts`, `cli/src/lib/state.ts`.
+- **`scope:'device'` native accounts move off the shared file into the device doc (PHNX-3315).**
+  `addNativeAccount` accepted `scope:'device'` but always wrote the central
+  `accounts.native` map, so a per-box login (and its email / `identityKey` PII)
+  landed in the git-tracked, fleet-synced `agents.yaml`. A native login is
+  machine-local, so its home now follows its scope: a `scope:'device'` identity
+  (and any binding that targets it) writes this box's device doc `accounts:` block,
+  keeping its identity PII off the shared file; genuinely fleet-shared account
+  `defaults` and `scope:'version'` identities stay central. Every account reader
+  (`listNativeAccounts`, `findUnifiedAccount`, binding resolution, rename/remove)
+  merges the fleet-shared central store with this box's device slice. A
+  fold-then-delete migration relocates existing `scope:'device'` natives and their
+  bindings out of central (forward-only; no history rewrite). Source:
+  `cli/src/lib/account-registry.ts`, `cli/src/lib/devices/config-migration.ts`,
+  `cli/src/lib/state.ts`.
+
+- **`tmux.enabled` now gates remote `--device` runs too — no more forced tmux wrap (PHNX-3316).**
+  `resolveTmuxWrap` (`cli/src/lib/exec.ts`) no longer lets `remoteDispatch`
+  override the device's `tmux.enabled`: off (the default) means a followed
+  `agents run --device <host>` spawns the agent directly, with no tmux session
+  on the peer. Durability for a bare remote run comes from the existing
+  auto-reconnect in `cli/src/lib/hosts/reconnect.ts`, whose target
+  (`agents sessions focus <id> --local`) already resumes the harness session in
+  place when no pane exists — a dropped link costs the in-flight turn, not the
+  conversation. One case still wraps regardless: a followed remote run whose
+  launcher has no TTY (CI, scripts, another agent driving the CLI), where the
+  detached pane is the run's only interface.
+  `undurable` is now reached only when a wrap was actually wanted (opted-in
+  device, or the no-TTY case) but the peer has no tmux; its refusal message
+  names the `agents ssh <host> 'agents devices config <host> tmux.enabled off'`
+  alternative (the key is machine-local, so it must be set on the peer)
+  alongside `--raw`.
+  RUSH-3125's forced wrap conflated durability with an ergonomics preference
+  and wrapped boxes whose operator had explicitly left tmux off.
+  `hosts/reconnect.ts`'s header premise, the `hosts/dispatch.ts`
+  REMOTE_INTERACTIVE_ENV comments, and the `tmux.enabled` help text
+  (`device-config.ts`) are updated to match; wrap-matrix tests cover the new
+  gate.
+
+- **Share attribution bar: full-width chrome, not a floating box.** The bar was injected `position:sticky` inside `<body>`, so on a page whose body is a narrow centered column (`max-width` + `margin:auto`) it inherited that width and rendered as a floating black rectangle. It's now `position:fixed`, full viewport width, with an injected `html{padding-top}` pushing the page content down beneath it — clean top chrome on any page layout. `flex-wrap:nowrap` + left-side ellipsis keep it one line so the push height stays correct. Source: `cli/src/lib/share/worker-template.ts`.
+
 ## 1.22.52
 
 - **`agents artifacts share --visibility me|org` — identity-gated share pages (PHNX-3260).**

package/README.md

@@ -1085,7 +1085,7 @@ agents harness add deepinfra --account deepinfra
 
 One provider account **is** one `agents secrets` bundle -- `agents accounts add` creates it with secrets policy `never`, so a background agent launch on that account never raises Touch ID. `agents accounts` (no subcommand) lists provider bundles next to harness-native signed-in identities so you see both kinds of credential together; `accounts list` / `inspect <name>` / `set-key <name>` (rotate) / `rename` / `remove` manage a bundle by its stable id, independent of its current label. `accounts switch <harness>` is the fast picker over that default -- it writes the same binding as `set-default`, and balanced rotation already honors it.
 
-Harness-native OAuth logins (Claude Code's own `/login`, `codex login`, and so on) stay exactly where the harness put them -- agi-cli discovers and displays them but never copies, renames, or converts them into a provider bundle. Native `accounts name` / `attach` is only for harnesses agents-cli can isolate today (claude, codex, grok; muse when an email is present). A device-scoped login (kimi, droid, …) is refused with a named reason; provider `accounts add --provider` is unrestricted. `accounts sync <name> --device <device>` is the only way a provider account crosses machines, and it's explicit: nothing syncs automatically. Selection order for a run is explicit `--account`, then `accounts set-default` / `switch` for that harness, then the harness's native/balanced account behavior.
+Harness-native OAuth logins (Claude Code's own `/login`, `codex login`, and so on) stay exactly where the harness put them -- agi-cli discovers and displays them but never copies, renames, or converts them into a provider bundle. Native `accounts name` / `attach` is only for harnesses agents-cli can isolate today (claude, codex, grok; muse when an email is present). A device-scoped login (kimi, droid, …) is refused with a named reason; provider `accounts add --provider` is unrestricted. Native **labels** (`agents accounts label codex personal`) bind to a stable identityKey on the central account row in `agents.yaml`, which `agents repo push/pull` already syncs fleet-wide, so `codex#personal` selects the same login on every box. `accounts sync <name> --device <device>` is the only way a **provider** account credential crosses machines, and it's explicit: nothing copies OAuth automatically. Selection order for a run is explicit `--account`, then `accounts set-default` / `switch` for that harness, then the harness's native/balanced account behavior.
 
 ---
 

package/dist/commands/accounts.js

@@ -464,7 +464,7 @@ export function registerAccountsCommand(program) {
 agents accounts label codex@0.146.0 personal
 agents accounts label codex work --account you@example.com
 agents run codex#work`,
-        notes: 'The label binds to the signed-in account identity, not the version — codex#work keeps selecting that account after it moves to a newer install. One signed-in login needs no selector; with several, an interactive terminal opens a picker, while scripts pass --account or <harness>@<version>.',
+        notes: 'The label binds to the signed-in account identity, not the version — codex#work keeps selecting that account after it moves to a newer install. Labels live on the central account rows in agents.yaml, which `agents repo push/pull` already syncs fleet-wide, keyed by (agent, identityKey). One signed-in login needs no selector; with several, an interactive terminal opens a picker, while scripts pass --account or <harness>@<version>.',
     });
     accounts.command('attach <account> <target>')
         .description('Attach a named account to a native installation or custom harness')

package/dist/commands/exec.js

@@ -1569,15 +1569,19 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                             });
                         }
                     }
-                    // A network drop kills the local ssh client (exit 255) but the remote
-                    // agent survives in its detached tmux session. With a known session id
-                    // (Claude's forced id, a resumed run, or a non-Claude id we just
-                    // resolved from the remote hook record) and a tmux-hosted run,
-                    // re-attach the live pane automatically instead of exiting — the user
-                    // never has to notice the drop and `agents sessions focus` by hand.
-                    // `raw` runs aren't tmux wrapped, so there is nothing to reconnect to.
-                    // For `run auto` prefer the join-resolved id (the harness the remote
-                    // ACTUALLY picked) over the explicit --session-id only claude adopts.
+                    // A network drop kills the local ssh client (exit 255). What the
+                    // remote agent does next depends on the peer's tmux.enabled
+                    // (PHNX-3316): wrapped, it survives in its detached pane and the
+                    // reconnect rejoins it; bare (the default), the drop SIGHUPs it and
+                    // the reconnect resumes the session in place from disk. Either way,
+                    // with a known session id (Claude's forced id, a resumed run, or a
+                    // non-Claude id we just resolved from the remote hook record) we
+                    // reconnect automatically instead of exiting — the user never has
+                    // to notice the drop and `agents sessions focus` by hand.
+                    // `raw` runs opted out of all of this, so there is nothing to
+                    // reconnect to. For `run auto` prefer the join-resolved id (the
+                    // harness the remote ACTUALLY picked) over the explicit
+                    // --session-id only claude adopts.
                     const { pickReconnectTarget, reconnectInteractiveSession, afterInteractiveRemoteExit, SSH_CONN_FAILURE } = await import('../lib/hosts/reconnect.js');
                     const reconnectTarget = pickReconnectTarget({
                         agent: runAgent,
@@ -1814,6 +1818,7 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
         let accountConfigVersion;
         let profileProvider;
         let fromProfile = false;
+        let profileName;
         let profileFallbackModel;
         let workflowModel;
         // WORKFLOW.md capability scoping, translated to Claude headless flags below.
@@ -1897,6 +1902,7 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                 profileProvider = readProfile(rawAgent).provider;
                 profileFallbackModel = resolved.fallbackModel;
                 fromProfile = true;
+                profileName = resolved.profileName;
                 process.stderr.write(chalk.gray(`Resolved custom harness '${resolved.profileName}' -> ${agent}${version ? `@${version}` : ''}\n`));
                 if (resolved.tierNote) {
                     process.stderr.write(chalk.gray(`[agents] ${resolved.tierNote}\n`));
@@ -2745,6 +2751,7 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
         }
         const execOptions = {
             agent,
+            harnessName: profileName,
             version,
             configVersion: accountConfigVersion,
             prompt,

package/dist/commands/fleet-capture.js

@@ -71,6 +71,13 @@ async function runCapture(opts) {
         secretsBundles: listBundles().map((b) => b.name),
         routines: listJobs().map((j) => j.name),
     };
+    // Discovery decisions and dismissals are device-scoped now (PHNX-3315): they
+    // live in each box's device doc and sync via the repo, so `capture` must NOT
+    // hoist the cross-box union back into the shared `agents.yaml` `fleet:` block
+    // (that would recreate the N-boxes-rewrite-one-map conflict Task A removed and
+    // re-arm the fold-then-delete migration on every capture). `meta.fleet` carries
+    // only the roster/defaults; any lingering central-legacy discovery/ignored is
+    // carried forward verbatim and drained by the migration.
     const next = captureFleet(meta.fleet, inputs);
     if (opts.dryRun) {
         console.log(chalk.gray('# agents.yaml fleet: block (dry run — not written)'));

package/dist/commands/focus.js

@@ -31,6 +31,7 @@ import { multiItemPicker } from '../lib/picker.js';
 import { sessionRecoveryRunArgs } from '../lib/session/recovery.js';
 import { shellQuote, assertValidSshTarget } from '../lib/ssh-exec.js';
 import { openSurfaces, currentContext, availableBackends, detectCurrentBackend, } from '../lib/terminal/index.js';
+import { addressabilityRecoveryHint } from '../lib/terminal/resolve.js';
 import { isInteractiveTerminal, isPromptCancelled } from './utils.js';
 import { setHelpSections } from '../lib/help.js';
 const INHERITED_FOCUS_OPTIONS = [
@@ -534,6 +535,7 @@ export async function focusSelectedSession(meta, active, self) {
             return;
         }
         console.log(chalk.yellow('This live session has no session id or living attach rail to focus.'));
+        console.log(chalk.gray(addressabilityRecoveryHint(active, meta.id)));
         process.exitCode = 1;
         return;
     }

package/dist/commands/go.js

@@ -34,6 +34,7 @@ import { getDefaultSocketPath } from '../lib/tmux/paths.js';
 import { sshExec, sshStream, assertValidSshTarget, shellQuote, SSH_CONN_FAILURE_CODE } from '../lib/ssh-exec.js';
 import { connectionEndedNotice } from '../lib/hosts/reconnect.js';
 import { enumerateGhosttyTabs, assignGhosttyTabs } from '../lib/session/ghostty-tabs.js';
+import { addressabilityRecoveryHint } from '../lib/terminal/resolve.js';
 const execFileAsync = promisify(execFile);
 export function registerGoCommand(program) {
     program
@@ -318,7 +319,7 @@ export async function refuseFallback(s, remote) {
         return;
     }
     console.log(chalk.yellow(`Can't jump to ${shortId(s)} — it's in ${s.host ?? 'an unknown terminal'} with no attach rail (not tmux/Ghostty).`) +
-        chalk.gray(`\nTry: agents sessions resume ${shortId(s)}`));
+        chalk.gray(`\n${addressabilityRecoveryHint(s)}`));
     process.exitCode = 1;
 }
 export async function jumpTo(s, self, fallback = refuseFallback) {

package/dist/commands/sessions-inject.js

@@ -26,7 +26,11 @@ async function resolveTarget(sessionId) {
     const resolution = resolveInjectTargetForSession(match);
     if (!resolution.addressable) {
         // Surface the resolver's precise reason (host/rail), not a generic "not tmux".
-        return { target: null, reason: `Session "${sessionId}": ${resolution.reason}` };
+        return {
+            target: null,
+            reason: `Session "${sessionId}": ${resolution.reason}`,
+            hint: resolution.hint,
+        };
     }
     return { target: resolution.target };
 }
@@ -43,10 +47,11 @@ async function runInject(sessionId, text, options) {
     else {
         const resolved = await resolveTarget(sessionId);
         if (!resolved.target) {
+            const message = resolved.hint ? `${resolved.reason}\n${resolved.hint}` : resolved.reason;
             if (options.json)
-                console.log(JSON.stringify({ ok: false, error: resolved.reason }));
+                console.log(JSON.stringify({ ok: false, error: message }));
             else
-                console.error(chalk.red(resolved.reason));
+                console.error(chalk.red(message));
             process.exit(1);
         }
         target = resolved.target;

package/dist/commands/sessions-picker.js

@@ -9,6 +9,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import chalk from 'chalk';
 import { truncate, humanDuration } from '../lib/format.js';
+import { sessionDisplayAgent } from '../lib/session/types.js';
 import { fetchPeerPreviewDigest } from '../lib/session/remote-list.js';
 import { parseSession, sanitizeForTerminal, SNAPSHOT_TODO_TOOLS } from '../lib/session/parse.js';
 import { safeTeamText } from '../lib/session/team-filter.js';
@@ -404,7 +405,7 @@ function formatHeader(session, events) {
     const { createdAgo, lastActiveAgo, duration } = extractTiming(session, events);
     // Line 1: Agent v version · shortId · model · account
     const line1 = [];
-    line1.push(chalk.gray(`${displayAgent(session.agent)}${session.version ? ` v${session.version}` : ''}`));
+    line1.push(chalk.gray(`${displayAgent(sessionDisplayAgent(session))}${session.version ? ` v${session.version}` : ''}`));
     if (session.shortId)
         line1.push(chalk.dim(session.shortId));
     if (model)

package/dist/commands/sessions.js

@@ -18,7 +18,7 @@ import { sanitizeForTerminal, redactSecrets } from '../lib/redact.js';
 import { resolveProjectKey } from '../lib/project-key.js';
 import { listProjectDefs, resolveProjectNameForCwd } from '../lib/projects.js';
 import ora from 'ora';
-import { SESSION_AGENTS, isAgentTmuxAlias } from '../lib/session/types.js';
+import { SESSION_AGENTS, isAgentTmuxAlias, sessionDisplayAgent } from '../lib/session/types.js';
 import { discoverArtifacts, readArtifact, resolveArtifact } from '../lib/session/artifacts.js';
 import { looksLikePath, toComparablePath, homeDir, needsWindowsShell, composeWin32CommandLine } from '../lib/platform/index.js';
 import { getActiveSessions, describeActiveDiscoveryHealth, sessionProcessIsLocal, backfillActiveRowsFromIndex, isRunningLiveSession, serializeActiveSessionsForJson, serializeSessionsJson, shortIdFromName } from '../lib/session/active.js';
@@ -233,9 +233,10 @@ async function renderArtifactsForSession(session, listAll, name) {
         console.log(chalk.gray('No file-write artifacts found in this session.'));
         return;
     }
-    const agentColor = colorAgent(session.agent);
+    const shown = sessionDisplayAgent(session);
+    const agentColor = colorAgent(shown);
     console.log('');
-    console.log(agentColor(session.agent) +
+    console.log(agentColor(shown) +
         chalk.gray(` · ${session.shortId} · ${formatRelativeTime(session.timestamp)}`));
     console.log(chalk.gray('─'.repeat(72)));
     for (const a of artifacts) {
@@ -726,7 +727,8 @@ function fitCell(content, room) {
  */
 export function renderActiveRowLines(s, indent, termW) {
     const idCol = chalk.dim(padToWidth((s.sessionId?.slice(0, 8)) ?? '-', ROW_ID_W));
-    const kindCol = colorAgent(s.kind)(padToWidth(truncateToWidth(s.kind, ROW_AGENT_W), ROW_AGENT_W + 1));
+    const shownKind = sessionDisplayAgent({ agent: s.kind, harness: s.harness });
+    const kindCol = colorAgent(shownKind)(padToWidth(truncateToWidth(shownKind, ROW_AGENT_W), ROW_AGENT_W + 1));
     const versionCol = chalk.gray(padToWidth(truncateToWidth(s.version ?? '', ROW_VERSION_W), ROW_VERSION_W + 1));
     const statusCol = statusColor(s.status)(padToWidth(truncateToWidth(activityLabel(s), ROW_STATUS_W - 1), ROW_STATUS_W));
     const ownerCol = chalk.cyan(padToWidth(truncateToWidth(ownerLabel(s), ROW_OWNER_W - 1), ROW_OWNER_W));
@@ -1010,6 +1012,7 @@ export function serializeResolvedSessionsJson(sessions) {
         id: session.id,
         shortId: session.shortId,
         agent: session.agent,
+        harness: session.harness,
         origin: session.origin,
         timestamp: session.timestamp,
         lastActivity: session.lastActivity,
@@ -1805,7 +1808,8 @@ function runOutcomeDetail(meta) {
 /** Compact per-session metadata line under a linked session row. */
 function linkedSessionMeta(session) {
     const parts = [];
-    parts.push(session.version ? `${session.agent} v${session.version}` : session.agent);
+    const shown = sessionDisplayAgent(session);
+    parts.push(session.version ? `${shown} v${session.version}` : shown);
     if (session.account)
         parts.push(session.account);
     if (session.model)
@@ -2996,7 +3000,8 @@ function timeCell(age, topicSlack) {
  * when `showTicket` — otherwise a listing with no refs would waste a column of
  * dashes and needlessly truncate the topic. Worktree stays a trailing badge. */
 export function flatSessionRow(session, live, showTicket = false, cols = {}, bookmarked = false) {
-    const agentColor = colorAgent(session.agent);
+    const shown = sessionDisplayAgent(session);
+    const agentColor = colorAgent(shown);
     const age = sessionAgeParts(session.timestamp, session.lastActivity);
     const project = session.project || '-';
     const tag = originTag(session) || teamTag(session);
@@ -3045,7 +3050,7 @@ export function flatSessionRow(session, live, showTicket = false, cols = {}, boo
     const topicW = Math.max(MIN_TOPIC_W, width - fixedW - modelW - when.extraW);
     return (bookmarkCell +
         chalk.white(padToWidth(truncateToWidth(session.shortId, 9), 10)) +
-        agentColor(padToWidth(truncateToWidth(session.agent, 8), 9)) +
+        agentColor(padToWidth(truncateToWidth(shown, 8), 9)) +
         chalk.yellow(padToWidth(truncateToWidth(session.version || '-', 7), 8)) +
         (modelW ? chalk.yellow(padToWidth(truncateToWidth(modelLabel(session.model), modelW - 1), modelW)) : '') +
         machineCell +
@@ -3060,7 +3065,8 @@ export function flatSessionRow(session, live, showTicket = false, cols = {}, boo
 }
 /** One tree-mode row (grouped under a dir header): id · agent · badges · topic · time. No version/project column. */
 function treeSessionRow(session, live) {
-    const agentColor = colorAgent(session.agent);
+    const shown = sessionDisplayAgent(session);
+    const agentColor = colorAgent(shown);
     const age = sessionAgeParts(session.timestamp, session.lastActivity);
     const tag = originTag(session) || teamTag(session);
     const label = session.label;
@@ -3082,7 +3088,7 @@ function treeSessionRow(session, live) {
     const topicW = Math.max(12, baseTopicW - when.extraW);
     return ('  ' +
         chalk.dim(padToWidth(session.shortId, 9)) +
-        agentColor(padToWidth(truncateToWidth(session.agent, 7), 8)) +
+        agentColor(padToWidth(truncateToWidth(shown, 7), 8)) +
         (badges ? badges + ' ' : '') +
         (glyph ? glyph + ' ' : '') +
         statusCell +
@@ -3246,7 +3252,8 @@ const TEAM_HANDLE_W = 16;
  * identity the `--teams` view exists to show (RUSH-1997).
  */
 function teamMemberRow(session, live) {
-    const agentColor = colorAgent(session.agent);
+    const shown = sessionDisplayAgent(session);
+    const agentColor = colorAgent(shown);
     const origin = session.teamOrigin;
     const age = sessionAgeParts(session.timestamp, session.lastActivity);
     const handle = safeTeamText(origin?.handle) ?? session.shortId;
@@ -3267,7 +3274,7 @@ function teamMemberRow(session, live) {
     const topicW = Math.max(12, baseTopicW - when.extraW);
     return ('  ' +
         chalk.dim(padToWidth(session.shortId, 9)) +
-        agentColor(padToWidth(truncateToWidth(session.agent, 7), 8)) +
+        agentColor(padToWidth(truncateToWidth(shown, 7), 8)) +
         chalk.yellow(padToWidth(truncateToWidth(mode || '-', TEAM_MODE_W), TEAM_MODE_W + 1)) +
         (badges ? badges + ' ' : '') +
         (glyph ? glyph + ' ' : '') +
@@ -3444,13 +3451,14 @@ function renderArchivedSession(session, mode, options = {}) {
         }, null, 2));
         return;
     }
-    const agentColor = colorAgent(session.agent);
+    const shown = sessionDisplayAgent(session);
+    const agentColor = colorAgent(shown);
     const absTime = formatAbsoluteTime(session.timestamp);
     const title = session.label || session.topic;
     console.log('');
     if (title)
         console.log(chalk.bold.white(title));
-    console.log(agentColor(session.agent) +
+    console.log(agentColor(shown) +
         (session.version ? chalk.yellow(` ${session.version}`) : '') +
         (session.project ? chalk.cyan(`  ${session.project}`) : '') +
         chalk.gray(`  ${absTime} (${formatRelativeTime(session.timestamp)})`) +
@@ -3481,7 +3489,7 @@ async function renderSession(session, mode, filters, options = {}) {
         console.log(chalk.yellow('Session transcript not available (file no longer exists).'));
         console.log(chalk.gray(`Path: ${session.filePath}`));
         if (session.version)
-            console.log(chalk.gray(`Version: ${session.agent} ${session.version}`));
+            console.log(chalk.gray(`Version: ${sessionDisplayAgent(session)} ${session.version}`));
         if (session.project)
             console.log(chalk.gray(`Project: ${session.project}`));
         if (session.account)
@@ -3489,11 +3497,12 @@ async function renderSession(session, mode, filters, options = {}) {
         console.log(chalk.gray(`Time: ${session.timestamp}`));
         return;
     }
-    const spinner = ora(`Parsing ${session.agent} session...`).start();
+    const spinner = ora(`Parsing ${sessionDisplayAgent(session)} session...`).start();
     const parsedEvents = parseSession(session.filePath, session.agent);
     spinner.stop();
     let events = filterEvents(parsedEvents, filters);
-    const agentColor = colorAgent(session.agent);
+    const shown = sessionDisplayAgent(session);
+    const agentColor = colorAgent(shown);
     console.log('');
     if (mode === 'summary') {
         const stats = computeSummaryStats(events);
@@ -3507,7 +3516,7 @@ async function renderSession(session, mode, filters, options = {}) {
             const badges = signalBadges(metaSignals(session));
             console.log(chalk.bold.white(title) + (badges ? '  ' + badges : ''));
         }
-        console.log(agentColor(session.agent) +
+        console.log(agentColor(shown) +
             (session.version ? chalk.yellow(` ${session.version}`) : '') +
             modelStr +
             (session.project ? chalk.cyan(`  ${session.project}`) + branchStr : branchStr) +
@@ -3521,7 +3530,7 @@ async function renderSession(session, mode, filters, options = {}) {
         return;
     }
     if (mode === 'markdown') {
-        console.log(agentColor(session.agent) +
+        console.log(agentColor(shown) +
             (session.version ? chalk.yellow(` ${session.version}`) : '') +
             (session.project ? chalk.cyan(` ${session.project}`) : '') +
             chalk.gray(` ${formatRelativeTime(session.timestamp)}`) +
@@ -3662,7 +3671,8 @@ export function liveHostLabel(a) {
     return viewer && viewer !== a.host ? `${a.host}→${viewer}` : a.host;
 }
 export function formatPickerLabel(s, query, cols = {}, ssh, host = '', bookmarked = false, live) {
-    const agentColor = colorAgent(s.agent);
+    const shown = sessionDisplayAgent(s);
+    const agentColor = colorAgent(shown);
     const age = sessionAgeParts(s.timestamp, s.lastActivity);
     const project = s.project || '-';
     // SSH-launch origin (live rows only): mirrors the flat listing's `ssh←<device>`
@@ -3727,7 +3737,7 @@ export function formatPickerLabel(s, query, cols = {}, ssh, host = '', bookmarke
         // live row with no session id is named by its pid or cloud task, which can
         // run past the column and shunt every later column out of alignment.
         chalk.white(padRight(truncate(s.shortId, 9), 10)) +
-        agentColor(padRight(truncate(s.agent, 8), 9)) +
+        agentColor(padRight(truncate(shown, 8), 9)) +
         chalk.yellow(padRight(truncate(versionStr, 7), 8)) +
         machineCell +
         hostCell +

package/dist/commands/ssh.js

@@ -1136,7 +1136,7 @@ function registerDevicesCommands(program) {
     registerFleetApplyAlias(devicesCmd);
     devicesCmd
         .command('register <name>')
-        .description('Register a discovered node and sync the approval through agents.yaml fleet.discovery.')
+        .description("Register a discovered node and record the approval in this box's device doc (fleet.discovery), unioned fleet-wide.")
         .action(async (name) => {
         try {
             const nodes = parseTailscaleStatus(tailscaleStatusJson());
@@ -1145,11 +1145,20 @@ function registerDevicesCommands(program) {
                 console.error(chalk.red(`'${name}' is not a current tailscale node. See 'agents devices sync'.`));
                 process.exit(1);
             }
-            await removeIgnored(name); // a re-registered node is no longer dismissed
+            await removeIgnored(name); // clear THIS box's dismissal, if any
             const d = await upsertDevice(name, nodeToDeviceInput(node));
             setDeviceDiscoveryStatus(name, 'approved');
             clearPendingSentinel(name); // drop the notification immediately
             console.log(chalk.green(`Registered '${name}'`) + chalk.gray(` (${d.platform})`));
+            // A dismissal on another box still wins the union (ignored beats
+            // approved), so approving here does not un-dismiss it fleet-wide — say so
+            // rather than imply the node is now discoverable everywhere (PHNX-3315).
+            const otherDismissals = loadIgnoredEntries().filter((e) => e.name === name);
+            if (otherDismissals.length > 0 || getDeviceDiscoveryStatus(name) === 'ignored') {
+                const boxes = [...new Set(otherDismissals.map((e) => e.ignoredOn))].sort().join(', ') || 'another box';
+                console.error(chalk.yellow(`Note: '${name}' is still dismissed on: ${boxes}, so it stays ignored fleet-wide`) +
+                    chalk.gray(` until you run \`agents devices unignore ${name}\` there.`));
+            }
         }
         catch (err) {
             console.error(chalk.red(err.message));
@@ -1158,7 +1167,7 @@ function registerDevicesCommands(program) {
     });
     devicesCmd
         .command('ignore <name>')
-        .description('Dismiss a node and sync the decision through agents.yaml fleet.discovery (also removes it locally).')
+        .description("Dismiss a node and record the decision in this box's device doc (fleet.ignored), unioned fleet-wide (also removes it locally).")
         .action(async (name) => {
         try {
             await removeDevice(name);
@@ -1176,13 +1185,25 @@ function registerDevicesCommands(program) {
         .command('unignore <name>')
         .description('Undo `ignore`: allow a node to be discovered and registered again.')
         .action(async (name) => {
-        const portableWasIgnored = getDeviceDiscoveryStatus(name) === 'ignored';
-        const ok = await removeIgnored(name);
-        if (!ok && !portableWasIgnored) {
+        const wasIgnored = getDeviceDiscoveryStatus(name) === 'ignored' || loadIgnoredEntries().some((e) => e.name === name);
+        // A box can edit only its OWN device doc (PHNX-3315), so this clears just
+        // this box's dismissal/approval decision.
+        await removeIgnored(name);
+        setDeviceDiscoveryStatus(name, undefined);
+        // Re-evaluate the cross-box union AFTER clearing our slice: another box's
+        // dismissal keeps the node ignored fleet-wide (ignored beats approved), so
+        // never report a false "no longer ignoring" — name the box(es) to clear.
+        const remaining = loadIgnoredEntries().filter((e) => e.name === name);
+        if (remaining.length > 0 || getDeviceDiscoveryStatus(name) === 'ignored') {
+            const boxes = [...new Set(remaining.map((e) => e.ignoredOn))].sort().join(', ') || 'another box';
+            console.error(chalk.yellow(`Cleared this box's decision, but '${name}' is still dismissed on: ${boxes}.`) +
+                chalk.gray(`\nRun \`agents devices unignore ${name}\` there too to clear it fleet-wide.`));
+            return;
+        }
+        if (!wasIgnored) {
             console.error(chalk.gray(`'${name}' was not ignored.`));
             return;
         }
-        setDeviceDiscoveryStatus(name, undefined);
         console.log(chalk.green(`No longer ignoring '${name}'`) + chalk.gray(' — run `agents devices sync` to register it.'));
     });
     const ignoredCmd = devicesCmd
@@ -1219,11 +1240,13 @@ function registerDevicesCommands(program) {
       agents devices unignore old-laptop   # undo a dismissal
     `,
         notes: `
-      Dismissals live in the tracked central agents.yaml (fleet.ignored) and
-      sync with 'agents repo push/pull', so a node dismissed on one box stays
-      dismissed everywhere. An ignored node is not a device — it never enters
-      the registry, so 'agents devices list' never shows it; this command is
-      where dismissals are visible.
+      Dismissals live in each box's tracked device doc
+      (devices/<host>/agents.yaml fleet.ignored) and sync with 'agents repo
+      push/pull'; the effective list is their cross-box union, so a node
+      dismissed on one box stays dismissed everywhere without the boxes ever
+      rewriting one shared file. An ignored node is not a device — it never
+      enters the registry, so 'agents devices list' never shows it; this command
+      is where dismissals are visible.
     `,
     });
     // ─── devices config (unified settings surface) ────────────────────────────