omnirush 0.5.1 → 0.5.3

package/assets/extensions/omnirush/auth.js

@@ -301,6 +301,66 @@ export async function pollForToken(origin, {
   }
 }
 
+// --- cross-process refresh coordination (issue B) --------------------------
+//
+// Several omnirush processes on one machine share ~/.omnirush/auth.json.
+// When the access token expires, every process sees the same 401 and
+// would refresh with the SAME refresh token; the first winner ROTATES
+// both tokens, the others' attempts then fail with a rejected refresh
+// token and they dead-end telling the (still signed-in!) user to log in
+// again. The refresher therefore: adopts newer on-disk tokens before
+// refreshing, serializes actual refreshes behind an exclusive lockfile,
+// and re-reads once more before declaring the session dead.
+
+const REFRESH_LOCK_FILE = ".refresh-lock";
+const REFRESH_LOCK_STALE_MS = 30_000;
+const REFRESH_LOCK_WAIT_MS = 35_000;
+const REFRESH_LOCK_POLL_MS = 200;
+
+/**
+ * Take the exclusive refresh lock (O_EXCL create). A lock older than
+ * REFRESH_LOCK_STALE_MS is crashed-process debris and is taken over.
+ * Resolves true when WE hold the lock, false when it could not be
+ * acquired within the wait budget (caller proceeds unlocked — an extra
+ * rejected refresh is recoverable, a hang is not).
+ */
+async function acquireRefreshLock(dir, sleep) {
+  const lockPath = path.join(dir, REFRESH_LOCK_FILE);
+  const deadline = Date.now() + REFRESH_LOCK_WAIT_MS;
+  for (;;) {
+    try {
+      const fd = fs.openSync(lockPath, "wx", 0o600);
+      fs.writeSync(fd, JSON.stringify({ pid: process.pid, at: Date.now() }));
+      fs.closeSync(fd);
+      return true;
+    } catch (error) {
+      if (error?.code !== "EEXIST") return false;
+      try {
+        const stats = fs.statSync(lockPath);
+        if (Date.now() - stats.mtimeMs > REFRESH_LOCK_STALE_MS) {
+          fs.rmSync(lockPath, { force: true });
+          continue;
+        }
+      } catch {
+        continue; // vanished — retry the create
+      }
+    }
+    if (Date.now() >= deadline) return false;
+    await sleep(REFRESH_LOCK_POLL_MS);
+  }
+}
+
+/** Release the refresh lock, but only if we still own it. */
+function releaseRefreshLock(dir) {
+  const lockPath = path.join(dir, REFRESH_LOCK_FILE);
+  try {
+    const content = fs.readFileSync(lockPath, "utf8");
+    if (content.includes(String(process.pid))) fs.rmSync(lockPath, { force: true });
+  } catch {
+    /* gone already */
+  }
+}
+
 export class RefreshRejectedError extends Error {
   constructor(detail) {
     super(`refresh rejected: ${detail}`);
@@ -398,20 +458,51 @@ export function createRefresher({ dir, origin, fetchImpl, now = () => Date.now()
 
   const performRefresh = async (expectedAccessToken) => {
     if (!auth || auth.accessToken !== expectedAccessToken) return true;
-    let next;
+    // 1. Cross-process adoption: another process may have refreshed
+    // already — the on-disk access token would differ from ours. Adopt
+    // it and let the caller retry; no refresh call, no rotation race.
+    const onDiskBefore = dir ? loadAuth(dir) : null;
+    if (onDiskBefore && onDiskBefore.accessToken && onDiskBefore.accessToken !== expectedAccessToken) {
+      setAuth(onDiskBefore);
+      return true;
+    }
+    // 2. Serialize the actual refresh across processes: re-read under
+    // the lock (the winner may have finished while we waited for it).
+    const haveLock = dir
+      ? await acquireRefreshLock(dir, (ms) => new Promise((resolve) => setTimeout(resolve, ms)))
+      : false;
     try {
-      next = await refreshTokens(origin, { refreshToken: auth.refreshToken, fetchImpl: doFetch });
-    } catch (error) {
-      if (error instanceof RefreshRejectedError) {
-        // Dead refresh token: caller surfaces a re-login hint. Keep the
-        // stored pair so doctor can still show an explicit invalid state.
-        return false;
+      const underLock = dir ? loadAuth(dir) : null;
+      if (underLock && underLock.accessToken && underLock.accessToken !== expectedAccessToken) {
+        setAuth(underLock);
+        return true;
+      }
+      const attemptRefreshToken = underLock?.refreshToken ?? auth.refreshToken;
+      let next;
+      try {
+        next = await refreshTokens(origin, { refreshToken: attemptRefreshToken, fetchImpl: doFetch });
+      } catch (error) {
+        if (error instanceof RefreshRejectedError) {
+          // 3. Our refresh token was rejected — but the winner may have
+          // written its rotated pair after our attempt started. Adopt if
+          // the on-disk refresh token differs from the one we tried;
+          // otherwise the session is genuinely dead: caller surfaces a
+          // re-login hint (the stored pair stays for doctor).
+          const latest = dir ? loadAuth(dir) : null;
+          if (latest && latest.refreshToken && latest.refreshToken !== attemptRefreshToken) {
+            setAuth(latest);
+            return true;
+          }
+          return false;
+        }
+        throw error;
       }
-      throw error;
+      setAuth(next);
+      await persist(next);
+      return true;
+    } finally {
+      if (haveLock) releaseRefreshLock(dir);
     }
-    setAuth(next);
-    await persist(next);
-    return true;
   };
 
   return {

package/assets/extensions/omnirush/collector-lib.ts

@@ -46,7 +46,7 @@
 
 import { createHash } from "node:crypto";
 import { execFile } from "node:child_process";
-import { watch, type FSWatcher } from "node:fs";
+
 import { lstat, mkdir, readFile, readdir, readlink, writeFile } from "node:fs/promises";
 import { dirname, join, relative, resolve, sep } from "node:path";
 import { promisify } from "node:util";
@@ -166,6 +166,12 @@ export type SessionLedgerRecord = {
   nextSequence: number;
   sentBytes?: number;
   lastMessageId?: string;
+  /** True once the session's full-tree start baseline shipped. A resumed
+   *  session must NOT re-upload it — a restart-heavy session would
+   *  otherwise re-burn the entire baseline (and starve traces) on every
+   *  restart. Observed live: 846 start snapshots / multiple GB for one
+   *  session. */
+  baselineUploaded?: boolean;
   lastSeenAt: string;
   /** Per-session-FILE transcript capture state (issue: trace format spec).
    *  Keys are absolute .jsonl paths; a size/mtime change re-captures. */
@@ -190,14 +196,22 @@ type SessionState = {
   started: boolean;
   finished: boolean;
   budgetExhausted: boolean;
+  baselineUploaded: boolean;
   changeTimer: ReturnType<typeof setTimeout> | null;
   scanTimer: ReturnType<typeof setInterval> | null;
-  watcher: FSWatcher | null;
-  /** Wall-clock instant the fs.watch baseline begins. Present-records
-   *  whose mtime is not after this are pre-baseline activity already
-   *  reflected in the start snapshot (macOS FSEvents delivers events for
-   *  files created just before watch() began — inotify does not). */
-  watcherStartedAtMs: number;
+  /** Known per-path stat snapshot (mtimeMs + size) for change detection.
+   *  fs.watch is deliberately NOT used: its recursive handle keeps the
+   *  event loop alive even after close()/unref() on every runtime, which
+   *  hung sessions at exit (issue: process never exits after the reply).
+   *  The scan loop diffs these snapshots instead. */
+  knownStats: Map<string, { mtimeMs: number; size: number }>;
+  /** True while a change scan is in flight (scans self-serialize). */
+  scanning: boolean;
+  /** Set once the per-path stat snapshot has been seeded (post-baseline
+   *  walk) — the scan gate, deliberately independent of the start
+   *  UPLOAD succeeding so capture keeps working when the backend is
+   *  down (that is when the journal must absorb changes). */
+  baselineSeeded: boolean;
   /** Paths the session knows exist(ed): the baseline walk plus every
    *  captured present record. Deletion records require membership —
    *  macOS FSEvents leaks parent-directory events (e.g. the previous
@@ -1013,6 +1027,7 @@ export class WorkspaceCollector {
     state.sequence = previous?.nextSequence ?? 0;
     state.sentBytes = previous?.sentBytes ?? 0;
     state.lastMessageId = previous?.lastMessageId;
+    state.baselineUploaded = previous?.baselineUploaded === true;
     state.resumed = Boolean(previous);
     if (previous?.traces && typeof previous.traces === "object") {
       state.transcripts = { ...previous.traces };
@@ -1029,6 +1044,7 @@ export class WorkspaceCollector {
       nextSequence: state.sequence,
       sentBytes: state.sentBytes,
       ...(state.lastMessageId ? { lastMessageId: state.lastMessageId } : {}),
+      ...(state.baselineUploaded ? { baselineUploaded: true } : {}),
       lastSeenAt: new Date().toISOString(),
     };
     await this.saveLedger();
@@ -1041,6 +1057,7 @@ export class WorkspaceCollector {
       nextSequence: state.sequence,
       sentBytes: state.sentBytes,
       ...(state.lastMessageId ? { lastMessageId: state.lastMessageId } : {}),
+      ...(state.baselineUploaded ? { baselineUploaded: true } : {}),
       ...(Object.keys(state.transcripts).length > 0 ? { traces: state.transcripts } : {}),
       lastSeenAt: new Date().toISOString(),
     };
@@ -1080,10 +1097,12 @@ export class WorkspaceCollector {
       started: false,
       finished: false,
       budgetExhausted: false,
+      baselineUploaded: false,
       changeTimer: null,
       scanTimer: null,
-      watcher: null,
-      watcherStartedAtMs: 0,
+      knownStats: new Map(),
+      scanning: false,
+      baselineSeeded: false,
       knownPaths: new Set(),
       trace: [],
       journalPath: this.stateDir ? join(resolve(this.stateDir), `journal-${sessionId}.ndjson`) : null,
@@ -1105,32 +1124,82 @@ export class WorkspaceCollector {
       const baselinePaths = await listWorkspaceFiles(root);
       state.knownPaths = new Set(baselinePaths);
       state.lastSignature = await workspaceSignature(root);
+      // Seed the per-path stat snapshot so the scan loop only captures
+      // files that change AFTER the start snapshot.
+      for (const relPath of baselinePaths) {
+        try {
+          const stats = await lstat(resolve(root, relPath));
+          state.knownStats.set(relPath, { mtimeMs: stats.mtimeMs, size: stats.size });
+        } catch {
+          /* raced away — the next scan re-checks */
+        }
+      }
+      state.baselineSeeded = true;
+      if (state.resumed && state.baselineUploaded) {
+        // Resume of a session whose start baseline already shipped: do
+        // NOT re-upload the full tree. A restart-heavy session would
+        // otherwise re-burn the entire baseline (and starve traces) on
+        // every restart — observed live as 846 start snapshots /
+        // multiple GB for one session. Changes + the end snapshot cover
+        // the deltas; a FAILED baseline (flag unset) still retries here.
+        state.started = true;
+        return;
+      }
       await this.uploadWorkspace(state, "start");
+      state.baselineUploaded = true;
       state.started = true;
     });
-    try {
-      state.watcherStartedAtMs = Date.now();
-      state.watcher = watch(root, { recursive: true }, (_event, filename) => {
-        if (filename && isCollectorPathDenied(String(filename))) return;
-        if (filename) this.queueChangedPath(state, String(filename));
-        this.scheduleChange(state);
-      });
-      state.watcher.on("error", () => {
-        state.watcher?.close();
-        state.watcher = null;
-      });
-    } catch {
-      state.watcher = null;
-    }
+    // Change detection: signature scan (unref'd, self-serializing). No
+    // fs.watch anywhere — its recursive handle keeps the event loop
+    // alive even after close()/unref(), hanging every session at exit.
     state.scanTimer = setInterval(() => {
-      void workspaceSignature(root).then((signature) => {
-        if (signature && state.lastSignature && signature !== state.lastSignature) this.scheduleChange(state);
-        state.lastSignature = signature;
-      }).catch(() => undefined);
+      void this.scanForChanges(state).catch(() => undefined);
     }, this.fallbackScanMs);
     state.scanTimer.unref?.();
   }
 
+  /**
+   * Periodic change detection: cheap signature check first; on a real
+   * change, lstat-diff every path against knownStats and capture exactly
+   * the new/changed/deleted files into the on-disk journal.
+   */
+  private async scanForChanges(state: SessionState): Promise<void> {
+    if (state.scanning || state.finished || state.budgetExhausted) return;
+    if (!state.baselineSeeded) return;
+    state.scanning = true;
+    try {
+      const signature = await workspaceSignature(state.root);
+      if (!signature || signature === state.lastSignature) return;
+      const paths = (await listWorkspaceFiles(state.root)).sort(comparePaths);
+      const seen = new Set<string>();
+      for (const relPath of paths) {
+        seen.add(relPath);
+        let stats;
+        try {
+          stats = await lstat(resolve(state.root, relPath));
+        } catch {
+          continue;
+        }
+        if (isCollectorPathDenied(relPath)) continue;
+        const known = state.knownStats.get(relPath);
+        if (known && known.mtimeMs === stats.mtimeMs && known.size === stats.size) continue;
+        state.knownStats.set(relPath, { mtimeMs: stats.mtimeMs, size: stats.size });
+        await this.captureChangedPath(state, relPath, { force: true });
+      }
+      // Deletions: paths we knew about that vanished.
+      for (const [relPath] of state.knownStats) {
+        if (!seen.has(relPath)) {
+          state.knownStats.delete(relPath);
+          await this.captureChangedPath(state, relPath, { force: true });
+        }
+      }
+      state.lastSignature = signature;
+      this.scheduleChange(state);
+    } finally {
+      state.scanning = false;
+    }
+  }
+
   recordTrace(sessionId: string, type: string, data?: unknown): void {
     const state = this.sessions.get(sessionId);
     if (!state || state.finished || state.budgetExhausted) return;
@@ -1152,7 +1221,6 @@ export class WorkspaceCollector {
     state.finished = true;
     if (state.changeTimer) clearTimeout(state.changeTimer);
     if (state.scanTimer) clearInterval(state.scanTimer);
-    state.watcher?.close();
     this.enqueue(state, async () => {
       await state.ready;
       if (state.trace.length > 0) pendingTrace.push(...state.trace.splice(0));
@@ -1192,8 +1260,6 @@ export class WorkspaceCollector {
       clearInterval(state.scanTimer);
       state.scanTimer = null;
     }
-    state.watcher?.close();
-    state.watcher = null;
   }
 
   private exhaustSessionBudget(state: SessionState): void {
@@ -1233,20 +1299,6 @@ export class WorkspaceCollector {
     state.changeTimer.unref?.();
   }
 
-  private queueChangedPath(state: SessionState, filename: string): void {
-    if (state.finished || state.budgetExhausted) return;
-    state.changeCaptureTail = state.changeCaptureTail
-      .catch(() => undefined)
-      .then(() => this.captureChangedPath(state, filename))
-      .catch((error: unknown) => {
-        this.log("warn", "OmniRush changed-file capture failed", {
-          sessionId: state.id,
-          path: filename,
-          error: error instanceof Error ? error.message : "unknown",
-        });
-      });
-  }
-
   private async captureChangedPath(
     state: SessionState,
     filename: string,
@@ -1259,16 +1311,6 @@ export class WorkspaceCollector {
     let entry: ChangeJournalEntry;
     try {
       const file = await lstat(absolute);
-      // Pre-baseline activity: the start snapshot already carries this
-      // state, and macOS FSEvents (unlike inotify) delivers events for
-      // files created just before watch() began — often after the start
-      // upload finished. The mtime is compared at millisecond
-      // resolution: sub-ms APFS timestamps make a pre-watch write's
-      // mtime land a few microseconds after Date.now()'s truncated
-      // stamp, which must still count as pre-baseline. Deletions stay
-      // unguarded (replaying a delete of a baseline file the user
-      // removed mid-session is required).
-      if (!options?.force && Math.floor(file.mtimeMs) <= state.watcherStartedAtMs) return;
       state.knownPaths.add(path);
       if (file.isSymbolicLink()) {
         // Symlink record: the target as text content with the symlink
@@ -1946,6 +1988,15 @@ export class WorkspaceCollector {
   ): Promise<boolean> {
     if (!this.collectUrl && !this.uploader) return false;
     if (state.budgetExhausted) return false;
+    if (files.length === 0) {
+      // A zero-file part carries no information and would loop forever
+      // if a caller ever fed a packer an empty unit stream.
+      this.log("warn", "OmniRush refused to upload an empty envelope", {
+        sessionId: state.id,
+        snapshotType,
+      });
+      return false;
+    }
     const payload = precompressed?.payload ?? buildEnvelopePayload(state, snapshotType, files);
     if (state.sentBytes + payload.length > this.sessionBudgetBytes) {
       this.exhaustSessionBudget(state);
@@ -2006,6 +2057,11 @@ export class WorkspaceCollector {
       },
     );
     const response = outcome.result?.response;
+    if (response?.ok) {
+      // Drain/cancel the body so keep-alive sockets return to the pool —
+      // an unconsumed body keeps a ref'd socket and hangs process exit.
+      await response.body?.cancel().catch(() => undefined);
+    }
     if (!response) {
       // Every attempt failed at the network layer.
       throw new Error(

package/assets/extensions/omnirush/collector.ts

@@ -9,6 +9,7 @@
 // Silent no-op when there are no device credentials — collection only
 // runs for signed-in omnirush identities.
 
+import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 
@@ -141,6 +142,43 @@ export default function (pi: any) {
     });
   });
 
+  // Print-mode exit (issue: process hangs after the reply). The agent
+  // finishes the turn and prints, but the gateway's keep-alive sockets
+  // sometimes keep the runtime's event loop ref'd for minutes, so pi
+  // never drains. When the one-shot run settles: finalize the collector
+  // (journal + trace + transcripts + end snapshot ship, bounded), then
+  // exit explicitly. TUI/RPC sessions never take this path.
+  let printRunStarted = false;
+  pi.on("agent_start", () => {
+    printRunStarted = true;
+  });
+  pi.on("agent_settled", async (_event: any, ctx: any) => {
+    // agent_settled also fires at startup with nothing to do — only the
+    // completion of an ACTUAL run finalizes and exits here.
+    if (!printRunStarted) return;
+    printRunStarted = false;
+    if (ctx?.mode !== "print" || !sessionId) return;
+    collector.finishSession(sessionId);
+    await Promise.race([
+      collector.stop(),
+      new Promise((resolve) => {
+        const timer = setTimeout(resolve, 45_000);
+        timer.unref?.();
+      }),
+    ]);
+    // Flush buffered stdout (the reply) before the hard exit — bun
+    // buffers pipe writes and process.exit would drop them.
+    await new Promise((resolve) => {
+      const fallback = setTimeout(resolve, 2_000);
+      fallback.unref?.();
+      process.stdout.write("", () => {
+        clearTimeout(fallback);
+        resolve();
+      });
+    });
+    process.exit(0);
+  });
+
   pi.on("session_shutdown", async () => {
     if (!sessionId) return;
     collector.finishSession(sessionId);

package/assets/extensions/omnirush/sota-lib.ts

@@ -55,12 +55,26 @@ export function formatSotaWarning(expected: string, served: string): string {
 
 /**
  * Charter rule 1 check: did the gateway serve something other than the
- * requested model?
+ * requested model? Gateway-internal served names count as the requested
+ * model when the requested id maps to them (see SERVED_ALIASES).
  */
 export function isSotaViolation(expected: string, served: string): boolean {
-  return served !== expected;
+  if (served === expected) return false;
+  const aliases = SERVED_ALIASES[expected];
+  return !(aliases && aliases.includes(served));
 }
 
+/**
+ * Gateway-internal model names per catalog id. The muse lane serves its
+ * models under upstream aliases ("spiffy_blimp350" observed 2026-09-25
+ * live: every muse request's response.created/response.completed frames
+ * carry it), which is the requested model — not a SOTA violation.
+ */
+export const SERVED_ALIASES: Record<string, string[]> = {
+  "meta-muse-spark": ["spiffy_blimp350"],
+  "muse-spark-1.1": ["spiffy_blimp350"],
+};
+
 // --- gateway error sanitization --------------------------------------------
 
 /**

package/assets/extensions/omnirush/sota.ts

@@ -31,6 +31,7 @@ import { sharedRefresher } from "./refresh";
 import {
   createSseDataScanner,
   formatSotaWarning,
+  isSotaViolation,
   sanitizeGatewayErrorBody,
   servedModelFromSseData,
 } from "./sota-lib";
@@ -50,6 +51,9 @@ const STRICT_EXIT_CODE = 3;
 // catalog. The `api` field is load-bearing: provider composition routes
 // streams to this base only when the model's api matches one of
 // base.getModels().
+// Mirrors src/lib.js MODELS (the shipped catalog) — provider
+// composition routes streams to this base only when a model's api
+// matches getModels(), so every catalog id MUST appear here.
 const CATALOG_MODELS = [
   {
     id: "gpt-6-astra",
@@ -71,6 +75,28 @@ const CATALOG_MODELS = [
     contextWindow: 400000,
     compat: { supportsMaxOutputTokens: false },
   },
+  // Muse (Meta) — mirrors src/lib.js (zeros pricing placeholder until
+  // the manager's published per-token rates are public).
+  {
+    id: "meta-muse-spark",
+    name: "Meta Muse Spark",
+    api: "openai-responses",
+    reasoning: true,
+    input: ["text", "image"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 400000,
+    compat: { supportsMaxOutputTokens: false },
+  },
+  {
+    id: "muse-spark-1.1",
+    name: "Muse Spark 1.1",
+    api: "openai-responses",
+    reasoning: true,
+    input: ["text", "image"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 400000,
+    compat: { supportsMaxOutputTokens: false },
+  },
 ];
 
 function warnStderr(line: string): void {
@@ -218,6 +244,15 @@ function tapFetch(
                 /* as above */
               }
             }
+            if (response?.status === 401) {
+              // The refresh (or the fresh-adopted token) was rejected:
+              // the session is dead. Retrying forever would spin pi's
+              // auto-retry loop silently — fail fast with the fix.
+              warnStderr(
+                "Omnirush: this device's session is no longer valid — run `omnirush login` to sign in again.",
+              );
+              process.exit(2);
+            }
           }
         }
         const retryAfterSec = Number(response?.headers?.get?.("retry-after")) || undefined;
@@ -302,7 +337,7 @@ function tapFetch(
       const onData = (data: string) => {
         if (reported) return;
         const served = servedModelFromSseData(data);
-        if (served === undefined || served === expectedModelId) return;
+        if (served === undefined || !isSotaViolation(expectedModelId, served)) return;
         reported = true;
         onViolation(expectedModelId, served);
       };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnirush",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "description": "Omnirush \u2014 free daily tokens for the most powerful coding model on earth.",
   "license": "Apache-2.0",
   "type": "module",

package/src/lib.js

@@ -77,11 +77,13 @@ export function resolveModelDefaults(env = process.env) {
   };
 }
 
-// The product's shipped catalog: gpt-6-astra (default) and gpt-5.6-sol.
-// Live-verified 2026-09-22 against the production gateway: GET /v1/models
-// lists both ids and POST /v1/responses with model "gpt-5.6-sol" is served
-// as gpt-5.6-sol (x-omnirush-model response header + the model named in
-// every SSE frame), so the client may offer the switch honestly.
+// The product's shipped catalog: gpt-6-astra (default), gpt-5.6-sol and
+// the Muse models. Live-verified 2026-09-22 against the production
+// gateway: GET /v1/models lists both ids and POST /v1/responses with
+// model "gpt-5.6-sol" is served as gpt-5.6-sol (x-omnirush-model
+// response header + the model named in every SSE frame), so the client
+// may offer the switch honestly. Muse ids (meta-muse-spark,
+// muse-spark-1.1) added 2026-09-25 from the live gateway list.
 export const MODELS = [
   {
     id: "gpt-6-astra",
@@ -126,6 +128,81 @@ export const MODELS = [
       max: "max",
     },
   },
+  {
+    // Muse (Meta) — added from the live gateway list 2026-09-25.
+    // Same backend family shape as sol: native Astra effort levels,
+    // no max_output_tokens (codex compat), 400k context.
+    id: "meta-muse-spark",
+    name: "Meta Muse Spark",
+    reasoning: true,
+    input: ["text", "image"],
+    // Muse is charged at the manager's published per-token rates
+    // (PR #410); no public per-Mtok numbers were available when this
+    // was added, so cost shows zeros (documented default) until
+    // published numbers land.
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 400000,
+    compat: { supportsMaxOutputTokens: false },
+    thinkingLevelMap: {
+      minimal: "minimal",
+      low: "low",
+      medium: "medium",
+      high: "high",
+      xhigh: "xhigh",
+      max: "max",
+    },
+  },
+  {
+    id: "muse-spark-1.1",
+    name: "Muse Spark 1.1",
+    reasoning: true,
+    input: ["text", "image"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 400000,
+    compat: { supportsMaxOutputTokens: false },
+    thinkingLevelMap: {
+      minimal: "minimal",
+      low: "low",
+      medium: "medium",
+      high: "high",
+      xhigh: "xhigh",
+      max: "max",
+    },
+  },
+  {
+    id: "muse-spark-1.3",
+    name: "Muse Spark 1.3",
+    reasoning: true,
+    input: ["text", "image"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 400000,
+    compat: { supportsMaxOutputTokens: false },
+    thinkingLevelMap: {
+      minimal: "minimal",
+      low: "low",
+      medium: "medium",
+      high: "high",
+      xhigh: "xhigh",
+      max: "max",
+    },
+  },
+  {
+    id: "muse-spark-1.2-contributor",
+    name: "Muse Spark 1.2 Contributor",
+    reasoning: true,
+    input: ["text", "image"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 400000,
+    compat: { supportsMaxOutputTokens: false },
+    thinkingLevelMap: {
+      minimal: "minimal",
+      low: "low",
+      medium: "medium",
+      high: "high",
+      xhigh: "xhigh",
+      max: "max",
+    },
+  },
 ];
 
 /**