@ai-devkit/agent-manager 0.41.0 → 0.42.0

package/src/__tests__/harnesses/muse/MuseSessionParser.test.ts

@@ -0,0 +1,279 @@
+/**
+ * Tests for harnesses/muse/MuseSessionParser.ts — framed transcript parsing.
+ *
+ * Muse session.jsonl lines are frames: either a direct inner record, a
+ * `record_json` string, or a `retained_frame` wrapper whose children carry
+ * `record_json` strings. Inner records dispatch on `payload_type`.
+ */
+
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { AgentStatus } from "../../../adapters/AgentAdapter.js";
+import { MuseSessionParser } from "../../../harnesses/muse/MuseSessionParser.js";
+
+const SID = "01a12618-d918-7b63-91c8-4e896326eb1a";
+
+function frame(inner: unknown): string {
+  return JSON.stringify(inner);
+}
+
+function wrapped(inner: unknown): string {
+  return JSON.stringify({ record_json: JSON.stringify(inner) });
+}
+
+function retained(inner: unknown): string {
+  return JSON.stringify({
+    retained_frame: "session_permission_transaction",
+    frame_schema_version: 1,
+    children: [{ child_index: 0, record_json: JSON.stringify(inner) }],
+  });
+}
+
+function intent(text: string, sequence: number, recordedAtUs: number): unknown {
+  return {
+    schema_version: 1,
+    stream: { kind: "session", id: SID },
+    sequence,
+    recorded_at: recordedAtUs,
+    record_type: "event",
+    payload_type: "runtime.user_intent.accepted",
+    payload: {
+      intent_id: `intent-${sequence}`,
+      refill_blocks: [{ kind: "text", text }],
+    },
+  };
+}
+
+function assistantMessage(text: string, sequence: number, recordedAtUs: number): unknown {
+  return {
+    schema_version: 1,
+    stream: { kind: "session", id: SID },
+    sequence,
+    recorded_at: recordedAtUs,
+    record_type: "event",
+    payload_type: "runtime.session",
+    payload: {
+      kind: "run",
+      run_id: "run-1",
+      event: { kind: "assistant_message_committed", text },
+    },
+  };
+}
+
+function metadata(recordedAtUs: number): unknown {
+  return {
+    schema_version: 1,
+    stream: { kind: "session", id: SID },
+    sequence: 1,
+    recorded_at: recordedAtUs,
+    record_type: "event",
+    payload_type: "runtime.session.metadata",
+    payload: {
+      kind: "metadata",
+      record: { workspace_root: "/Users/tester/proj", model_id: "muse-spark-1.3" },
+    },
+  };
+}
+
+function nameChanged(name: string, sequence: number, recordedAtUs: number): unknown {
+  return {
+    schema_version: 1,
+    stream: { kind: "session", id: SID },
+    sequence,
+    recorded_at: recordedAtUs,
+    record_type: "event",
+    payload_type: "session.name.changed",
+    payload: { session_id: SID, previous_name: null, new_name: name },
+  };
+}
+
+describe("MuseSessionParser", () => {
+  let parser: MuseSessionParser;
+  const tempDirs: string[] = [];
+
+  beforeEach(() => {
+    parser = new MuseSessionParser();
+  });
+
+  afterEach(() => {
+    for (const dir of tempDirs) {
+      try {
+        fs.rmSync(dir, { recursive: true, force: true });
+      } catch {
+        /* best effort */
+      }
+    }
+    tempDirs.length = 0;
+  });
+
+  function writeTranscript(lines: string[]): string {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "muse-parser-test-"));
+    tempDirs.push(dir);
+    const filePath = path.join(dir, "session.jsonl");
+    fs.writeFileSync(filePath, lines.join("\n"));
+    return filePath;
+  }
+
+  it("returns null for missing or empty files", () => {
+    expect(parser.readSession("/nonexistent/session.jsonl", "/proj")).toBeNull();
+    expect(parser.readSession(writeTranscript([]), "/proj")).toBeNull();
+  });
+
+  it("skips unparseable lines and wrapper frames without records", () => {
+    const filePath = writeTranscript([
+      "not json at all",
+      JSON.stringify({ retained_frame: "x", children: [] }),
+      frame(intent("hello", 2, 1791640525332173)),
+    ]);
+    const session = parser.readSession(filePath, "/proj");
+    expect(session?.lastUserMessage).toBe("hello");
+  });
+
+  it("unwraps record_json strings and retained children", () => {
+    const filePath = writeTranscript([
+      wrapped(intent("first", 2, 1791640525332173)),
+      retained(intent("second", 3, 1791640525332174)),
+    ]);
+    const session = parser.readSession(filePath, "/proj");
+    expect(session?.firstUserMessage).toBe("first");
+    expect(session?.lastUserMessage).toBe("second");
+  });
+
+  it("reads workspace root, model, and display name", () => {
+    const filePath = writeTranscript([
+      frame(metadata(1791640525332173)),
+      frame(intent("hi", 2, 1791640525332174)),
+      frame(nameChanged("flowing-monoceros", 3, 1791640525332175)),
+    ]);
+    // Empty project path lets the recorded workspace root win (archive sessions).
+    const session = parser.readSession(filePath, "");
+    expect(session?.projectPath).toBe("/Users/tester/proj");
+    expect(session?.modelId).toBe("muse-spark-1.3");
+    expect(session?.displayName).toBe("flowing-monoceros");
+    // First user message is found even when it is not on the first line.
+    expect(session?.firstUserMessage).toBe("hi");
+  });
+
+  it("normalizes microsecond timestamps to millisecond dates", () => {
+    const filePath = writeTranscript([frame(intent("hi", 2, 1791640525332173))]);
+    const session = parser.readSession(filePath, "/proj");
+    expect(session?.lastActive).toEqual(new Date(1791640525332));
+  });
+
+  it("maps last user intent to RUNNING and committed reply to WAITING", () => {
+    const running = parser.readSession(
+      writeTranscript([
+        frame(intent("q", 2, 1791640525332173)),
+        frame(assistantMessage("a", 3, 1791640525332174)),
+        frame(intent("q2", 4, 1791640525332175)),
+      ]),
+      "/proj",
+    );
+    expect(parser.determineStatus(running!)).toBe(AgentStatus.RUNNING);
+
+    const waiting = parser.readSession(
+      writeTranscript([
+        frame(intent("q", 2, 1791640525332173)),
+        frame(assistantMessage("a", 3, 1791640525332174)),
+      ]),
+      "/proj",
+    );
+    expect(parser.determineStatus(waiting!)).toBe(AgentStatus.WAITING);
+  });
+
+  it("maps approval waits and terminal runs to WAITING and IDLE", () => {
+    const waiting = parser.readSession(
+      writeTranscript([
+        frame({
+          schema_version: 1,
+          stream: { kind: "session", id: SID },
+          sequence: 2,
+          recorded_at: 1791640525332173,
+          record_type: "event",
+          payload_type: "runtime.session",
+          payload: {
+            kind: "run",
+            run_id: "run-1",
+            event: { kind: "approval_wait.effect.started", tool_name: "edit" },
+          },
+        }),
+      ]),
+      "/proj",
+    );
+    expect(parser.determineStatus(waiting!)).toBe(AgentStatus.WAITING);
+
+    const idle = parser.readSession(
+      writeTranscript([
+        frame({
+          schema_version: 1,
+          stream: { kind: "session", id: SID },
+          sequence: 2,
+          recorded_at: 1791640525332173,
+          record_type: "event",
+          payload_type: "runtime.session",
+          payload: { kind: "run", run_id: "run-1", event: { kind: "terminal" } },
+        }),
+      ]),
+      "/proj",
+    );
+    expect(parser.determineStatus(idle!)).toBe(AgentStatus.IDLE);
+  });
+
+  it("returns UNKNOWN when no conversation signal exists", () => {
+    const session = parser.readSession(
+      writeTranscript([frame(metadata(1791640525332173))]),
+      "/proj",
+    );
+    expect(parser.determineStatus(session!)).toBe(AgentStatus.UNKNOWN);
+  });
+
+  it("getConversation returns ordered messages and honors tail", () => {
+    const filePath = writeTranscript([
+      frame(metadata(1791640525332173)),
+      frame(intent("first question", 2, 1791640525332174)),
+      frame(assistantMessage("first answer", 3, 1791640525332175)),
+      frame(intent("second question", 4, 1791640525332176)),
+    ]);
+    const full = parser.getConversation(filePath);
+    expect(full.map((m) => [m.role, m.content])).toEqual([
+      ["user", "first question"],
+      ["assistant", "first answer"],
+      ["user", "second question"],
+    ]);
+    const tail = parser.getConversation(filePath, { tail: 1 });
+    expect(tail).toEqual([
+      { role: "user", content: "second question", timestamp: expect.anything() },
+    ]);
+  });
+
+  it("returns [] for a missing transcript and tool calls in verbose mode", () => {
+    expect(parser.getConversation("/nonexistent/session.jsonl")).toEqual([]);
+    const filePath = writeTranscript([
+      frame({
+        schema_version: 1,
+        stream: { kind: "session", id: SID },
+        sequence: 2,
+        recorded_at: 1791640525332173,
+        record_type: "event",
+        payload_type: "runtime.session",
+        payload: {
+          kind: "run",
+          run_id: "run-1",
+          event: {
+            kind: "assistant_tool_calls_committed",
+            tool_calls: [{ tool_name: "read_file" }, { tool_name: "search" }],
+          },
+        },
+      }),
+    ]);
+    expect(parser.getConversation(filePath)).toEqual([]);
+    expect(parser.getConversation(filePath, { verbose: true })).toEqual([
+      {
+        role: "assistant",
+        content: "tool calls: read_file, search",
+        timestamp: expect.anything(),
+      },
+    ]);
+  });
+});

package/src/__tests__/harnesses/opencode/OpenCodeSessionParser.test.ts

@@ -143,6 +143,7 @@ function insertPart(
   db: Database.Database,
   input: { messageId: string; sessionId: string; data: unknown; timeCreated: number },
 ): void {
-  db.prepare("INSERT INTO part (message_id, session_id, data, time_created) VALUES (?, ?, ?, ?)")
-    .run(input.messageId, input.sessionId, JSON.stringify(input.data), input.timeCreated);
+  db.prepare(
+    "INSERT INTO part (message_id, session_id, data, time_created) VALUES (?, ?, ?, ?)",
+  ).run(input.messageId, input.sessionId, JSON.stringify(input.data), input.timeCreated);
 }

package/src/__tests__/harnesses/readiness/AgentReadiness.test.ts

@@ -68,6 +68,7 @@ function fixture(overrides: Partial<AgentReadinessOptions> = {}) {
     ".gemini/antigravity-cli",
     ".config/opencode",
     ".config/devin",
+    ".config/muse",
     ".pi",
   ]) {
     files[path.join(homeDir, directory)] = "<dir>";
@@ -128,6 +129,7 @@ describe("agent readiness", () => {
       "copilot",
       "pi",
       "devin",
+      "muse",
     ]);
     for (const [agent, report] of Object.entries(reports) as Array<
       [ReadinessAgentType, (typeof reports)[ReadinessAgentType]]
@@ -166,6 +168,7 @@ describe("agent readiness", () => {
     expect(reports.kiro.integration).toBeUndefined();
     expect(reports.antigravity_cli.integration).toBeUndefined();
     expect(reports.opencode.integration).toBeUndefined();
+    expect(reports.muse.integration).toBeUndefined();
   });
 
   it("resolves agent executables from PATH directories containing spaces", async () => {
@@ -309,6 +312,39 @@ describe("agent readiness", () => {
     });
   });
 
+  it("checks Muse auth from the muse auth.json file", async () => {
+    const authPath = path.join("/home/test", ".config", "muse", "auth.json");
+    const { options, files } = fixture();
+    files[authPath] = JSON.stringify({ meta: { token: "secret" } });
+
+    const report = await getAgentReadinessReport("muse", options);
+
+    expect(report.auth).toMatchObject({ state: "authenticated", status: "pass" });
+    expect(report.globalConfig).toMatchObject({ status: "pass" });
+  });
+
+  it("reports Muse as unauthenticated with an empty auth file", async () => {
+    const authPath = path.join("/home/test", ".config", "muse", "auth.json");
+    const { options, files } = fixture();
+    files[authPath] = JSON.stringify({});
+
+    const report = await getAgentReadinessReport("muse", options);
+
+    expect(report.auth).toMatchObject({
+      state: "unauthenticated",
+      status: "fail",
+      errors: ["Muse credential file has no entries"],
+    });
+  });
+
+  it("reports Muse as unauthenticated without an auth file", async () => {
+    const { options } = fixture();
+
+    const report = await getAgentReadinessReport("muse", options);
+
+    expect(report.auth).toMatchObject({ state: "unauthenticated", status: "fail" });
+  });
+
   it("reports Devin as unauthenticated without a login line", async () => {
     const { options } = fixture({
       runCommand: vi.fn(async (command) => {

package/src/__tests__/harnesses/runtimeProfiles.test.ts

@@ -36,6 +36,19 @@ describe("harness runtime profiles", () => {
     expect(runtimeAgentMatchesHarness("gemini", "gemini_cli")).toBe(true);
     expect(runtimeAgentMatchesHarness("codex", "claude")).toBe(false);
   });
+
+  it("profiles the versioned muse launcher", () => {
+    expect(HARNESS_RUNTIME_PROFILES.muse).toMatchObject({
+      command: "muse",
+      runtimeKind: "muse",
+      discoveryAliases: ["muse"],
+    });
+    expect(
+      HARNESS_RUNTIME_PROFILES.muse.matches("/Users/dev/.local/bin/muse-bin-1.4.4-R5419.1"),
+    ).toBe(true);
+    expect(HARNESS_RUNTIME_PROFILES.muse.matches("/usr/local/bin/muse")).toBe(true);
+    expect(runtimeAgentMatchesHarness("muse", "muse")).toBe(true);
+  });
 });
 
 describe("harness matchers with executables under paths containing spaces", () => {

package/src/__tests__/utils/process.test.ts

@@ -18,6 +18,8 @@ import {
   captureProcessSnapshot,
   createProcessSnapshotCapture,
   filterByProcessNames,
+  matchesExecutablePrefix,
+  snapshotOptions,
   executableBasename,
   executablePath,
   type ProcessExec,
@@ -259,6 +261,34 @@ describe("filterByProcessNames", () => {
     expect(filterByProcessNames(processes, ["node"])).toEqual([processes[0], processes[1]]);
     expect(filterByProcessNames(processes, ["node.exe"])).toEqual([processes[0], processes[1]]);
   });
+
+  it("matches versioned launchers by basename prefix without leaking to siblings", () => {
+    const processes: ProcessInfo[] = [
+      { pid: 1, command: "/Users/dev/.local/bin/muse-bin-1.4.4-R5419.1", cwd: "", tty: "" },
+      { pid: 2, command: "/usr/local/bin/muse", cwd: "", tty: "" },
+      { pid: 3, command: "/usr/bin/museums", cwd: "", tty: "" },
+      { pid: 4, command: "/usr/local/bin/claude", cwd: "", tty: "" },
+    ];
+
+    expect(filterByProcessNames(processes, ["muse"], ["muse"])).toEqual([
+      processes[0],
+      processes[1],
+    ]);
+    // Exact names alone never match the versioned launcher.
+    expect(filterByProcessNames(processes, ["muse"])).toEqual([processes[1]]);
+    // No prefixes: previous behavior is unchanged.
+    expect(filterByProcessNames(processes, ["claude"])).toEqual([processes[3]]);
+    expect(matchesExecutablePrefix(processes[0].command, new Set(["muse"]))).toBe(true);
+    expect(matchesExecutablePrefix(processes[2].command, new Set(["muse"]))).toBe(false);
+    expect(matchesExecutablePrefix(processes[0].command, new Set())).toBe(false);
+  });
+
+  it("builds snapshot options with prefixes only when present", () => {
+    const isCandidate = () => true;
+    expect(snapshotOptions([], isCandidate)).toEqual({ isCandidate });
+    const withPrefixes = snapshotOptions(["muse"], isCandidate);
+    expect(withPrefixes).toMatchObject({ namePrefixes: ["muse"], isCandidate });
+  });
 });
 
 describe("executables installed under paths containing spaces", () => {

package/src/adapters/AgentAdapter.ts

@@ -17,6 +17,7 @@ export const AGENT_TYPES = [
   "copilot",
   "pi",
   "devin",
+  "muse",
 ] as const;
 
 /**
@@ -201,6 +202,14 @@ export interface AgentAdapter {
   /** Executable basenames required for shared process discovery. */
   readonly processNames?: readonly string[];
 
+  /**
+   * Basename prefixes for shared process discovery: an argv[0] basename
+   * matches when it equals the prefix or starts with `<prefix>-`.
+   * For versioned launchers such as `muse-bin-1.4.4-R5419.1`.
+   * Recall-oriented like `processNames`; `canHandle` stays the precision gate.
+   */
+  readonly processNamePrefixes?: readonly string[];
+
   /**
    * Detect running agents of this type
    * @returns List of detected agents

package/src/fixtures/capture.ts

@@ -13,7 +13,7 @@ import { fileURLToPath } from "node:url";
 import Database from "better-sqlite3";
 import type { AgentAdapter, AgentInfo } from "../adapters/AgentAdapter.js";
 import { AgentRegistry } from "../utils/AgentRegistry.js";
-import { captureProcessSnapshot } from "../utils/process.js";
+import { captureProcessSnapshot, snapshotOptions } from "../utils/process.js";
 import { FixtureBundle, normalizeAgents, sanitize, withFrozenClock } from "./bundle.js";
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../../..");
@@ -133,12 +133,22 @@ function collectSqliteDumps(
       (dump) => {
         const dirs = uniqueCwds(processes);
         if (dirs.length === 0) return;
-        const sessions = dump.rows("session", `WHERE directory IN ${dump.inList(dirs)} ORDER BY rowid`, dirs);
+        const sessions = dump.rows(
+          "session",
+          `WHERE directory IN ${dump.inList(dirs)} ORDER BY rowid`,
+          dirs,
+        );
         const sids = sessions.map((s) => s.id);
         dump.insertRows("session", sessions);
         if (sids.length === 0) return;
-        dump.insertRows("message", dump.rows("message", `WHERE session_id IN ${dump.inList(sids)} ORDER BY rowid`, sids));
-        dump.insertRows("part", dump.rows("part", `WHERE session_id IN ${dump.inList(sids)} ORDER BY rowid`, sids));
+        dump.insertRows(
+          "message",
+          dump.rows("message", `WHERE session_id IN ${dump.inList(sids)} ORDER BY rowid`, sids),
+        );
+        dump.insertRows(
+          "part",
+          dump.rows("part", `WHERE session_id IN ${dump.inList(sids)} ORDER BY rowid`, sids),
+        );
       },
       ["session", "message", "part"],
     );
@@ -170,7 +180,9 @@ function collectSqliteDumps(
           clauses.push(`id IN ${dump.inList(lockSids)}`);
           args.push(...lockSids);
         }
-        const sessions = clauses.length ? dump.rows("sessions", `WHERE ${clauses.join(" OR ")} ORDER BY rowid`, args) : [];
+        const sessions = clauses.length
+          ? dump.rows("sessions", `WHERE ${clauses.join(" OR ")} ORDER BY rowid`, args)
+          : [];
         const sids = sessions.map((s) => s.id);
         dump.insertRows("sessions", sessions);
         if (sids.length === 0) return;
@@ -180,11 +192,17 @@ function collectSqliteDumps(
         // replay without hauling full transcripts into the bundle.
         for (const sid of sids) {
           const reachable = [
-            ...dump.rows("message_nodes", "WHERE session_id = ? ORDER BY node_id DESC LIMIT 1", [sid]),
+            ...dump.rows("message_nodes", "WHERE session_id = ? ORDER BY node_id DESC LIMIT 1", [
+              sid,
+            ]),
             // The newest-created_at row — `MAX(created_at)` reads only the
             // value, and `= MAX(...)` unbounded explodes when batch-written
             // nodes share a timestamp.
-            ...dump.rows("message_nodes", "WHERE session_id = ? ORDER BY created_at DESC, node_id DESC LIMIT 1", [sid]),
+            ...dump.rows(
+              "message_nodes",
+              "WHERE session_id = ? ORDER BY created_at DESC, node_id DESC LIMIT 1",
+              [sid],
+            ),
             ...dump.rows(
               "message_nodes",
               "WHERE session_id = ? AND json_extract(chat_message, '$.role') = 'user' ORDER BY node_id DESC LIMIT 8",
@@ -245,15 +263,10 @@ function dumpSqliteDb(
     const dump = {
       inList: (xs: unknown[]) => `(${xs.map(() => "?").join(",")})`,
       rows: (table: string, clause: string, args: unknown[]) =>
-        db.prepare(`SELECT * FROM "${table}" ${clause}`).all(...args) as Record<
-          string,
-          unknown
-        >[],
+        db.prepare(`SELECT * FROM "${table}" ${clause}`).all(...args) as Record<string, unknown>[],
       insertRows: (table: string, rs: Record<string, unknown>[]) => {
         for (const r of rs) {
-          stmts.push(
-            `INSERT INTO "${table}" VALUES (${Object.values(r).map(sqlLit).join(",")});`,
-          );
+          stmts.push(`INSERT INTO "${table}" VALUES (${Object.values(r).map(sqlLit).join(",")});`);
         }
       },
     };
@@ -317,9 +330,11 @@ export async function captureLive(adapter: AgentAdapter, caseName = "live"): Pro
   }
 
   const { processes, agents, registry } = await withFrozenClock(frozenNow, async () => {
-    const snapshot = await captureProcessSnapshot([...names], {
-      isCandidate: (p) => adapter.canHandle(p),
-    });
+    const prefixes = adapter.processNamePrefixes ? [...adapter.processNamePrefixes] : [];
+    const snapshot = await captureProcessSnapshot(
+      [...names],
+      snapshotOptions(prefixes, (p) => adapter.canHandle(p)),
+    );
     // Registry read must precede detection — detectAgents persists its own
     // results, which would poison the captured view.
     const registryBefore = collectRegistryEntries(realHome, snapshot);

package/src/harnesses/devin/DevinAdapter.ts

@@ -64,12 +64,7 @@ const UTILITY_SUBCOMMANDS = new Set([
  * Flags that always consume the next argv token as their value.
  * (`devin --help`, main-command options.)
  */
-const REQUIRED_VALUE_FLAGS = new Set([
-  "--prompt-file",
-  "--config",
-  "--permission-mode",
-  "--model",
-]);
+const REQUIRED_VALUE_FLAGS = new Set(["--prompt-file", "--config", "--permission-mode", "--model"]);
 
 /**
  * Flags whose value is optional: the next token is consumed only when it
@@ -91,11 +86,7 @@ const OPTIONAL_VALUE_FLAGS = new Set([
  */
 function firstPositionalToken(command: string): string | null {
   const argv0 = executablePath(command);
-  const tokens = command
-    .trim()
-    .slice(argv0.length)
-    .trim()
-    .split(/\s+/);
+  const tokens = command.trim().slice(argv0.length).trim().split(/\s+/);
   for (let i = 0; i < tokens.length; i++) {
     const token = tokens[i];
     if (!token) continue;
@@ -213,10 +204,7 @@ export class DevinAdapter implements AgentAdapter {
    * backend, not a separate agent. Standalone `acp` processes (external ACP
    * clients) keep their own agent entry.
    */
-  private isAcpBackendChild(
-    proc: ProcessInfo,
-    processByPid: Map<number, ProcessInfo>,
-  ): boolean {
+  private isAcpBackendChild(proc: ProcessInfo, processByPid: Map<number, ProcessInfo>): boolean {
     if (firstPositionalToken(proc.command)?.toLowerCase() !== "acp") return false;
     if (proc.ppid === undefined) return false;
     return processByPid.has(proc.ppid);

package/src/harnesses/devin/DevinAgentMapper.ts

@@ -9,11 +9,7 @@ import { isIdle, processOnlyAgent } from "../shared.js";
 export class DevinAgentMapper {
   constructor(private readonly dbPath: string) {}
 
-  mapSessionToAgent(
-    session: DevinSession,
-    stats: DevinSessionStats,
-    proc: ProcessInfo,
-  ): AgentInfo {
+  mapSessionToAgent(session: DevinSession, stats: DevinSessionStats, proc: ProcessInfo): AgentInfo {
     const lastActive =
       stats.lastTimeUpdated > 0
         ? new Date(stats.lastTimeUpdated)

package/src/harnesses/devin/DevinSessionParser.ts

@@ -78,10 +78,7 @@ export class DevinSessionParser {
       }
 
       for (const { nodeId, message } of parsed) {
-        if (
-          message.message_id &&
-          latestNodeByMessageId.get(message.message_id) !== nodeId
-        ) {
+        if (message.message_id && latestNodeByMessageId.get(message.message_id) !== nodeId) {
           continue;
         }
 
@@ -98,9 +95,7 @@ export class DevinSessionParser {
 
         if (role === "assistant") {
           const thinking =
-            typeof message.thinking === "string"
-              ? message.thinking
-              : message.thinking?.thinking;
+            typeof message.thinking === "string" ? message.thinking : message.thinking?.thinking;
           if (verbose && thinking) {
             messages.push({ role: "assistant", content: `[thinking] ${thinking}` });
           }
@@ -179,11 +174,7 @@ export class DevinSessionParser {
    * shell `!` commands and `/` slash commands are skipped. Falls back to a
    * bounded `is_user_input` node scan in the same direction.
    */
-  private userPrompt(
-    db: Database.Database,
-    sessionId: string,
-    direction: "ASC" | "DESC",
-  ): string {
+  private userPrompt(db: Database.Database, sessionId: string, direction: "ASC" | "DESC"): string {
     try {
       const prompt = db
         .prepare<[string], { content: string }>(`

package/src/harnesses/index.ts

@@ -9,6 +9,7 @@ import { KiroAdapter } from "./kiro/KiroAdapter.js";
 import { OpenCodeAdapter } from "./opencode/OpenCodeAdapter.js";
 import { PiAdapter } from "./pi/PiAdapter.js";
 import { DevinAdapter } from "./devin/DevinAdapter.js";
+import { MuseAdapter } from "./muse/MuseAdapter.js";
 
 /**
  * One instance of every built-in harness adapter, in registration order
@@ -26,5 +27,6 @@ export function createBuiltinAdapters(): AgentAdapter[] {
     new OpenCodeAdapter(),
     new PiAdapter(),
     new DevinAdapter(),
+    new MuseAdapter(),
   ];
 }