@phnx-labs/agents-cli 1.20.41 → 1.20.43

package/dist/lib/session/active.js

@@ -26,6 +26,7 @@ import { AgentManager } from '../teams/agents.js';
 import { getTerminalsDir } from '../state.js';
 import { readPidSessionEntry, prunePidSessionRegistry } from './pid-registry.js';
 import { buildClaudeLabelMap } from './discover.js';
+import { buildRunNameMap } from './run-names.js';
 import { latestSessionFileForCwd } from './db.js';
 import { extractSessionTopic } from './prompt.js';
 import { readSessionTail } from './tail.js';
@@ -120,11 +121,24 @@ function claudeProjectDirName(cwd) {
  * fall back to the most-recent-mtime .jsonl in the project's folder.
  */
 function findClaudeSessionFile(cwd, sessionId) {
-    const projectDir = path.join(HOME, '.claude', 'projects', claudeProjectDirName(cwd));
+    return pickSessionFile(path.join(HOME, '.claude', 'projects', claudeProjectDirName(cwd)), sessionId);
+}
+/**
+ * Pick a Claude transcript file within a project dir.
+ *
+ * With a CONCRETE session id: return that id's `<id>.jsonl` or undefined — NEVER a
+ * sibling's. Falling back to the newest file here is the bug that made N distinct
+ * co-located sessions (e.g. several editor tabs in one cwd, or two worktree siblings)
+ * all collapse onto ONE file and render identical preview + topic (they look like
+ * duplicate cards). The mtime fallback is only sound when NO id is known.
+ *
+ * With NO id: return the newest `.jsonl` by mtime (the legitimate single-session
+ * heuristic for a directly-launched agent with no registry entry).
+ */
+export function pickSessionFile(projectDir, sessionId) {
     if (sessionId) {
         const specific = path.join(projectDir, `${sessionId}.jsonl`);
-        if (fs.existsSync(specific))
-            return specific;
+        return fs.existsSync(specific) ? specific : undefined;
     }
     let files;
     try {
@@ -146,8 +160,12 @@ function findClaudeSessionFile(cwd, sessionId) {
     return best?.path;
 }
 function classifyActivity(sessionFile) {
+    // No resolvable transcript is NOT evidence of activity — default to idle. (Before
+    // the no-borrow fix in pickSessionFile this rarely fired because every terminal
+    // borrowed the newest file; now a session with an unresolved id lands here, and
+    // "running" would wrongly light it up.)
     if (!sessionFile)
-        return 'running';
+        return 'idle';
     try {
         const mtimeMs = fs.statSync(sessionFile).mtimeMs;
         return Date.now() - mtimeMs < ACTIVE_MTIME_WINDOW_MS ? 'running' : 'idle';
@@ -325,10 +343,25 @@ export async function listTerminalsActive() {
         procByPid.set(r.pid, r);
     // 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) => {
-        const sessionFile = findSessionFileForKind(t.kind, t.cwd ?? undefined, t.sessionId);
+        // 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 resolvedId = readPidSessionEntry(t.pid)?.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;
+        // 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 state = computeLiveState(t.kind, sessionFile, t.cwd ?? undefined, isPidAlive(t.pid));
@@ -341,6 +374,7 @@ export async function listTerminalsActive() {
             sessionId: t.sessionId ?? sessionIdFromFile(sessionFile),
             cwd: t.cwd ?? undefined,
             label,
+            name,
             topic,
             sessionFile,
             startedAtMs: t.startedAtMs,
@@ -539,6 +573,21 @@ function detectHost(pid, procByPid) {
     }
     return undefined;
 }
+/**
+ * Resolve the host app for a single pid by walking its process ancestry with the
+ * same HOST_MATCHERS logic `detectHost` uses. Reads the whole process table per
+ * call, so it's for the low-cardinality renderer path (one tmux client per
+ * session), not a hot loop. Returns undefined when nothing above the pid is a
+ * recognised UI. Exported for the "viewing in <app>" resolver.
+ */
+export async function hostFromPid(pid) {
+    if (!pid || pid < 1)
+        return undefined;
+    const procByPid = new Map();
+    for (const r of await readProcessTable())
+        procByPid.set(r.pid, r);
+    return detectHost(pid, procByPid);
+}
 /** IDE / terminal / multiplexer hosts all count as UI-hosted. Absence = truly headless. */
 const UI_HOSTS = new Set([
     'code', 'cursor', 'codium', 'windsurf',
@@ -703,17 +752,97 @@ export async function listUnattributedActive(attributed) {
     return out;
 }
 /**
- * Union of all four sources. Teams and terminals spawn actual CLI processes
- * that also show up in `ps`, so headless attribution runs last with the
- * already-attributed PIDs removed.
+ * Agents hosted in the shared-socket tmux server — the authoritative source for
+ * tmux-wrapped interactive spawns (see src/lib/exec.ts `runInTmux`). Enumerates
+ * every pane on the shared socket and keeps those whose session meta was stamped
+ * with `labels.agent` + `labels.sessionId` by the spawn-wrap. Because tmux (not a
+ * per-window `live-terminals.json`) is the source of truth, a tmux-hosted agent is
+ * ALWAYS captured with its exact `%pane` even when the extension registry is stale
+ * or absent. `source: 'teams'` is skipped — teammates are surfaced by listTeamsActive.
+ */
+export async function listTmuxAgentSessions() {
+    const { getDefaultSocketPath } = await import('../tmux/paths.js');
+    const { readSessionMeta } = await import('../tmux/session.js');
+    const { runTmux } = await import('../tmux/binary.js');
+    const socket = getDefaultSocketPath();
+    if (!fs.existsSync(socket))
+        return [];
+    let res;
+    try {
+        res = await runTmux({
+            socket,
+            args: ['list-panes', '-a', '-F', '#{pane_id}\t#{session_name}\t#{pane_pid}\t#{pane_current_path}'],
+            throwOnError: false,
+        });
+    }
+    catch {
+        return [];
+    }
+    if (res.code !== 0)
+        return [];
+    const out = [];
+    const seen = new Set();
+    for (const line of res.stdout.split('\n')) {
+        if (!line.trim())
+            continue;
+        const [pane, sessName, pidRaw, curPath] = line.split('\t');
+        if (!pane || !sessName)
+            continue;
+        const meta = readSessionMeta(sessName);
+        const agent = meta?.labels?.agent;
+        const sessionId = meta?.labels?.sessionId;
+        if (!agent || !sessionId)
+            continue; // only our stamped agent sessions
+        if (meta?.source === 'teams')
+            continue; // teammates come from listTeamsActive
+        if (seen.has(sessionId))
+            continue; // first pane per session wins
+        seen.add(sessionId);
+        const pid = parseInt(pidRaw, 10) || undefined;
+        const cwd = meta?.cwd ?? (curPath || undefined);
+        const sessionFile = findSessionFileForKind(agent, cwd, sessionId);
+        const topic = sessionFile ? quickExtractTopic(sessionFile) : undefined;
+        const state = computeLiveState(agent, sessionFile, cwd, pid ? isPidAlive(pid) : true);
+        // Provenance is known exactly here (the pane IS a tmux pane) — set it so
+        // enrichProvenance skips it and the locator/reply rails resolve off the pane.
+        const provenance = {
+            host: os.hostname(),
+            transport: 'local',
+            mux: { kind: 'tmux', socket, pane },
+            reply: { rail: 'tmux', target: pane, socket },
+        };
+        out.push(applyState({
+            context: 'terminal',
+            kind: agent,
+            host: 'tmux',
+            pid,
+            sessionId,
+            cwd,
+            topic,
+            sessionFile,
+            provenance,
+        }, state, sessionFile));
+    }
+    return out;
+}
+/**
+ * Union of all sources. Teams and terminals spawn actual CLI processes that
+ * also show up in `ps`, so headless attribution runs last with the already-
+ * attributed PIDs removed. The tmux source goes FIRST into the dedupe so a
+ * tmux-hosted agent's row (which carries the exact `%pane`) wins over a staler
+ * terminal/headless row for the same session id.
  */
 export async function getActiveSessions(opts = {}) {
-    const [teams, terminals, cloud] = await Promise.all([
+    const [tmuxAgents, teams, terminals, cloud] = await Promise.all([
+        listTmuxAgentSessions().catch(() => []),
         listTeamsActive().catch(() => []),
         listTerminalsActive().catch(() => []),
         Promise.resolve(listCloudActive()),
     ]);
     const knownPids = new Set();
+    for (const s of tmuxAgents)
+        if (s.pid)
+            knownPids.add(s.pid);
     for (const s of teams)
         if (s.pid)
             knownPids.add(s.pid);
@@ -721,7 +850,7 @@ export async function getActiveSessions(opts = {}) {
         if (s.pid)
             knownPids.add(s.pid);
     const unattributed = opts.skipHeadless ? [] : await listUnattributedActive(knownPids);
-    const merged = dedupeBySession([...teams, ...terminals, ...cloud, ...unattributed]);
+    const merged = dedupeBySession([...tmuxAgents, ...teams, ...terminals, ...cloud, ...unattributed]);
     await enrichProvenance(merged);
     return merged;
 }

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

@@ -22,6 +22,7 @@ export interface SessionRow {
     git_branch: string | null;
     topic: string | null;
     label: string | null;
+    name: string | null;
     message_count: number | null;
     token_count: number | null;
     cost_usd: number | null;
@@ -128,6 +129,16 @@ export declare function upsertSessionsBatch(entries: Array<{
  * Leaves FTS5 content/topic/project untouched — cheap to call every run.
  */
 export declare function syncLabels(labelMap: Map<string, string | null>): number;
+/**
+ * Sync `agents run --name` handles for a set of sessions, keyed by session id.
+ * The name's source of truth lives outside the transcript (host task sidecars,
+ * run-name sidecars written at launch), so — like {@link syncLabels} — it is
+ * re-applied by id every scan rather than parsed per-file. Updates only
+ * `sessions.name` (names resolve via a direct column tier in ftsSearch, not
+ * FTS, so there's no session_text column to touch). Only writes when the value
+ * differs; cheap to call every run. Returns the number of rows updated.
+ */
+export declare function syncNames(nameMap: Map<string, string | null>): number;
 /**
  * Sync topics (session titles) for a set of sessions, keyed by id. For agents
  * whose human-readable title lives in a side index that updates independently

package/dist/lib/session/db.js

@@ -13,7 +13,7 @@ import { getSessionsDir, getSessionsDbPath } from '../state.js';
 const SESSIONS_DIR = getSessionsDir();
 const DB_PATH = getSessionsDbPath();
 /** Current schema version; bumped when migrations are added. */
-const SCHEMA_VERSION = 8;
+const SCHEMA_VERSION = 9;
 /**
  * Canonicalize a file path for use as a scan_ledger key. The same physical
  * session file is reachable via multiple aliases — `~/.claude/projects/x.jsonl`
@@ -52,6 +52,7 @@ CREATE TABLE IF NOT EXISTS sessions (
   git_branch TEXT,
   topic TEXT,
   label TEXT,
+  name TEXT,
   message_count INTEGER,
   token_count INTEGER,
   cost_usd REAL,
@@ -188,6 +189,15 @@ function migrateSchema(db, fromVersion) {
         db.exec(`UPDATE sessions SET last_activity = timestamp WHERE last_activity IS NULL`);
         db.exec(`DELETE FROM scan_ledger;`);
     }
+    if (fromVersion < 9) {
+        // v8 → v9: `agents run --name <slug>` gives a run a durable launch handle,
+        // resolvable via `agents sessions <name>`. Additive column; NO rescan — the
+        // name is set at run time (host sidecar / run-name sidecar), not parsed from
+        // transcripts, so existing rows stay valid with a NULL name.
+        const cols = db.prepare(`PRAGMA table_info(sessions)`).all();
+        if (!cols.some(c => c.name === 'name'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN name TEXT`);
+    }
 }
 /** Open (or return the cached) sessions database, applying migrations as needed. */
 export function getDB() {
@@ -401,13 +411,13 @@ export function recordScans(entries) {
 const upsertSessionStmt = (db) => db.prepare(`
   INSERT INTO sessions (
     id, short_id, agent, version, account, timestamp, last_activity,
-    project, cwd, git_branch, topic, label, message_count, token_count,
+    project, cwd, git_branch, topic, label, name, message_count, token_count,
     cost_usd, duration_ms,
     file_path, file_mtime_ms, file_size, scanned_at, is_team_origin,
     pr_url, pr_number, worktree_slug, ticket_id
   ) VALUES (
     @id, @short_id, @agent, @version, @account, @timestamp, @last_activity,
-    @project, @cwd, @git_branch, @topic, @label, @message_count, @token_count,
+    @project, @cwd, @git_branch, @topic, @label, @name, @message_count, @token_count,
     @cost_usd, @duration_ms,
     @file_path, @file_mtime_ms, @file_size, @scanned_at, @is_team_origin,
     @pr_url, @pr_number, @worktree_slug, @ticket_id
@@ -471,6 +481,7 @@ export function upsertSession(meta, content, scan) {
         git_branch: meta.gitBranch ?? null,
         topic: meta.topic ?? null,
         label: meta.label ?? null,
+        name: meta.name ?? null,
         message_count: meta.messageCount ?? null,
         token_count: meta.tokenCount ?? null,
         cost_usd: meta.costUsd ?? null,
@@ -538,37 +549,52 @@ export function upsertSessionsBatch(entries) {
         for (const { meta, content, scan } of items) {
             if (alreadyIndexed.has(meta.id))
                 continue;
-            upsert.run({
-                id: meta.id,
-                short_id: meta.shortId,
-                agent: meta.agent,
-                version: meta.version ?? null,
-                account: meta.account ?? null,
-                timestamp: meta.timestamp,
-                last_activity: resolveLastActivity(meta, scan),
-                project: meta.project ?? null,
-                cwd: meta.cwd ?? null,
-                git_branch: meta.gitBranch ?? null,
-                topic: meta.topic ?? null,
-                label: meta.label ?? null,
-                message_count: meta.messageCount ?? null,
-                token_count: meta.tokenCount ?? null,
-                cost_usd: meta.costUsd ?? null,
-                duration_ms: meta.durationMs ?? null,
-                file_path: meta.filePath,
-                file_mtime_ms: scan?.fileMtimeMs ?? null,
-                file_size: scan?.fileSize ?? null,
-                scanned_at: now,
-                is_team_origin: meta.isTeamOrigin ? 1 : 0,
-                pr_url: meta.prUrl ?? null,
-                pr_number: meta.prNumber ?? null,
-                worktree_slug: meta.worktreeSlug ?? null,
-                ticket_id: meta.ticketId ?? null,
-            });
-            delText.run(meta.id);
-            insText.run(meta.id, meta.label ?? '', meta.topic ?? '', meta.project ?? '', content ?? '');
-            if (scan && meta.filePath) {
-                ledger.run(canonicalLedgerKey(meta.filePath), scan.fileMtimeMs, scan.fileSize, now);
+            // Per-row guard: one malformed session (e.g. a required field that resolves to
+            // NULL) must not abort the whole batch and take down the entire `agents sessions`
+            // listing. A constraint error uses SQLite's ABORT resolution — it reverts only the
+            // failing statement, not the transaction — and the db.transaction wrapper only rolls
+            // back when the error escapes `fn`, so catching + skipping here leaves the txn valid
+            // and committable. We deliberately do NOT stamp the ledger for a skipped row, so the
+            // next scan re-tries it (self-healing once the underlying parser is fixed).
+            try {
+                upsert.run({
+                    id: meta.id,
+                    short_id: meta.shortId,
+                    agent: meta.agent,
+                    version: meta.version ?? null,
+                    account: meta.account ?? null,
+                    timestamp: meta.timestamp,
+                    last_activity: resolveLastActivity(meta, scan),
+                    project: meta.project ?? null,
+                    cwd: meta.cwd ?? null,
+                    git_branch: meta.gitBranch ?? null,
+                    topic: meta.topic ?? null,
+                    label: meta.label ?? null,
+                    name: meta.name ?? null,
+                    message_count: meta.messageCount ?? null,
+                    token_count: meta.tokenCount ?? null,
+                    cost_usd: meta.costUsd ?? null,
+                    duration_ms: meta.durationMs ?? null,
+                    file_path: meta.filePath,
+                    file_mtime_ms: scan?.fileMtimeMs ?? null,
+                    file_size: scan?.fileSize ?? null,
+                    scanned_at: now,
+                    is_team_origin: meta.isTeamOrigin ? 1 : 0,
+                    pr_url: meta.prUrl ?? null,
+                    pr_number: meta.prNumber ?? null,
+                    worktree_slug: meta.worktreeSlug ?? null,
+                    ticket_id: meta.ticketId ?? null,
+                });
+                delText.run(meta.id);
+                insText.run(meta.id, meta.label ?? '', meta.topic ?? '', meta.project ?? '', content ?? '');
+                if (scan && meta.filePath) {
+                    ledger.run(canonicalLedgerKey(meta.filePath), scan.fileMtimeMs, scan.fileSize, now);
+                }
+            }
+            catch (err) {
+                if (process.stderr.isTTY) {
+                    console.error(`Warning: skipped unindexable session ${meta.id}: ${err.message}`);
+                }
             }
         }
     });
@@ -612,6 +638,45 @@ export function syncLabels(labelMap) {
     txn(updates);
     return updates.length;
 }
+/**
+ * Sync `agents run --name` handles for a set of sessions, keyed by session id.
+ * The name's source of truth lives outside the transcript (host task sidecars,
+ * run-name sidecars written at launch), so — like {@link syncLabels} — it is
+ * re-applied by id every scan rather than parsed per-file. Updates only
+ * `sessions.name` (names resolve via a direct column tier in ftsSearch, not
+ * FTS, so there's no session_text column to touch). Only writes when the value
+ * differs; cheap to call every run. Returns the number of rows updated.
+ */
+export function syncNames(nameMap) {
+    if (nameMap.size === 0)
+        return 0;
+    const db = getDB();
+    const ids = [...nameMap.keys()];
+    const CHUNK = 500;
+    const updates = [];
+    for (let i = 0; i < ids.length; i += CHUNK) {
+        const chunk = ids.slice(i, i + CHUNK);
+        const placeholders = chunk.map(() => '?').join(',');
+        const rows = db
+            .prepare(`SELECT id, name FROM sessions WHERE id IN (${placeholders})`)
+            .all(...chunk);
+        for (const row of rows) {
+            const live = nameMap.get(row.id) ?? null;
+            if ((live ?? '') !== (row.name ?? '')) {
+                updates.push({ id: row.id, name: live });
+            }
+        }
+    }
+    if (updates.length === 0)
+        return 0;
+    const upd = db.prepare(`UPDATE sessions SET name = ? WHERE id = ?`);
+    const txn = db.transaction((items) => {
+        for (const { id, name } of items)
+            upd.run(name, id);
+    });
+    txn(updates);
+    return updates.length;
+}
 /**
  * Sync topics (session titles) for a set of sessions, keyed by id. For agents
  * whose human-readable title lives in a side index that updates independently
@@ -674,6 +739,7 @@ function rowToMeta(row) {
         account: row.account ?? undefined,
         topic: row.topic ?? undefined,
         label: row.label ?? undefined,
+        name: row.name ?? undefined,
         isTeamOrigin: row.is_team_origin === 1,
         prUrl: row.pr_url ?? undefined,
         prNumber: row.pr_number ?? undefined,
@@ -942,26 +1008,39 @@ export function ftsSearch(input, limit = 200) {
     const lower = trimmed.toLowerCase();
     const seen = new Set();
     const hits = [];
-    // Tier 1-3: label-based matches, ordered by exactness.
+    // Tier 1-3: handle-based matches, ordered by exactness. A session's handle is
+    // its /rename `label` OR its `agents run --name` handle — both are user-chosen
+    // aliases and rank identically, so typing either the renamed title or the run
+    // name resolves the session ahead of any FTS content hit.
     const labelRows = db.prepare(`
-    SELECT id, label FROM sessions
-    WHERE label IS NOT NULL AND LOWER(label) LIKE ?
-  `).all(`%${lower}%`);
+    SELECT id, label, name FROM sessions
+    WHERE (label IS NOT NULL AND LOWER(label) LIKE ?)
+       OR (name  IS NOT NULL AND LOWER(name)  LIKE ?)
+  `).all(`%${lower}%`, `%${lower}%`);
     let hasExactLabelMatch = false;
     for (const row of labelRows) {
-        const labelLower = row.label.toLowerCase();
-        let score;
-        if (labelLower === lower) {
-            score = 1_000_000;
-            hasExactLabelMatch = true;
-        }
-        else if (labelLower.startsWith(lower)) {
-            score = 900_000;
-        }
-        else {
-            score = 800_000;
+        // Score against whichever handle matches best (exact > prefix > contains).
+        let score = 0;
+        for (const handle of [row.label, row.name]) {
+            if (!handle)
+                continue;
+            const h = handle.toLowerCase();
+            if (!h.includes(lower))
+                continue;
+            if (h === lower) {
+                score = Math.max(score, 1_000_000);
+                hasExactLabelMatch = true;
+            }
+            else if (h.startsWith(lower)) {
+                score = Math.max(score, 900_000);
+            }
+            else {
+                score = Math.max(score, 800_000);
+            }
         }
-        // matchedTerms is empty for label hits — the picker can render the label
+        if (score === 0)
+            continue;
+        // matchedTerms is empty for handle hits — the picker can render the handle
         // itself as the highlight, no badge needed.
         hits.push({ sessionId: row.id, score, matchedTerms: [] });
         seen.add(row.id);

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

@@ -150,6 +150,11 @@ export declare function readCodexMeta(filePath: string, resolveAccount?: () => s
 export declare function scanClaudeSession(filePath: string): Promise<ClaudeSessionScan>;
 /** Read up to maxLines non-empty lines from the beginning of a file. */
 export declare function readFirstLines(filePath: string, maxLines: number): Promise<string[]>;
+/** Parse a single Kimi session state.json file to extract session metadata. */
+export declare function readKimiMeta(filePath: string): {
+    meta: SessionMeta;
+    content: string;
+} | null;
 /** Parse a time filter string (relative like '7d' or ISO timestamp) into epoch milliseconds. */
 export declare function parseTimeFilter(input: string): number;
 export {};

package/dist/lib/session/discover.js

@@ -25,7 +25,8 @@ import { extractPrUrl, detectWorktree, detectTicket, isPrCreateCommand } from '.
 import { costOfUsage } from '../pricing/index.js';
 import { machineId } from './sync/config.js';
 import { mapBounded } from '../concurrency.js';
-import { getDB, getScanStampByPath, getScanStampsForPaths, recordScans, syncLabels, syncTopics, upsertSessionsBatch, querySessions, countSessions, ftsSearch, tryClaimScan, releaseScan, } from './db.js';
+import { getDB, getScanStampByPath, getScanStampsForPaths, recordScans, syncLabels, syncNames, syncTopics, upsertSessionsBatch, querySessions, countSessions, ftsSearch, tryClaimScan, releaseScan, } from './db.js';
+import { buildRunNameMap } from './run-names.js';
 const HOME = os.homedir();
 // Versions can live under either repo: the user repo (current canonical
 // location, ~/.agents/.history/versions/) or the system repo (legacy / npm-shipped,
@@ -63,6 +64,9 @@ export async function discoverSessions(options) {
             // reads to behavioral EDR (CrowdStrike Falcon) as a ransomware-style bulk
             // file-enumeration sweep. Same dirs, same results — just not all at once.
             await scanAgentsBounded(agents, agent => dispatchAgentScan(agent, onProgress));
+            // Apply `agents run --name` handles onto the freshly-scanned rows by id —
+            // the same idempotent, re-applied-every-scan pattern as /rename labels.
+            syncNames(buildRunNameMap());
         }
         finally {
             releaseScan(process.pid);
@@ -2345,7 +2349,7 @@ async function scanKimiIncremental(onProgress) {
     recordScans(touched);
 }
 /** Parse a single Kimi session state.json file to extract session metadata. */
-function readKimiMeta(filePath) {
+export function readKimiMeta(filePath) {
     let state;
     try {
         state = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
@@ -2362,7 +2366,14 @@ function readKimiMeta(filePath) {
     const topic = title || lastPrompt || undefined;
     const createdAt = typeof state.createdAt === 'string' ? state.createdAt : undefined;
     const updatedAt = typeof state.updatedAt === 'string' ? state.updatedAt : undefined;
-    const timestamp = updatedAt || createdAt;
+    // Coerce to never-null, the same way every other parser does (Rush/Hermes/Droid/…):
+    // a real createdAt/updatedAt still wins; otherwise fall back to the state.json mtime.
+    // Kimi was the lone parser that could yield `undefined`, which binds NULL into
+    // `timestamp TEXT NOT NULL` and aborts the whole batch index. mtime also matches how
+    // the listing already ranks Kimi (last_activity resolves to the file mtime).
+    const stat = safeStatSync(filePath);
+    const timestamp = updatedAt || createdAt
+        || (stat ? stat.mtime.toISOString() : new Date().toISOString());
     const shortId = sessionId.replace(/^session_/, '').slice(0, 8);
     // Try to infer project from session directory path
     // ~/.kimi-code/sessions/<workdir_hash>/session_<uuid>/

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

@@ -1,11 +1,9 @@
 /**
- * SSH target: a bare ssh-config host alias (e.g. `yosemite-s1`) or `user@host`.
- * The strict allowlist blocks shell metacharacters and a leading `-`, so a target
- * can never be smuggled in as an ssh argv flag.
+ * POSIX single-quote a string for safe interpolation into a remote shell command.
+ * Always wraps (unlike the bare-passthrough variant in `ssh-exec.ts`) — the
+ * forwarded `agents` argv is embedded verbatim inside `bash -lc '<cmd>'`, so
+ * every token is quoted to keep the command boundary unambiguous.
  */
-export declare const SSH_TARGET_RE: RegExp;
-export declare function assertValidSshTarget(host: string): void;
-/** POSIX single-quote a string for safe interpolation into a remote shell command. */
 export declare function shellQuote(s: string): string;
 /**
  * Strip the `--host`/`-H` flag (and its value) from a raw `agents sessions` argv,

package/dist/lib/session/remote.js

@@ -27,24 +27,17 @@ import { join } from 'path';
 import { createHash } from 'crypto';
 import chalk from 'chalk';
 import { getCacheDir } from '../state.js';
-import { SSH_OPTS, controlOpts } from '../ssh-exec.js';
+import { SSH_OPTS, controlOpts, assertValidSshTarget } from '../ssh-exec.js';
 import { remoteShellFor, buildWindowsAgentsCommand } from '../hosts/remote-cmd.js';
 import { resolveRemoteOsSync } from '../hosts/remote-os.js';
 import { formatRelativeTime } from './relative-time.js';
 import { terminalWidth } from './width.js';
 /**
- * SSH target: a bare ssh-config host alias (e.g. `yosemite-s1`) or `user@host`.
- * The strict allowlist blocks shell metacharacters and a leading `-`, so a target
- * can never be smuggled in as an ssh argv flag.
+ * POSIX single-quote a string for safe interpolation into a remote shell command.
+ * Always wraps (unlike the bare-passthrough variant in `ssh-exec.ts`) — the
+ * forwarded `agents` argv is embedded verbatim inside `bash -lc '<cmd>'`, so
+ * every token is quoted to keep the command boundary unambiguous.
  */
-export const SSH_TARGET_RE = /^[a-zA-Z0-9._-]+(@[a-zA-Z0-9._-]+)?$/;
-export function assertValidSshTarget(host) {
-    if (!SSH_TARGET_RE.test(host)) {
-        throw new Error(`Invalid SSH target ${JSON.stringify(host)}. Expected a host alias or user@host ` +
-            `(letters, digits, '.', '_', '-').`);
-    }
-}
-/** POSIX single-quote a string for safe interpolation into a remote shell command. */
 export function shellQuote(s) {
     return `'${s.replace(/'/g, `'\\''`)}'`;
 }

package/dist/lib/session/run-names.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Run-name index: the join between a `agents run --name <slug>` handle and the
+ * session id of the run it named.
+ *
+ * `agents run` records `<sessionId>.json` here at launch whenever both a name
+ * and a session id are known up front (Claude pre-mints its id — see
+ * spawnAgent). The session-discovery pass reads these sidecars and applies the
+ * names onto the SQLite index by id (via syncNames), the same idempotent,
+ * re-applied-every-scan pattern as Claude `/rename` labels. Names therefore
+ * survive transcript rescans without being parsed out of the transcript itself.
+ *
+ * Mirrors the host-task sidecar convention (`~/.agents/.cache/hosts/<id>.json`),
+ * one small JSON per run under `~/.agents/.cache/run-names/`.
+ */
+export interface RunNameRecord {
+    sessionId: string;
+    name: string;
+    agent: string;
+    cwd?: string;
+    ts: number;
+}
+export declare function runNamesDir(): string;
+/**
+ * Record a run's `--name` handle keyed by its session id. Best-effort: a failed
+ * write must never break the run itself. No-op without both a name and id.
+ */
+export declare function recordRunName(rec: Omit<RunNameRecord, 'ts'>): void;
+/**
+ * Build the sessionId → name map from every run-name sidecar, for syncNames to
+ * apply onto the index. Returns an empty map when the dir doesn't exist yet.
+ */
+export declare function buildRunNameMap(): Map<string, string | null>;