@phnx-labs/agents-cli 1.22.22 → 1.22.23

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

@@ -2,7 +2,7 @@ import type { CloudTaskStatus } from '../cloud/types.js';
 import { type PidSessionEntry } from './pid-registry.js';
 import { type HookSessionIndex } from './hook-sessions.js';
 import { type SessionState, type SessionActivity, type AwaitingReason, type StructuredQuestion, type TodoProgress, type DetectedPr, type DetectedWorktree, type DetectedTicket } from './state.js';
-import { type SessionAttachment } from './types.js';
+import { type SessionAgentId, type SessionAttachment } from './types.js';
 import { type SessionProvenance } from './provenance.js';
 import { type DeviceRegistry } from '../devices/registry.js';
 import { type Presence } from './detached.js';
@@ -111,6 +111,13 @@ export interface ActiveSession {
     attachments?: SessionAttachment[];
     sessionFile?: string;
     startedAtMs?: number;
+    /**
+     * Agent version (e.g. `2.1.207`) for the row's `agent version` cell. Not a
+     * live-scan signal — a running process does not report its own semver — so it
+     * is backfilled at render time from the indexed {@link SessionMeta} by session
+     * id (RUSH-2205), never asserted by a source.
+     */
+    version?: string;
     /**
      * Last-activity epoch — the transcript's last write (mtime). Distinct from
      * {@link startedAtMs} (session START): a session begun 3h ago but last touched
@@ -294,6 +301,16 @@ export declare const ACTIVE_SESSION_STALE_MS: number;
  * concern) — this is the lifecycle threshold, not the freshness window.
  */
 export declare const ABANDONED_STALE_MS: number;
+/**
+ * Every process executable ("comm") name that identifies a given session-agent
+ * kind in the headless `ps`-scan. Driven off the AGENTS registry's `cliCommand`
+ * (the real executable name — e.g. `agy` for antigravity, `cursor-agent` for
+ * cursor) plus {@link EXTRA_SESSION_AGENT_COMMS} for members with no registry
+ * row. Exported so the completeness test can assert every {@link SESSION_AGENTS}
+ * member resolves — the fix for the harness-parity gap where bare-headless
+ * grok/kimi/antigravity/openclaw/hermes/rush were silently dropped.
+ */
+export declare function sessionAgentComms(id: SessionAgentId): string[];
 /**
  * Resolve an agent kind from a process's reported executable. `comm` may be an
  * absolute path (shim-launched agents), and Windows image names carry an
@@ -600,6 +617,24 @@ export declare function foldHostLink(rows: ActiveSession[]): void;
  * renderer shows the short id. Pure over the array; exported for tests.
  */
 export declare function annotateOrchestratorLabels(sessions: ActiveSession[]): void;
+/**
+ * Attach provenance (host / local-vs-SSH / tmux pane / reply rail) to every
+ * session that has a live pid. Mutates in place. Runs after dedupe so we probe
+ * each session once, not once per fork pid. Probes run in parallel — each is a
+ * single /proc read (Linux) or `ps` call (macOS); failures leave `provenance`
+ * undefined rather than blocking the listing. The probes use the same bounded
+ * concurrency as the adjacent per-PID lsof sweep so large session lists cannot
+ * spawn one `ps eww` subprocess per row at once on macOS.
+ *
+ * A row that already carries provenance (the tmux path, which knows its exact
+ * mux/reply from the pane) is not skipped — it is probe-and-MERGED. The tmux
+ * path can only stamp a `transport:'local'` placeholder because the pane alone
+ * doesn't reveal how the shell above it was reached; the process env does. So we
+ * still read the env and fill in the real SSH origin/term, while preserving the
+ * authoritative mux/reply the pane already gave us. Skipping this (the old
+ * behavior) is exactly why ssh-launched tmux sessions rendered as local.
+ */
+export declare function enrichProvenance(sessions: ActiveSession[], probe?: (pid: number) => Promise<SessionProvenance | undefined>): Promise<void>;
 /**
  * Match an SSH client IP to a registered device (pure — testable with a plain
  * registry object). Returns the device name + ssh login user when the IP is a

package/dist/lib/session/active.js

@@ -25,7 +25,7 @@ import { listActiveTasks } from '../cloud/store.js';
 import { AgentManager } from '../teams/agents.js';
 import { getTerminalsDir } from '../state.js';
 import { readPidSessionEntry, listPidSessionEntries, prunePidSessionRegistry } from './pid-registry.js';
-import { readSessionActorRecord } from './actor-sidecar.js';
+import { readSessionActorRecord, writeSessionAliasRecord } from './actor-sidecar.js';
 import { loadHookSessionIndex, resolveHookSessionRecord, readStateSessionRecord } from './hook-sessions.js';
 import { buildClaudeLabelMap, getAgentSessionDirs } from './discover.js';
 import { buildRunNameMap } from './run-names.js';
@@ -35,7 +35,8 @@ import { readSessionTailWithRaw } from './tail.js';
 import { parseSession } from './parse.js';
 import { computeTokPerSec } from './throughput.js';
 import { inferSessionState } from './state.js';
-import { isSessionTrackedAgent } from './types.js';
+import { isSessionTrackedAgent, SESSION_AGENTS } from './types.js';
+import { AGENTS } from '../agents.js';
 import { detectProvenance } from './provenance.js';
 import { loadDevices } from '../devices/registry.js';
 import { presenceFromStore } from './detached.js';
@@ -132,15 +133,47 @@ export const ABANDONED_STALE_MS = 2 * 24 * 60 * 60_000;
  * just reintroduce the same class of bug with a lower probability.
  */
 const TMUX_FIELD_SEP = ':';
-/** Executables we recognize as agent CLIs when scanning the process table. */
-const AGENT_CLI_NAMES = {
-    claude: 'claude',
-    codex: 'codex',
-    gemini: 'gemini',
-    'cursor-agent': 'cursor',
-    opencode: 'opencode',
-    droid: 'droid',
+/**
+ * Process comm names that are NOT derivable from the AGENTS registry's
+ * `cliCommand`. `rush` is a {@link SESSION_AGENTS} member with no AGENTS registry
+ * row (it is the Rush app, not a managed harness), so its executable name is
+ * mapped explicitly here. Everything else flows from the registry below.
+ */
+const EXTRA_SESSION_AGENT_COMMS = {
+    rush: ['rush'],
 };
+/**
+ * Every process executable ("comm") name that identifies a given session-agent
+ * kind in the headless `ps`-scan. Driven off the AGENTS registry's `cliCommand`
+ * (the real executable name — e.g. `agy` for antigravity, `cursor-agent` for
+ * cursor) plus {@link EXTRA_SESSION_AGENT_COMMS} for members with no registry
+ * row. Exported so the completeness test can assert every {@link SESSION_AGENTS}
+ * member resolves — the fix for the harness-parity gap where bare-headless
+ * grok/kimi/antigravity/openclaw/hermes/rush were silently dropped.
+ */
+export function sessionAgentComms(id) {
+    const comms = new Set();
+    const cli = AGENTS[id]?.cliCommand;
+    if (cli)
+        comms.add(cli);
+    for (const extra of EXTRA_SESSION_AGENT_COMMS[id] ?? [])
+        comms.add(extra);
+    return [...comms];
+}
+/**
+ * Executables we recognize as agent CLIs when scanning the process table. Built
+ * once from {@link sessionAgentComms} across {@link SESSION_AGENTS} — a single
+ * derived source, not a second hand-maintained allowlist that drifts from the
+ * discovery surface (the harness-parity code-review rule).
+ */
+const AGENT_CLI_NAMES = (() => {
+    const map = {};
+    for (const id of SESSION_AGENTS) {
+        for (const comm of sessionAgentComms(id))
+            map[comm] = id;
+    }
+    return map;
+})();
 /**
  * Resolve an agent kind from a process's reported executable. `comm` may be an
  * absolute path (shim-launched agents), and Windows image names carry an
@@ -1310,7 +1343,7 @@ export async function listTmuxAgentSessions() {
     try {
         res = await runTmux({
             socket,
-            args: ['list-panes', '-a', '-F', ['#{pane_id}', '#{session_name}', '#{pane_pid}', '#{pane_current_path}'].join(TMUX_FIELD_SEP)],
+            args: ['list-panes', '-a', '-F', ['#{pane_id}', '#{session_name}', '#{pane_pid}', '#{pane_dead}', '#{pane_current_path}'].join(TMUX_FIELD_SEP)],
             throwOnError: false,
             // A wedged tmux server must not hang the whole active-session scan. The
             // catch below turns a timeout into an empty tmux source (the other sources
@@ -1351,8 +1384,8 @@ export async function listTmuxAgentSessions() {
         // The path is the LAST field, so rejoin its tail: a directory containing the
         // separator must not truncate it (the earlier fields cannot contain one).
         const parts = line.split(TMUX_FIELD_SEP);
-        const [pane, sessName, pidRaw] = parts;
-        const curPath = parts.slice(3).join(TMUX_FIELD_SEP);
+        const [pane, sessName, pidRaw, paneDeadRaw] = parts;
+        const curPath = parts.slice(4).join(TMUX_FIELD_SEP);
         if (!pane || !sessName)
             continue;
         const meta = readSessionMeta(sessName);
@@ -1378,6 +1411,9 @@ export async function listTmuxAgentSessions() {
             if (backfilled)
                 id = { ...id, sessionId: backfilled };
         }
+        if (id.sessionId && shortIdFromName(sessName)) {
+            writeSessionAliasRecord(id.sessionId, sessName);
+        }
         // Dedupe by resolved session id; an as-yet-unresolved id (a hookless/lagging
         // split) keys on the unique pane so it still surfaces as its own row.
         const dedupKey = id.sessionId ?? pane;
@@ -1395,7 +1431,10 @@ export async function listTmuxAgentSessions() {
         // bug). Refuse to guess: an id-less pane surfaces as its own row instead.
         const sessionFile = id.sessionId ? findSessionFileForKind(id.agent, cwd, id.sessionId) : undefined;
         const topic = sessionFile ? quickExtractTopic(sessionFile) : undefined;
-        const pidAlive = pid ? isPidAlive(pid, liveEntry?.startedAtMs) : true;
+        // `remain-on-exit` retains the pane after its child exits. pane_dead is the
+        // authoritative signal; a retained pane is diagnostic, not attachable.
+        const paneDead = paneDeadRaw === '1';
+        const pidAlive = !paneDead && (pid ? isPidAlive(pid, liveEntry?.startedAtMs) : true);
         const { state, tokPerSec } = computeLiveSignals(id.agent, sessionFile, cwd, pidAlive);
         const { birthtimeMs, mtimeMs } = sessionFileTimes(sessionFile);
         // The mux/reply rails are known exactly here (the pane IS a tmux pane), so we
@@ -1620,7 +1659,9 @@ function foldPresence(rows) {
  * session that has a live pid. Mutates in place. Runs after dedupe so we probe
  * each session once, not once per fork pid. Probes run in parallel — each is a
  * single /proc read (Linux) or `ps` call (macOS); failures leave `provenance`
- * undefined rather than blocking the listing.
+ * undefined rather than blocking the listing. The probes use the same bounded
+ * concurrency as the adjacent per-PID lsof sweep so large session lists cannot
+ * spawn one `ps eww` subprocess per row at once on macOS.
  *
  * A row that already carries provenance (the tmux path, which knows its exact
  * mux/reply from the pane) is not skipped — it is probe-and-MERGED. The tmux
@@ -1630,11 +1671,11 @@ function foldPresence(rows) {
  * authoritative mux/reply the pane already gave us. Skipping this (the old
  * behavior) is exactly why ssh-launched tmux sessions rendered as local.
  */
-async function enrichProvenance(sessions) {
-    await Promise.all(sessions.map(async (s) => {
+export async function enrichProvenance(sessions, probe = detectProvenance) {
+    await mapBounded(sessions, async (s) => {
         if (!s.pid)
             return;
-        const probed = await detectProvenance(s.pid);
+        const probed = await probe(s.pid);
         if (!probed)
             return;
         if (!s.provenance) {
@@ -1649,7 +1690,7 @@ async function enrichProvenance(sessions) {
         }
         if (probed.term && !s.provenance.term)
             s.provenance.term = probed.term;
-    }));
+    }, { concurrency: LSOF_CONCURRENCY });
 }
 /**
  * Match an SSH client IP to a registered device (pure — testable with a plain

package/dist/lib/session/actor-sidecar.d.ts

@@ -7,6 +7,8 @@ export interface SessionActorRecord {
     initiatedBy?: 'human' | 'agent';
     /** Effective permissions mode used by the launcher. */
     mode?: SessionRunMode;
+    /** Stable wrapper names that resolve to this native session id. */
+    aliases?: string[];
     startedAtMs: number;
 }
 /**
@@ -15,6 +17,18 @@ export interface SessionActorRecord {
  * No-ops without a concrete session id (nothing to key on).
  */
 export declare function writeSessionActorRecord(record: SessionActorRecord): void;
+export declare function writeSessionAliasRecord(sessionId: string, alias: string): void;
+export type SessionAliasResolution = {
+    kind: 'resolved';
+    sessionId: string;
+} | {
+    kind: 'ambiguous';
+    sessionIds: string[];
+} | {
+    kind: 'not-found';
+};
+/** Resolve an exact alias, or a unique prefix/suffix of at least six chars. */
+export declare function resolveSessionAlias(selector: string): SessionAliasResolution;
 /** Read one session's actor record. Returns undefined if absent/corrupt. */
 export declare function readSessionActorRecord(sessionId: string): SessionActorRecord | undefined;
 /**

package/dist/lib/session/actor-sidecar.js

@@ -33,6 +33,25 @@ function isSafeSessionId(sessionId) {
 function recordPath(sessionId) {
     return path.join(sidecarDir(), `${sessionId}.json`);
 }
+function isSafeAlias(alias) {
+    return /^ag-[a-z][a-z0-9-]*-[0-9a-f]{8}$/i.test(alias);
+}
+function hasRecordData(record) {
+    return typeof record.actor === 'string'
+        || typeof record.mode === 'string'
+        || (Array.isArray(record.aliases) && record.aliases.some(alias => typeof alias === 'string'));
+}
+function normalizedAliases(aliases) {
+    if (!Array.isArray(aliases))
+        return [];
+    return [...new Set(aliases
+            .filter((alias) => typeof alias === 'string' && isSafeAlias(alias))
+            .map(alias => alias.toLowerCase()))];
+}
+function writeRecord(record) {
+    fs.mkdirSync(sidecarDir(), { recursive: true });
+    fs.writeFileSync(recordPath(record.sessionId), JSON.stringify(record), 'utf8');
+}
 /**
  * Record the actor a session was launched under. Never throws — the sidecar is
  * an attribution optimization; a session with no record simply scans unattributed.
@@ -42,13 +61,57 @@ export function writeSessionActorRecord(record) {
     if (!isSafeSessionId(record.sessionId))
         return;
     try {
-        fs.mkdirSync(sidecarDir(), { recursive: true });
-        fs.writeFileSync(recordPath(record.sessionId), JSON.stringify(record), 'utf8');
+        const previous = readSessionActorRecord(record.sessionId);
+        writeRecord({
+            ...previous,
+            ...record,
+            aliases: normalizedAliases([...(previous?.aliases ?? []), ...(record.aliases ?? [])]),
+        });
     }
     catch {
         /* degrade to an unattributed row */
     }
 }
+export function writeSessionAliasRecord(sessionId, alias) {
+    if (!isSafeSessionId(sessionId) || !isSafeAlias(alias))
+        return;
+    try {
+        const previous = readSessionActorRecord(sessionId);
+        writeRecord({
+            sessionId,
+            actor: previous?.actor,
+            initiatedBy: previous?.initiatedBy,
+            mode: previous?.mode,
+            aliases: normalizedAliases([...(previous?.aliases ?? []), alias]),
+            startedAtMs: previous?.startedAtMs ?? Date.now(),
+        });
+    }
+    catch {
+        /* the native id remains usable */
+    }
+}
+/** Resolve an exact alias, or a unique prefix/suffix of at least six chars. */
+export function resolveSessionAlias(selector) {
+    const normalized = selector.trim().toLowerCase();
+    if (!normalized)
+        return { kind: 'not-found' };
+    const exact = new Set();
+    const fuzzy = new Set();
+    for (const record of loadSessionActorIndex().values()) {
+        for (const alias of normalizedAliases(record.aliases)) {
+            if (alias === normalized)
+                exact.add(record.sessionId);
+            else if (normalized.length >= 6 && (alias.startsWith(normalized) || alias.endsWith(normalized)))
+                fuzzy.add(record.sessionId);
+        }
+    }
+    const matches = exact.size > 0 ? [...exact] : [...fuzzy];
+    if (matches.length === 0)
+        return { kind: 'not-found' };
+    if (matches.length > 1)
+        return { kind: 'ambiguous', sessionIds: matches.sort() };
+    return { kind: 'resolved', sessionId: matches[0] };
+}
 /** Read one session's actor record. Returns undefined if absent/corrupt. */
 export function readSessionActorRecord(sessionId) {
     if (!isSafeSessionId(sessionId))
@@ -63,7 +126,7 @@ export function readSessionActorRecord(sessionId) {
     try {
         const parsed = JSON.parse(raw);
         if (parsed && typeof parsed === 'object' && typeof parsed.sessionId === 'string' &&
-            (typeof parsed.actor === 'string' || typeof parsed.mode === 'string')) {
+            hasRecordData(parsed)) {
             return parsed;
         }
     }
@@ -91,7 +154,7 @@ export function loadSessionActorIndex() {
         try {
             const parsed = JSON.parse(fs.readFileSync(path.join(sidecarDir(), f), 'utf8'));
             if (parsed && typeof parsed === 'object' && typeof parsed.sessionId === 'string' &&
-                (typeof parsed.actor === 'string' || typeof parsed.mode === 'string')) {
+                hasRecordData(parsed)) {
                 out.set(parsed.sessionId, parsed);
             }
         }

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

@@ -12,7 +12,7 @@ import { type IndexedToolCall } from './tool-calls.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/05-sessions.md calls the constant the source of truth). */
-export declare const SCHEMA_VERSION = 33;
+export declare const SCHEMA_VERSION = 34;
 /**
  * Bump to force `agents sessions backfill resources` to re-derive every
  * session's skill/slash-command tallies on its next run (resource_scan_ledger

package/dist/lib/session/db.js

@@ -26,7 +26,7 @@ const DB_PATH = getSessionsDbPath();
 /** 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/05-sessions.md calls the constant the source of truth). */
-export const SCHEMA_VERSION = 33;
+export const SCHEMA_VERSION = 34;
 /**
  * Bump to force `agents sessions backfill resources` to re-derive every
  * session's skill/slash-command tallies on its next run (resource_scan_ledger
@@ -779,6 +779,37 @@ function migrateSchema(db, fromVersion) {
         db.exec(`CREATE INDEX IF NOT EXISTS idx_sessions_account_key ON sessions(account_key)`);
         backfillClaudeAccounts(db);
     }
+    if (fromVersion < 34) {
+        // v33 -> v34: claude-opus-5 and claude-sonnet-5 were missing from the pricing
+        // table. `getModelPricing` matches on a dash-bounded prefix, so neither could fall
+        // back to its Claude 4 entry: both resolved to null and every session using them
+        // priced to $0 -- silently, because an unpriced model contributes nothing rather
+        // than raising. On one real index that was 526 sessions, 478 of them the current
+        // default model.
+        //
+        // Adding the prices alone fixes nothing already indexed: cost_usd is computed at
+        // scan time, and the scanner skips any transcript whose (file_mtime_ms, file_size)
+        // is unchanged. Nor can those rows be repaired in place -- the row stores
+        // token_count and output_tokens, not the uncached-input / cache-read / cache-write
+        // split the price table needs -- so the figure has to come from re-reading the
+        // transcript.
+        //
+        // Flush ONLY the affected transcripts, not the whole ledger. A blanket
+        // `DELETE FROM scan_ledger` (what v5 -> v6 did when cost was introduced) would
+        // re-parse every session on the next scan and break the contract the other
+        // migrations here are tested against: adding a column must not invalidate warm
+        // session ledgers. Scoping it to the rows that actually mispriced keeps every
+        // other ledger entry warm and still guarantees the numbers correct themselves.
+        db.exec(`
+      DELETE FROM scan_ledger
+      WHERE file_path IN (
+        SELECT file_path FROM sessions
+        WHERE cost_usd IS NULL
+          AND file_path IS NOT NULL AND file_path <> ''
+          AND (model LIKE 'claude-opus-5%' OR model LIKE 'claude-sonnet-5%')
+      );
+    `);
+    }
 }
 /**
  * Stamp `account_key` / `account_org` / `account` on every Claude row from its

package/dist/lib/session/discover.js

@@ -47,6 +47,8 @@ const HOME = os.homedir();
 const VERSIONS_ROOTS = [getHistoryDir(), getAgentsDir()];
 const RUSH_SESSIONS_DIR = path.join(HOME, '.rush', 'sessions');
 const HERMES_SESSIONS_DIR = path.join(HOME, '.hermes', 'sessions');
+/** Muse Code sessions: ~/.local/share/muse/sessions/YYYY/MM/DD/<uuid>/session.jsonl */
+const MUSE_SESSIONS_DIR = path.join(HOME, '.local', 'share', 'muse', 'sessions');
 /** How long OpenClaw channel/cron snapshots stay valid before we re-shell-out. */
 const OPENCLAW_TTL_MS = 60_000;
 const ACTIVE_APPEND_RESCAN_DEBOUNCE_MS = 5_000;
@@ -303,6 +305,7 @@ function dispatchAgentScan(agent, onProgress) {
         case 'droid': return scanDroidIncremental(onProgress);
         case 'grok': return scanGrokIncremental(onProgress);
         case 'cursor': return scanCursorIncremental(onProgress);
+        case 'muse': return scanMuseIncremental(onProgress);
         default: return Promise.resolve();
     }
 }
@@ -2274,6 +2277,171 @@ function readHermesMeta(filePath) {
     };
     return { meta, content: userTexts.join('\n') };
 }
+/**
+ * Muse Code stores one session per directory under
+ * ~/.local/share/muse/sessions/YYYY/MM/DD/<uuid>/session.jsonl (event-sourced
+ * JSONL). Walk the tree for session.jsonl files and index each one.
+ *
+ * Also scan version homes (`versions/muse/<v>/home/.local/share/muse/sessions`)
+ * so managed/isolated runs that rewrite HOME still show up in `agents sessions`.
+ */
+function scanMuseIncremental(onProgress) {
+    const roots = [];
+    if (fs.existsSync(MUSE_SESSIONS_DIR))
+        roots.push(MUSE_SESSIONS_DIR);
+    for (const root of VERSIONS_ROOTS) {
+        const versionsBase = path.join(root, 'versions', 'muse');
+        if (!fs.existsSync(versionsBase))
+            continue;
+        try {
+            for (const version of fs.readdirSync(versionsBase)) {
+                const dir = path.join(versionsBase, version, 'home', '.local', 'share', 'muse', 'sessions');
+                if (fs.existsSync(dir))
+                    roots.push(dir);
+            }
+        }
+        catch {
+            /* unreadable */
+        }
+    }
+    if (roots.length === 0)
+        return Promise.resolve();
+    const filePaths = [];
+    const walk = (dir) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const ent of entries) {
+            const full = path.join(dir, ent.name);
+            if (ent.isDirectory()) {
+                // Skip subagent child sessions — nested under subagent/<id>/
+                if (ent.name === 'subagent')
+                    continue;
+                walk(full);
+            }
+            else if (ent.name === 'session.jsonl') {
+                filePaths.push(full);
+            }
+        }
+    };
+    for (const root of roots)
+        walk(root);
+    const changed = filterChangedFiles(filePaths);
+    if (changed.length === 0)
+        return Promise.resolve();
+    onProgress?.({ agent: 'muse', parsed: 0, total: changed.length });
+    const scanEntries = [];
+    const touched = [];
+    const seen = new Set();
+    let parsed = 0;
+    for (const { filePath, scan } of changed) {
+        try {
+            const result = readMuseMeta(filePath);
+            if (result && !seen.has(result.meta.id)) {
+                seen.add(result.meta.id);
+                scanEntries.push({ meta: result.meta, content: result.content, scan });
+            }
+            else {
+                touched.push({ filePath, scan });
+            }
+        }
+        catch {
+            touched.push({ filePath, scan });
+        }
+        parsed++;
+        onProgress?.({ agent: 'muse', parsed, total: changed.length });
+    }
+    upsertSessionsBatch(scanEntries);
+    recordScans(touched);
+    return Promise.resolve();
+}
+/** Parse a Muse session.jsonl for session metadata + first user prompt text. */
+function readMuseMeta(filePath) {
+    // Path shape: .../sessions/YYYY/MM/DD/<uuid>/session.jsonl
+    const sessionId = path.basename(path.dirname(filePath));
+    if (!/^[0-9a-f-]{36}$/i.test(sessionId))
+        return null;
+    let content;
+    try {
+        content = fs.readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+    const userTexts = [];
+    let topic;
+    let messageCount = 0;
+    let model;
+    let project;
+    let firstTs;
+    let lastTs;
+    for (const line of content.split('\n')) {
+        if (!line.trim())
+            continue;
+        let raw;
+        try {
+            raw = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (typeof raw.recorded_at === 'number') {
+            const v = raw.recorded_at;
+            // Muse logs use microseconds; values < 1e14 are treated as milliseconds.
+            const ms = v > 1e14 ? Math.floor(v / 1000) : v;
+            const ts = new Date(ms).toISOString();
+            if (!firstTs)
+                firstTs = ts;
+            lastTs = ts;
+        }
+        const payloadType = raw.payload_type;
+        const payload = raw.payload;
+        if (payloadType === 'runtime.session.metadata') {
+            const record = payload?.record;
+            if (typeof record?.workspace_root === 'string')
+                project = record.workspace_root;
+        }
+        if (payloadType === 'runtime.command_intake.received') {
+            const cmd = payload?.record?.command;
+            if (cmd?.kind === 'turn_submit' && typeof cmd.prompt === 'string' && cmd.prompt.trim()) {
+                messageCount++;
+                userTexts.push(cmd.prompt.trim());
+                if (!topic)
+                    topic = extractSessionTopic(cmd.prompt.trim());
+            }
+        }
+        const event = payload?.event ?? payload;
+        if (event?.kind === 'assistant_message_committed' && typeof event.text === 'string') {
+            messageCount++;
+        }
+        if (event?.kind === 'model_request_configured' && typeof event.model === 'string') {
+            model = event.model;
+        }
+        if (typeof event?.model === 'string' && !model)
+            model = event.model;
+    }
+    const stat = safeStatSync(filePath);
+    const timestamp = lastTs
+        || firstTs
+        || (stat ? stat.mtime.toISOString() : new Date().toISOString());
+    const shortId = deriveShortId(sessionId);
+    const meta = {
+        id: sessionId,
+        shortId,
+        agent: 'muse',
+        timestamp,
+        project,
+        filePath,
+        model,
+        topic,
+        messageCount: messageCount || undefined,
+    };
+    return { meta, content: userTexts.join('\n') };
+}
 /** Extract plain text from a Hermes message content field (string or list of parts). */
 function extractHermesMessageText(content) {
     if (typeof content === 'string')

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

@@ -133,6 +133,16 @@ export declare function parseGrok(filePath: string): SessionEvent[];
 export declare function parseOpenCode(filePath: string): SessionEvent[];
 /** Parse a Rush JSONL session file into normalized events. */
 export declare function parseRush(filePath: string): SessionEvent[];
+/**
+ * Muse Code session.jsonl → normalized events.
+ *
+ * Muse records an append-only event log. We map:
+ *   - runtime.command_intake.received / turn_submit → user message
+ *   - assistant_message_committed → assistant message
+ *   - model_completed.usage → usage
+ *   - tool-related events when present
+ */
+export declare function parseMuse(filePath: string): SessionEvent[];
 /** Parse a Hermes session JSON file into normalized events. */
 export declare function parseHermes(filePath: string): SessionEvent[];
 /** Parse a Kimi session state.json file by reading its agents/main/wire.jsonl. */