@phnx-labs/agents-cli 1.22.27 → 1.22.29

package/dist/lib/session/active.js

@@ -71,6 +71,74 @@ const LSOF_STAGGER_MS = 10;
  */
 const LSOF_TIMEOUT_MS = 5_000;
 const PS_SNAPSHOT_TIMEOUT_MS = 10_000;
+/**
+ * Process-local process-table memo (#2047). One `getActiveSessions` scan can
+ * call `ps -A` from the terminal path, the headless path, and host ancestry —
+ * without this, each is a full process-table snapshot. 5s is well under the
+ * ~10–30s menu-bar / `--active` poll so a quiet re-poll usually reuses the
+ * snapshot; a brand-new agent pid still appears on the next full refresh.
+ */
+export const PROCESS_TABLE_FRESH_MS = 5_000;
+/**
+ * How long {@link listUnattributedActive} may reuse its last full `ps`+`lsof`
+ * result (#2047). Between full rescans the previous rows are re-emitted after
+ * dropping dead PIDs and PIDs that are now attributed. A *shrinking* attributed
+ * set forces a rescan so a process that just left teams/terminals can reappear
+ * as headless instead of vanishing until the next cold poll.
+ */
+export const UNATTRIBUTED_RESCAN_MS = 15_000;
+/** Injectable clock for the active-scan memos (tests only). */
+let activeScanNow = () => Date.now();
+/** Test seam: override the clock used by process-table / unattributed memos. */
+export function setActiveScanClockForTest(fn) {
+    activeScanNow = fn ?? (() => Date.now());
+}
+let processTableCache;
+let processTableLiveReads = 0;
+let unattributedCache;
+let unattributedFullRescans = 0;
+/** Test seam: drop the process-table + unattributed memos and their counters. */
+export function clearActiveScanCachesForTest() {
+    processTableCache = undefined;
+    processTableLiveReads = 0;
+    unattributedCache = undefined;
+    unattributedFullRescans = 0;
+    activeScanNow = () => Date.now();
+}
+/** Test seam: how many times the live `ps` / CIM path actually ran. */
+export function processTableLiveReadCountForTest() {
+    return processTableLiveReads;
+}
+/** Test seam: how many full unattributed (ps + lsof) rescans ran. */
+export function unattributedFullRescanCountForTest() {
+    return unattributedFullRescans;
+}
+/**
+ * True when any pid in `prev` is absent from `next` — the attributed set
+ * shrank, so a process may need to reappear as unattributed. Pure for tests.
+ */
+export function attributedSetLostPids(prev, next) {
+    for (const p of prev) {
+        if (!next.has(p))
+            return true;
+    }
+    return false;
+}
+/**
+ * Drop rows whose pid is now attributed or no longer alive. Pure over the
+ * inputs so the unattributed TTL reuse path is unit-testable without a live
+ * 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) {
+    return sessions.filter((s) => {
+        if (s.pid == null)
+            return false;
+        if (attributed.has(s.pid))
+            return false;
+        return alive(s.pid, s.startedAtMs);
+    });
+}
 export function activeStatusFromCloudStatus(status) {
     switch (status) {
         case 'running':
@@ -373,6 +441,19 @@ function readLiveTerminals() {
 function claudeProjectDirName(cwd) {
     return cwd.replace(/[/.]/g, '-');
 }
+/**
+ * Process-local memo for Claude transcript path resolution. Each active-session
+ * poll re-walks every Claude version-home `projects/` tree for every live pid
+ * (#2047). A resolved path is sticky while the file still exists; a miss or a
+ * vanished file re-walks. Cap size so a long-lived process cannot retain every
+ * cwd it has ever seen.
+ */
+const CLAUDE_SESSION_FILE_CACHE_MAX = 256;
+const claudeSessionFileCache = new Map();
+/** Test seam: drop the Claude session-file path memo. */
+export function clearClaudeSessionFileCacheForTest() {
+    claudeSessionFileCache.clear();
+}
 /**
  * Locate the active Claude session file for a process. If we know the session
  * UUID (from terminal env or team parent), prefer the exact match. Otherwise
@@ -390,6 +471,28 @@ function claudeProjectDirName(cwd) {
  * the rest of the CLI uses, so this stays in lockstep with discovery.
  */
 function findClaudeSessionFile(cwd, sessionId) {
+    // Only memoize when the exact session UUID is known. Without an id the
+    // resolver picks newest-by-mtime under the project dir; caching that path
+    // would stick to an old transcript after a new session starts in the same cwd.
+    if (sessionId) {
+        const cacheKey = `${cwd}\0${sessionId}`;
+        const hit = claudeSessionFileCache.get(cacheKey);
+        if (hit !== undefined) {
+            try {
+                if (fs.existsSync(hit))
+                    return hit;
+            }
+            catch { /* re-resolve */ }
+            claudeSessionFileCache.delete(cacheKey);
+        }
+        const resolved = pickClaudeSessionFileAcrossRoots(getAgentSessionDirs('claude', 'projects'), cwd, sessionId);
+        if (resolved) {
+            if (claudeSessionFileCache.size >= CLAUDE_SESSION_FILE_CACHE_MAX)
+                claudeSessionFileCache.clear();
+            claudeSessionFileCache.set(cacheKey, resolved);
+        }
+        return resolved;
+    }
     return pickClaudeSessionFileAcrossRoots(getAgentSessionDirs('claude', 'projects'), cwd, sessionId);
 }
 /**
@@ -562,6 +665,19 @@ function parseTailEventsForKind(agent, sessionFile) {
     }
     return events.length > LIVE_STATE_MAX_EVENTS ? events.slice(-LIVE_STATE_MAX_EVENTS) : events;
 }
+/**
+ * Process-local memo for {@link computeLiveSignals}. The menu-bar / `--active`
+ * poll re-reads every live session on a ~30s tick (#2047). When a transcript's
+ * mtime (and pidAlive / kind / cwd) are unchanged, re-parsing the tail yields
+ * the same signals — skip the parse. Bound the map so a long-lived daemon that
+ * sees thousands of sessions over its life cannot retain them forever.
+ */
+const LIVE_SIGNALS_CACHE_MAX = 512;
+const liveSignalsCache = new Map();
+/** Test seam: drop the in-process live-signals memo. */
+export function clearLiveSignalsCacheForTest() {
+    liveSignalsCache.clear();
+}
 /**
  * Derive the inferred state (working / waiting / idle + preview/badges) and, for
  * the two harnesses whose raw lines carry it, the output-token throughput.
@@ -575,6 +691,9 @@ function parseTailEventsForKind(agent, sessionFile) {
  * `unknown` it used to fall through to. An opaque/untracked kind or an
  * unreadable/empty transcript yields an empty signal set, and the caller's
  * {@link resolveFallbackStatus} reports the honest live floor (`running`).
+ *
+ * Unchanged-mtime hits reuse the previous result (see {@link liveSignalsCache})
+ * so a 30s active-session poll does not re-tail every quiet transcript.
  */
 export function computeLiveSignals(kind, sessionFile, cwd, pidAlive) {
     if (!sessionFile)
@@ -584,21 +703,31 @@ export function computeLiveSignals(kind, sessionFile, cwd, pidAlive) {
         mtimeMs = fs.statSync(sessionFile).mtimeMs;
     }
     catch { /* vanished between calls */ }
+    const cacheKey = `${kind}\0${sessionFile}\0${cwd ?? ''}`;
+    const cached = liveSignalsCache.get(cacheKey);
+    if (cached && cached.mtimeMs === mtimeMs && cached.pidAlive === pidAlive) {
+        return cached.signals;
+    }
     const ctx = { cwd, pidAlive, mtimeMs, activeWindowMs: ACTIVE_MTIME_WINDOW_MS };
+    let signals = {};
     if (kind === 'claude' || kind === 'codex') {
         const { events, content } = readSessionTailWithRaw(sessionFile, kind);
-        if (events.length === 0)
-            return {};
-        const state = inferSessionState(events, ctx);
-        const tokPerSec = computeTokPerSec(content, kind);
-        return { state, tokPerSec: tokPerSec > 0 ? tokPerSec : undefined };
+        if (events.length > 0) {
+            const state = inferSessionState(events, ctx);
+            const tokPerSec = computeTokPerSec(content, kind);
+            signals = { state, tokPerSec: tokPerSec > 0 ? tokPerSec : undefined };
+        }
     }
-    if (!isSessionTrackedAgent(kind))
-        return {};
-    const events = parseTailEventsForKind(kind, sessionFile);
-    if (events.length === 0)
-        return {};
-    return { state: inferSessionState(events, ctx) };
+    else if (isSessionTrackedAgent(kind)) {
+        const events = parseTailEventsForKind(kind, sessionFile);
+        if (events.length > 0) {
+            signals = { state: inferSessionState(events, ctx) };
+        }
+    }
+    if (liveSignalsCache.size >= LIVE_SIGNALS_CACHE_MAX)
+        liveSignalsCache.clear();
+    liveSignalsCache.set(cacheKey, { mtimeMs, pidAlive, signals });
+    return signals;
 }
 /** Map inferred activity onto the coarse ActiveStatus used by the renderer and counts. */
 function statusFromActivity(activity) {
@@ -880,8 +1009,24 @@ const HOST_MATCHERS = [
  * walk ancestry chains to attribute child processes to their terminal hosts.
  * `comm` may be an absolute path for shim-launched agents, so basename before
  * matching against AGENT_CLI_NAMES.
+ *
+ * Memoized for {@link PROCESS_TABLE_FRESH_MS} so one active-session scan (and a
+ * quiet re-poll within the window) does not re-shell `ps -A` / CIM for every
+ * caller — terminal host detection, headless attribution, and `hostFromPid`
+ * all share the same snapshot (#2047).
  */
 async function readProcessTable() {
+    const now = activeScanNow();
+    if (processTableCache && now - processTableCache.at < PROCESS_TABLE_FRESH_MS) {
+        return processTableCache.rows;
+    }
+    const rows = await readProcessTableLive();
+    processTableCache = { at: now, rows };
+    return rows;
+}
+/** Uncached process-table snapshot (the live `ps` / CIM path). */
+async function readProcessTableLive() {
+    processTableLiveReads += 1;
     if (process.platform === 'win32')
         return readProcessTableWin32();
     let out;
@@ -1138,8 +1283,27 @@ export function foldSubordinateAgents(candidates, ppidMap, readEntry) {
  * Classified by walking the ppid chain: any recognised UI ancestor (IDE
  * helper, terminal-app, or multiplexer) means `terminal`; nothing of the
  * sort means `headless` (daemon, launchd-spawned, orphan).
+ *
+ * Full `ps`+`lsof` rescans are throttled to {@link UNATTRIBUTED_RESCAN_MS}
+ * (#2047). Between rescans the previous rows are re-emitted after dropping
+ * dead PIDs and PIDs that are now attributed. A shrinking attributed set
+ * forces a rescan so a process that just left teams/terminals can reappear
+ * as headless.
  */
 export async function listUnattributedActive(attributed) {
+    const now = activeScanNow();
+    if (unattributedCache &&
+        now - unattributedCache.at < UNATTRIBUTED_RESCAN_MS &&
+        !attributedSetLostPids(unattributedCache.attributed, attributed)) {
+        return filterCachedUnattributed(unattributedCache.sessions, attributed, isPidAlive);
+    }
+    const out = await listUnattributedActiveLive(attributed);
+    unattributedCache = { at: now, attributed: new Set(attributed), sessions: out };
+    return out;
+}
+/** Unthrottled headless scan (live process table + cwd probes). */
+async function listUnattributedActiveLive(attributed) {
+    unattributedFullRescans += 1;
     const table = await readProcessTable();
     const procByPid = new Map();
     const ppidMap = new Map();

package/dist/lib/session/bash-command.d.ts

@@ -19,6 +19,22 @@ export interface BashCommandInfo {
     summary: string;
     signal: 'high' | 'mid' | 'low';
 }
+/**
+ * TOOL_REGISTRY (category + action, aliases flattened to their own keys)
+ * serialized as the body of a Python dict literal. The embedded activity-log
+ * hook script (`ACTIVITY_LOG_HOOK_SCRIPT` in `activity.ts`) runs standalone
+ * under `python3` and can't import this module, so its taxonomy is generated
+ * from this single source instead of hand-duplicated (#1889 — the two had
+ * already drifted: the hand-authored copy was missing `rmdir`).
+ */
+export declare function pythonToolRegistryLiteral(indent?: string): string;
+/**
+ * VALUE_FLAGS serialized as the body of a Python dict of sets. Same reason as
+ * {@link pythonToolRegistryLiteral}: the activity-log hook script embeds this
+ * table and must not hand-drift from the TypeScript source (#1889 — the Python
+ * copy was missing `agents`/`linear` two-level tools).
+ */
+export declare function pythonValueFlagsLiteral(indent?: string): string;
 export declare function unwrapCommand(cmd: string): string;
 /**
  * Split a possibly-compound Bash command into simple commands, then tokenize each

package/dist/lib/session/bash-command.js

@@ -95,6 +95,25 @@ const TOOL_REGISTRY = {
     sleep: { category: 'wait', signal: 'low', action: 'sleeping' },
     wait: { category: 'wait', signal: 'low', action: 'waiting' },
 };
+/**
+ * TOOL_REGISTRY (category + action, aliases flattened to their own keys)
+ * serialized as the body of a Python dict literal. The embedded activity-log
+ * hook script (`ACTIVITY_LOG_HOOK_SCRIPT` in `activity.ts`) runs standalone
+ * under `python3` and can't import this module, so its taxonomy is generated
+ * from this single source instead of hand-duplicated (#1889 — the two had
+ * already drifted: the hand-authored copy was missing `rmdir`).
+ */
+export function pythonToolRegistryLiteral(indent = '    ') {
+    const lines = [];
+    for (const [name, info] of Object.entries(TOOL_REGISTRY)) {
+        const entry = `{"category": ${JSON.stringify(info.category)}, "action": ${JSON.stringify(info.action)}}`;
+        lines.push(`${indent}${JSON.stringify(name)}: ${entry},`);
+        for (const alias of info.aliases ?? []) {
+            lines.push(`${indent}${JSON.stringify(alias)}: ${entry},`);
+        }
+    }
+    return lines.join('\n');
+}
 /**
  * Two-level tools (bucket key includes the subcommand) mapped to the flags that
  * consume the *following* token as their value, per tool. The subcommand scan
@@ -124,6 +143,25 @@ const VALUE_FLAGS = {
     agents: new Set(['-H', '--host', '--device']),
     linear: new Set(),
 };
+/**
+ * VALUE_FLAGS serialized as the body of a Python dict of sets. Same reason as
+ * {@link pythonToolRegistryLiteral}: the activity-log hook script embeds this
+ * table and must not hand-drift from the TypeScript source (#1889 — the Python
+ * copy was missing `agents`/`linear` two-level tools).
+ */
+export function pythonValueFlagsLiteral(indent = '    ') {
+    const lines = [];
+    for (const [name, flags] of Object.entries(VALUE_FLAGS)) {
+        if (flags.size === 0) {
+            lines.push(`${indent}${JSON.stringify(name)}: set(),`);
+            continue;
+        }
+        // Stable order for golden-string equality (install/write checks).
+        const items = [...flags].sort().map((f) => JSON.stringify(f)).join(', ');
+        lines.push(`${indent}${JSON.stringify(name)}: {${items}},`);
+    }
+    return lines.join('\n');
+}
 /** Tools whose bucket key includes the second token (subcommand). */
 const TWO_LEVEL_TOOLS = new Set(Object.keys(VALUE_FLAGS));
 /** Remote wrappers whose bucket key carries an `ssh→` prefix on the inner command. */
@@ -145,10 +183,20 @@ export function unwrapCommand(cmd) {
     const env = s.match(/^([A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|\S+)\s+)+(.+)$/);
     if (env)
         return unwrapCommand(env[2]);
+    // export VAR=value prefix, same shape as the bare env-var prefix above (#1889)
+    const exportPrefix = s.match(/^export\s+(?:[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|\S+)\s+)*[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|\S+)\s*(?:&&|;|\n)\s*([\s\S]+)$/);
+    if (exportPrefix)
+        return unwrapCommand(exportPrefix[1]);
     // sudo / time prefix (value-taking flags like `-u user` consume their argument)
     const prefix = s.match(/^(?:sudo|time)(?:\s+(?:-[uUgGhpCrtDR]\s+\S+|-\S+))*\s+(.+)$/);
     if (prefix)
         return unwrapCommand(prefix[1]);
+    // set -euo pipefail && command / set -x; command (shell-option prefix; `-o`
+    // mode names like `pipefail` trail a flag without their own `-`, so consume
+    // everything up to the first operator rather than itemizing flag shapes)
+    const setPrefix = s.match(/^set\s+[^&;\n]+?(?:&&|;|\n)\s*([\s\S]+)$/);
+    if (setPrefix)
+        return unwrapCommand(setPrefix[1]);
     // cd foo && command  (also `cd foo; command` and newline-separated `cd foo\ncommand`)
     const cd = s.match(/^cd\s+\S+\s*(?:&&|;|\n)\s*([\s\S]+)$/);
     if (cd)
@@ -157,6 +205,23 @@ export function unwrapCommand(cmd) {
     const npx = s.match(/^(?:npx|bunx)\s+(?:-\S+\s+)*(.+)$/);
     if (npx)
         return unwrapCommand(npx[1]);
+    // for X in ...; do command; done — unwrap to the loop body, not the `for` keyword
+    const forLoop = s.match(/^for\s+[\s\S]+?\bdo\b\s*([\s\S]+?)\s*;?\s*done\b[\s\S]*$/);
+    if (forLoop)
+        return unwrapCommand(forLoop[1]);
+    // until condition; do command; done
+    const untilLoop = s.match(/^until\s+[\s\S]+?\bdo\b\s*([\s\S]+?)\s*;?\s*done\b[\s\S]*$/);
+    if (untilLoop)
+        return unwrapCommand(untilLoop[1]);
+    // if condition; then command; fi — unwrap to the `then` branch, the real work;
+    // the condition itself is usually a test/comparison, not the command of interest
+    const ifCond = s.match(/^if\s+[\s\S]+?\bthen\b\s*([\s\S]+?)\s*;?\s*(?:elif\b|else\b|fi\b)[\s\S]*$/);
+    if (ifCond)
+        return unwrapCommand(ifCond[1]);
+    // (command) subshell, e.g. `(gh pr create --title x)` or `(cd /repo && npm i)`
+    const subshell = s.match(/^\(\s*([\s\S]+?)\s*\)\s*(?:&&|;|\|\|)[\s\S]*$/) ?? s.match(/^\(\s*([\s\S]+?)\s*\)\s*$/);
+    if (subshell)
+        return unwrapCommand(subshell[1]);
     return s;
 }
 function splitOnOperators(cmd) {

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

@@ -323,6 +323,10 @@ export declare function latestSessionFileForCwd(agent: SessionAgentId, cwd: stri
     maxAgeMs?: number;
     nowMs?: number;
 }): string | undefined;
+/** Process-local diagnostics for the real-filesystem existence-cache tests. */
+export declare function getSessionExistenceCacheStats(): {
+    sweeps: number;
+};
 /** Query sessions from the database, applying filters and ordering by last-activity descending (default). */
 export declare function querySessions(options?: QueryOptions): SessionMeta[];
 /** Count sessions matching the given filter options. */

package/dist/lib/session/db.js

@@ -1043,6 +1043,7 @@ export function getDB() {
 }
 /** Close the cached database connection. */
 export function closeDB() {
+    clearSessionExistenceCache();
     if (dbInstance) {
         dbInstance.close();
         dbInstance = null;
@@ -2277,17 +2278,18 @@ function buildSessionWhere(options) {
     const clause = where.length > 0 ? `WHERE ${where.join(' AND ')}` : '';
     return { clause, params };
 }
-/**
- * Resolve which of the given file paths no longer exist, batching the check
- * per directory instead of one `fs.existsSync` stat syscall per file.
- * Transcript trees put many sessions in the same directory (one Claude
- * `~/.claude/projects/<slug>/` holds every session for that project), so
- * `readdirSync` once per directory and a Set membership test collapses what
- * used to be N stat syscalls into (number of distinct directories) readdir
- * syscalls — the same existence answer, far fewer syscalls on a large index
- * (RUSH-2211). Falls back to per-file existsSync only when the directory
- * itself can't be listed (permissions, race with a concurrent delete).
- */
+const directoryMembershipCache = new Map();
+let directoryMembershipSweepCount = 0;
+const DIRECTORY_MTIME_SETTLE_MS = 2_000;
+/** Process-local diagnostics for the real-filesystem existence-cache tests. */
+export function getSessionExistenceCacheStats() {
+    return { sweeps: directoryMembershipSweepCount };
+}
+/** Clear process-local directory membership state when the session DB closes. */
+function clearSessionExistenceCache() {
+    directoryMembershipCache.clear();
+    directoryMembershipSweepCount = 0;
+}
 function findMissingFilePaths(filePaths) {
     const byDir = new Map();
     for (const p of filePaths) {
@@ -2303,21 +2305,36 @@ function findMissingFilePaths(filePaths) {
     for (const [dir, basenames] of byDir) {
         let entries;
         try {
-            entries = new Set(fs.readdirSync(dir));
+            const stat = fs.statSync(dir);
+            const cached = directoryMembershipCache.get(dir);
+            const now = Date.now();
+            const settled = now - stat.mtimeMs > DIRECTORY_MTIME_SETTLE_MS;
+            const fresh = cached && now - cached.cachedAtMs <= DIRECTORY_MTIME_SETTLE_MS;
+            if (settled && fresh && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
+                entries = cached.entries;
+            }
+            else {
+                entries = new Set(fs.readdirSync(dir));
+                directoryMembershipCache.set(dir, { mtimeMs: stat.mtimeMs, size: stat.size, cachedAtMs: now, entries });
+                directoryMembershipSweepCount++;
+            }
         }
         catch {
+            directoryMembershipCache.delete(dir);
             // Directory itself is gone (or unreadable) — every file in it is missing.
             // Also covers the race where readdir loses to a concurrent delete: fall
             // back to a direct stat rather than assuming existence.
             for (const base of basenames) {
-                if (!fs.existsSync(path.join(dir, base)))
-                    missing.add(path.join(dir, base));
+                const filePath = path.join(dir, base);
+                if (!fs.existsSync(filePath))
+                    missing.add(filePath);
             }
             continue;
         }
         for (const base of basenames) {
+            const filePath = path.join(dir, base);
             if (!entries.has(base))
-                missing.add(path.join(dir, base));
+                missing.add(filePath);
         }
     }
     return missing;

package/dist/lib/session/remote-bundle.js

@@ -40,7 +40,7 @@ export async function pullBundlesFromHosts(hosts, exportArgs) {
     for (const t of targets) {
         const cmd = remoteAgentsCommand(['sessions', 'export', ...exportArgs, '--stdout'], t.os);
         process.stderr.write(chalk.dim(`Pulling sessions from ${t.name}…\n`));
-        const res = sshExec(t.target, cmd, { timeoutMs: REMOTE_EXPORT_TIMEOUT_MS });
+        const res = sshExec(t.target, cmd, { timeoutMs: REMOTE_EXPORT_TIMEOUT_MS, extraSshArgs: t.extraSshArgs });
         if (res.timedOut) {
             errors.push(`${t.name}: timed out after ${Math.round(REMOTE_EXPORT_TIMEOUT_MS / 1000)}s`);
             continue;

package/dist/lib/staleness/detectors/skills.d.ts

@@ -1,3 +1,5 @@
 import type { AgentId } from '../../types.js';
 import type { ResourceDetector } from './types.js';
+/** Exported for unit tests (RUSH-2320 #2). Production callers: list() below. */
+export declare function skillDirsMatch(src: string, dest: string): boolean;
 export declare const skillsDetectors: Partial<Record<AgentId, ResourceDetector>>;

package/dist/lib/staleness/detectors/skills.js

@@ -9,7 +9,8 @@ import { capableAgents } from '../../capabilities.js';
 import { resolveSkillSource } from '../writers/sources.js';
 import { lazyAgentMap } from '../writers/lazy-map.js';
 const SKILL_COPY_IGNORE = new Set(['.DS_Store', '.git', '.gitignore', '.venv', '__pycache__', 'node_modules']);
-function skillDirsMatch(src, dest) {
+/** Exported for unit tests (RUSH-2320 #2). Production callers: list() below. */
+export function skillDirsMatch(src, dest) {
     const entries = fs.readdirSync(src, { withFileTypes: true });
     for (const entry of entries) {
         if (entry.isSymbolicLink())
@@ -25,7 +26,21 @@ function skillDirsMatch(src, dest) {
                 return false;
         }
         else {
-            if (!fs.existsSync(destPath))
+            // Stat-first (RUSH-2320 #2): size mismatch is a definitive miss with no
+            // content reads. Do NOT treat equal mtimes as equal content — src and
+            // dest are different trees (version home vs source), and copyFileSync
+            // does not preserve mtime, so mtime equality is accidental and unsafe.
+            // Content compare only when sizes match.
+            let srcStat;
+            let destStat;
+            try {
+                srcStat = fs.statSync(srcPath);
+                destStat = fs.statSync(destPath);
+            }
+            catch {
+                return false;
+            }
+            if (srcStat.size !== destStat.size)
                 return false;
             if (fs.readFileSync(srcPath, 'utf-8') !== fs.readFileSync(destPath, 'utf-8'))
                 return false;

package/dist/lib/staleness/index.d.ts

@@ -16,7 +16,16 @@ export type { SyncManifest } from './types.js';
 export { MANIFEST_VERSION } from './types.js';
 export declare function loadManifest(agent: AgentId, version: string): SyncManifest | null;
 export declare function saveManifest(agent: AgentId, version: string, manifest: SyncManifest): void;
-export declare function buildManifest(agent: AgentId, version: string, cwd: string): SyncManifest;
+/**
+ * Snapshot current resource fingerprints for `agent@version`.
+ *
+ * When `previous` is supplied (the still-loaded post-guard manifest), any
+ * entry whose stored path/mtime/size still match via the checker's `isFresh`
+ * is carried forward without re-hashing. Measured: full rebuild ~716 ms →
+ * carry-forward near the 5.67 ms `isStale` cost on an unchanged tree
+ * (RUSH-2320 #3).
+ */
+export declare function buildManifest(agent: AgentId, version: string, cwd: string, previous?: SyncManifest | null): SyncManifest;
 /**
  * True when any tracked resource has drifted from the stored manifest.
  * Walks every resource type in turn and returns true at the first miss —

package/dist/lib/staleness/index.js

@@ -69,7 +69,16 @@ export function saveManifest(agent, version, manifest) {
         catch { /* ignore */ }
     }
 }
-export function buildManifest(agent, version, cwd) {
+/**
+ * Snapshot current resource fingerprints for `agent@version`.
+ *
+ * When `previous` is supplied (the still-loaded post-guard manifest), any
+ * entry whose stored path/mtime/size still match via the checker's `isFresh`
+ * is carried forward without re-hashing. Measured: full rebuild ~716 ms →
+ * carry-forward near the 5.67 ms `isStale` cost on an unchanged tree
+ * (RUSH-2320 #3).
+ */
+export function buildManifest(agent, version, cwd, previous) {
     const manifest = {
         v: MANIFEST_VERSION,
         syncedAt: new Date().toISOString(),
@@ -85,14 +94,30 @@ export function buildManifest(agent, version, cwd) {
     };
     for (const { checker, field } of STANDARD_CHECKERS) {
         const target = manifest[field];
+        const prevMap = (previous?.[field] ?? {});
         for (const name of checker.listNames(cwd)) {
+            const prev = prevMap[name];
+            if (prev !== undefined && checker.isFresh(name, prev, cwd)) {
+                target[name] = prev;
+                continue;
+            }
             const entry = checker.build(name, cwd);
             if (entry !== null)
                 target[name] = entry;
         }
     }
-    manifest.rules = buildRules(agent, version, cwd);
-    manifest.permissions = buildPermissions();
+    if (previous?.rules && !isRulesStale(previous.rules, agent, version, cwd)) {
+        manifest.rules = previous.rules;
+    }
+    else {
+        manifest.rules = buildRules(agent, version, cwd);
+    }
+    if (previous?.permissions && !isPermissionsStale(previous.permissions)) {
+        manifest.permissions = previous.permissions;
+    }
+    else {
+        manifest.permissions = buildPermissions();
+    }
     return manifest;
 }
 /**

package/dist/lib/teams/agents.d.ts

@@ -156,6 +156,7 @@ export declare class AgentProcess {
     worktreePath: string | null;
     hostName: string | null;
     hostTarget: string | null;
+    hostIdentityFile: string | null;
     repoPath: string | null;
     remotePid: number | null;
     remoteLog: string | null;