@phnx-labs/agents-cli 1.22.117 → 1.22.119

package/dist/lib/secrets-policy.js

@@ -18,7 +18,7 @@ import { isHostPinned, isDevicePinned, managedKnownHostsPath } from './devices/k
 import { machineId, normalizeHost } from './session/sync/config.js';
 import { readFleetSharedDeviceStates, updateFleetSharedDeviceStateAsync, } from './fleet-shared-state.js';
 import { getCacheDir, getUserAgentsDir, readMeta } from './state.js';
-import { listNativeAccounts, readSlots } from './account-registry.js';
+import { dropSlots, listNativeAccounts, readSlots } from './account-registry.js';
 import { claudeAccountTokenKey, isClaudeWorkerHomeSeeded, provisionWorkerSlot, readReservedCredential } from './claude-account-token.js';
 import { configuredDeviceRole, isHeadedDeviceRole, selfConfiguredDeviceRole } from './device-config.js';
 import { AUTH_STORE_ALIAS, AUTH_BUNDLE_BACKEND, RESERVED_BUNDLE_NAMES, isReservedBundleName, ReservedBundleWrongBackendError, assertReservedAuthBackend, isReservedBundleBackendError, RESERVED_STORES, reservedStoreName, isReservedStoreName, assertStorableCredentialKind, inspectReservedAuthBundle, } from './reserved-stores.js';
@@ -245,6 +245,26 @@ export async function syncReservedAuthBundle(deps = {}) {
 // The functions below fix both. The plan is per ACCOUNT and per KEY
 // (`<ENV>_<accountId>`), not per bundle, and targets `role=worker` peers only.
 //
+// PRESENCE IS FIRST-HAND + ROTATION-AWARE (PHNX-4116). Each device's account-
+// state daemon publishes a per-account verdict row into `accounts.rows`
+// (`account-state-daemon-service.ts`), and the usage-sync SSH exchange stores
+// each peer's reply at `devices/<peer>/daemon-state.json`. A key counts as
+// present on a peer only when BOTH hold:
+//   1. FIRST-HAND — the peer's own reply reports a NON-`missing` verdict for the
+//      account (its slot materialized). This is what a publisher-side memo alone
+//      could never see: a key removed on the worker out of band flips the next
+//      verdict to `missing`, so the push resumes within a tick.
+//   2. ROTATION — the fingerprint (`workerCredential.mintedAt`) we last delivered
+//      to that peer matches the account's CURRENT fingerprint. A re-mint
+//      (`accounts login`) rotates the reserved key and bumps `mintedAt` while the
+//      peer's OLD token keeps authenticating, so its verdict stays non-`missing`;
+//      verdict alone would read `present` forever and the rotated key would never
+//      reach the worker. The delivery memo is a LOCAL rotation cursor keyed per
+//      (peer, bundle, key) → fingerprint, never synced, never the primary signal.
+// A peer reply with no `accounts.rows` field at all (an older CLI) is not proof
+// of an empty inventory, so the plan FAILS CLOSED and skips it (INFO), rather
+// than treating "no rows" as "holds nothing" and pushing every key blindly.
+//
 // INVARIANT 1 (transport, retain nothing): materializing a worker slot happens
 // on the box where the key LANDED (`reconcileLocalWorkerSlots` ->
 // `provisionWorkerSlot`); the credential itself only ever moves over the
@@ -254,10 +274,34 @@ export async function syncReservedAuthBundle(deps = {}) {
 // `isCredentialSafeToPropagate` stays false).
 // ---------------------------------------------------------------------------
 const EMPTY_KEY_SET = new Set();
+/**
+ * Skip reason for a peer that has never sent a daemon-state reply (no
+ * `devices/<peer>/daemon-state.json`). auth-sync logs these at INFO — a
+ * brand-new or never-dialed worker legitimately has no reply on an early tick,
+ * so it is informational, not a warning. Stable so the service classifies the
+ * skip without matching a substring.
+ */
+export const SKIP_REASON_NO_PEER_REPLY = 'no daemon-state reply from this peer yet';
+/**
+ * Skip reason for a peer whose reply exists but carries no `accounts.rows` field
+ * at all (an older CLI that does not publish per-account verdicts, or a partial
+ * state written before the account-state daemon ran). Without those rows there is
+ * no first-hand knowledge of what the peer holds, so the plan FAILS CLOSED and
+ * skips rather than pushing every key blindly. auth-sync logs it at INFO — it is
+ * transient during a rolling upgrade. An EMPTY `accounts.rows` array (a peer with
+ * no registered account) is NOT this case: it is a legitimate "holds nothing",
+ * and its keys are (correctly) pushed to provision it.
+ */
+export const SKIP_REASON_NO_ACCOUNT_ROWS = 'daemon-state reply carries no account rows (fail closed)';
 /**
  * Pure plan: for each worker peer, push each bundle it is missing at least one
  * key of. Deterministic (peers and bundles sorted) so it pins exactly in tests.
- * A headed peer is skipped BEFORE any key comparison -- it never receives a key.
+ * A headed peer is skipped BEFORE any key comparison -- it never receives a key;
+ * a peer with no reply yet (`hasReply: false`) is skipped next -- there is no
+ * first-hand knowledge of what it holds, so nothing is pushed to it this tick;
+ * a peer whose reply carries no `accounts.rows` field (`hasAccountRows: false`)
+ * is skipped FAIL-CLOSED for the same reason (an older CLI's reply is not proof
+ * of an empty inventory), rather than pushing every key blindly.
  */
 export function planReservedStoreSync(accounts, peers) {
     const keysByBundle = new Map();
@@ -274,6 +318,14 @@ export function planReservedStoreSync(accounts, peers) {
             items.push({ action: 'skip', device: peer.name, reason: 'headed device receives the account row, never a durable key' });
             continue;
         }
+        if (!peer.hasReply) {
+            items.push({ action: 'skip', device: peer.name, reason: SKIP_REASON_NO_PEER_REPLY });
+            continue;
+        }
+        if (!peer.hasAccountRows) {
+            items.push({ action: 'skip', device: peer.name, reason: SKIP_REASON_NO_ACCOUNT_ROWS });
+            continue;
+        }
         if (!peer.reachable) {
             items.push({ action: 'skip', device: peer.name, reason: 'unreachable' });
             continue;
@@ -318,14 +370,44 @@ export function reservedSyncTargets(meta) {
     }
     return out;
 }
-// --- publisher-side delivery memo -----------------------------------------
-// A push sends a WHOLE bundle; the receiver reports no per-key inventory today
-// (that is T3's per-account verdict seam). So the publisher records what it has
-// delivered to each peer, keyed by the credential's fingerprint, to answer "does
-// the peer already have this key" without re-pushing an unchanged bundle every
-// tick. A new account (no memo entry) or a re-mint (fingerprint change) is not a
-// hit, so it propagates within one tick. The memo is LOCAL publisher bookkeeping,
-// never synced.
+/** Narrow a peer's opaque `accounts.rows` to the verdict fields the planner reads. */
+export function readPeerAccountVerdicts(state) {
+    const rows = state?.accounts?.rows;
+    if (!Array.isArray(rows))
+        return [];
+    const out = [];
+    for (const row of rows) {
+        if (!row || typeof row !== 'object' || Array.isArray(row))
+            continue;
+        const r = row;
+        if (typeof r.accountId === 'string' && typeof r.harness === 'string' && typeof r.verdict === 'string') {
+            out.push({ accountId: r.accountId, harness: r.harness, verdict: r.verdict });
+        }
+    }
+    return out;
+}
+/**
+ * True when the peer's reply carried an `accounts.rows` array at all (present,
+ * even if empty). An older CLI, or a partial state written before the account-
+ * state daemon ran, has no such field — and its absence must NOT read as "the
+ * peer holds nothing", or the plan would push every key blindly. An EMPTY array
+ * (a peer with no registered account) IS a valid first-hand "holds nothing".
+ */
+export function peerHasAccountRows(state) {
+    return Array.isArray(state?.accounts?.rows);
+}
+// --- publisher-side delivery memo (rotation) -------------------------------
+// A peer's verdict says WHETHER it holds a working credential for an account, but
+// not WHICH one: a re-mint (`accounts login`) rotates the reserved key and bumps
+// `workerCredential.mintedAt`, yet the peer's OLD token keeps authenticating, so
+// its verdict stays `live`/`unverified` and never flips to `missing`. Verdict
+// alone would therefore read `present` forever and the new key would never reach
+// the worker. The publisher records the fingerprint it last delivered per
+// (peer, bundle, key); presence requires BOTH the peer's own verdict AND a
+// delivered-fingerprint match, so a re-mint (fingerprint change) re-pushes within
+// a tick while a key removed on the worker (verdict `missing`) also re-pushes.
+// LOCAL publisher bookkeeping, never synced — it is a rotation cursor, not a
+// substitute for the first-hand verdict.
 function deliveryMemoPath(root = getCacheDir()) {
     return path.join(root, 'reserved-sync-delivered.json');
 }
@@ -346,18 +428,29 @@ function writeDeliveryMemo(memo, root = getCacheDir()) {
     fs.writeFileSync(deliveryMemoPath(root), `${JSON.stringify(memo, null, 2)}\n`, 'utf-8');
 }
 /**
- * The keys a peer is KNOWN to hold, per bundle, from what we have delivered to it
- * (memo, matched by fingerprint) plus the coarse legacy-`auth` verdict: a peer
- * reporting `auth.status === 'ready'` is known to hold every legacy `auth` key.
- * Reserved `__<harness>__` bundles have no coarse verdict, so their presence comes
- * from the memo alone -- which is what makes a newly-added reserved account push.
+ * The reserved keys a peer is KNOWN to hold, per bundle. Two conditions must BOTH
+ * hold (PHNX-4116):
+ *
+ * 1. FIRST-HAND — the peer's own daemon-state reply reports a NON-`missing`
+ *    verdict for the account, so it has a working credential for it (its slot
+ *    materialized). A `missing` verdict, or no row for the account at all, means
+ *    it does not — self-correcting: a key removed on the worker flips its next
+ *    verdict to `missing` and the push resumes, which a publisher-side memo alone
+ *    could never see.
+ * 2. ROTATION — the fingerprint we last delivered to this peer (`delivered`)
+ *    matches the account's CURRENT fingerprint. A re-mint bumps
+ *    `workerCredential.mintedAt` while the old token still authenticates, so the
+ *    verdict stays non-`missing`; without this the rotated key would never
+ *    propagate. A never-delivered key (no memo entry ⇒ `undefined`) never
+ *    matches, so a newly-added account still pushes.
  */
-export function peerPresentKeys(peer, accounts, memo, legacyAuthReady) {
+export function peerPresentKeys(accounts, verdicts, delivered) {
+    const held = new Set(verdicts.filter((v) => v.verdict !== 'missing').map((v) => `${v.harness}:${v.accountId}`));
     const present = {};
     for (const account of accounts) {
-        const known = memo[memoKey(peer, account.bundle, account.key)] === account.fingerprint
-            || (legacyAuthReady && account.bundle === AUTH_STORE_ALIAS);
-        if (!known)
+        if (!held.has(`${account.harness}:${account.accountId}`))
+            continue;
+        if (delivered(account.bundle, account.key) !== account.fingerprint)
             continue;
         (present[account.bundle] ??= new Set()).add(account.key);
     }
@@ -425,13 +518,18 @@ export async function syncReservedStores(deps = {}) {
     }
     const memo = readDeliveryMemo(deps.cacheDir);
     const pinned = deps.isPinned ?? ((name) => isHostPinned(name, managedKnownHostsPath()));
-    const peers = devices.map((d) => ({
-        name: d.name,
-        headed: isHeadedDeviceRole(peerRole(d.name)),
-        reachable: isDialableDevice(d),
-        pinned: isDevicePinned(d, pinned),
-        presentKeys: peerPresentKeys(d.name, targets, memo, stateByDevice.get(normalizeHost(d.name))?.auth?.status === 'ready'),
-    }));
+    const peers = devices.map((d) => {
+        const state = stateByDevice.get(normalizeHost(d.name));
+        return {
+            name: d.name,
+            headed: isHeadedDeviceRole(peerRole(d.name)),
+            reachable: isDialableDevice(d),
+            pinned: isDevicePinned(d, pinned),
+            hasReply: state !== undefined,
+            hasAccountRows: peerHasAccountRows(state),
+            presentKeys: peerPresentKeys(targets, readPeerAccountVerdicts(state), (bundle, key) => memo[memoKey(d.name, bundle, key)]),
+        };
+    });
     const plan = planReservedStoreSync(targets, peers);
     const byName = new Map(devices.map((d) => [d.name, d]));
     const push = deps.push ?? ((bundle, host) => pushBundleToHostAsync(bundle, host, {
@@ -452,6 +550,9 @@ export async function syncReservedStores(deps = {}) {
             const out = await push(item.bundle, sshTarget(profile));
             if (out.ok) {
                 result.pushed.push({ device: item.device, bundle: item.bundle, keys: item.keys });
+                // Record the fingerprint delivered so an UNCHANGED key is not re-pushed
+                // next tick; a re-mint (new fingerprint) or a removed key (verdict flips
+                // `missing`) still re-pushes.
                 for (const key of item.keys) {
                     const fp = targets.find((t) => t.bundle === item.bundle && t.key === key)?.fingerprint;
                     if (fp)
@@ -469,6 +570,15 @@ export async function syncReservedStores(deps = {}) {
     writeDeliveryMemo(memo, deps.cacheDir ?? getCacheDir());
     return result;
 }
+/**
+ * Fire-and-forget the daemon log without pulling its module graph into every
+ * consumer of this file: `reconcileLocalWorkerSlots` is synchronous and only
+ * runs inside the daemon (where daemon.js is already loaded), so the dynamic
+ * import is paid only on the rare tick that actually drops a slot.
+ */
+function defaultWorkerSlotLog(level, message) {
+    void import('./daemon/daemon.js').then((m) => m.log(level, message)).catch(() => { });
+}
 function defaultSlotSeeded(harness, slotDir) {
     return harness === 'claude' ? isClaudeWorkerHomeSeeded(slotDir) : true;
 }
@@ -482,8 +592,10 @@ function defaultSlotSeeded(harness, slotDir) {
  * seeded (no `hasCompletedOnboarding`) is provisioned again so it converges.
  */
 export function reconcileLocalWorkerSlots(deps = {}) {
-    const result = { provisioned: [], skipped: [], errors: [] };
-    const role = deps.selfRole ?? selfConfiguredDeviceRole();
+    const result = { provisioned: [], dropped: [], skipped: [], errors: [] };
+    // `'selfRole' in deps` (not `??`) so a caller can inject an explicit `undefined`
+    // to mean "unmarked device"; a caller that omits it reads the real machine role.
+    const role = 'selfRole' in deps ? deps.selfRole : selfConfiguredDeviceRole();
     if (isHeadedDeviceRole(role))
         return result; // headed boxes provision via native login
     const meta = (deps.readMetaFn ?? readMeta)();
@@ -492,6 +604,41 @@ export function reconcileLocalWorkerSlots(deps = {}) {
     const provision = deps.provision ?? provisionWorkerSlot;
     const slotSeeded = deps.slotSeeded ?? defaultSlotSeeded;
     const byId = new Map(listNativeAccounts(meta).map((account) => [account.id, account]));
+    // Drop stale worker slots (PHNX-4116). A `deviceAccounts.slots` record whose
+    // accountId is no longer a registered native account is a leftover from an
+    // older account-id generation — every worker held 8 such duplicates, each a
+    // full HOME carrying a live setup-token in `.claude/.oauth_token`. Delete that
+    // credential (a 0600 file) and drop the record, but KEEP the slot directory:
+    // `.claude/projects` holds session transcripts. Fail closed — an empty
+    // registry is a transient read, and stripping every slot on it would wipe a
+    // healthy box's whole slot set, so drop nothing until the registry answers.
+    // This deletion runs ONLY on a device explicitly marked `worker`: provisioning
+    // above is safe on an unmarked box, but destroying a credential is not — an
+    // unmarked device is not headed (`isHeadedDeviceRole(undefined)` is false) yet
+    // must never run a credential-deleting branch.
+    if (role === 'worker' && byId.size > 0) {
+        const stale = Object.values(slots).filter((slot) => !byId.has(slot.accountId));
+        const droppable = [];
+        for (const slot of stale) {
+            try {
+                // force ignores an already-absent token; a real failure (EACCES) keeps
+                // the slot so the record is never dropped while its credential lingers.
+                fs.rmSync(path.join(slot.slotDir, '.claude', '.oauth_token'), { force: true });
+                droppable.push(slot);
+            }
+            catch (err) {
+                result.errors.push({ accountId: slot.accountId, message: `stale slot credential not removed, slot kept: ${err.message}` });
+            }
+        }
+        if (droppable.length > 0) {
+            (deps.dropSlots ?? dropSlots)(droppable.map((slot) => slot.accountId));
+            const log = deps.log ?? defaultWorkerSlotLog;
+            for (const slot of droppable) {
+                result.dropped.push(slot.accountId);
+                log('INFO', `worker-slot: dropped stale slot ${slot.accountId} — no longer a registered account; removed its credential, kept ${slot.slotDir} for transcripts`);
+            }
+        }
+    }
     // Resolve each account to the one (bundle, key) the push plan uses: a T1 row's
     // reserved `__<harness>__` key, or the legacy `auth` key by email for a claude
     // row predating T1. Both are worker credentials this box may already hold, so

package/dist/lib/session/active.d.ts

@@ -52,10 +52,10 @@ export declare function attributedSetLostPids(prev: Set<number>, next: Set<numbe
  * process table. `alive` receives the row's `startedAtMs` so callers can apply
  * the same pid-reuse guard {@link isPidAlive} uses elsewhere.
  */
-export declare function filterCachedUnattributed(sessions: ActiveSession[], attributed: Set<number>, alive: (pid: number, startedAtMs?: number) => boolean): ActiveSession[];
+export declare function filterCachedUnattributed(sessions: ActiveSession[], attributed: Set<number>, alive: (pid: number, startedAtMs?: number) => boolean, ppidMap?: Map<number, number>): ActiveSession[];
 type ActiveContext = 'terminal' | 'teams' | 'cloud' | 'headless';
 /** The SessionMeta fields the live-row backfill reads — the enrichment a running process cannot report. */
-export type BackfillMeta = Pick<SessionMeta, 'version' | 'account' | 'timestamp' | 'label' | 'firstUserMessage' | 'lastUserMessage' | 'generatedTitle' | 'ticketId' | 'prUrl' | 'prNumber' | 'origin' | 'routineName' | 'harness' | 'tokenCount' | 'durationMs' | 'subAgentCount' | 'lastActivity'>;
+export type BackfillMeta = Pick<SessionMeta, 'version' | 'account' | 'accountId' | 'accountKey' | 'timestamp' | 'label' | 'firstUserMessage' | 'lastUserMessage' | 'generatedTitle' | 'ticketId' | 'prUrl' | 'prNumber' | 'origin' | 'routineName' | 'harness' | 'tokenCount' | 'durationMs' | 'subAgentCount' | 'lastActivity'>;
 /**
  * Fold index-only enrichment onto live rows, then RE-DERIVE the recap for every
  * row it touched. The re-derive is load-bearing: `foldRecap` runs inside
@@ -65,6 +65,8 @@ export type BackfillMeta = Pick<SessionMeta, 'version' | 'account' | 'timestamp'
  * backfill call sites is what keeps them from drifting apart.
  */
 export declare function backfillActiveRowsFromMeta(sessions: ActiveSession[], metaById: Map<string, BackfillMeta>): void;
+/** Resolve a display name only when the indexed identity names one registered slot. */
+export declare function sessionAccountLabel(kind: string, session: Pick<SessionMeta, 'accountId' | 'accountKey' | 'account'>, accounts?: import("../account-registry.js").NativeAccount[]): string | undefined;
 export declare function backfillActiveRowsFromIndex(sessions: ActiveSession[]): void;
 export declare function isRunningLiveSession(s: ActiveSession): boolean;
 export declare function activeSessionProjectKey(s: Pick<ActiveSession, 'cwd' | 'context'>): string;
@@ -319,6 +321,13 @@ export interface ActiveSession {
      * `accountKey`.
      */
     account?: string;
+    /**
+     * Human account-slot name (e.g. `gmail` in `claude#gmail`), display-only.
+     * Backfilled alongside {@link account} from indexed accountId/accountKey/email
+     * and the account registry. Unknown or ambiguous slots stay undefined.
+     * Never group on this label; use the index's `accountKey`.
+     */
+    accountLabel?: string;
     /**
      * Last-activity epoch — the transcript's last write (mtime). Distinct from
      * {@link startedAtMs} (session START): a session begun 3h ago but last touched
@@ -486,7 +495,7 @@ export interface ActiveSession {
     };
     /**
      * The editor tab that launched this agent (`AGENT_TERMINAL_ID`), from the pid
-     * registry. This is the one identifier that survives an SSH hop AND a session
+     * registry or the published terminal entry. This is the one identifier that survives an SSH hop AND a session
      * rotation: a Factory tab offloaded to a device has no local process to inspect,
      * and its spawn-time session id goes stale the moment the agent moves to another
      * session (`/clear`, exit-and-rerun), so `--active --device <device>` joined on
@@ -494,6 +503,8 @@ export interface ActiveSession {
      * did not inherit a terminal id.
      */
     terminalId?: string;
+    /** Published editor tab index, retained across agent restarts. */
+    tabIndex?: number;
     /**
      * The launch id (`AGENT_LAUNCH_ID`) the CLI stamps on every agent at spawn — a
      * stable UUID that is identical locally and across an SSH hop and survives a
@@ -501,9 +512,8 @@ export interface ActiveSession {
      * non-Claude harnesses only mint after boot) it exists from the first tick, so
      * it is the join key a client uses to re-identify a session on the watch stream.
      * Populated wherever the by-pid launch registry resolves — reliably for
-     * `agents run`-launched processes; still absent for editor-launched terminals
-     * whose shell pid does not line up with the agent-pid registry today (the same
-     * limitation the `readPidSessionEntry` call in `listTerminalsActive` documents).
+     * `agents run`-launched processes and editor terminals with a recorded live
+     * agent descendant.
      */
     launchId?: string;
     /**
@@ -750,6 +760,7 @@ interface ProcRow {
     tty?: string;
     comm: string;
     kind?: string;
+    startTime?: string;
 }
 /** Parse `ConvertTo-Csv` output of Win32_Process rows. Exported for tests. */
 export declare function parseWin32ProcessCsv(out: string): ProcRow[];

package/dist/lib/session/active.js

@@ -24,7 +24,9 @@ import { execFile, execFileSync } from 'child_process';
 import { promisify } from 'util';
 import { listActiveTasks } from '../cloud/store.js';
 import { AgentManager } from '../teams/agents.js';
-import { getTerminalsDir } from '../state.js';
+import { getTerminalsDir, readMeta } from '../state.js';
+import { listNativeAccounts } from '../account-registry.js';
+import { parseNativeIdentityKey } from '../native-accounts.js';
 import { readLivePidSessionEntry as readPidSessionEntry, listPidSessionEntries, prunePidSessionRegistry, sessionIdFromLivePid, isSessionIdShape, } from './pid-registry.js';
 import { readSessionActorRecord, writeSessionAliasRecord } from './actor-sidecar.js';
 import { loadHookSessionIndex, resolveHookSessionRecord, readStateSessionRecord } from './hook-sessions.js';
@@ -129,11 +131,11 @@ export function attributedSetLostPids(prev, next) {
  * process table. `alive` receives the row's `startedAtMs` so callers can apply
  * the same pid-reuse guard {@link isPidAlive} uses elsewhere.
  */
-export function filterCachedUnattributed(sessions, attributed, alive) {
+export function filterCachedUnattributed(sessions, attributed, alive, ppidMap) {
     return sessions.filter((s) => {
         if (s.pid == null)
             return false;
-        if (attributed.has(s.pid))
+        if (attributed.has(s.pid) || (ppidMap && hasAttributedAncestor(s.pid, ppidMap, attributed)))
             return false;
         return alive(s.pid, s.startedAtMs);
     });
@@ -147,6 +149,7 @@ export function filterCachedUnattributed(sessions, attributed, alive) {
  * backfill call sites is what keeps them from drifting apart.
  */
 export function backfillActiveRowsFromMeta(sessions, metaById) {
+    const accounts = listNativeAccounts(readMeta());
     for (const s of sessions) {
         if (!s.sessionId)
             continue;
@@ -157,6 +160,7 @@ export function backfillActiveRowsFromMeta(sessions, metaById) {
             s.version = m.version;
         if (!s.account && m.account)
             s.account = m.account;
+        s.accountLabel ??= sessionAccountLabel(s.kind, m, accounts);
         if (!s.label && m.label)
             s.label = m.label;
         if (!s.firstUserMessage && m.firstUserMessage)
@@ -196,6 +200,30 @@ export function backfillActiveRowsFromMeta(sessions, metaById) {
         applyRecap(s);
     }
 }
+/** Resolve a display name only when the indexed identity names one registered slot. */
+export function sessionAccountLabel(kind, session, accounts = listNativeAccounts(readMeta())) {
+    const matches = accounts.filter(account => {
+        if (account.agent !== kind)
+            return false;
+        if (session.accountId)
+            return account.id === session.accountId;
+        if (session.accountKey && !session.accountKey.startsWith('unattributed:')) {
+            // Claude's index groups quota by org; the registry names a login within it.
+            const indexed = parseNativeIdentityKey(account.agent, session.accountKey);
+            const emailMatches = !!session.account && account.identityLabel?.toLowerCase() === session.account.toLowerCase();
+            if (!indexed || (!indexed.account && !emailMatches))
+                return false;
+            if (account.identityKey === session.accountKey)
+                return true;
+            const registered = parseNativeIdentityKey(account.agent, account.identityKey);
+            return !!registered
+                && Object.entries(indexed).every(([key, value]) => registered[key] === value)
+                && (!session.account || emailMatches);
+        }
+        return !!session.account && account.identityLabel?.toLowerCase() === session.account.toLowerCase();
+    });
+    return matches.length === 1 ? matches[0].name : undefined;
+}
 function loadBackfillMetaFor(sessions) {
     const byId = new Map();
     try {
@@ -1062,49 +1090,48 @@ export async function listTerminalsActive() {
     const procByPid = new Map();
     for (const r of await readProcessTable())
         procByPid.set(r.pid, r);
+    const children = childrenByParent(new Map([...procByPid.values()].map(r => [r.pid, r.ppid])));
     // Build label map from Claude's sessions/*.json for /rename support
     const labelMap = buildClaudeLabelMap();
     // Run-name handles (`agents run --name`) keyed by session id, for the same
     // sessionId → handle resolution as labels.
     const runNameMap = buildRunNameMap();
     return entries.map((t) => {
-        // The id cached in live-terminals.json goes stale when Claude rotates its
-        // transcript uuid on resume/compact, so it often no longer matches any
-        // <id>.jsonl. When the pid registry knows this pid's current id, prefer it —
-        // the same source the headless path uses. NOTE: live-terminals.json stores the
-        // SHELL pid, while the by-pid registry is keyed by the AGENT pid, so for
-        // editor-launched terminals this lookup returns undefined today and we fall
-        // back to the stale cached id — the duplicate-card fix comes from
-        // pickSessionFile no longer borrowing a sibling, not from this lookup. Kept as
-        // a forward-looking hook for the cases where the pid does line up.
-        const pidEntry = readPidSessionEntry(t.pid);
+        // Keep the shell pid for tab ownership and headless suppression; the live
+        // agent below it owns the session after an exit-and-rerun in the same tab.
+        const directEntry = readPidSessionEntry(t.pid, procByPid.get(t.pid)?.startTime);
+        const candidate = directEntry?.sessionId ? directEntry
+            : (!t.pidDead ? terminalDescendantEntry(t.pid, procByPid, children) : undefined) ?? directEntry;
+        const pidEntry = candidate && (!isSessionTrackedAgent(t.kind) || candidate.agent === t.kind) ? candidate : undefined;
         const resolvedId = pidEntry?.sessionId ?? t.sessionId;
-        const sessionFile = findSessionFileForKind(t.kind, t.cwd ?? undefined, resolvedId);
-        // Prefer label from live terminal, fall back to Claude's session label
-        const label = t.label ?? (t.sessionId ? labelMap.get(t.sessionId) : undefined) ?? undefined;
+        const cwd = pidEntry?.cwd ?? t.cwd ?? undefined;
+        const sessionKind = pidEntry?.agent ?? t.kind;
+        const sessionFile = findSessionFileForKind(sessionKind, cwd, resolvedId);
+        const label = t.label ?? (resolvedId ? labelMap.get(resolvedId) : undefined) ?? undefined;
         // Durable run name from `agents run --name`, resolved by the run's session id.
         const name = resolvedId ? runNameMap.get(resolvedId) ?? undefined : undefined;
         // Extract topic from session file (first meaningful user message)
         const topic = sessionFile ? quickExtractTopic(sessionFile) : undefined;
         const pidAlive = isPidAlive(t.pid, t.startedAtMs);
-        const { state, tokPerSec } = computeLiveSignals(t.kind, sessionFile, t.cwd ?? undefined, pidAlive);
+        const { state, tokPerSec } = computeLiveSignals(sessionKind, sessionFile, cwd, pidAlive);
         return applyState({
             context: 'terminal',
-            kind: t.kind,
+            kind: sessionKind,
             harness: pidEntry?.harness,
             host: detectHost(t.pid, procByPid),
             tty: procByPid.get(t.pid)?.tty,
             pid: t.pid,
-            sessionId: t.sessionId ?? sessionIdFromFile(sessionFile),
+            sessionId: resolvedId ?? sessionIdFromFile(sessionFile),
             launchId: pidEntry?.launchId,
-            terminalId: pidEntry?.terminalId,
-            cwd: t.cwd ?? undefined,
+            terminalId: pidEntry?.terminalId ?? t.terminalId,
+            tabIndex: t.tabIndex,
+            cwd,
             label,
             name,
             topic,
             tokPerSec,
             sessionFile,
-            startedAtMs: t.startedAtMs,
+            startedAtMs: pidEntry?.startedAtMs ?? t.startedAtMs,
             lastActivityMs: sessionFileTimes(sessionFile).mtimeMs,
             windowId: t.windowId,
             windowHeartbeatMs: t.windowHeartbeatMs,
@@ -1183,16 +1210,16 @@ async function readProcessTableLive() {
         return readProcessTableWin32();
     let out;
     try {
-        ({ stdout: out } = await execFileAsync('ps', ['-A', '-o', 'pid=,ppid=,tty=,comm='], { encoding: 'utf8', maxBuffer: 16 * 1024 * 1024, timeout: PS_SNAPSHOT_TIMEOUT_MS }));
+        ({ stdout: out } = await execFileAsync('ps', ['-A', '-o', 'pid=,ppid=,tty=,lstart=,comm='], { encoding: 'utf8', maxBuffer: 16 * 1024 * 1024, timeout: PS_SNAPSHOT_TIMEOUT_MS }));
     }
     catch {
         return [];
     }
     const rows = [];
     for (const line of out.split('\n')) {
-        // pid ppid tty comm — tty is a single token ('ttys003', 's003', or '??'/'?'
+        // pid ppid tty lstart comm — tty is a single token ('ttys003', 's003', or '??'/'?'
         // for none); comm stays last so it may contain spaces.
-        const m = line.trim().match(/^(\d+)\s+(\d+)\s+(\S+)\s+(.+)$/);
+        const m = line.trim().match(/^(\d+)\s+(\d+)\s+(\S+)\s+(\S+\s+\S+\s+\d+\s+\S+\s+\d+)\s+(.+)$/);
         if (!m)
             continue;
         const pid = parseInt(m[1], 10);
@@ -1201,8 +1228,8 @@ async function readProcessTableLive() {
             continue;
         const ttyRaw = m[3];
         const tty = ttyRaw === '??' || ttyRaw === '?' || ttyRaw === '-' ? undefined : ttyRaw;
-        const commRaw = m[4].trim();
-        rows.push({ pid, ppid, tty, comm: commRaw, kind: agentKindFromComm(commRaw) });
+        const commRaw = m[5].trim();
+        rows.push({ pid, ppid, tty, startTime: m[4], comm: commRaw, kind: agentKindFromComm(commRaw) });
     }
     return rows;
 }
@@ -1240,6 +1267,50 @@ export function parseWin32ProcessCsv(out) {
     }
     return rows;
 }
+function childrenByParent(ppidMap) {
+    const children = new Map();
+    for (const [pid, ppid] of ppidMap) {
+        const siblings = children.get(ppid);
+        if (siblings)
+            siblings.push(pid);
+        else
+            children.set(ppid, [pid]);
+    }
+    return children;
+}
+function terminalDescendantEntry(pid, processes, children) {
+    // Windows only proves pidExists: a recycled PID can be a live shell descendant.
+    // Retain the published identity until that platform can prove process starts.
+    if (process.platform === 'win32')
+        return undefined;
+    let pending = children.get(pid) ?? [];
+    const seen = new Set([pid]);
+    while (pending.length) {
+        const next = [];
+        let recordedAgent = false;
+        let newest;
+        for (const child of pending) {
+            if (seen.has(child))
+                continue;
+            seen.add(child);
+            const entry = readPidSessionEntry(child, processes.get(child)?.startTime);
+            if (!entry || !isSessionTrackedAgent(entry.agent)) {
+                next.push(...(children.get(child) ?? []));
+                continue;
+            }
+            // A recorded agent is a boundary even before its session ID is known:
+            // its tools may launch agents of their own, which never own this tab.
+            recordedAgent = true;
+            if (entry.sessionId && (!newest || entry.startedAtMs > newest.startedAtMs
+                || (entry.startedAtMs === newest.startedAtMs && entry.pid > newest.pid)))
+                newest = entry;
+        }
+        if (recordedAgent)
+            return newest;
+        pending = next;
+    }
+    return undefined;
+}
 /**
  * True when any ancestor in pid's parent chain is a known attributed PID.
  * VS Code / Cursor terminals store the *shell* PID in live-terminals.json,
@@ -1456,11 +1527,11 @@ export async function listUnattributedActive(attributed) {
     if (unattributedCache &&
         now - unattributedCache.at < UNATTRIBUTED_RESCAN_MS &&
         !attributedSetLostPids(unattributedCache.attributed, attributed)) {
-        return filterCachedUnattributed(unattributedCache.sessions, attributed, isPidAlive);
+        return filterCachedUnattributed(unattributedCache.sessions, attributed, isPidAlive, unattributedCache.ppidMap);
     }
-    const out = await listUnattributedActiveLive(attributed);
-    unattributedCache = { at: now, attributed: new Set(attributed), sessions: out };
-    return out;
+    const result = await listUnattributedActiveLive(attributed);
+    unattributedCache = { at: now, attributed: new Set(attributed), ...result };
+    return result.sessions;
 }
 /** Unthrottled headless scan (live process table + cwd probes). */
 async function listUnattributedActiveLive(attributed) {
@@ -1495,28 +1566,13 @@ async function listUnattributedActiveLive(attributed) {
     // lacks an exact launch-time id, so an all-Claude set does neither. The ~3s
     // poll must not re-read the dir (or re-invert the map) per candidate.
     let hookIndex;
-    let childrenByParent;
+    let children;
     // Durable `agents run --name` handles keyed by session id — the same source the
     // terminal path uses to name a row. Headless agents have no live-terminals
     // label and no /rename, so without this a `--name`d headless run would surface
     // with only a topic and no tab title. Built once per scan.
     const runNameMap = buildRunNameMap();
-    const ensureChildren = () => {
-        if (childrenByParent)
-            return childrenByParent;
-        const m = new Map();
-        // The hook records under the agent pid; a wrapper/shell pid we recorded has
-        // the agent as a child, so we resolve via a recorded pid's immediate children.
-        for (const [childPid, parentPid] of ppidMap) {
-            const arr = m.get(parentPid);
-            if (arr)
-                arr.push(childPid);
-            else
-                m.set(parentPid, [childPid]);
-        }
-        childrenByParent = m;
-        return m;
-    };
+    const ensureChildren = () => children ??= childrenByParent(ppidMap);
     const out = [];
     for (let i = 0; i < kept.length; i++) {
         const { pid, kind } = kept[i];
@@ -1603,7 +1659,7 @@ async function listUnattributedActiveLive(attributed) {
     }
     // Housekeeping: drop registry files for pids that have since died.
     prunePidSessionRegistry(isPidAlive);
-    return out;
+    return { sessions: out, ppidMap };
 }
 /**
  * Attribute a single tmux pane to the agent actually running in it.

package/dist/lib/session/db.d.ts

@@ -14,7 +14,7 @@ import { type TimelineState } from './timeline.js';
 /** Current schema version; bumped when migrations are added. Exported so tests
  * assert against the constant instead of hardcoding a number that every bump
  * then has to chase (docs/sessions.md calls the constant the source of truth). */
-export declare const SCHEMA_VERSION = 50;
+export declare const SCHEMA_VERSION = 51;
 /**
  * Bump to force the content extractor (assistant-answer text, alongside the
  * user-prompt text every harness already accumulates) to re-derive on every