@phnx-labs/agents-cli 1.22.118 → 1.22.119

package/dist/lib/projects.js

@@ -411,6 +411,37 @@ function projectRootsAbs(defs) {
     }
     return out;
 }
+/**
+ * The repository paths a project claims, as `{ slug, prefix }` with `prefix`
+ * repo-relative and `dir/` shaped — the same ownership {@link projectRootsAbs}
+ * applies to a session's cwd, expressed against the repository instead of a
+ * checkout: a `defaultPath` narrowed under `root` claims that subtree of the
+ * primary `repo`, and a `repos[]` entry with a `subpath` claims that subpath. A
+ * project with no narrowed claim on a repository claims all of it and yields no
+ * row for it. Two cases of {@link projectRootsAbs} have no repository form and
+ * yield nothing here: a `defaultPath` outside `root` (no repo-relative path),
+ * and the weak root of a narrowed project (it only takes what nobody claims,
+ * which for a PR is the `repo-wide` scope).
+ */
+export function repoPathClaims(def) {
+    const out = [];
+    const add = (slug, rel) => {
+        const trimmed = rel.split(path.sep).join('/').replace(/^\.\/+/, '').replace(/\/+$/, '');
+        if (trimmed && trimmed !== '.')
+            out.push({ slug, prefix: `${trimmed}/` });
+    };
+    if (def.repo && def.root && def.defaultPath) {
+        const rootAbs = path.resolve(expandLocalHome(def.root));
+        const defaultAbs = path.resolve(expandLocalHome(def.defaultPath));
+        if (isUnder(defaultAbs, rootAbs))
+            add(def.repo, path.relative(rootAbs, defaultAbs));
+    }
+    for (const r of def.repos ?? []) {
+        if (r.slug && r.subpath)
+            add(r.slug, r.subpath);
+    }
+    return out;
+}
 /** True when `child` is `parent` or nested under it (path-segment aware). */
 function isUnder(child, parent) {
     if (child === parent)

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/pid-registry.d.ts

@@ -58,8 +58,10 @@ export interface PidSessionEntry {
         startTime?: string;
     };
 }
+/** ps lstart fields can differ in padding or date formatting between invocations. */
+export declare function processStartTimesMatch(recorded: string | undefined, observed: string | undefined): boolean | undefined;
 /** Read-only identity proof for exact joins. Unknown is never a positive match. */
-export declare function pidSessionEntryMatchesLiveProcess(entry: PidSessionEntry): boolean | undefined;
+export declare function pidSessionEntryMatchesLiveProcess(entry: PidSessionEntry, startTime?: string): boolean | undefined;
 export declare function isSessionIdShape(value: string): boolean;
 export declare function extractSessionIdArg(args: string[]): string | undefined;
 /**
@@ -86,8 +88,9 @@ export declare function sessionIdFromLivePid(pid: number): string | undefined;
 export declare function writePidSessionEntry(entry: PidSessionEntry): void;
 /** Look up a live pid's recorded session. Returns undefined if absent/corrupt. */
 export declare function readPidSessionEntry(pid: number): PidSessionEntry | undefined;
-/** Live consumers require identity proof; raw history is not a PID binding. */
-export declare function readLivePidSessionEntry(pid: number): PidSessionEntry | undefined;
+/** Live consumers require identity proof; raw history is not a PID binding.
+ * A shared process snapshot may supply lstart to avoid a per-pid ps probe. */
+export declare function readLivePidSessionEntry(pid: number, startTime?: string): PidSessionEntry | undefined;
 /**
  * Every recorded launch, one entry per live-or-dead pid. Used to index launches
  * by their `tmuxPane` so the authoritative tmux source can attribute a pane it did

package/dist/lib/session/pid-registry.js

@@ -55,16 +55,25 @@ function darwinStartTime(pid) {
         return undefined;
     }
 }
+function processStartTimeMs(value) {
+    return typeof value === 'string' ? Date.parse(value.trim().replace(/\s+/g, ' ')) : NaN;
+}
+/** ps lstart fields can differ in padding or date formatting between invocations. */
+export function processStartTimesMatch(recorded, observed) {
+    const recordedMs = processStartTimeMs(recorded);
+    const observedMs = processStartTimeMs(observed);
+    return Number.isFinite(recordedMs) && Number.isFinite(observedMs) ? recordedMs === observedMs : undefined;
+}
 /** Read-only identity proof for exact joins. Unknown is never a positive match. */
-export function pidSessionEntryMatchesLiveProcess(entry) {
+export function pidSessionEntryMatchesLiveProcess(entry, startTime) {
     if (!Number.isInteger(entry.pid) || entry.pid < 1)
         return undefined;
     if (process.platform === 'darwin') {
         const exists = pidExists(entry.pid);
         if (exists !== true)
             return exists;
-        const start = darwinStartTime(entry.pid);
-        return start && entry.processIdentity?.startTime ? start === entry.processIdentity.startTime : undefined;
+        const start = startTime ?? darwinStartTime(entry.pid);
+        return processStartTimesMatch(entry.processIdentity?.startTime, start);
     }
     if (process.platform !== 'linux')
         return undefined;
@@ -233,8 +242,9 @@ export function readPidSessionEntry(pid) {
     }
     return undefined;
 }
-/** Live consumers require identity proof; raw history is not a PID binding. */
-export function readLivePidSessionEntry(pid) {
+/** Live consumers require identity proof; raw history is not a PID binding.
+ * A shared process snapshot may supply lstart to avoid a per-pid ps probe. */
+export function readLivePidSessionEntry(pid, startTime) {
     const entry = readPidSessionEntry(pid);
     if (!entry || !hostProcessView())
         return undefined;
@@ -244,8 +254,8 @@ export function readLivePidSessionEntry(pid) {
         // Upgrade a native legacy launch only after the home namespace is proven,
         // and the actual process start excludes a recycled PID. Hook timestamps may
         // be later than process start, but cannot predate this process incarnation.
-        const start = darwinStartTime(pid);
-        const startMs = start ? Date.parse(start) : NaN;
+        const start = startTime ?? darwinStartTime(pid);
+        const startMs = processStartTimeMs(start);
         if (Number.isFinite(startMs) && entry.startedAtMs >= startMs - 1000 && entry.startedAtMs <= Date.now()) {
             const scope = hostProcessView();
             entry.processIdentity = process.platform === 'linux'
@@ -257,7 +267,7 @@ export function readLivePidSessionEntry(pid) {
             catch { /* read remains useful */ }
         }
     }
-    return pidSessionEntryMatchesLiveProcess(entry) === true ? entry : undefined;
+    return pidSessionEntryMatchesLiveProcess(entry, startTime) === true ? entry : undefined;
 }
 /**
  * Every recorded launch, one entry per live-or-dead pid. Used to index launches

package/dist/lib/session/remote/watch.d.ts

@@ -88,7 +88,7 @@ export declare function sessionWatchRowKey(scope: string, row: ActiveSession): s
 export declare function toSessionWatchRow(scope: string, row: ActiveSession): SessionWatchRow;
 /** Project one durable indexed session into the same canonical watch contract
  * as live sessions. This is the only history backfill consumed by AGI EXT. */
-export declare function toPreviousSessionWatchRow(scope: string, session: SessionMeta): SessionWatchRow;
+export declare function toPreviousSessionWatchRow(scope: string, session: SessionMeta, accounts?: import("../../account-registry.js").NativeAccount[]): SessionWatchRow;
 /** Stream-local sequencer and convergent row diff. */
 export declare class SessionWatchState {
     readonly streamId: string;

package/dist/lib/session/remote/watch.js

@@ -8,7 +8,9 @@ import { machineId, normalizeHost } from '../../machine-id.js';
 import { shellQuote } from '../../ssh-exec.js';
 import { streamFromPeer } from './peer-stream.js';
 import { buildWindowsAgentsCommand, remoteShellFor } from '../../hosts/remote-cmd.js';
-import { isReapableOrphan } from '../active.js';
+import { isReapableOrphan, sessionAccountLabel } from '../active.js';
+import { listNativeAccounts } from '../../account-registry.js';
+import { readMeta } from '../../state.js';
 import { querySessions, readSessionSummaryAny, readSessionTimelineAny } from '../db.js';
 import { linearIssueUrl } from '../linear.js';
 import { sessionAgentSupportsResume } from '../recovery.js';
@@ -79,7 +81,7 @@ function previousRowTitle(session, foldedHeadline) {
 }
 /** Project one durable indexed session into the same canonical watch contract
  * as live sessions. This is the only history backfill consumed by AGI EXT. */
-export function toPreviousSessionWatchRow(scope, session) {
+export function toPreviousSessionWatchRow(scope, session, accounts = listNativeAccounts(readMeta())) {
     const resumable = sessionAgentSupportsResume(session.agent);
     const sourceDevice = normalizeHost(session.machine ?? scope);
     const startedAtMs = epochMs(session.timestamp);
@@ -125,6 +127,7 @@ export function toPreviousSessionWatchRow(scope, session) {
         ...(session.firstUserMessage ? { firstUserMessage: session.firstUserMessage } : {}),
         ...(session.version ? { version: session.version } : {}),
         ...(session.account ? { account: session.account } : {}),
+        accountLabel: sessionAccountLabel(session.agent, session, accounts),
         ...(session.prUrl ? { pr: { url: session.prUrl, number: session.prNumber } } : {}),
         ...(worktree ? { worktree } : {}),
         ...(session.gitBranch ? { branch: session.gitBranch } : {}),
@@ -226,10 +229,11 @@ export class SessionWatchState {
         const liveRows = sourceRows.map((row) => toSessionWatchRow(scope, row));
         const sourceIds = new Set(liveRows.map((row) => row.sessionId).filter((id) => Boolean(id)));
         const rows = new Map(liveRows.map((row) => [row.rowKey, row]));
+        const accounts = indexedRows.length ? listNativeAccounts(readMeta()) : [];
         for (const indexed of indexedRows) {
             if (sourceIds.has(indexed.id))
                 continue;
-            const row = toPreviousSessionWatchRow(scope, indexed);
+            const row = toPreviousSessionWatchRow(scope, indexed, accounts);
             rows.set(row.rowKey, row);
         }
         this.prunePrevious(scope, rows);

package/dist/lib/types.d.ts

@@ -199,6 +199,12 @@ export interface AgentConfig {
      * without this flag only see plugin skills through the flattened copies.
      */
     nativePluginSkills?: boolean;
+    /**
+     * Directories under the version home's `skills/` that the harness itself
+     * writes (Claude Code's `synced` bucket). The sync never placed them, so the
+     * full-sync orphan sweep and skill cleanup must never remove them.
+     */
+    ownedSkillDirs?: readonly string[];
     /**
      * This agent's *own* cloud backend. `agents cloud run --agent <id>` routes
      * here when no `--provider` is given (precedence: --provider > this >

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.22.118",
+  "version": "1.22.119",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",