@phnx-labs/agents-cli 1.22.82 → 1.22.84

package/CHANGELOG.md

@@ -1,5 +1,52 @@
 # Changelog
 
+## 1.22.84
+
+- **`agents feed watch` is cheap enough to leave running (PHNX-3939).** The watcher
+  cost ~42% of a core steadily on a box with 1,437 activity logs / 64 MB, because
+  every 500 ms tick re-read and re-parsed the whole activity corpus and re-read
+  every row's block, resolution, and PR status. It now keeps a per-file cursor and
+  reads only the bytes appended since the last tick (`ActivityStream`), and
+  reconciles attention only when something announced a change — a block or
+  resolution written under the feed dir, watched directly — or when the 45 s
+  PR-status TTL has expired. Measured on the same box over 5 minutes, steady
+  state: `--local` **41.9% → 0.31% CPU** (RSS 313 MB → 140 MB) and the full
+  13-peer fleet fan-out **50.0% → 0.37% CPU** (RSS 606 MB → 143 MB), with an
+  identical envelope stream. Source: `cli/src/lib/feed/activity-stream.ts`,
+  `cli/src/lib/feed/watch.ts`.
+
+- **A fleet peer that cannot be reached no longer gets a fresh `ssh` every few
+  seconds (PHNX-3939).** `agents feed watch` and `agents sessions watch` respawned
+  each peer's `--local` subscription on a bare 2 s timer with the child's stderr
+  discarded, so an offline box burned a ConnectTimeout-plus-2s cycle for the whole
+  life of the watcher and reported only `ssh exited 255`. Both fan-outs now share
+  one implementation with per-peer exponential backoff (2 s doubling to a 60 s
+  cap, reset on a healthy protocol event), the peer's own stderr surfaced as the
+  `unavailable` reason, and a peer parked after three consecutive failed spawns
+  until the device registry changes or the capped delay elapses. Source:
+  `cli/src/lib/session/remote/peer-stream.ts`.
+
+- **`agents accounts connect` refuses on a worker before any install or browser login (PHNX-3940).** A worker never runs an interactive OAuth flow (credential-management.md invariant 7). On a non-headed device (`worker` or unmarked), connect throws and does nothing — no slot, no install, no browser. Add the account on a personal/desktop box; workers are provisioned from the durable credential. Source: `cli/src/lib/accounts/connect.ts`.
+
+- **Every session row carries the request the agent was given and a timeline of what it did (PHNX-3939).** `agents sessions --active --json`, `sessions watch --json`, `feed watch --json`, history rows and the fleet session mirror gain three optional fields: `request` (the LATEST genuine user turn, tidied — the user's own sentence, with screenshot/clip paths, `@dir` mentions and pasted terminal echo pulled out into `attachments` / `pastedLines`, never rewritten), `timeline` (narration-anchored steps — one per line the agent said, with the tool calls under it folded into per-verb counts, failures, blocked calls and milestones; the last 8 in full plus a counter for everything older), and `files` (the paths the session created / modified / deleted, from the harness's own ledger where it keeps one). The fold is deterministic and needs no model; the optional summarizer now takes the narration as input and stays off by default. Computed by the daemon inside its existing reader-gated 15s tick, reading only the bytes each transcript grew by, and cached in the new stamp-validated `session_timelines` table — zero cost on the request path. Source: `cli/src/lib/session/timeline.ts`, `cli/src/lib/session/timeline-pass.ts`, `cli/src/lib/session/db.ts`.
+- **A `/model` echo or a skill body can no longer become a session's title (PHNX-3939).** `extractSessionTopic` consulted a shorter skip list than `cleanFirstUserMessage`, so harness scaffolding — `<local-command-stdout>`, `Base directory for this skill:`, hook feedback, `<hook_result>`, `<notification>` — became a session's topic and then its displayed name. The two lists are now one, and the row title / `userPromptClean` are derived from the raw latest genuine user turn (with the row's attachments in hand) instead of the already-collapsed topic. Source: `cli/src/lib/session/prompt.ts`, `cli/src/lib/session/active.ts`.
+- **`agents sessions trace <id> --steps` prints the step list the sidebar shows.** The same fold as the session row, as text: `NN  +MMs  source  headline  · 6 run · 2 blocked · worktree created`, with a totals footer. The CLI door to the timeline for an agent working without the extension. Source: `cli/src/commands/sessions-trace.ts`.
+- **The parser keeps the per-tool label every harness writes (PHNX-3939).** Claude's Bash `input.description`, Kimi's `tool.call.description`, OpenCode's `state.input.description` / `state.title` and Codex's parsed command now ride the normalized `SessionEvent` as `label`, so a live row's now-line reads as the sentence the model wrote for it instead of a re-derived command summary. Codex additionally gains a reader for its typed `item_completed` stream (`AgentMessage` phase, `parsed_cmd`, `FileChange`, `Extension`, `SubAgentActivity`, `ImageView`, `ContextCompaction`) — kept separate from `parseCodexContent` because the two describe the same turn, and an unknown item type folds to a counted call rather than throwing. Claude permission/hook denials are now distinguished from command failures (`blocked` vs `failed`). Source: `cli/src/lib/session/parse.ts`.
+- **`sessions watch` history rows cover every transcript-writing harness.** `readPreviousSessionsForWatch` queried only claude/codex/muse/opencode, so a Kimi, Grok, Cursor or Droid session never appeared as a Previous row. Source: `cli/src/lib/session/remote/watch.ts`.
+- **The timeline redacts and de-escapes the transcript text it ships.** `projectTimeline` is the single place folded text leaves the fold, so step headlines, the now-line and milestone marks now run through `redactSecrets` (on by default; `sessions trace --no-redact` is the only opt-out) and always through `sanitizeForTerminal`. Without it a Bash call with no `description` fell back to raw command text, so a pasted token rode the session row into the git-tracked `~/.agents/devices/<device>/daemon-state.json`, and a transcript carrying ESC sequences could clear the operator's screen on `sessions trace --steps`. `--steps` now honours the command's own `--redact` default, and `sanitizeEvent` covers the new `label` and `phase` fields. Source: `cli/src/lib/session/timeline.ts`, `cli/src/lib/session/parse.ts`, `cli/src/commands/sessions-trace.ts`.
+- **A 4-16 MiB transcript on a non-resumable harness gets a timeline.** Whole-file eligibility was gated on the per-session allowance, capped at 4 MiB however idle the tick was, while `unavailable` only fired above 16 MiB — so a kimi/grok/gemini/cursor/opencode/droid session in that band got no row at all (not `ready`, not `partial`, not `unavailable`) and was counted `reused`, leaving the daemon log reading healthy. It is now gated on what the tick can actually afford, the byte budget is debited by the bytes each branch really reads (the whole file for a whole-file re-parse, not its growth delta), and a session that genuinely does not fit writes a `partial` row naming the budget. A per-session fold that throws is logged and counted `skipped` instead of swallowed. Source: `cli/src/lib/session/timeline-pass.ts`.
+- **Cursor and Droid keep their per-call label too.** Both write the same human one-liner through the shared Anthropic-message parser — Cursor as `description`, Droid as `summary` — and neither reached `SessionEvent.label`, so a Droid `Execute{command:"ls -la", summary:"List files"}` rendered its now-line as `ls -la` while the equivalent Claude call read `List files`. Source: `cli/src/lib/session/parse.ts`.
+- **A tool cut short with Ctrl-C counts as blocked, not failed.** `toolUseResult.interrupted` joins `toolDenialKind` as an input to `blocked`, so interrupting an agent no longer inflates its failure count. Source: `cli/src/lib/session/parse.ts`.
+- **`now` ships only on the live step, and `ready` is never an empty step list.** `attachTool` sets the now-line on every step as it folds; every finished step kept a stale one, so a consumer rendered a now-line on completed work at ~700 bytes a row. A fold that produced no step now reports its state honestly instead of `ready` with nothing in it. The fleet mirror also carries `mix` and `live` through the consume path, which rebuilt each step from a field list that dropped both while keeping `now`. Source: `cli/src/lib/session/timeline.ts`, `cli/src/lib/session/mirror.ts`.
+
+## 1.22.83
+
+- **The Claude status line shows the registered account NAME (PHNX-3987).** A login named with `agents accounts` (`work`, `dev`, …) now renders that name between the host and the model — `yosemite · work · Fable 5.1 · …` — which is what tells several same-harness logins apart at a glance; an unnamed login keeps the email label. The lookup is the one `agents view` and the device inventories already use, lifted into `findNativeAccountByIdentity` so the three copies share it. Source: `cli/src/lib/claude-statusline.ts`, `cli/src/lib/account-registry.ts`.
+
+- **`agents accounts rename` / `remove` / `view` honor per-harness account names (PHNX-3988).** Native labels are unique per harness (PHNX-3887), but rename/remove still ran a fleet-wide uniqueness check and resolved a bare name to whichever harness row the store ordered first — so renaming Codex's `cxicloud` to `icloud` failed because Claude already owned `icloud`. Rename now scopes uniqueness to the target row's harness, so one harness can take a name another already uses; a duplicate within the same harness is still refused. Rename, remove, and view accept `<harness>#<name>` and refuse an ambiguous bare name rather than guessing. Source: `cli/src/lib/account-registry.ts`, `cli/src/commands/accounts.ts`.
+
+- **Feed activity polling reuses unchanged log tails (PHNX-3939).** The activity reader caches file-version-validated tails and timestamp summaries within a bounded process-local budget. Cursor polls skip unchanged historical events without parsing them again; appends, rewrites, replacements and tail-budget changes invalidate the cached snapshot. Returned events remain independently mutable, with timestamp, filter and limit behavior preserved.
+
 ## 1.22.82
 
 - **The Claude status line names the signed-in account before the model (PHNX-3987).** The managed `agents __claude-statusline` render now reads `host · account · model · 5h n% · 7d n% · ◆ reminder`, where the account is the email the running Claude is signed into (plus the org name for a Team/Enterprise seat, the same label `agents view` renders), read from the `.claude.json` of the home Claude is actually running with — the version home under the launch shim, `$HOME` otherwise. A never-signed-in home omits the part. Source: `cli/src/lib/claude-statusline.ts`.

package/dist/commands/accounts.js

@@ -21,7 +21,7 @@ import { connectRefusal, connectSupported, runConnect } from '../lib/accounts/co
 import { acquireAuthOperationLock } from '../lib/accounts/auth-operation-lock.js';
 import { readAndResolveBundleEnv } from '../lib/secrets/bundles.js';
 import { getAccountProvider, listAccountProviders, providerAuthenticatesHarness } from '../lib/account-provider-registry.js';
-import { accountBindings, addAccount, addNativeAccount, bindAccount, findAccount, findUnifiedAccount, inspectAccount, labelNativeAccount, listNativeAccounts, nativeAccountHome, readAccountRegistry, removeAccount, renameAccount, setAccountSecret, unbindAccount } from '../lib/account-registry.js';
+import { accountBindings, addAccount, addNativeAccount, assertUnambiguousNativeAccount, bindAccount, findAccount, findUnifiedAccount, inspectAccount, labelNativeAccount, listNativeAccounts, nativeAccountHome, parseAccountSelector, readAccountRegistry, removeAccount, renameAccount, setAccountSecret, unbindAccount } from '../lib/account-registry.js';
 import { registerMintCommand } from './auth-mint.js';
 /** Comma-joined list of harnesses `accounts connect` can drive today. */
 function connectSupportedList() {
@@ -535,7 +535,7 @@ export function registerAccountsCommand(program) {
 agents accounts connect codex personal
 agents accounts connect claude work   # again → reuses work's home, fails closed on a different identity
 agents run claude --account work`,
-        notes: `Each NEW account gets a fresh opaque installation label and its own isolated home, so ten accounts can share the same upstream release while keeping separate logins. Connect installs the current release even when it is already installed under another label, then launches the harness's native login there — the OAuth credential is never copied or fleet-synced. Reconnecting an existing account by name reuses its home and refuses to overwrite a home now signed in as a different identity. Supported for version-scoped, isolable harnesses (${connectSupportedList()}); others fail with a clear reason. Provider API-key/token accounts use 'agents accounts add' instead.`,
+        notes: `Each NEW account gets a fresh opaque installation label and its own isolated home, so ten accounts can share the same upstream release while keeping separate logins. Connect installs the current release even when it is already installed under another label, then launches the harness's native login there — the OAuth credential is never copied or fleet-synced. Reconnecting an existing account by name reuses its home and refuses to overwrite a home now signed in as a different identity. Headed devices only: on a worker connect refuses before any slot, install, or browser — add the account on a personal/desktop box and provision workers from the durable credential. Supported for version-scoped, isolable harnesses (${connectSupportedList()}); others fail with a clear reason. Provider API-key/token accounts use 'agents accounts add' instead.`,
     });
     accounts.command('add <name>')
         .description('Add a durable API key, setup token, or bearer token')
@@ -580,12 +580,21 @@ agents run claude --account work`,
             console.log(chalk.green(`Updated credential for account '${name}'.`));
         });
     });
-    accounts.command('view <name>').alias('inspect').description('Show safe account metadata, custody, and attachments').option('--json', 'Machine-readable output').action(async (name, o, command) => {
+    const viewCmd = accounts.command('view <name>')
+        .alias('inspect')
+        .description('Show safe account metadata, custody, and attachments. Target may be <harness>#<name> when the name exists for several harnesses')
+        .option('--json', 'Machine-readable output')
+        .action(async (name, o, command) => {
         await runAccountsAction(command, async () => {
             const meta = readMeta();
-            const unified = findUnifiedAccount(name, meta);
+            const selector = parseAccountSelector(name);
+            assertUnambiguousNativeAccount(meta, selector.name, selector.agent);
+            const unified = findUnifiedAccount(selector.name, meta, undefined, selector.agent);
             if (!unified)
                 throw new Error(`Unknown account '${name}'.`);
+            if (selector.agent && unified.kind === 'native' && unified.agent !== selector.agent) {
+                throw new Error(`Unknown ${selector.agent} account '${selector.name}'.`);
+            }
             const account = unified.kind === 'provider'
                 ? { ...publicAccount(inspectAccount(unified.name)), custody: 'agents secrets (policy never)', attached: accountBindings(unified.id, meta) }
                 : { ...unified, custody: `${unified.agent} (not stored by agents-cli)`, attached: accountBindings(unified.id, meta) };
@@ -607,6 +616,11 @@ agents run claude --account work`,
             console.log(`  attached: ${account.attached.length ? account.attached.join(', ') : 'none'}`);
         });
     });
+    setHelpSections(viewCmd, {
+        examples: `agents accounts view work --json
+agents accounts view codex#icloud`,
+        notes: 'Native names are unique per harness. A bare name that exists for several harnesses is refused — pick one with <harness>#<name>.',
+    });
     accounts.command('name <source> <name>')
         .description('Name a signed-in native installation without copying its OAuth credentials')
         .action(async (source, name, _o, command) => {
@@ -723,12 +737,25 @@ agents run codex#work`,
             console.log(chalk.green(`Detached ${name} from ${target}.`));
         });
     });
-    accounts.command('rename <old> <new>').description('Rename an account without changing its stable id').action(async (oldName, newName, _o, command) => {
+    const renameCmd = accounts.command('rename <old> <new>')
+        .description('Rename an account without changing its stable id. Target may be <harness>#<name> when the name exists for several harnesses')
+        .action(async (oldName, newName, _o, command) => {
         await runAccountsAction(command, () => { renameAccount(oldName, newName); });
     });
-    accounts.command('remove <name>').description('Remove an account and its device-local credential').action(async (name, _o, command) => {
+    setHelpSections(renameCmd, {
+        examples: `agents accounts rename cxicloud icloud
+agents accounts rename codex#icloud cloud`,
+        notes: 'Native names are unique per harness. A bare name that exists for several harnesses is refused — pick one with <harness>#<name>.',
+    });
+    const removeCmd = accounts.command('remove <name>')
+        .description('Remove an account and its device-local credential. Target may be <harness>#<name> when the name exists for several harnesses')
+        .action(async (name, _o, command) => {
         await runAccountsAction(command, () => { removeAccount(name); });
     });
+    setHelpSections(removeCmd, {
+        examples: `agents accounts remove claude#icloud`,
+        notes: 'Native names are unique per harness. A bare name that exists for several harnesses is refused — pick one with <harness>#<name>.',
+    });
     accounts.command('set-default <agent> <name>')
         .description('Use this account for a harness when --account is omitted')
         .action(async (agentRaw, name, _o, command) => {
@@ -849,6 +876,7 @@ agents accounts name claude@2.1.220 work
 agents accounts label codex@0.146.0 personal
 agents accounts attach work claude@2.1.225
 agents accounts view work --json
+agents accounts view codex#icloud
 agents accounts switch claude
 agents accounts switch claude work
 agents accounts set-default claude work

package/dist/commands/sessions-trace.d.ts

@@ -1,4 +1,5 @@
 import type { Command } from 'commander';
+import type { SessionMeta } from '../lib/session/types.js';
 import type { SessionTrajectory } from '../lib/session/trajectory.js';
 import type { TrajectoryComparison, TrajectoryDivergence, TrajectorySummary } from '../lib/session/trajectory-compare.js';
 import type { TrajectoryStep } from '../lib/session/trajectory.js';
@@ -50,6 +51,7 @@ interface TraceOptions {
     output?: string;
     open?: boolean;
     errorsOnly?: boolean;
+    steps?: boolean;
     redact?: boolean;
     all?: boolean;
     since?: string;
@@ -73,6 +75,15 @@ export declare function chooseFormat(options: TraceOptions, isTTY: boolean): Ren
  * clear message. Pure, so the boundaries are unit-tested without the command.
  */
 export declare function decideTraceLayout(options: Pick<TraceOptions, 'tree' | 'compare'>, selectorCount: number, resolvedCount: number): 'single' | 'compare' | 'lineage';
+/**
+ * Render one session's narration-anchored step list — the same fold the daemon
+ * caches and the sidebar renders, computed here from the transcript so the
+ * command works for any session, live or closed, cached or not.
+ */
+export declare function renderSessionSteps(session: SessionMeta, options?: {
+    redact?: boolean;
+    knownSecrets?: readonly string[];
+}): string;
 /** Attach the trace behaviour to a command node (canonical or top-level alias). */
 export declare function configureTraceCommand(cmd: Command): Command;
 /** Canonical `agents sessions trace <selectors...>`. */

package/dist/commands/sessions-trace.js

@@ -23,6 +23,8 @@ import { knownSecretValuesFromEnv } from '../lib/redact.js';
 import { getCacheDir } from '../lib/state.js';
 import { discoverSessions } from '../lib/session/discover.js';
 import { parseSession } from '../lib/session/parse.js';
+import { foldTimeline, projectSessionFiles, projectTimeline } from '../lib/session/timeline.js';
+import { parseTimelineEvents } from '../lib/session/timeline-pass.js';
 import { buildTrajectory } from '../lib/session/trajectory.js';
 import { diffTrajectories } from '../lib/session/trajectory-compare.js';
 import { buildLineage } from '../lib/session/trajectory-lineage.js';
@@ -134,6 +136,53 @@ export function decideTraceLayout(options, selectorCount, resolvedCount) {
     }
     return 'single';
 }
+/** One step's counters, rendered as the sidebar renders them: `6 run · 2 blocked`. */
+function stepDetail(step) {
+    const mix = Object.entries(step.mix ?? {})
+        .filter(([, count]) => (count ?? 0) > 0)
+        .sort((a, b) => (b[1] ?? 0) - (a[1] ?? 0))
+        .map(([verb, count]) => `${count} ${verb}`);
+    return [
+        ...mix,
+        step.failed ? `${step.failed} failed` : '',
+        step.blocked ? `${step.blocked} blocked` : '',
+        ...(step.marks ?? []),
+    ].filter(Boolean).join(' · ');
+}
+/**
+ * Render one session's narration-anchored step list — the same fold the daemon
+ * caches and the sidebar renders, computed here from the transcript so the
+ * command works for any session, live or closed, cached or not.
+ */
+export function renderSessionSteps(session, options = {}) {
+    const state = foldTimeline(parseTimelineEvents(session.filePath, session.agent), undefined, {});
+    const timeline = projectTimeline(state, undefined, state.steps.length, options);
+    if (!timeline.steps.length) {
+        return `No steps folded for ${session.shortId || session.id}` +
+            `${timeline.reason ? ` — ${timeline.reason}` : ''}\n`;
+    }
+    const startMs = state.firstMs ?? Date.parse(timeline.steps[0].at);
+    const lines = timeline.steps.map((step, index) => {
+        const offsetS = Math.max(0, Math.round((Date.parse(step.at) - startMs) / 1000));
+        const detail = stepDetail(step);
+        return [
+            String(index + 1).padStart(2),
+            `+${offsetS}s`.padStart(7),
+            step.source.slice(0, 4).padEnd(4),
+            step.text,
+            detail ? `· ${detail}` : '',
+        ].filter(Boolean).join('  ');
+    });
+    const files = projectSessionFiles(state);
+    const footer = [
+        `${timeline.steps.length} steps`,
+        `${timeline.tools} tools`,
+        timeline.failed ? `${timeline.failed} failed` : '',
+        timeline.blocked ? `${timeline.blocked} blocked` : '',
+        files ? `${files.total} file${files.total === 1 ? '' : 's'} changed` : '',
+    ].filter(Boolean).join(' · ');
+    return `${lines.join('\n')}\n\n${footer}\n`;
+}
 /** Attach the trace behaviour to a command node (canonical or top-level alias). */
 export function configureTraceCommand(cmd) {
     cmd
@@ -144,6 +193,7 @@ export function configureTraceCommand(cmd) {
         .option('-o, --output <path>', 'Write the rendering to a path instead of opening/printing')
         .option('--no-open', 'Do not open the HTML; print its path instead')
         .option('--errors-only', 'Collapse the text trajectory to error steps and their neighbours')
+        .option('--steps', 'Print the narration-anchored step list the sidebar shows (the same fold as the session row)')
         .option('--compare', 'Force the compare layout for exactly two selectors (this is also the default for two)')
         .option('--tree', 'Render the lineage of one session — it and every session it spawned')
         .option('--no-redact', 'Local-only: skip secret redaction of derived labels (never for a shared file)')
@@ -161,6 +211,9 @@ agents sessions trace a1b2c3d4 --text
 # Just the failures and their neighbours — for a triaging agent
 agents sessions trace a1b2c3d4 --text --errors-only
 
+# What the agent said it was doing, step by step — the sidebar's timeline as text
+agents sessions trace a1b2c3d4 --steps
+
 # The stable JSON envelope for the AGI EXT Fleet panel or a tool
 agents sessions trace a1b2c3d4 --json
 
@@ -223,6 +276,9 @@ Three or more selectors, and --tree with more than one selector, fail loud.`,
         // count — a single content-search selector matching two sessions must NOT
         // silently become a compare. All the fail-loud boundaries live in the pure
         // decideTraceLayout so they are unit-tested (see sessions-trace.test.ts).
+        if (options.steps && selectors.length > 1) {
+            throw new Error('--steps renders one session\'s step list; pass a single selector.');
+        }
         const layout = decideTraceLayout(options, selectors.length, sessions.length);
         const redact = options.redact !== false;
         const knownSecrets = redact ? knownSecretValuesFromEnv() : undefined;
@@ -333,6 +389,21 @@ Three or more selectors, and --tree with more than one selector, fail loud.`,
         }
         // One selector — the single-session trajectory.
         const session = sessions[0];
+        // --steps is the CLI door to the timeline fold the sidebar renders, so an
+        // agent can read what a session DID without the extension (PHNX-3939). It is
+        // a different model from the trajectory (narration beats, not tool steps),
+        // so it short-circuits before buildTrajectory rather than reshaping it.
+        if (options.steps) {
+            const out = renderSessionSteps(session, { redact, knownSecrets });
+            if (options.output) {
+                fs.writeFileSync(options.output, out, { mode: 0o600 });
+                process.stderr.write(chalk.green(`Wrote step list to ${options.output}\n`));
+            }
+            else {
+                process.stdout.write(out);
+            }
+            return;
+        }
         const model = buildOne(session);
         if (format === 'json') {
             const out = JSON.stringify(buildTraceEnvelope([model]), null, 2) + '\n';

package/dist/commands/view.js

@@ -20,7 +20,7 @@ import { listCliStatus } from '../lib/cli-resources.js';
 import { isCapable } from '../lib/capabilities.js';
 import { discoverPlugins, pluginSupportsAgent } from '../lib/plugins/plugins.js';
 import { getAgentsDir, getUserAgentsDir, getEffectivePromptcutsPath, readMergedPromptcuts, readMeta } from '../lib/state.js';
-import { listNativeAccounts } from '../lib/account-registry.js';
+import { findNativeAccountByIdentity } from '../lib/account-registry.js';
 import { buildNativeCatalog } from '../lib/account-catalog.js';
 import { connectSupported } from '../lib/accounts/connect.js';
 import { readInstallation } from '../lib/installations/store.js';
@@ -67,11 +67,8 @@ export const accountColumnLabel = accountDisplayLabel;
  */
 export function namedAccountColumnLabel(agentId, info) {
     const display = accountColumnLabel(info);
-    const identityKey = info?.accountKey ?? info?.email?.toLowerCase();
-    if (!identityKey)
-        return display;
-    const saved = listNativeAccounts(readMeta()).find(item => item.agent === agentId && item.identityKey === identityKey);
-    return saved ? `${saved.name} · ${display || saved.identityLabel || identityKey}` : display;
+    const saved = findNativeAccountByIdentity(readMeta(), agentId, info);
+    return saved ? `${saved.name} · ${display || saved.identityLabel || saved.identityKey}` : display;
 }
 /** Human account identity; release labels belong only in installation diagnostics. */
 export function nativeAccountViewLabel(row) {

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

@@ -1,4 +1,4 @@
-import type { AgentId, Meta } from './types.js';
+import { type AgentId, type Meta } from './types.js';
 import { type AccountAuthKind } from './account-provider-registry.js';
 export interface CredentialAccount {
     id: string;
@@ -43,6 +43,18 @@ export declare function findAccount(name: string, doc?: AccountRegistryDocument)
  * accumulate). On an id collision the device slice wins.
  */
 export declare function listNativeAccounts(meta: Pick<Meta, 'accounts' | 'deviceAccounts'>): NativeAccount[];
+/**
+ * The native account registered for one harness login, or null when that login
+ * is unnamed. `info` is the login's identity as `getAccountInfo` /
+ * `readClaudeHomeConfig` report it; the match key is the same value every
+ * catalog and inventory groups a home on — the stable `accountKey`, else the
+ * lowercased email. The one lookup behind `agents view`, the device
+ * inventories, and the Claude status line.
+ */
+export declare function findNativeAccountByIdentity(meta: Pick<Meta, 'accounts' | 'deviceAccounts'>, agent: AgentId, info: {
+    accountKey?: string | null;
+    email?: string | null;
+} | null | undefined): NativeAccount | null;
 /**
  * Resolve one account by name or id across both stores, native first.
  *
@@ -55,6 +67,23 @@ export declare function listNativeAccounts(meta: Pick<Meta, 'accounts' | 'device
  * able to omit it.
  */
 export declare function findUnifiedAccount(nameOrId: string, meta: Pick<Meta, 'accounts' | 'deviceAccounts'>, doc?: AccountRegistryDocument, preferAgent?: AgentId): UnifiedAccount | null;
+/**
+ * Split a management selector into its harness and name. `<harness>#<name>`
+ * pins the harness; a bare name (or row id) carries none. Native names are
+ * unique per harness (PHNX-3887), so a bare name alone can legitimately match a
+ * claude row AND a codex row — the selector is how rename/remove say which.
+ */
+export declare function parseAccountSelector(input: string): {
+    agent?: AgentId;
+    name: string;
+};
+/**
+ * Refuse a bare name that native rows in several harnesses share. A
+ * harness-qualified selector (`agent` set) never hits this — uniqueness is
+ * per harness. Ids are unique so they never collide either. Shared by
+ * rename/remove/view so the message stays one string.
+ */
+export declare function assertUnambiguousNativeAccount(meta: Pick<Meta, 'accounts' | 'deviceAccounts'>, name: string, agent?: AgentId): void;
 /**
  * Validate a native account NAME (charset + per-harness uniqueness) WITHOUT a
  * known identity — the pre-flight `agents accounts connect` runs before it
@@ -120,8 +149,16 @@ export interface AddAccountOptions {
 }
 export declare function addAccount(name: string, provider: string, auth: AccountAuthKind, secret: string, base?: string, opts?: AddAccountOptions): CredentialAccount;
 export declare function setAccountSecret(name: string, secret: string, base?: string): void;
-export declare function renameAccount(oldName: string, newName: string, base?: string): void;
-export declare function removeAccount(name: string, base?: string): void;
+/**
+ * `oldSelector` is a bare name, a row id, or `<harness>#<name>`. A native row
+ * carries its harness, so the new name only has to be free within THAT harness
+ * (PHNX-3887 / PHNX-3988): renaming codex's `cxicloud` to `icloud` is fine
+ * while claude's `icloud` stays untouched. Provider accounts have no harness
+ * and stay globally unique.
+ */
+export declare function renameAccount(oldSelector: string, newName: string, base?: string): void;
+/** `selector` is a bare name, a row id, or `<harness>#<name>` (see {@link renameAccount}). */
+export declare function removeAccount(selector: string, base?: string): void;
 export declare function inspectAccount(name: string, base?: string): CredentialAccount & {
     secretPresent: boolean;
     policy: 'never';

package/dist/lib/account-registry.js

@@ -23,6 +23,7 @@ import * as yaml from 'yaml';
 import chalk from 'chalk';
 import { atomicWriteFileSync } from './fs-atomic.js';
 import { getUserAgentsDir, readMeta, updateMeta } from './state.js';
+import { isAgentId } from './types.js';
 import { deleteKeychainToken, getKeychainToken, hasKeychainToken } from './secrets/index.js';
 import { bundleExists, deleteBundle, listBundles, readAndResolveBundleEnv, readBundle, renameBundle, writeBundleWithItems } from './secrets/bundles.js';
 import { getAccountProvider } from './account-provider-registry.js';
@@ -148,6 +149,20 @@ export function listNativeAccounts(meta) {
     const merged = { ...meta.accounts?.native, ...meta.deviceAccounts?.native };
     return Object.values(merged).map(account => ({ ...account, kind: 'native' }));
 }
+/**
+ * The native account registered for one harness login, or null when that login
+ * is unnamed. `info` is the login's identity as `getAccountInfo` /
+ * `readClaudeHomeConfig` report it; the match key is the same value every
+ * catalog and inventory groups a home on — the stable `accountKey`, else the
+ * lowercased email. The one lookup behind `agents view`, the device
+ * inventories, and the Claude status line.
+ */
+export function findNativeAccountByIdentity(meta, agent, info) {
+    const identityKey = info?.accountKey ?? info?.email?.toLowerCase();
+    if (!identityKey)
+        return null;
+    return listNativeAccounts(meta).find(account => account.agent === agent && account.identityKey === identityKey) ?? null;
+}
 /**
  * Resolve one account by name or id across both stores, native first.
  *
@@ -168,8 +183,9 @@ export function findUnifiedAccount(nameOrId, meta, doc, preferAgent) {
     // merged store happened to order first, so `agents run claude#<email>` died with
     // "Account 'personal' is a codex login and cannot authenticate the claude harness"
     // while that identity's own claude login sat right there. Prefer the harness being
-    // launched; fall back to the first match so a management lookup with no harness in
-    // hand (rename/remove/view) behaves exactly as before.
+    // launched; fall back to the first match when the caller has no harness in hand.
+    // rename/remove/view refuse an ambiguous *name* via assertUnambiguousNativeAccount
+    // before they get here — this fallback is for identityLabel collisions.
     const native = matches.find(account => account.agent === preferAgent) ?? matches[0];
     if (native)
         return native;
@@ -179,10 +195,46 @@ export function findUnifiedAccount(nameOrId, meta, doc, preferAgent) {
 function nativeIdentityRows(meta, agent, identityKey) {
     return listNativeAccounts(meta).filter(account => account.agent === agent && account.identityKey === identityKey);
 }
+/**
+ * Split a management selector into its harness and name. `<harness>#<name>`
+ * pins the harness; a bare name (or row id) carries none. Native names are
+ * unique per harness (PHNX-3887), so a bare name alone can legitimately match a
+ * claude row AND a codex row — the selector is how rename/remove say which.
+ */
+export function parseAccountSelector(input) {
+    const hash = input.indexOf('#');
+    if (hash < 0)
+        return { name: input };
+    const agentRaw = input.slice(0, hash);
+    const name = input.slice(hash + 1).trim();
+    if (!isAgentId(agentRaw))
+        throw new Error(`Unknown agent '${agentRaw}'.`);
+    if (!name)
+        throw new Error('Select an account after #.');
+    return { agent: agentRaw, name };
+}
+/**
+ * Refuse a bare name that native rows in several harnesses share. A
+ * harness-qualified selector (`agent` set) never hits this — uniqueness is
+ * per harness. Ids are unique so they never collide either. Shared by
+ * rename/remove/view so the message stays one string.
+ */
+export function assertUnambiguousNativeAccount(meta, name, agent) {
+    const matches = listNativeAccounts(meta).filter(account => (agent === undefined || account.agent === agent) && (account.id === name || account.name === name));
+    const harnesses = [...new Set(matches.map(account => account.agent))].sort();
+    if (harnesses.length > 1) {
+        throw new Error(`Account '${name}' exists for several harnesses (${harnesses.join(', ')}). `
+            + `Pick one with <harness>#${name}, e.g. ${harnesses[0]}#${name}.`);
+    }
+}
 /** Every row (central + this box's device store) for the identity that `name`
- * (id or account name) resolves to. */
-function nativeRowsForNameOrId(meta, name) {
-    const found = listNativeAccounts(meta).find(account => account.id === name || account.name === name);
+ * (id or account name) resolves to. With `agent` set only that harness's rows
+ * are considered; without it, a name owned by rows in several harnesses is
+ * refused rather than resolved to whichever the store ordered first. */
+function nativeRowsForNameOrId(meta, name, agent) {
+    assertUnambiguousNativeAccount(meta, name, agent);
+    const matches = listNativeAccounts(meta).filter(account => (agent === undefined || account.agent === agent) && (account.id === name || account.name === name));
+    const found = matches[0];
     if (!found)
         return [];
     return nativeIdentityRows(meta, found.agent, found.identityKey);
@@ -197,9 +249,9 @@ function nativeRowsForNameOrId(meta, name) {
  * actually ambiguous at the point of use: the selector is `<harness>#<label>`,
  * and `findUnifiedAccount` already disambiguates via `preferAgent`.
  *
- * Pass `agent` to scope the check to that harness. Omit it for management
- * lookups with no harness in hand (rename/remove), which keep the old
- * fleet-wide check so a rename cannot collide with an unrelated harness's row.
+ * Pass `agent` to scope the check to that harness. Every native path has one
+ * in hand — connect/label from the caller, rename from the row being renamed —
+ * so the un-scoped form is only for provider accounts.
  *
  * Provider (non-native) accounts stay globally unique — they are selected by
  * bare name via `--account`, with no harness to scope them by.
@@ -493,21 +545,32 @@ export function setAccountSecret(name, secret, base = getUserAgentsDir()) {
     bundle.created_at = readBundle(account.name).created_at; // rotate the secret, keep the bundle's birth time
     writeBundleWithItems(bundle, items);
 }
-export function renameAccount(oldName, newName, base = getUserAgentsDir()) {
+/**
+ * `oldSelector` is a bare name, a row id, or `<harness>#<name>`. A native row
+ * carries its harness, so the new name only has to be free within THAT harness
+ * (PHNX-3887 / PHNX-3988): renaming codex's `cxicloud` to `icloud` is fine
+ * while claude's `icloud` stays untouched. Provider accounts have no harness
+ * and stay globally unique.
+ */
+export function renameAccount(oldSelector, newName, base = getUserAgentsDir()) {
     assertName(newName);
-    const doc = readAccountRegistry(base);
     const meta = readMeta();
-    const rows = nativeRowsForNameOrId(meta, oldName);
+    const selector = parseAccountSelector(oldSelector);
+    const rows = nativeRowsForNameOrId(meta, selector.name, selector.agent);
     if (rows.length) {
-        assertUniqueUnifiedName(newName, meta, doc, new Set(rows.map(account => account.id)));
+        assertUniqueUnifiedName(newName, meta, undefined, new Set(rows.map(account => account.id)), rows[0].agent);
         // Sweep every row for the identity (PHNX-3206) in its owning store (PHNX-3315)
         // and any per-harness default that points to the old name or row ids.
         const rowScope = rows[0].scope;
-        const idsToRename = new Set([oldName, ...rows.map(row => row.id)]);
+        const renamedAgent = rows[0].agent;
+        const renamedIds = new Set(rows.map(row => row.id));
         updateMeta(current => {
             const defaults = { ...current.accounts?.defaults };
             for (const [agent, value] of Object.entries(defaults)) {
-                if (idsToRename.has(value))
+                // Ids are unique so an id match may rewrite any harness's default. A
+                // bare-name match must only rewrite THIS harness — two harnesses may
+                // legitimately share the same native name (PHNX-3988).
+                if (renamedIds.has(value) || (agent === renamedAgent && value === selector.name))
                     defaults[agent] = newName;
             }
             const next = { ...current, accounts: { ...current.accounts, defaults } };
@@ -527,9 +590,12 @@ export function renameAccount(oldName, newName, base = getUserAgentsDir()) {
         });
         return;
     }
-    const account = findAccount(oldName, doc);
+    if (selector.agent)
+        throw new Error(`Unknown ${selector.agent} account '${selector.name}'.`);
+    const doc = readAccountRegistry(base);
+    const account = findAccount(selector.name, doc);
     if (!account)
-        throw new Error(`Unknown account '${oldName}'.`);
+        throw new Error(`Unknown account '${selector.name}'.`);
     assertUniqueUnifiedName(newName, meta, doc);
     const idsToRename = new Set([account.name, account.id]);
     updateMeta(current => {
@@ -543,9 +609,11 @@ export function renameAccount(oldName, newName, base = getUserAgentsDir()) {
     renameBundle(account.name, newName); // moves metadata + secret, preserves ACCOUNT_ID
     renameProfileConsumers(account.name, newName, base);
 }
-export function removeAccount(name, base = getUserAgentsDir()) {
+/** `selector` is a bare name, a row id, or `<harness>#<name>` (see {@link renameAccount}). */
+export function removeAccount(selector, base = getUserAgentsDir()) {
     const meta = readMeta();
-    const rows = nativeRowsForNameOrId(meta, name);
+    const parsed = parseAccountSelector(selector);
+    const rows = nativeRowsForNameOrId(meta, parsed.name, parsed.agent);
     if (rows.length) {
         const bindings = [...new Set(rows.flatMap(row => accountBindings(row.id, meta)))].sort();
         if (bindings.length)
@@ -571,6 +639,9 @@ export function removeAccount(name, base = getUserAgentsDir()) {
         });
         return;
     }
+    if (parsed.agent)
+        throw new Error(`Unknown ${parsed.agent} account '${parsed.name}'.`);
+    const name = parsed.name;
     const account = findAccount(name, readAccountRegistry(base));
     if (!account)
         throw new Error(`Unknown account '${name}'.`);

package/dist/lib/accounts/connect.d.ts

@@ -18,6 +18,12 @@ export declare function connectSupported(agent: AgentId): boolean;
  */
 export declare function connectRefusal(agent: AgentId): string | null;
 export declare function assertConnectSupported(agent: AgentId): void;
+/**
+ * Named reason connect refuses on a non-headed device, or null when this box
+ * may run an interactive login. Workers never mint a native OAuth login
+ * (credential-management.md invariant 7 + Provisioning model).
+ */
+export declare function connectWorkerRefusal(agent: AgentId, name?: string): string | null;
 export declare function loginInvocation(agent: AgentId): LoginInvocation;
 /**
  * Mint a fresh, opaque installation slot. `acct-<hex>` — alnum + hyphen only, so