@phnx-labs/agents-cli 1.22.51 → 1.22.53

package/dist/commands/detach.js

@@ -123,7 +123,7 @@ function spawnHeadless(command, args, logFile) {
     });
 }
 export async function detachAction(id, opts = {}) {
-    const { self, activeById } = await gatherLiveTargets(!!opts.local, { includeCloud: true });
+    const { self, activeById } = await gatherLiveTargets(!!opts.local, { includeCloud: true, selector: id });
     const resolved = resolveOne(activeById, id);
     if ('error' in resolved) {
         console.error(chalk.red(resolved.error));

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.d.ts

@@ -16,6 +16,7 @@ import type { Command } from 'commander';
 import { probeAttachRail, type AttachRailLiveness, type UnreachableFallback } from './go.js';
 import { type ActiveSession } from '../lib/session/active.js';
 import { type SessionMeta } from '../lib/session/types.js';
+export { looksLikeTmuxAlias, resolveTmuxAliasState, shouldAttachLocalTmuxAliasBeforeFleet, type TmuxAliasState } from '../lib/session/local-tmux-attach.js';
 import { type LiveStatusFilter } from './sessions.js';
 import { openSurfaces, type Backend } from '../lib/terminal/index.js';
 /** Options for `sessions focus` — device scope + the `--active` live-state filters. */
@@ -99,16 +100,6 @@ export declare function isAttachableLiveSession(session: ActiveSession): boolean
  * ("Session transcript not available (file no longer exists). Path: ").
  */
 export declare function dedupeSessionsByLogicalId(rows: SessionMeta[], self?: string): SessionMeta[];
-export type TmuxAliasState = 'not-an-alias' | 'no-server' | 'absent' | 'dead' | 'live';
-/** Shape of the tmux alias the CLI mints for an agent session: `ag-<agent>-<shortid>`.
- * Delegates to the one canonical matcher beside the name parsers in active.ts. */
-export declare function looksLikeTmuxAlias(selector: string): boolean;
-/**
- * Classify a selector against the live tmux server. Split from the attach so the
- * decision is testable against a real tmux server without replacing the caller's
- * shell (attaching is not something a test can undo).
- */
-export declare function resolveTmuxAliasState(selector: string, socket?: string): Promise<TmuxAliasState>;
 /**
  * The session to focus once an id/identity selector has resolved across the
  * fleet. Prefer the already-gathered candidate-pool row (it carries the live

package/dist/commands/focus.js

@@ -17,8 +17,9 @@ import chalk from 'chalk';
 import { confirm } from '@inquirer/prompts';
 import { gatherLiveTargets, pickLiveTarget, pickLiveTargets, jumpTo, probeAttachRail, refuseFallback } from './go.js';
 import { sessionProcessIsLocal, sessionProcessHost, shortIdFromName } from '../lib/session/active.js';
-import { attachTmux, ensureSessionHookRepaired, getDefaultSocketPath, hasSession, runTmux } from '../lib/tmux/index.js';
 import { isAgentTmuxAlias } from '../lib/session/types.js';
+import { attachLocalLiveSelector } from '../lib/session/local-tmux-attach.js';
+export { looksLikeTmuxAlias, resolveTmuxAliasState, shouldAttachLocalTmuxAliasBeforeFleet } from '../lib/session/local-tmux-attach.js';
 import { buildSessionRecoveryCommand, filterSessionsByQuery, formatLiveStatusHeadline, formatPickerLabel, isRunningLiveSession, pickerColumnsFor, resumeSessionInPlace, resolveSessionMetadataValue, resolveSessionAgentName, requestedLiveStatuses, } from './sessions.js';
 import { resolveBackend, CONFIRM_THRESHOLD } from './sessions-resume.js';
 import { runOnPeer } from '../lib/session/remote-list.js';
@@ -30,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 = [
@@ -221,6 +223,18 @@ export async function focusAction(id, opts) {
             process.exitCode = 1;
             return;
         }
+        // A live local tmux alias — or a bare 8-hex short id naming exactly one
+        // live local pane — attaches immediately, before any fleet SSH.
+        // `collectSessionCandidates` fans out twice (transcript pool + live
+        // roster), so a selector that is already a pane on THIS box used to print
+        // two unreachable-device lists and stall on offline peers (~2 min measured
+        // on yosemite-s0 for `sessions resume ag-claude-0145ab8f --attach-only`)
+        // and only then attach. SES-41 / PHNX-3292: an alive `ag-<agent>-<8hex>`
+        // pane is attached by name; the pane is sufficient, no fleet SSH needed. A
+        // dead/absent pane falls through to id resolution.
+        if (await attachLocalLiveSelector(textSelector, hosts)) {
+            return;
+        }
         // RUSH-2477: an id selector for a LOCAL indexed session resolves against the
         // WAL index alone — a plain read, no write-heavy discovery scan (none of
         // `tryClaimScan`/`releaseScan`'s `BEGIN IMMEDIATE` writer lock) and no
@@ -268,12 +282,6 @@ export async function focusAction(id, opts) {
         let exact = idSelector
             ? dedupeSessionsByLogicalId(sessions.filter((session) => session.id.toLowerCase().startsWith(idSelector)), self)
             : [];
-        // A tmux alias naming a LIVE local session attaches directly. This must run
-        // before the metadata resolver: that resolver treats an unmatched alias as a
-        // keyword query, so `ag-kimi-632c1fbc` came back as 13 unrelated text hits
-        // while the pane was alive and attachable the whole time.
-        if (exact.length === 0 && textSelector && !hosts.length && await attachLiveTmuxAlias(textSelector))
-            return;
         // Not live (or remote-scoped): an alias still carries the session's shortid,
         // so resolve by THAT rather than handing the whole `ag-<agent>-<shortid>`
         // string to the resolver — which treats an unmatched alias as a keyword
@@ -396,25 +404,6 @@ function looksLikeIdentitySelector(selector) {
     return !!selector && (/^[0-9a-f][0-9a-f-]{5,}$/i.test(selector) ||
         isAgentTmuxAlias(selector));
 }
-/**
- * Attach a live tmux session named exactly as the selector, without needing the
- * session index to know anything about it.
- *
- * SES-41 requires a `ag-<agent>-<8hex>` tmux alias to resolve, but the alias's
- * hex is the LAUNCH id, not the harness session id, and for a harness that
- * writes no `state/sessions/<pid>.json` record there is no mapping back to a
- * SessionMeta at all. Measured on yosemite-s0: `--resolve ag-kimi-632c1fbc`
- * fell through to a keyword search and returned 13 unrelated rows, while the
- * pane itself was alive (`%124`, `kimi-code`). The pane is the thing the user
- * asked for, and its NAME is sufficient to attach it — so an unattributable
- * session is still reachable instead of being a dead end that forces raw
- * `tmux -S … attach`.
- *
- * Returns false when this is not an alias, the server/session is absent, or
- * every pane is dead — the caller then continues to normal id resolution.
- * SES-39's "re-read `pane_dead` immediately before attach" is honoured here:
- * liveness is queried at attach time, not read from the roster.
- */
 /**
  * Rank two rows that are the same logical session, best first.
  *
@@ -447,59 +436,6 @@ export function dedupeSessionsByLogicalId(rows, self) {
     }
     return [...byId.values()];
 }
-/** Shape of the tmux alias the CLI mints for an agent session: `ag-<agent>-<shortid>`.
- * Delegates to the one canonical matcher beside the name parsers in active.ts. */
-export function looksLikeTmuxAlias(selector) {
-    return isAgentTmuxAlias(selector);
-}
-/**
- * Classify a selector against the live tmux server. Split from the attach so the
- * decision is testable against a real tmux server without replacing the caller's
- * shell (attaching is not something a test can undo).
- */
-export async function resolveTmuxAliasState(selector, socket) {
-    if (!looksLikeTmuxAlias(selector))
-        return 'not-an-alias';
-    const sock = socket ?? getDefaultSocketPath();
-    if (!fs.existsSync(sock))
-        return 'no-server';
-    if (!(await hasSession(selector, sock).catch(() => false)))
-        return 'absent';
-    const panes = await runTmux({
-        socket: sock,
-        args: ['list-panes', '-t', `=${selector}`, '-F', '#{pane_dead}'],
-    }).catch(() => undefined);
-    const states = (panes?.stdout ?? '').split('\n').map(s => s.trim()).filter(Boolean);
-    return states.some(d => d === '0') ? 'live' : 'dead';
-}
-async function attachLiveTmuxAlias(selector) {
-    const socket = getDefaultSocketPath();
-    if (await resolveTmuxAliasState(selector, socket) !== 'live')
-        return false;
-    if (!process.stdout.isTTY) {
-        console.error(chalk.red(`"${selector}" is a live tmux session, but attaching needs a TTY.`));
-        console.error(chalk.gray(`  Run it from a terminal, or: agents tmux attach ${selector}`));
-        process.exitCode = 1;
-        return true;
-    }
-    // Already inside a tmux client on this socket — which is the normal state for
-    // an interactive agent session here — MOVE that client instead of nesting a
-    // second one. jumpTo (go.ts) does the same; attaching from inside tmux
-    // otherwise stacks clients rather than taking you to the session.
-    if (process.env.TMUX) {
-        await runTmux({ socket, args: ['switch-client', '-t', `=${selector}`], throwOnError: false }).catch(() => { });
-        console.log(chalk.gray(`Switched this tmux client to ${selector}.`));
-        return true;
-    }
-    console.log(chalk.gray(`Attaching ${selector} — Ctrl-b d to detach.`));
-    // Repair a legacy/stale pane-died hook before handing the session to an
-    // attach client — the 5-min daemon reconcile that used to cover this was
-    // deleted; attach-time repair is what closes the gap now (RUSH-2435).
-    await ensureSessionHookRepaired(selector, socket);
-    const code = await attachTmux({ socket, args: ['attach-session', '-t', `=${selector}`] });
-    process.exitCode = code;
-    return true;
-}
 function hasFocusFilters(opts, statuses) {
     return statuses.length > 0 || !!(opts.active || opts.local || opts.device?.length || focusOptionAgent(opts) ||
         opts.all || opts.teams || opts.inTeam || opts.routine || opts.project || opts.skill || opts.plugin ||
@@ -599,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.d.ts

@@ -29,6 +29,28 @@ export declare function filterLivePool(sessions: ActiveSession[], opts?: {
     hosts?: string[];
     statuses?: LiveStatusFilter[];
 }): ActiveSession[];
+/**
+ * Live rows whose session id starts with `selector` (case-insensitive prefix).
+ * Same match `resolveOne` uses, so skip-fleet and resolve stay aligned.
+ */
+export declare function localLiveSelectorMatches(sessions: ActiveSession[], selector: string): ActiveSession[];
+/**
+ * Skip `gatherRemoteActive` when local already answered the selector:
+ * two local matches fail closed without waiting for a sleeping peer that
+ * might collide; a single local hit skips only when the selector is a full
+ * UUID or unique-enough 8-hex (`isUniqueEnoughSelector`). A shorter unique
+ * local prefix still races the fleet so a remote collision can fail closed.
+ * Zero matches still race the fleet.
+ */
+export declare function shouldSkipRemoteSweep(localMatches: ActiveSession[], selector: string): boolean;
+/**
+ * First-hit abort predicate for a live-id fleet race. A full UUID is globally
+ * unique so the first exact hit is the only hit. A unique-enough live prefix
+ * (8+ chars, the tmux `ag-<agent>-<8hex>` short id) aborts remaining SSH once
+ * a reachable peer answers — unanswered boxes must not delay (PHNX-3298).
+ * Shorter prefixes stay all-settle.
+ */
+export declare function isDefinitiveLiveMatch(session: ActiveSession, selector: string): boolean;
 /**
  * Live jump targets (local + remote), keyed by session id. Cloud is excluded by
  * default (it has no local pid to attach), but `detach` opts in with
@@ -38,11 +60,15 @@ export declare function filterLivePool(sessions: ActiveSession[], opts?: {
  * `hosts` scopes the sweep to named devices — the fan-out only dials them, and the
  * pool is then filtered to `s.machine ∈ hosts` so a stray local row can't leak in.
  * `statuses` narrows to the live-state words `--active` uses (orphan/crashed/…).
+ * `selector` (detach/stop) skips fleet SSH when local already has a unique live
+ * id or a local collision; omit it for browse (`focus` with no id) so the picker
+ * still all-settles.
  */
 export declare function gatherLiveTargets(local: boolean, opts?: {
     includeCloud?: boolean;
     hosts?: string[];
     statuses?: LiveStatusFilter[];
+    selector?: string;
 }): Promise<{
     self: string;
     activeById: Map<string, ActiveSession>;

package/dist/commands/go.js

@@ -18,21 +18,23 @@ import path from 'path';
 import { execFile } from 'child_process';
 import { promisify } from 'util';
 import { getActiveSessions, findSessionFileForKind, sessionProcessIsLocal, sessionProcessHost } from '../lib/session/active.js';
+import { isSessionIdShape } from '../lib/session/pid-registry.js';
 import { gatherRemoteActive } from '../lib/session/remote-active.js';
 import { discoverSessions } from '../lib/session/discover.js';
 import { deriveShortId } from '../lib/session/short-id.js';
-import { dedupeByMachineSession, mergeLocalFirst, pickSessionInteractive, matchesLiveStatus, filterSessionsByQuery, formatPickerLabel, pickerColumnsFor, } from './sessions.js';
+import { dedupeByMachineSession, mergeLocalFirst, pickSessionInteractive, matchesLiveStatus, filterSessionsByQuery, formatPickerLabel, pickerColumnsFor, isUniqueEnoughSelector, } from './sessions.js';
 import { buildPreview } from './sessions-picker.js';
 import { multiItemPicker } from '../lib/picker.js';
 import { isPromptCancelled } from './utils.js';
 import { focusAction } from './focus.js';
 import { machineId } from '../lib/session/sync/config.js';
 import { attachTmux, runTmux } from '../lib/tmux/binary.js';
-import { ensureSessionHookRepaired, paneExitStatus } from '../lib/tmux/session.js';
+import { ensureSessionHookRepaired, paneExitStatus, teardownIfAgentExited } from '../lib/tmux/session.js';
 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
@@ -64,6 +66,50 @@ export function filterLivePool(sessions, opts = {}) {
     }
     return out;
 }
+/**
+ * Live rows whose session id starts with `selector` (case-insensitive prefix).
+ * Same match `resolveOne` uses, so skip-fleet and resolve stay aligned.
+ */
+export function localLiveSelectorMatches(sessions, selector) {
+    const q = selector.toLowerCase();
+    return sessions.filter((s) => (s.sessionId ?? '').toLowerCase().startsWith(q));
+}
+/**
+ * Skip `gatherRemoteActive` when local already answered the selector:
+ * two local matches fail closed without waiting for a sleeping peer that
+ * might collide; a single local hit skips only when the selector is a full
+ * UUID or unique-enough 8-hex (`isUniqueEnoughSelector`). A shorter unique
+ * local prefix still races the fleet so a remote collision can fail closed.
+ * Zero matches still race the fleet.
+ */
+export function shouldSkipRemoteSweep(localMatches, selector) {
+    if (localMatches.length >= 2)
+        return true;
+    if (localMatches.length === 1)
+        return isUniqueEnoughSelector(selector);
+    return false;
+}
+/**
+ * First-hit abort predicate for a live-id fleet race. A full UUID is globally
+ * unique so the first exact hit is the only hit. A unique-enough live prefix
+ * (8+ chars, the tmux `ag-<agent>-<8hex>` short id) aborts remaining SSH once
+ * a reachable peer answers — unanswered boxes must not delay (PHNX-3298).
+ * Shorter prefixes stay all-settle.
+ */
+export function isDefinitiveLiveMatch(session, selector) {
+    const id = (session.sessionId ?? '').toLowerCase();
+    const q = selector.trim().toLowerCase();
+    if (!id || !q)
+        return false;
+    if (isSessionIdShape(q))
+        return id === q;
+    return q.length >= 8 && id.startsWith(q);
+}
+function liveSelectorEarlyExit(selector) {
+    if (!selector || !isUniqueEnoughSelector(selector))
+        return undefined;
+    return { isDefinitive: (item) => isDefinitiveLiveMatch(item, selector) };
+}
 /**
  * Live jump targets (local + remote), keyed by session id. Cloud is excluded by
  * default (it has no local pid to attach), but `detach` opts in with
@@ -73,6 +119,9 @@ export function filterLivePool(sessions, opts = {}) {
  * `hosts` scopes the sweep to named devices — the fan-out only dials them, and the
  * pool is then filtered to `s.machine ∈ hosts` so a stray local row can't leak in.
  * `statuses` narrows to the live-state words `--active` uses (orphan/crashed/…).
+ * `selector` (detach/stop) skips fleet SSH when local already has a unique live
+ * id or a local collision; omit it for browse (`focus` with no id) so the picker
+ * still all-settles.
  */
 export async function gatherLiveTargets(local, opts = {}) {
     const self = machineId();
@@ -81,9 +130,16 @@ export async function gatherLiveTargets(local, opts = {}) {
         if (!s.machine)
             s.machine = self;
     let active = localActive;
-    if (!local) {
+    const skipRemote = local || (opts.selector
+        ? shouldSkipRemoteSweep(opts.hosts?.length
+            ? filterLivePool(localLiveSelectorMatches(localActive, opts.selector), { hosts: opts.hosts })
+            : localLiveSelectorMatches(localActive, opts.selector), opts.selector)
+        : false);
+    if (!skipRemote) {
         try {
-            const remote = await gatherRemoteActive(opts.hosts);
+            const remote = await gatherRemoteActive(opts.hosts, {
+                earlyExit: liveSelectorEarlyExit(opts.selector),
+            });
             active = dedupeByMachineSession([...localActive, ...remote.sessions]);
         }
         catch { /* remote sweep is best-effort */ }
@@ -263,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) {
@@ -320,7 +376,10 @@ export async function jumpTo(s, self, fallback = refuseFallback) {
         // attach-time repair is what closes the gap now (RUSH-2435).
         if (session)
             await ensureSessionHookRepaired(session, socket);
-        process.exit(await attachTmux({ socket, args: ['attach-session', '-t', tgt] }));
+        const code = await attachTmux({ socket, args: ['attach-session', '-t', tgt] });
+        if (session)
+            await teardownIfAgentExited(session, socket);
+        process.exit(code);
     }
     // Path A: local Ghostty — focus its tab (Cmd+N via System Events).
     if (s.host === 'ghostty') {

package/dist/commands/monitors.js

@@ -358,8 +358,8 @@ async function guardAgainstDuplicateMonitor(config, force) {
     // different arguments (another PR) are not a clash and still pass.
     if (process.env[NO_MONITOR_FANOUT_ENV])
         return;
-    const fleet = await gatherFleetMonitors();
     const mine = monitorFingerprint(config);
+    const fleet = await gatherFleetMonitors({ againstFingerprint: mine });
     const clash = fleet.monitors.find((r) => monitorFingerprint(r.monitor) === mine);
     if (clash) {
         stderrLine(chalk.red(`Monitor '${clash.monitor.name}' on ${chalk.bold(clash.machine)} already watches this exact source and fires the same action.`));

package/dist/commands/repo.js

@@ -29,7 +29,7 @@ function resolveRepoPath(target) {
     return path.join(HOME, `.agents-${trimmed}`);
 }
 import { applyExtraAliasToVersions, ensureAgentsDir, getExtraRepoDir, getSystemAgentsDir, getUserAgentsDir, readMeta, resolveExtraRepoDir, updateMeta, } from '../lib/state.js';
-import { parseSource, pullRepo, commitAndPush, isGitRepo, isSystemRepoOrigin, adoptRepo, getRemoteUrl, sameGitRemote, displayHomePath, syncRepoGit, } from '../lib/git.js';
+import { parseSource, pullRepo, commitAndPush, isGitRepo, isSystemRepoOrigin, adoptRepo, adoptUserRepoIfNeeded, recordUserRepoRemote, resolveUserRepoRemoteUrl, getRemoteUrl, sameGitRemote, displayHomePath, syncRepoGit, } from '../lib/git.js';
 import { DEFAULT_SYSTEM_REPO } from '../lib/types.js';
 import { ALL_AGENT_IDS, isAgentName, resolveAgentName } from '../lib/agents.js';
 import { refresh } from '../lib/refresh.js';
@@ -1126,8 +1126,33 @@ Examples:
         }
         for (const t of targets) {
             if (!fs.existsSync(t.dir) || !isGitRepo(t.dir)) {
-                console.log(chalk.yellow(`  ${t.alias}: not a git repo, skipping`));
-                continue;
+                // The user repo self-heals in place instead of being skipped: adopt a
+                // non-git / partial checkout against its remote, preserving runtime
+                // state, then fall through to the normal sync (PHNX-3301). System is
+                // cloned by setup and extras by `repo add`, so those still skip.
+                if (t.alias === 'user' && fs.existsSync(t.dir)) {
+                    const spinner = ora(`Adopting ${formatRepoTarget(t.alias, t.dir)} in place...`).start();
+                    const adopted = await adoptUserRepoIfNeeded(t.dir);
+                    if (!adopted || !adopted.success) {
+                        spinner.fail(`${formatRepoTarget(t.alias, t.dir)}: ${adopted?.error ?? 'adopt failed'}`);
+                        if (adopted?.needsUrl)
+                            console.log(chalk.gray('  git-back it: agents repo pull user <git-url>'));
+                        process.exitCode = 1;
+                        continue;
+                    }
+                    spinner.succeed(`${formatRepoTarget(t.alias, t.dir)}: adopted in place → ${adopted.commit} (${adopted.materialized} file(s) materialized${adopted.reconciledAgentsYaml ? ', agents.yaml reconciled' : ''})`);
+                    if (adopted.localEdits.length > 0) {
+                        console.log(chalk.yellow(`  kept ${adopted.localEdits.length} local edit(s): ${adopted.localEdits.slice(0, 5).join(', ')}${adopted.localEdits.length > 5 ? ', …' : ''}`));
+                    }
+                    if (adopted.agentsYamlBackup) {
+                        console.log(chalk.gray(`  saved the previous agents.yaml to ${adopted.agentsYamlBackup}`));
+                    }
+                    // Now a git repo — fall through to the normal sync below.
+                }
+                else {
+                    console.log(chalk.yellow(`  ${t.alias}: not a git repo, skipping`));
+                    continue;
+                }
             }
             const push = t.alias !== 'system';
             const spinner = ora(`Syncing ${formatRepoTarget(t.alias, t.dir)}...`).start();
@@ -1136,6 +1161,9 @@ Examples:
                 const pushed = result.pushed ? ' (pushed)' : '';
                 spinner.succeed(`${formatRepoTarget(t.alias, t.dir)}: ${result.commit}${pushed}`);
                 if (t.alias === 'user') {
+                    const u = resolveUserRepoRemoteUrl(t.dir);
+                    if (u)
+                        recordUserRepoRemote(t.dir, u);
                     const { reconcileDeviceDiscoveryPolicies } = await import('../lib/devices/discovery-policy.js');
                     await reconcileDeviceDiscoveryPolicies();
                 }

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-resume.d.ts

@@ -22,6 +22,7 @@ export interface ResumeOptions extends StrictResumeOptions {
     local?: boolean;
 }
 export declare function registerSessionsResumeCommand(sessionsCmd: Command): void;
+export declare function sessionsResumeAction(query: string | undefined, prompt: string | undefined, options: ResumeOptions): Promise<void>;
 /** IDs and tmux aliases are actions, not picker search text. Human phrases keep
  * the existing pre-filtered picker, while an explicit identity resumes directly. */
 export declare function isDirectResumeSelector(query: string): boolean;

package/dist/commands/sessions-resume.js

@@ -28,6 +28,7 @@ import { looksLikeSessionId } from '../lib/session/discover.js';
 import { machineId } from '../lib/session/sync/config.js';
 import { sessionOriginDevice, sessionRecoveryDestinationMatches } from '../lib/session/recovery.js';
 import { runStrictResume, wantsStrictResume } from './resume.js';
+import { attachLocalLiveSelector } from '../lib/session/local-tmux-attach.js';
 /** Opening more than this many live sessions at once asks for confirmation first. */
 export const CONFIRM_THRESHOLD = 5;
 export function registerSessionsResumeCommand(sessionsCmd) {
@@ -101,7 +102,7 @@ export function registerSessionsResumeCommand(sessionsCmd) {
         await sessionsResumeAction(query, prompt, options);
     });
 }
-async function sessionsResumeAction(query, prompt, options) {
+export async function sessionsResumeAction(query, prompt, options) {
     const strictOpts = {
         mode: options.mode,
         interactive: options.interactive,
@@ -115,8 +116,18 @@ async function sessionsResumeAction(query, prompt, options) {
     // must go through sessions focus so they cannot silently fork a copy
     // (AGI EXT still shells `sessions resume <id> --local`).
     if (query && (isDirectResumeSelector(query) || wantsStrictResume(prompt, strictOpts))) {
+        const hosts = options.device ? [options.device] : [];
+        // PHNX-3292: a live LOCAL tmux pane (the exact alias, or a unique 8-hex
+        // short id) attaches immediately, before any fleet SSH — the product rule
+        // is "first unique match wins," and a pane already on this box is the
+        // fastest possible match. This applies to bare resume too, not just
+        // `--attach-only`: a prompt/mode/headless/cwd override still means the
+        // caller wants strict resume semantics (a scripted continue), so that
+        // case is excluded via wantsStrictResume.
+        if (!wantsStrictResume(prompt, strictOpts) && await attachLocalLiveSelector(query.trim(), hosts)) {
+            return;
+        }
         if (resumeUsesLifecycleDispatch(query, prompt, options)) {
-            const hosts = options.device ? [options.device] : [];
             await dispatchSessionLifecycleInPlace(query.trim(), hosts, !!options.attachOnly, !!options.local);
             return;
         }

package/dist/commands/sessions-stop.js

@@ -32,7 +32,7 @@ export function registerSessionsStopCommand(program) {
     });
 }
 export async function stopSessionAction(id, opts = {}) {
-    const { self, activeById } = await gatherLiveTargets(!!opts.local, { includeCloud: true });
+    const { self, activeById } = await gatherLiveTargets(!!opts.local, { includeCloud: true, selector: id });
     const resolved = resolveOne(activeById, id);
     if ('error' in resolved) {
         console.error(chalk.red(resolved.error));