@songsid/agend 2.2.0-alpha.2 → 2.2.0-alpha.4

package/dist/transcript-sources.d.ts

@@ -1,6 +1,7 @@
 import { type RolloutIndex } from "./rollout-index.js";
 import { type KiroDbLane } from "./kiro-transcript-lane.js";
 export { extractKiroAssistantStrings } from "./kiro-db-reader.js";
+import type { TranscriptTurnEvent } from "./transcript-turns.js";
 export interface ToolUseEvent {
     name: string;
     input: unknown;
@@ -11,6 +12,8 @@ export interface TranscriptEvents {
         name: string;
     }>;
     assistantTexts: string[];
+    /** #1510: turn boundaries, from a source that records them (codex). */
+    turns?: TranscriptTurnEvent[];
 }
 export interface TranscriptCheckpoint {
     path: string;
@@ -51,6 +54,8 @@ export declare class CodexRolloutSource implements TranscriptSource {
      */
     private accepted;
     private readonly index;
+    /** #1510: the turn the records being read belong to (its `task_started`), carried across polls of one file. */
+    private openTurnId;
     constructor(workingDirectory: string, sessionsDir?: string, _now?: number, index?: RolloutIndex);
     reset(): void;
     checkpoint(): Promise<TranscriptCheckpoint | null>;
@@ -70,6 +75,49 @@ export declare class CodexRolloutSource implements TranscriptSource {
     private fileBelongsToUs;
     poll(): Promise<TranscriptEvents>;
 }
+/**
+ * #1510: muse's turn boundaries, from its session logs (`<root>/<YYYY>/<MM>/<DD>/<id>/session.jsonl`, recorded on
+ * 1.4.4 in tests/fixtures/reply-guard-1510). Only turns are read; muse's tool activity is not.
+ *
+ * - a run is a turn: `runtime.session` run `started` → `terminal {reason}` (null: done; "cancelled …": the user
+ *   stopped it; anything else: it failed);
+ * - a message is `runtime.user_intent.accepted` (its text, surface "main") and lands in a run with
+ *   `user_intent.materialized` — a new run, or the active one when it was typed mid-run;
+ * - the end-of-turn reminder observers write their own session directories and no main-surface intents.
+ *
+ * Every log whose head names this working directory is followed: ownership is decided later, by the delivered text
+ * (TranscriptTurnLedger), so two muse instances in one directory cannot vouch for each other. The directory tree is
+ * re-listed at most every `listTtlMs`; between listings only the logs already known are read, and only when they grew.
+ * Logs present when the source is created are read from their end (existing history is not this launch's).
+ */
+export declare class MuseSessionSource implements TranscriptSource {
+    private workingDirectory;
+    private root;
+    private listTtlMs;
+    private now;
+    /**
+     * session.jsonl path → where to read next (cwd-matched logs only): a byte offset, or `{ anchor }` for a log that
+     * existed before this source (read from its last line boundary at `anchor` bytes, or at its size when first read
+     * if its size was not known then — never from its start).
+     */
+    private files;
+    /** Every log present at the baseline, with its size then (null: it was there, its size could not be read). */
+    private preexisting;
+    /** Whether the baseline listing saw the whole tree; if not, a log found later may be old and is read from its end. */
+    private baselineComplete;
+    private rejected;
+    private sizes;
+    private listedAt;
+    private baselined;
+    /** intent_id → its text and time, until it materializes (bounded). */
+    private intents;
+    constructor(workingDirectory: string, root?: string, listTtlMs?: number, now?: () => number);
+    reset(): void;
+    initialize(): Promise<void>;
+    private list;
+    poll(): Promise<TranscriptEvents>;
+    private parse;
+}
 /**
  * The conversation database for one kiro store.
  *
@@ -112,6 +160,10 @@ includeHistory?: boolean): KiroConversationRead;
  * Kiro 2.19 moved primary conversations to conversations_v2 in data.sqlite3;
  * legacy releases use <uuid>.jsonl plus sibling <uuid>.json metadata.
  */
+/** The Kiro legacy fallback's scan bounds (#1490): see KiroSessionSource.resolveActiveSession. */
+export declare const KIRO_FULL_SCAN_MS = 30000;
+export declare const KIRO_QUIET_MS: number;
+export declare const KIRO_SCAN_CONCURRENCY = 16;
 export declare class KiroSessionSource implements TranscriptSource {
     private workingDirectory;
     private sessionsDir;
@@ -137,6 +189,22 @@ export declare class KiroSessionSource implements TranscriptSource {
      * `null` = the file does not concern us (another cwd, or a subagent child).
      */
     private metaCache;
+    /** The sessions directory as last listed: re-listed only when its mtime moves (a session added or removed). */
+    private sessionsListing;
+    private fullScanAt;
+    /** Monotonic clock for the full-scan spacing; wall clock for comparing with file times. Test hooks. */
+    private mono;
+    private wall;
+    /**
+     * The newest session of this working directory, from its metadata (#1490). It used to run `readdirSync` plus a
+     * `statSync` of every metadata file on the event loop, on every 2 s poll while the store had no row for us: 16–18 ms
+     * per instance with 5,000 sessions. Now it is asynchronous and bounded:
+     *   - the directory is listed again only when its mtime moved, or when it was read right after a change (file
+     *     times are coarse: a session created in the same tick would share that mtime), or on a full scan;
+     *   - a metadata file quiet for KIRO_QUIET_MS is not stat'ed again until the next full scan, so a poll costs one
+     *     stat of the directory plus the recently active files; an old session resumed is seen within KIRO_FULL_SCAN_MS;
+     *   - every full scan (each KIRO_FULL_SCAN_MS) re-stats everything, KIRO_SCAN_CONCURRENCY at a time.
+     */
     private resolveActiveSession;
     poll(): Promise<TranscriptEvents>;
 }

package/dist/transcript-sources.js

@@ -26,7 +26,8 @@ import { measureSyncWork } from "./sync-work-attribution.js";
  *   - Every poll re-resolves which transcript is active. Pinning to the first
  *     one found silently goes blind when the CLI starts a new session.
  */
-import { closeSync, existsSync, openSync, readdirSync, readFileSync, readSync, realpathSync, statSync } from "node:fs";
+import { closeSync, existsSync, openSync, readSync, realpathSync } from "node:fs";
+import { readdir, readFile, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { sharedRolloutIndex } from "./rollout-index.js";
@@ -34,6 +35,8 @@ import Database from "better-sqlite3";
 import { sharedKiroTranscriptLane } from "./kiro-transcript-lane.js";
 export { extractKiroAssistantStrings } from "./kiro-db-reader.js";
 import { lastLineBoundary, readNewLines } from "./transcript-jsonl.js";
+import { museSessionCwd, readFileHeadSync } from "./backend/muse.js";
+import { performance } from "node:perf_hooks";
 const EMPTY = { toolUses: [], toolResults: [], assistantTexts: [] };
 function emptyEvents() {
     return { toolUses: [], toolResults: [], assistantTexts: [] };
@@ -60,6 +63,8 @@ export class CodexRolloutSource {
      */
     accepted = new Set();
     index;
+    /** #1510: the turn the records being read belong to (its `task_started`), carried across polls of one file. */
+    openTurnId = "";
     constructor(workingDirectory, sessionsDir = join(process.env.CODEX_HOME?.trim() || join(homedir(), ".codex"), "sessions"), _now = Date.now(), index) {
         this.workingDirectory = workingDirectory;
         this.sessionsDir = sessionsDir;
@@ -69,6 +74,7 @@ export class CodexRolloutSource {
     reset() {
         this.currentFile = null;
         this.byteOffset = 0;
+        this.openTurnId = "";
         this.rejected.clear();
         this.accepted.clear();
         this.snapshotExistingFiles();
@@ -164,10 +170,12 @@ export class CodexRolloutSource {
             }
             this.currentFile = active.path;
             this.byteOffset = offset;
+            this.openTurnId = "";
         }
         const { lines, newOffset } = await readNewLines(this.currentFile, this.byteOffset);
         this.byteOffset = newOffset;
         const events = emptyEvents();
+        const turns = [];
         for (const line of lines) {
             let entry;
             try {
@@ -176,11 +184,32 @@ export class CodexRolloutSource {
             catch {
                 continue;
             }
-            if (entry.type !== "response_item")
-                continue;
             const p = entry.payload;
             if (!p)
                 continue;
+            // #1510: codex 0.162 writes one task_started per turn and ends it with task_complete (last_agent_message null
+            // after a provider error) or turn_aborted; a steer lands inside the open turn as another user message.
+            if (entry.type === "event_msg") {
+                if (p.type === "task_started" && typeof p.turn_id === "string") {
+                    this.openTurnId = p.turn_id;
+                    turns.push({ kind: "start", turnId: p.turn_id });
+                }
+                else if ((p.type === "task_complete" || p.type === "turn_aborted") && typeof p.turn_id === "string") {
+                    const end = p.type === "turn_aborted" ? "aborted" : p.last_agent_message == null ? "error" : "complete";
+                    turns.push({ kind: "end", turnId: p.turn_id, end });
+                }
+                continue;
+            }
+            if (entry.type !== "response_item")
+                continue;
+            if (p.type === "message" && p.role === "user") {
+                const text = (p.content ?? [])
+                    .map(block => typeof block.text === "string" ? block.text : "").join("\n");
+                const at = Date.parse(String(entry.timestamp ?? ""));
+                if (text.trim() && Number.isFinite(at))
+                    turns.push({ kind: "user", turnId: this.openTurnId, text, at });
+                continue;
+            }
             if (p.type === "function_call") {
                 let input = p.arguments;
                 if (typeof input === "string") {
@@ -210,8 +239,230 @@ export class CodexRolloutSource {
                 }
             }
         }
+        if (turns.length)
+            events.turns = turns;
+        return events;
+    }
+}
+/* -------------------------------------------------------------------- muse */
+/**
+ * #1510: muse's turn boundaries, from its session logs (`<root>/<YYYY>/<MM>/<DD>/<id>/session.jsonl`, recorded on
+ * 1.4.4 in tests/fixtures/reply-guard-1510). Only turns are read; muse's tool activity is not.
+ *
+ * - a run is a turn: `runtime.session` run `started` → `terminal {reason}` (null: done; "cancelled …": the user
+ *   stopped it; anything else: it failed);
+ * - a message is `runtime.user_intent.accepted` (its text, surface "main") and lands in a run with
+ *   `user_intent.materialized` — a new run, or the active one when it was typed mid-run;
+ * - the end-of-turn reminder observers write their own session directories and no main-surface intents.
+ *
+ * Every log whose head names this working directory is followed: ownership is decided later, by the delivered text
+ * (TranscriptTurnLedger), so two muse instances in one directory cannot vouch for each other. The directory tree is
+ * re-listed at most every `listTtlMs`; between listings only the logs already known are read, and only when they grew.
+ * Logs present when the source is created are read from their end (existing history is not this launch's).
+ */
+export class MuseSessionSource {
+    workingDirectory;
+    root;
+    listTtlMs;
+    now;
+    /**
+     * session.jsonl path → where to read next (cwd-matched logs only): a byte offset, or `{ anchor }` for a log that
+     * existed before this source (read from its last line boundary at `anchor` bytes, or at its size when first read
+     * if its size was not known then — never from its start).
+     */
+    files = new Map();
+    /** Every log present at the baseline, with its size then (null: it was there, its size could not be read). */
+    preexisting = new Map();
+    /** Whether the baseline listing saw the whole tree; if not, a log found later may be old and is read from its end. */
+    baselineComplete = false;
+    rejected = new Set();
+    sizes = new Map();
+    listedAt = Number.NEGATIVE_INFINITY;
+    baselined = false;
+    /** intent_id → its text and time, until it materializes (bounded). */
+    intents = new Map();
+    constructor(workingDirectory, root = join(homedir(), ".local", "share", "muse", "sessions"), listTtlMs = 30_000, now = () => performance.now()) {
+        this.workingDirectory = workingDirectory;
+        this.root = root;
+        this.listTtlMs = listTtlMs;
+        this.now = now;
+    }
+    reset() {
+        this.files.clear();
+        this.preexisting.clear();
+        this.rejected.clear();
+        this.sizes.clear();
+        this.intents.clear();
+        this.listedAt = Number.NEGATIVE_INFINITY;
+        this.baselined = false;
+        this.baselineComplete = false;
+    }
+    async initialize() { await this.list(); }
+    async list() {
+        this.listedAt = this.now();
+        const { logs, complete } = await listMuseSessionLogs(this.root);
+        if (!this.baselined) {
+            // The baseline is every log there now, whatever its head says: history is not this launch's, and a log whose
+            // cwd cannot be read yet is still history when it can.
+            for (const path of logs)
+                this.preexisting.set(path, await stat(path).then(st => st.size, () => null));
+            this.baselineComplete = complete;
+            this.baselined = true;
+        }
+        for (const path of logs) {
+            if (this.files.has(path) || this.rejected.has(path))
+                continue;
+            const head = readFileHeadSync(path, 65_536);
+            if (head === null)
+                continue;
+            const cwd = museSessionCwd(head);
+            if (cwd === null) {
+                // A log being started names its cwd within moments; one that still does not a minute on never will (the
+                // end-of-turn reminder observers write two such logs per turn) and is not read again.
+                const mtime = await stat(path).then(st => st.mtimeMs, () => null);
+                if (mtime !== null && Date.now() - mtime > 60_000)
+                    this.rejected.add(path);
+                continue;
+            }
+            if (cwd !== this.workingDirectory) {
+                this.rejected.add(path);
+                continue;
+            }
+            // Read from the start only a log provably made after the baseline.
+            const fresh = this.baselineComplete && !this.preexisting.has(path);
+            this.files.set(path, fresh ? 0 : { anchor: this.preexisting.get(path) ?? null });
+        }
+    }
+    async poll() {
+        if (!this.baselined || this.now() - this.listedAt >= this.listTtlMs)
+            await this.list();
+        const turns = [];
+        for (const [path, next] of this.files) {
+            const size = await stat(path).then(st => st.size, () => null);
+            if (size === null || size === this.sizes.get(path))
+                continue;
+            let from;
+            if (typeof next === "number")
+                from = next;
+            else {
+                try {
+                    from = await lastLineBoundary(path, next.anchor ?? size);
+                }
+                catch {
+                    continue;
+                }
+            }
+            let read;
+            try {
+                read = await readNewLines(path, from);
+            }
+            catch {
+                continue;
+            }
+            this.files.set(path, read.newOffset);
+            this.sizes.set(path, size);
+            // One record at a time: a record of an unexpected shape is skipped, never the batch it came in.
+            for (const line of read.lines) {
+                try {
+                    this.parse(line, turns);
+                }
+                catch { /* skipped */ }
+            }
+        }
+        const events = emptyEvents();
+        if (turns.length)
+            events.turns = turns;
         return events;
     }
+    parse(line, turns) {
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        const o = asRecord(parsed), p = asRecord(o?.payload);
+        if (!o || !p)
+            return;
+        const type = o.payload_type;
+        const at = typeof o.recorded_at === "number" && Number.isFinite(o.recorded_at) ? Math.floor(o.recorded_at / 1000) : NaN; // µs
+        if (type === "runtime.user_intent.accepted") {
+            if (p.surface !== "main" || typeof p.intent_id !== "string" || !Number.isFinite(at) || !Array.isArray(p.model_messages))
+                return;
+            const parts = [];
+            for (const message of p.model_messages) {
+                const content = asRecord(message)?.content;
+                if (!Array.isArray(content))
+                    return;
+                for (const block of content) {
+                    const b = asRecord(block);
+                    if (b?.kind === "text" && typeof b.text === "string")
+                        parts.push(b.text);
+                }
+            }
+            const text = parts.join("\n");
+            if (!text.trim())
+                return;
+            this.intents.set(p.intent_id, { text, at });
+            if (this.intents.size > 64)
+                this.intents.delete(this.intents.keys().next().value);
+        }
+        else if (type === "runtime.user_intent.materialized") {
+            const intent = typeof p.intent_id === "string" ? this.intents.get(p.intent_id) : undefined;
+            const runId = asRecord(p.outcome)?.run_id;
+            if (!intent || typeof runId !== "string")
+                return;
+            this.intents.delete(p.intent_id);
+            turns.push({ kind: "user", turnId: runId, text: intent.text, at: intent.at });
+        }
+        else if (type === "runtime.session" && p.kind === "run" && typeof p.run_id === "string") {
+            const event = asRecord(p.event);
+            if (event?.kind === "started")
+                turns.push({ kind: "start", turnId: p.run_id });
+            else if (event?.kind === "terminal" && "reason" in event) {
+                // Only what was recorded proves anything: an explicit null is a run that finished; a missing or unfamiliar
+                // reason ends nothing (the turn stays open, and the guard's running cap stands it down).
+                const reason = event.reason;
+                if (reason === null)
+                    turns.push({ kind: "end", turnId: p.run_id, end: "complete" });
+                else if (typeof reason === "string")
+                    turns.push({ kind: "end", turnId: p.run_id, end: reason.startsWith("cancelled") ? "aborted" : "error" });
+            }
+        }
+    }
+}
+function asRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+/**
+ * `<root>/<YYYY>/<MM>/<DD>/<id>/session.jsonl` for every session directory. `complete` is false when a directory
+ * that exists could not be read: what it holds is unknown. A root that does not exist yet is complete (empty).
+ */
+async function listMuseSessionLogs(root) {
+    let complete = true;
+    const children = async (dir, isRoot = false) => {
+        try {
+            return await readdir(dir);
+        }
+        catch (err) {
+            if (!(isRoot && err.code === "ENOENT"))
+                complete = false;
+            return [];
+        }
+    };
+    const logs = [];
+    for (const year of await children(root, true)) {
+        if (!/^\d{4}$/.test(year))
+            continue;
+        for (const month of await children(join(root, year))) {
+            for (const day of await children(join(root, year, month))) {
+                for (const session of await children(join(root, year, month, day)))
+                    logs.push(join(root, year, month, day, session, "session.jsonl"));
+            }
+        }
+    }
+    return { logs, complete };
 }
 /* -------------------------------------------------------------------- kiro */
 /**
@@ -294,6 +545,18 @@ includeHistory = true) {
  * Kiro 2.19 moved primary conversations to conversations_v2 in data.sqlite3;
  * legacy releases use <uuid>.jsonl plus sibling <uuid>.json metadata.
  */
+/** The Kiro legacy fallback's scan bounds (#1490): see KiroSessionSource.resolveActiveSession. */
+export const KIRO_FULL_SCAN_MS = 30_000;
+export const KIRO_QUIET_MS = 10 * 60_000;
+export const KIRO_SCAN_CONCURRENCY = 16;
+const KIRO_HOT_DIR_MS = 2_000;
+/** Run `task(0..count-1)`, at most `limit` at a time. */
+async function forEachLimited(count, limit, task) {
+    let next = 0;
+    const worker = async () => { while (next < count)
+        await task(next++); };
+    await Promise.all(Array.from({ length: Math.min(limit, count) }, worker));
+}
 export class KiroSessionSource {
     workingDirectory;
     sessionsDir;
@@ -365,26 +628,59 @@ export class KiroSessionSource {
      * `null` = the file does not concern us (another cwd, or a subagent child).
      */
     metaCache = new Map();
-    resolveActiveSession() {
-        let entries;
+    /** The sessions directory as last listed: re-listed only when its mtime moves (a session added or removed). */
+    sessionsListing = null;
+    fullScanAt = Number.NEGATIVE_INFINITY;
+    /** Monotonic clock for the full-scan spacing; wall clock for comparing with file times. Test hooks. */
+    mono = () => performance.now();
+    wall = () => Date.now();
+    /**
+     * The newest session of this working directory, from its metadata (#1490). It used to run `readdirSync` plus a
+     * `statSync` of every metadata file on the event loop, on every 2 s poll while the store had no row for us: 16–18 ms
+     * per instance with 5,000 sessions. Now it is asynchronous and bounded:
+     *   - the directory is listed again only when its mtime moved, or when it was read right after a change (file
+     *     times are coarse: a session created in the same tick would share that mtime), or on a full scan;
+     *   - a metadata file quiet for KIRO_QUIET_MS is not stat'ed again until the next full scan, so a poll costs one
+     *     stat of the directory plus the recently active files; an old session resumed is seen within KIRO_FULL_SCAN_MS;
+     *   - every full scan (each KIRO_FULL_SCAN_MS) re-stats everything, KIRO_SCAN_CONCURRENCY at a time.
+     */
+    async resolveActiveSession() {
+        const now = this.wall();
+        const full = this.mono() - this.fullScanAt >= KIRO_FULL_SCAN_MS;
+        let dirMtimeMs;
         try {
-            entries = readdirSync(this.sessionsDir);
+            dirMtimeMs = (await stat(this.sessionsDir)).mtimeMs;
         }
         catch {
             return null;
         }
-        let best = null;
-        const seen = new Set();
-        for (const e of entries) {
-            if (!e.endsWith(".json") || e.endsWith(".jsonl"))
-                continue;
-            const metaPath = join(this.sessionsDir, e);
-            seen.add(metaPath);
+        let listing = this.sessionsListing;
+        if (full || !listing || listing.mtimeMs !== dirMtimeMs || listing.hotWhenRead) {
+            let entries;
             try {
-                const st = statSync(metaPath);
-                let cached = this.metaCache.get(metaPath);
+                entries = await readdir(this.sessionsDir);
+            }
+            catch {
+                return null;
+            }
+            listing = { mtimeMs: dirMtimeMs, names: entries.filter(e => e.endsWith(".json") && !e.endsWith(".jsonl")).sort(), hotWhenRead: now - dirMtimeMs < KIRO_HOT_DIR_MS };
+            this.sessionsListing = listing;
+        }
+        if (full)
+            this.fullScanAt = this.mono();
+        const verdicts = new Array(listing.names.length).fill(null);
+        const names = listing.names;
+        await forEachLimited(names.length, KIRO_SCAN_CONCURRENCY, async (i) => {
+            const metaPath = join(this.sessionsDir, names[i]);
+            let cached = this.metaCache.get(metaPath);
+            if (!full && cached && now - cached.mtimeMs > KIRO_QUIET_MS) {
+                verdicts[i] = cached.meta;
+                return;
+            }
+            try {
+                const st = await stat(metaPath);
                 if (!cached || cached.mtimeMs !== st.mtimeMs || cached.size !== st.size) {
-                    const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
+                    const meta = JSON.parse(await readFile(metaPath, "utf-8"));
                     // Subagent sessions are children of a turn already being reported.
                     const ours = meta.cwd === this.workingDirectory && meta.session_created_reason !== "subagent";
                     cached = {
@@ -396,21 +692,31 @@ export class KiroSessionSource {
                     };
                     this.metaCache.set(metaPath, cached);
                 }
-                if (!cached.meta)
-                    continue;
-                if (!best || cached.meta.updated > best.updated) {
-                    const jsonlPath = join(this.sessionsDir, e.replace(/\.json$/, ".jsonl"));
-                    best = { jsonlPath, updated: cached.meta.updated, createdAtMs: cached.meta.created };
-                }
+                verdicts[i] = cached.meta;
             }
-            catch { /* partially written metadata — next poll */ }
-        }
+            catch { /* partially written metadata, or deleted meanwhile — next poll */ }
+        });
+        const seen = new Set(names.map(e => join(this.sessionsDir, e)));
         for (const known of this.metaCache.keys())
             if (!seen.has(known))
                 this.metaCache.delete(known);
-        return best && existsSync(best.jsonlPath)
-            ? { jsonlPath: best.jsonlPath, createdAtMs: best.createdAtMs }
-            : null;
+        let best = null;
+        names.forEach((e, i) => {
+            const meta = verdicts[i];
+            if (meta && (!best || meta.updated > best.updated)) {
+                best = { jsonlPath: join(this.sessionsDir, e.replace(/\.json$/, ".jsonl")), updated: meta.updated, createdAtMs: meta.created };
+            }
+        });
+        const chosen = best;
+        if (!chosen)
+            return null;
+        try {
+            await stat(chosen.jsonlPath);
+        }
+        catch {
+            return null;
+        }
+        return { jsonlPath: chosen.jsonlPath, createdAtMs: chosen.createdAtMs };
     }
     async poll() {
         // Current Kiro stores the primary session in SQLite; JSONL is now mostly
@@ -421,8 +727,8 @@ export class KiroSessionSource {
             return EMPTY;
         if (dbEvents !== null)
             return dbEvents;
-        const active = this.resolveActiveSession();
-        if (!active)
+        const active = await this.resolveActiveSession();
+        if (generation !== this.generation || !active)
             return EMPTY;
         if (active.jsonlPath !== this.currentFile) {
             if (active.createdAtMs >= this.createdAt) {
@@ -590,6 +896,7 @@ export function createTranscriptSource(backend, workingDirectory,
 storeHome) {
     switch (backend) {
         case "codex": return new CodexRolloutSource(workingDirectory);
+        case "muse": return new MuseSessionSource(workingDirectory);
         // undefined keeps each parameter's own default; only the store moves.
         case "kiro-cli": return new KiroSessionSource(workingDirectory, undefined, undefined, kiroStoreDbPath(storeHome));
         case "opencode": return new OpenCodeDbSource(workingDirectory);