@phnx-labs/agents-cli 1.22.51 → 1.22.53

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) ────────────────────────────

package/dist/commands/status.js

@@ -75,6 +75,11 @@ export function registerStatusCommand(syncCmd) {
         else {
             console.log(`  ${'.system repo'.padEnd(28)} ${chalk.green('up to date')}`);
         }
+        // A non-git / partial ~/.agents is its own drift state, not a per-agent
+        // "N missing" — surface it distinctly so the real problem isn't buried (PHNX-3301).
+        if (status.user.notGitRepo) {
+            console.log(`  ${'~/.agents (user repo)'.padEnd(28)} ${chalk.yellow('not a git repo — will adopt on next `agents repo sync user`')}`);
+        }
         if (status.agents.length === 0) {
             console.log(chalk.gray('  (no installed agent versions)'));
         }

package/dist/commands/sync.js

@@ -35,6 +35,8 @@ import { Option } from 'commander';
 import chalk from 'chalk';
 import { resolveSyncPassphraseFromEnv } from '../lib/secrets/sync-passphrase.js';
 import { agentLabel, resolveAgentName, MANAGED_AGENT_IDS, isAgentHardDeprecated, hardDeprecationError } from '../lib/agents.js';
+import { autoEvictCentralBrowserProfiles } from '../lib/browser/registry.js';
+import { shouldAutoClaimCentralProfile } from '../lib/browser/profiles.js';
 import { isVersionInstalled, syncResourcesToVersion, parseAgentSpec, resolveVersion, resolveVersionAlias, listInstalledVersions, healDanglingVersionPointers, getAvailableResources, getActuallySyncedResources, getProjectOnlyResources, getNewResources, hasNewResources, promptResourceSelection, promptNewResourceSelection, buildSelection, mergeRepoScopedSelections, listRepoNames, getVersionHomePath, } from '../lib/installations/versions.js';
 import { capableAgents } from '../lib/capabilities.js';
 import { parseHookManifest, registerHooksToSettings } from '../lib/hooks/install.js';
@@ -44,7 +46,7 @@ import { formatKeptProjectResources } from '../lib/project-resources.js';
 import { isInteractiveTerminal, isPromptCancelled } from './utils.js';
 import { runUmbrellaSync } from '../lib/sync-umbrella.js';
 import { addHostOption } from '../lib/hosts/option.js';
-import { syncRepoGit } from '../lib/git.js';
+import { syncRepoGit, adoptUserRepoIfNeeded, recordUserRepoRemote, resolveUserRepoRemoteUrl } from '../lib/git.js';
 import { getSystemAgentsDir, getUserAgentsDir, getEnabledExtraRepos } from '../lib/state.js';
 import { registerStatusCommand } from './status.js';
 /** Emit one JSON object to stdout for `--json` callers / fleet fan-out. */
@@ -206,6 +208,37 @@ async function runRepoGitSync(repo, quiet, outLog, errLog, json = false) {
     }
     if (!quiet && !json)
         outLog(chalk.bold(`Syncing ${repo} repo…`) + chalk.gray(` (${target.dir})`));
+    // Self-heal a non-git / partial user checkout in place before the git sync
+    // (PHNX-3301) — otherwise syncRepoGit hard-fails with "Not a git repo" and the
+    // only fix is a destructive re-clone. Only the user repo adopts: system is
+    // cloned by setup, extras by `repo add`.
+    if (repo === 'user') {
+        const adopted = await adoptUserRepoIfNeeded(target.dir);
+        if (adopted && !adopted.success) {
+            const hint = adopted.needsUrl
+                ? ' — git-back it: agents repo pull user <git-url>'
+                : '';
+            if (json) {
+                emitJson({ ok: false, mode: 'repo-git', repo, error: `${adopted.error}${hint}` });
+            }
+            else {
+                errLog(chalk.red(`sync ${repo} failed: ${adopted.error}`));
+                if (adopted.needsUrl)
+                    errLog(chalk.gray('  git-back it: agents repo pull user <git-url>'));
+            }
+            process.exitCode = 1;
+            return;
+        }
+        if (adopted?.success && !quiet && !json) {
+            outLog(chalk.green(`  adopted ${repo} in place → ${adopted.commit} (${adopted.materialized} file(s) materialized${adopted.reconciledAgentsYaml ? ', agents.yaml reconciled' : ''})`));
+            if (adopted.localEdits.length > 0) {
+                outLog(chalk.yellow(`  kept ${adopted.localEdits.length} local edit(s): ${adopted.localEdits.slice(0, 5).join(', ')}${adopted.localEdits.length > 5 ? ', …' : ''}`));
+            }
+            if (adopted.agentsYamlBackup) {
+                outLog(chalk.gray(`  saved the previous agents.yaml to ${adopted.agentsYamlBackup}`));
+            }
+        }
+    }
     const result = await syncRepoGit(target.dir, { push: target.push });
     if (!result.success) {
         if (json) {
@@ -217,6 +250,14 @@ async function runRepoGitSync(repo, quiet, outLog, errLog, json = false) {
         process.exitCode = 1;
         return;
     }
+    // Record the resolved remote so a future partial box (lost .git) can adopt in
+    // place without the operator re-typing the URL (PHNX-3301). Before the --json
+    // early-return so the record is refreshed on every healthy sync, JSON or not.
+    if (repo === 'user') {
+        const u = resolveUserRepoRemoteUrl(target.dir);
+        if (u)
+            recordUserRepoRemote(target.dir, u);
+    }
     if (json) {
         emitJson({
             ok: true,
@@ -290,12 +331,35 @@ async function runInteractiveReconcile(opts, outLog, errLog) {
         const target = resolveRepoGitTarget(repo);
         if (!target)
             continue;
+        // Adopt a non-git / partial user checkout in place before pulling (PHNX-3301).
+        if (repo === 'user') {
+            const adopted = await adoptUserRepoIfNeeded(target.dir);
+            if (adopted?.success) {
+                outLog(chalk.gray(`  adopted user in place → ${adopted.commit} (${adopted.materialized} file(s) materialized)`));
+            }
+            else if (adopted && !adopted.success) {
+                outLog(chalk.yellow(`  ! user: ${adopted.error}${adopted.needsUrl ? ' — agents repo pull user <git-url>' : ''}`));
+                continue;
+            }
+        }
         const res = await syncRepoGit(target.dir, { push: false });
-        if (res.success)
+        if (res.success) {
             outLog(chalk.gray(`  pulled ${repo} → ${res.commit}`));
+            if (repo === 'user') {
+                const u = resolveUserRepoRemoteUrl(target.dir);
+                if (u)
+                    recordUserRepoRemote(target.dir, u);
+            }
+        }
         else
             outLog(chalk.yellow(`  ! ${repo}: ${(res.error ?? 'pull failed').split('\n')[0]}`));
     }
+    // Drain the legacy central `browser:` tombstone now that the repos are pulled.
+    // Running AFTER the pull is load-bearing: it acts on a view of central that
+    // already reflects peers' drains, so it never re-claims a profile another box
+    // already migrated (which would flip that profile's kind identity->fungible).
+    // The interactive path is always non-quiet, non-json.
+    evictCentralBrowserProfilesForSync(false, false, outLog, errLog);
     // 2. One selection spanning the chosen repos.
     const selection = mergeRepoScopedSelections(repos, cwd);
     const hasResources = selection.memory === 'all' || Object.entries(selection).some(([kind, v]) => kind !== 'memory' && Array.isArray(v) && v.length > 0);
@@ -318,6 +382,36 @@ async function runInteractiveReconcile(opts, outLog, errLog) {
         }
     }
 }
+/**
+ * Drain the legacy central `browser:` tombstone during `agents sync` (PHNX-3315).
+ * New 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.
+ * Fold the ones THIS box can host into its device doc — host-gated, and the
+ * selection is computed under the meta lock (see autoEvictCentralBrowserProfiles)
+ * so it never races itself. Callers MUST invoke this AFTER the repo pull: acting
+ * on a pre-pull view of central risks re-claiming a profile a peer already
+ * drained, which would flip its kind identity->fungible. Non-fatal so a hiccup
+ * can never wedge the sync.
+ */
+function evictCentralBrowserProfilesForSync(quiet, json, outLog, errLog) {
+    try {
+        // Auto-claim ONLY remote (ssh://) tombstones — they are fungible by design,
+        // so a concurrent cross-machine double-claim is harmless. Local/cdp profiles
+        // have no per-machine ownership signal and are left central for an explicit
+        // `agents browser profiles claim` (PHNX-3315 review). See
+        // shouldAutoClaimCentralProfile.
+        const result = autoEvictCentralBrowserProfiles(shouldAutoClaimCentralProfile);
+        if (!quiet && !json && result.claimed.length > 0) {
+            outLog(chalk.gray(`  Claimed ${result.claimed.length} central browser profile(s) into this device: ${result.claimed.join(', ')}`));
+        }
+    }
+    catch (err) {
+        if (!quiet && !json) {
+            errLog(chalk.yellow(`  ! browser profile eviction skipped: ${err.message}`));
+        }
+    }
+}
 /**
  * The umbrella verb: bare `agents sync` (no agent) makes this machine current.
  * Resolves the flags + a secrets passphrase (env-only for now; tokenized auth
@@ -359,6 +453,12 @@ async function runUmbrella(opts, quiet, outLog, errLog, json = false) {
             log: (msg) => { if (!quiet && !json)
                 outLog(chalk.gray(`  ${msg}`)); },
         });
+        // Drain the legacy central `browser:` tombstone AFTER the umbrella pull, so
+        // we act on central as converged by this sync rather than a stale pre-pull
+        // copy that could re-claim a profile a peer already migrated. Skipped under
+        // --cloud (fetch-only, no local reconcile).
+        if (!opts.cloud)
+            evictCentralBrowserProfilesForSync(quiet, json, outLog, errLog);
         if (json) {
             emitJson({
                 // A refused resource is not a clean sync (RUSH-2700).

package/dist/commands/tmux.d.ts

@@ -17,9 +17,16 @@
  *   agents tmux send <name>[:pane] <keys> [--no-enter] [--raw]
  *   agents tmux capture <name>[:pane] [--lines N] [--ansi]
  *   agents tmux info <name>    [--json]
- *   agents tmux kill <name>
+ *   agents tmux kill [name]    no name → picker with live pane preview
  *   agents tmux kill-all       [--yes]
  */
 import type { Command } from 'commander';
+import { type ListedSession } from '../lib/tmux/index.js';
 /** Register the `agents tmux` command tree. */
 export declare function registerTmuxCommands(program: Command): void;
+/** Last useful line of a pane capture — what `tmux ls` shows so a name isn't a black box. */
+export declare function tmuxScreenSnippet(raw: string, max?: number): string;
+/** Last non-empty lines of a pane capture, for the kill-picker preview. */
+export declare function tmuxScreenPreview(raw: string, maxLines?: number): string;
+export declare function formatTmuxKillLabel(s: ListedSession, snippet: string, nowMs?: number): string;
+export declare function formatTmuxKillPreview(s: ListedSession, raw: string, nowMs?: number): string;

package/dist/commands/tmux.js

@@ -17,14 +17,15 @@
  *   agents tmux send <name>[:pane] <keys> [--no-enter] [--raw]
  *   agents tmux capture <name>[:pane] [--lines N] [--ansi]
  *   agents tmux info <name>    [--json]
- *   agents tmux kill <name>
+ *   agents tmux kill [name]    no name → picker with live pane preview
  *   agents tmux kill-all       [--yes]
  */
 import chalk from 'chalk';
-import { truncate } from '../lib/format.js';
+import { truncate, isInteractiveTerminal, isPromptCancelled } from '../lib/format.js';
 import * as path from 'path';
 import { setHelpSections } from '../lib/help.js';
-import { assertTmuxAvailable, attachTmux, capturePane, createSession, ensureSessionHookRepaired, getDefaultSocketPath, getTmuxVersion, hasSession, isTmuxInstalled, isTmuxVersionSupported, killAll, killSession, listSessions, MIN_TMUX_VERSION, readSessionMeta, sendKeys, splitPane, TmuxCommandError, TmuxSessionError, TmuxUnavailableError, } from '../lib/tmux/index.js';
+import { multiItemPicker } from '../lib/picker.js';
+import { assertTmuxAvailable, attachTmux, capturePane, createSession, ensureSessionHookRepaired, getDefaultSocketPath, getTmuxVersion, hasSession, isTmuxInstalled, isTmuxVersionSupported, killAll, killSession, teardownIfAgentExited, listSessions, MIN_TMUX_VERSION, readSessionMeta, sendKeys, splitPane, TmuxCommandError, TmuxSessionError, TmuxUnavailableError, } from '../lib/tmux/index.js';
 /** Register the `agents tmux` command tree. */
 export function registerTmuxCommands(program) {
     const tmux = program
@@ -47,8 +48,9 @@ export function registerTmuxCommands(program) {
       # Send a slash command from a script
       agents tmux send claude-debug "/clear"
 
-      # Clean up
+      # Clean up one by name, or pick from a list that shows each pane's last lines
       agents tmux kill claude-debug
+      agents tmux kill
     `,
         notes: `
       Storage:
@@ -145,7 +147,7 @@ export function registerTmuxCommands(program) {
     // ─── attach ─────────────────────────────────────────────────────────────────
     const attachCmd = tmux
         .command('attach <name>')
-        .description('Attach to a running session. Replaces this shell with the tmux client until you detach (Ctrl-b d).')
+        .description('Attach to a running session. Replaces this shell with the tmux client until you detach (Ctrl-b d) or the agent exits (session is then torn down).')
         .option('--socket <path>', 'Use a custom socket (default: shared server)');
     attachCmd.action(async (name, opts) => {
         await guardTmux(async () => {
@@ -163,6 +165,11 @@ export function registerTmuxCommands(program) {
             // deleted; attach-time repair is what closes the gap now (RUSH-2435).
             await ensureSessionHookRepaired(name, socket);
             const code = await attachTmux({ socket, args: ['attach-session', '-t', `=${name}`] });
+            // The v6 pane-died hook only detach-clients when a client is attached
+            // (so runInTmux can read the exit status). Attach verbs must kill the
+            // husk themselves — otherwise `tmux ls` still lists the session after
+            // the agent exits (PHNX-3293).
+            await teardownIfAgentExited(name, socket);
             process.exit(code);
         });
     });
@@ -170,25 +177,34 @@ export function registerTmuxCommands(program) {
     const listCmd = tmux
         .command('list')
         .alias('ls')
-        .description('List live tmux sessions on the shared server. Prunes stale meta files as a side effect.')
+        .description('List live tmux sessions on the shared server (name, age, last screen line). Prunes stale meta files as a side effect.')
         .option('--socket <path>', 'Use a custom socket (default: shared server)')
         .option('--json', 'Output as JSON');
     listCmd.action(async (opts) => {
         await guardTmux(async () => {
             const sessions = await listSessions({ socket: opts.socket });
-            if (opts.json) {
-                console.log(JSON.stringify(sessions));
-                return;
-            }
             if (sessions.length === 0) {
+                if (opts.json) {
+                    console.log('[]');
+                    return;
+                }
                 console.log(chalk.gray('No tmux sessions.'));
                 return;
             }
+            const screens = await captureScreens(sessions, opts.socket);
+            if (opts.json) {
+                console.log(JSON.stringify(sessions.map((s) => ({
+                    ...s,
+                    preview: tmuxScreenSnippet(screens.get(s.name) ?? ''),
+                }))));
+                return;
+            }
             for (const s of sessions) {
                 const age = formatAge(Date.now() / 1000 - s.createdAtTmux);
-                const cmd = s.meta?.cmd ? chalk.gray(`  ${truncate(s.meta.cmd, 60)}`) : '';
                 const attached = s.attached ? chalk.green(' [attached]') : '';
-                console.log(`  ${chalk.bold(s.name)}  ${s.windows}w  ${age}${attached}${cmd}`);
+                const snippet = tmuxScreenSnippet(screens.get(s.name) ?? '');
+                const preview = snippet ? chalk.gray(`  ${snippet}`) : '';
+                console.log(`  ${chalk.bold(s.name)}  ${s.windows}w  ${age}${attached}${preview}`);
             }
         });
     });
@@ -329,15 +345,35 @@ export function registerTmuxCommands(program) {
     });
     // ─── kill ───────────────────────────────────────────────────────────────────
     const killCmd = tmux
-        .command('kill <name>')
-        .description('Kill one tmux session. Idempotent — exits 0 even if the session was already gone.')
+        .command('kill [name]')
+        .description('Kill one tmux session, or pick from a list that shows each pane\'s last screen. Idempotent.')
         .option('--socket <path>', 'Use a custom socket (default: shared server)');
+    setHelpSections(killCmd, {
+        examples: `
+      # Kill by name
+      agents tmux kill ag-claude-04a1307c
+
+      # Pick from live panes — preview shows the last lines on screen
+      # (trust-folder stall, weekly-limit dialog, real work)
+      agents tmux kill
+    `,
+        notes: `
+      With no name, the picker captures each pane so you can tell a leaked
+      first-run dialog from an agent that is still working. Space multi-selects;
+      enter kills the checked rows (or the highlighted one if none are checked).
+      Ctrl-b d still keeps a live session; exiting the agent tears it down.
+    `,
+    });
     killCmd.action(async (name, opts) => {
         await guardTmux(async () => {
-            const killed = await killSession(name, opts.socket);
-            if (!killed) {
-                console.log(chalk.gray(`No session "${name}" — nothing to do.`));
+            if (name) {
+                const killed = await killSession(name, opts.socket);
+                if (!killed) {
+                    console.log(chalk.gray(`No session "${name}" — nothing to do.`));
+                }
+                return;
             }
+            await pickAndKillSessions(opts.socket);
         });
     });
     // ─── kill-all ───────────────────────────────────────────────────────────────
@@ -399,6 +435,120 @@ function collectLabel(value, acc) {
     acc[value.slice(0, eq)] = value.slice(eq + 1);
     return acc;
 }
+/** Last useful line of a pane capture — what `tmux ls` shows so a name isn't a black box. */
+export function tmuxScreenSnippet(raw, max = 72) {
+    const lines = raw
+        .split('\n')
+        .map((l) => l.replace(/\s+/g, ' ').trim())
+        .filter((l) => l.length > 0 && !/^[─═│┃┌┐└┘╰╯╭╮\s|-]+$/.test(l) && !/enter to confirm|esc to cancel|tab:next/i.test(l));
+    const tail = lines.slice(-8);
+    const preferred = [...tail].reverse().find((l) => /[?❯]|trust this folder|weekly limit|needs.you|waiting/i.test(l));
+    return truncate(preferred ?? tail[tail.length - 1] ?? '', max);
+}
+/** Last non-empty lines of a pane capture, for the kill-picker preview. */
+export function tmuxScreenPreview(raw, maxLines = 16) {
+    return raw
+        .split('\n')
+        .map((l) => l.replace(/\s+$/, ''))
+        .filter((l) => l.length > 0)
+        .slice(-maxLines)
+        .join('\n');
+}
+export function formatTmuxKillLabel(s, snippet, nowMs = Date.now()) {
+    const age = formatAge(nowMs / 1000 - s.createdAtTmux);
+    const agent = s.meta?.labels?.agent;
+    const bits = [s.name, age];
+    if (agent)
+        bits.push(agent);
+    if (snippet)
+        bits.push(snippet);
+    return bits.join('  ');
+}
+export function formatTmuxKillPreview(s, raw, nowMs = Date.now()) {
+    const age = formatAge(nowMs / 1000 - s.createdAtTmux);
+    const agent = s.meta?.labels?.agent;
+    const header = [
+        chalk.bold(s.name),
+        agent ? chalk.cyan(agent) : '',
+        chalk.gray(age),
+        s.attached ? chalk.green('attached') : chalk.gray('detached'),
+    ].filter(Boolean).join('  ');
+    const meta = [
+        s.meta?.cwd ? `cwd  ${s.meta.cwd}` : '',
+        s.meta?.cmd ? `cmd  ${truncate(s.meta.cmd, 80)}` : '',
+    ].filter(Boolean).join('\n');
+    const body = tmuxScreenPreview(raw) || chalk.gray('(empty pane)');
+    return [header, meta, '', chalk.gray('── last screen ──'), body].filter((line) => line !== '').join('\n');
+}
+async function captureScreens(sessions, socket) {
+    const rows = await Promise.all(sessions.map(async (s) => {
+        try {
+            const raw = await capturePane({ name: s.name, socket, lines: 40 });
+            return [s.name, raw];
+        }
+        catch {
+            return [s.name, ''];
+        }
+    }));
+    return new Map(rows);
+}
+async function pickAndKillSessions(socket) {
+    if (!isInteractiveTerminal()) {
+        console.error(chalk.red('Pass a session name, or run from a TTY to pick from a list with pane previews.'));
+        console.error(chalk.gray('  agents tmux ls          # names + last screen line'));
+        console.error(chalk.gray('  agents tmux kill <name>'));
+        process.exitCode = 1;
+        return;
+    }
+    const sessions = await listSessions({ socket });
+    if (sessions.length === 0) {
+        console.log(chalk.gray('No tmux sessions.'));
+        return;
+    }
+    const screens = await captureScreens(sessions, socket);
+    let chosen;
+    try {
+        chosen = await multiItemPicker({
+            message: 'Kill which tmux sessions?',
+            items: sessions,
+            filter: (q) => {
+                const needle = q.trim().toLowerCase();
+                if (!needle)
+                    return sessions;
+                return sessions.filter((s) => {
+                    const hay = [
+                        s.name,
+                        s.meta?.labels?.agent,
+                        s.meta?.cwd,
+                        s.meta?.cmd,
+                        screens.get(s.name),
+                    ].join(' ').toLowerCase();
+                    return hay.includes(needle);
+                });
+            },
+            labelFor: (s) => formatTmuxKillLabel(s, tmuxScreenSnippet(screens.get(s.name) ?? '')),
+            keyFor: (s) => s.name,
+            buildPreview: (s) => formatTmuxKillPreview(s, screens.get(s.name) ?? ''),
+            pageSize: 12,
+            emptyMessage: 'No sessions match.',
+            enterHint: 'kill',
+        });
+    }
+    catch (err) {
+        if (isPromptCancelled(err))
+            return;
+        throw err;
+    }
+    if (!chosen || chosen.length === 0)
+        return;
+    for (const s of chosen) {
+        const killed = await killSession(s.name, socket);
+        if (killed)
+            console.log(chalk.gray(`Killed ${s.name}`));
+        else
+            console.log(chalk.gray(`No session "${s.name}" — already gone.`));
+    }
+}
 function formatAge(secs) {
     if (secs < 60)
         return `${Math.max(0, Math.floor(secs))}s`;

package/dist/lib/account-registry.d.ts

@@ -34,7 +34,15 @@ export type UnifiedAccount = (CredentialAccount & {
 export declare function accountRegistryPath(base?: string): string;
 export declare function readAccountRegistry(base?: string): AccountRegistryDocument;
 export declare function findAccount(name: string, doc?: AccountRegistryDocument): CredentialAccount | null;
-export declare function listNativeAccounts(meta: Pick<Meta, 'accounts'>): NativeAccount[];
+/**
+ * Effective native accounts: the fleet-shared central store (version-scoped
+ * identities) merged with THIS box's own device doc (device-scoped identities).
+ * A native login is machine-local — its home follows its scope (PHNX-3315), so
+ * a `scope:'device'` identity is read from this box's device doc and never the
+ * shared central agents.yaml (which is where its email/identityKey PII used to
+ * accumulate). On an id collision the device slice wins.
+ */
+export declare function listNativeAccounts(meta: Pick<Meta, 'accounts' | 'deviceAccounts'>): NativeAccount[];
 /**
  * Resolve one account by name or id across both stores, native first.
  *
@@ -46,15 +54,17 @@ export declare function listNativeAccounts(meta: Pick<Meta, 'accounts'>): Native
  * running before the body, so callers that only need a native lookup must be
  * able to omit it.
  */
-export declare function findUnifiedAccount(nameOrId: string, meta: Pick<Meta, 'accounts'>, doc?: AccountRegistryDocument): UnifiedAccount | null;
+export declare function findUnifiedAccount(nameOrId: string, meta: Pick<Meta, 'accounts' | 'deviceAccounts'>, doc?: AccountRegistryDocument): UnifiedAccount | null;
 export declare function addNativeAccount(name: string, agent: AgentId, identityKey: string, identityLabel: string | undefined, scope: 'version' | 'device'): NativeAccount;
 /** Create or replace the version-independent label for one native identity. */
 export declare function labelNativeAccount(agent: AgentId, identityKey: string, identityLabel: string | undefined, label: string | undefined, scope: 'version' | 'device'): NativeAccount;
 export declare function bindAccount(nameOrId: string, target: string): UnifiedAccount;
 export declare function unbindAccount(nameOrId: string, target: string): void;
-export declare function accountBindings(accountId: string, meta: Pick<Meta, 'accounts'>): string[];
+/** Every target bound to `accountId`: this box's device-doc bindings merged over
+ * the fleet-shared central bindings (PHNX-3315). */
+export declare function accountBindings(accountId: string, meta: Pick<Meta, 'accounts' | 'deviceAccounts'>): string[];
 /** Explicit selection wins over a configured per-harness default. */
-export declare function resolveAccountSelection(explicit: string | undefined, agent: AgentId, meta: Pick<Meta, 'accounts'>, opts?: {
+export declare function resolveAccountSelection(explicit: string | undefined, agent: AgentId, meta: Pick<Meta, 'accounts' | 'deviceAccounts'>, opts?: {
     useDefault?: boolean;
     target?: string;
 }): string | undefined;
@@ -100,7 +110,7 @@ export type SpawnAccount = {
  * A native account bound to a different harness than the one being launched
  * fails loudly (EXEC-ACCOUNT-4). Returns null when nothing is selected.
  */
-export declare function resolveSpawnAccount(explicit: string | undefined, agent: AgentId, version: string | undefined, meta: Pick<Meta, 'accounts'>, opts?: {
+export declare function resolveSpawnAccount(explicit: string | undefined, agent: AgentId, version: string | undefined, meta: Pick<Meta, 'accounts' | 'deviceAccounts'>, opts?: {
     useDefault?: boolean;
     provider?: string;
     base?: string;