@phnx-labs/agents-cli 1.22.22 → 1.22.23

package/dist/lib/exec.js

@@ -17,11 +17,11 @@ import { isTierToken, resolveTier } from './model-tiers.js';
 import { createTimer, redactPrompt, redactArgs } from './events.js';
 import { sanitizeProcessEnv } from './secrets/bundles.js';
 import { resolveActor, actorEnv } from './actor.js';
-import { getShimsDir, getHistoryDir, getUserAgentsDir } from './state.js';
+import { getShimsDir, getHistoryDir } from './state.js';
 import { resolveCodexHome } from './codex-home.js';
 import { readCodexConfiguredModel } from './shims.js';
 import { writePidSessionEntry, extractSessionIdArg } from './session/pid-registry.js';
-import { writeSessionActorRecord } from './session/actor-sidecar.js';
+import { writeSessionActorRecord, writeSessionAliasRecord } from './session/actor-sidecar.js';
 import { loadHookSessionIndex, resolveHookSessionId } from './session/hook-sessions.js';
 import { sessionIdMarkerLine } from './hosts/session-marker.js';
 import { recordRunName } from './session/run-names.js';
@@ -30,6 +30,7 @@ import { composeWin32CommandLine } from './platform/index.js';
 import { isTmuxInstalled } from './tmux/binary.js';
 import { shellQuote } from './ssh-exec.js';
 import { resolveClaudeSetupToken } from './claude-account-token.js';
+import { codexEditWritableRoots, codexPolicyArgs } from './codex-policy.js';
 /**
  * Map a raw mode string (CLI flag, YAML field, env var) to the canonical Mode.
  *
@@ -172,6 +173,10 @@ export function resolveHeadlessMode(agent, requested, interactive, warningContex
 export function defaultModeFor(agent) {
     return AGENTS[agent].capabilities.modes[0];
 }
+/** Safe mode used when the user did not provide --mode or a configured default. */
+export function implicitModeFor(agent) {
+    return agent === 'codex' ? 'edit' : 'plan';
+}
 /**
  * Resolve interactive vs headless. Explicit flags are definitive and win over
  * inference: `--interactive` forces interactive, `--headless` forces headless.
@@ -441,11 +446,11 @@ export const AGENT_COMMANDS = {
         promptFlag: 'positional',
         resume: { subcommand: 'resume' },
         modeFlags: {
-            plan: ['--sandbox', 'read-only'],
-            // Sandboxed writes inside the workspace. Network stays on (workspace-write
-            // disables it by default) so edit-mode runs can still use git/gh/package
-            // installs. No approval bypass here — only `skip` drops the guardrails.
-            edit: ['--sandbox', 'workspace-write', '-c', 'sandbox_workspace_write.network_access=true'],
+            // Native Codex modes are assembled by codexPolicyArgs below. Named
+            // permission profiles keep filesystem access and network access
+            // independent; legacy --sandbox flags cannot express that combination.
+            plan: [],
+            edit: [],
             // skip = codex --yolo: drops the sandbox entirely and approves anything.
             skip: ['--dangerously-bypass-approvals-and-sandbox'],
         },
@@ -637,6 +642,29 @@ export const AGENT_COMMANDS = {
         },
         modelFlag: '--model',
     },
+    // Meta Muse Code (`muse exec` headless, `muse` TUI). Flags from
+    // `muse --help` / `muse exec --help` (v0.1.0): prompt is positional;
+    // --model selects muse-spark-*; --reasoning-effort is the effort dial;
+    // --disable-write approximates plan (no non-shell writes); --disable-approval
+    // keeps the sandbox (auto); --yolo drops approval+sandbox and trusts the
+    // workspace (skip). --json emits JSONL on stdout. Interactive resume is
+    // `muse resume <id>`; headless resume is `muse exec --session-id <id>` —
+    // see the muse resume branch in buildExecCommand.
+    muse: {
+        base: ['muse', 'exec'],
+        promptFlag: 'positional',
+        modeFlags: {
+            plan: ['--disable-write'],
+            edit: [],
+            auto: ['--disable-approval'],
+            skip: ['--yolo'],
+        },
+        jsonFlags: ['--json'],
+        modelFlag: '--model',
+        // Flag form covers headless (`--session-id`). Interactive uses the
+        // `resume` subcommand — special-cased in buildExecCommand.
+        resume: { flag: '--session-id' },
+    },
 };
 /**
  * Whether `agent` has a native resume form (Tier 1). Derived solely from the
@@ -665,12 +693,13 @@ export function buildExecCommand(options) {
     const template = AGENT_COMMANDS[options.agent];
     const cmd = [...template.base];
     const interactive = resolveInteractive(options);
-    // For Codex and Droid, 'exec' is the headless subcommand; for OpenCode, 'run'
-    // is. Drop it for interactive mode so we launch the TUI (`codex` / `droid` /
-    // `opencode`, each agent's default command) instead of the one-shot headless
-    // subcommand ('codex exec' / 'droid exec' / 'opencode run').
+    // For Codex, Droid, and Muse, 'exec' is the headless subcommand; for OpenCode,
+    // 'run' is. Drop it for interactive mode so we launch the TUI (`codex` /
+    // `droid` / `muse` / `opencode`) instead of the one-shot headless subcommand
+    // ('codex exec' / 'droid exec' / 'muse exec' / 'opencode run').
     if (interactive) {
-        if ((options.agent === 'codex' || options.agent === 'droid') && cmd[1] === 'exec') {
+        if ((options.agent === 'codex' || options.agent === 'droid' || options.agent === 'muse') &&
+            cmd[1] === 'exec') {
             cmd.splice(1, 1);
         }
         else if (options.agent === 'opencode' && cmd[1] === 'run') {
@@ -682,8 +711,18 @@ export function buildExecCommand(options) {
     // interactive drop above, `codex` -> `codex resume` (TUI). The session id is
     // pushed later as the first positional (before any prompt). `{ flag }` agents
     // (claude) need no base change — the flag is appended with the id below.
+    //
+    // Muse interactive resume is also a subcommand (`muse resume <id>`), but the
+    // session id MUST sit immediately after the verb — mode/model flags come
+    // after. So for interactive muse we push both `resume` and the id here, and
+    // skip the later generic resume flag path.
     const resumeSpec = options.resume ? template.resume : undefined;
-    if (resumeSpec && 'subcommand' in resumeSpec) {
+    let museInteractiveResumeDone = false;
+    if (options.agent === 'muse' && options.resume && interactive && options.sessionId) {
+        cmd.push('resume', options.sessionId);
+        museInteractiveResumeDone = true;
+    }
+    else if (resumeSpec && 'subcommand' in resumeSpec) {
         cmd.push(resumeSpec.subcommand);
     }
     // Use versioned alias if a specific version was requested (e.g., claude@2.1.98).
@@ -764,40 +803,26 @@ export function buildExecCommand(options) {
         // narrower than --yolo/-f, which also bypasses permission checks.
         cmd.push('--trust');
     }
-    // Codex's workspace-write sandbox blocks $HOME (verified against the live CLI
-    // and OpenAI's sandbox docs: writable roots extend scope "without removing the
-    // sandbox entirely"). But the model routinely shells out to `agents ...`, whose
-    // runtime state lives under ~/.agents — the SSH askpass shim
-    // (~/.agents/.cache/devices/askpass.sh), the device/stats cache, secrets,
-    // session writes, config tunings. Without ~/.agents as a writable root those
-    // inner writes fail with EROFS (e.g. `agents ssh` dies before connecting),
-    // which is why a remote `agents run codex` couldn't reach the fleet. Grant it
-    // implicitly whenever codex runs workspace-write — far narrower than --mode skip
-    // (danger-full-access). Fresh runs take --add-dir (below); resume forms reject
-    // --add-dir, so they take the same root via -c writable_roots here.
-    const codexWorkspaceWrite = options.agent === 'codex' && resolvedMode === 'edit';
-    if (resumeSpec && 'subcommand' in resumeSpec) {
+    if (options.agent === 'codex') {
+        const policyMode = resolvedMode === 'plan' || resolvedMode === 'skip' ? resolvedMode : 'edit';
+        const writableRoots = [...codexEditWritableRoots(), ...(options.addDirs ?? [])];
+        cmd.push(...codexPolicyArgs(policyMode, writableRoots));
+    }
+    else if (resumeSpec && 'subcommand' in resumeSpec) {
         if (resolvedMode === 'skip') {
             // skip = yolo on resume too; both `codex resume` (TUI) and
             // `codex exec resume` accept the bypass flag.
             cmd.push('--dangerously-bypass-approvals-and-sandbox');
         }
         else if (interactive) {
-            // `codex resume` (TUI) accepts the same -s/--sandbox flags as a fresh run.
             cmd.push(...modeFlags);
-            if (codexWorkspaceWrite)
-                cmd.push('-c', codexWritableRootsConfig(getUserAgentsDir()));
         }
         else {
             // `codex exec resume` rejects `--sandbox <mode>` (verified against
             // `codex exec resume --help` on 0.142.5), but takes -c config overrides —
             // map the mode through sandbox_mode so a non-skip resume never gets the
             // approval/sandbox bypass.
-            cmd.push('-c', `sandbox_mode=${resolvedMode === 'plan' ? 'read-only' : 'workspace-write'}`);
-            if (resolvedMode !== 'plan') {
-                cmd.push('-c', 'sandbox_workspace_write.network_access=true');
-                cmd.push('-c', codexWritableRootsConfig(getUserAgentsDir()));
-            }
+            cmd.push(...modeFlags);
         }
     }
     else if (options.agent === 'kimi' && !interactive) {
@@ -835,7 +860,7 @@ export function buildExecCommand(options) {
     // agents (codex) already pushed the verb above, so the id is the first
     // positional here — placed before the prompt positional appended later. Without
     // `resume`, the legacy claude-only `--session-id` CREATES a session with that id.
-    if (options.resume && options.sessionId && resumeSpec) {
+    if (options.resume && options.sessionId && resumeSpec && !museInteractiveResumeDone) {
         if ('flag' in resumeSpec) {
             const flag = interactive
                 ? (resumeSpec.interactiveFlag ?? resumeSpec.flag)
@@ -913,21 +938,10 @@ export function buildExecCommand(options) {
             cmd.push(template.promptFlag, options.prompt);
         }
     }
-    // Extra writable dirs. Claude and Codex both take `--add-dir`; for Codex it
-    // widens the workspace-write sandbox (teams relies on this to let teammates
-    // write ~/.agents), so it must actually be forwarded — it used to be
-    // claude-only, silently dropped for codex and masked by edit mode carrying
-    // the approval/sandbox bypass. Codex's resume forms reject --add-dir, so
-    // skip it there (claude's flag-based resume accepts it).
-    //
-    // On top of any user-supplied dirs, a fresh codex workspace-write run
-    // implicitly gets ~/.agents (deduped) so the CLI's own tooling — askpass,
-    // secrets, sessions, tunings — can write from inside the sandbox. Resume forms
-    // get the same root via -c writable_roots above (see codexWorkspaceWrite).
-    const codexImplicitDirs = codexWorkspaceWrite && !options.resume ? [getUserAgentsDir()] : [];
-    const addDirs = [...new Set([...(options.addDirs ?? []), ...codexImplicitDirs])];
-    if (addDirs.length > 0 &&
-        (options.agent === 'claude' || (options.agent === 'codex' && !options.resume))) {
+    // Codex add-dirs are folded into its named edit profile above, including on
+    // resume where the native CLI rejects --add-dir. Claude keeps its native flag.
+    const addDirs = [...new Set(options.addDirs ?? [])];
+    if (addDirs.length > 0 && options.agent === 'claude') {
         for (const dir of addDirs) {
             cmd.push('--add-dir', dir);
         }
@@ -1024,8 +1038,11 @@ export async function execShimPassthrough(agent, rawArgs, cwd, pinnedVersion) {
         if (fs.existsSync(cmdPath))
             binary = cmdPath;
     }
-    // The only flag the bash shim injects (codex); everything else is transparent.
-    const launchArgs = agent === 'codex' ? ['-c', 'check_for_update_on_startup=false'] : [];
+    // Match the POSIX shim: direct Codex launches default to the safe writable
+    // profile, while later user arguments can still override native settings.
+    const launchArgs = agent === 'codex'
+        ? ['-c', 'check_for_update_on_startup=false', ...codexPolicyArgs('edit')]
+        : [];
     // Mint a launch id and export it as AGENT_LAUNCH_ID so the agent's SessionStart
     // hook records the same id — the join key that maps this launch to its exact
     // session even though the recorded pid here is the cmd.exe wrapper (Windows) or
@@ -1192,14 +1209,28 @@ export function formatPaneTail(raw, maxLines = 30) {
  *      (Ctrl-b d) — return 0 and LEAVE the session for `agents focus` to re-attach.
  */
 async function runInTmux(options, executable, args) {
-    const { createSession, killSession, paneExitStatus, setSessionHook, slugifyName, agentPaneDiedHook, markSessionHookSchema } = await import('./tmux/session.js');
+    const { createSession, hasSession, killSession, paneExitStatus, setSessionHook, slugifyName, agentPaneDiedHook, markSessionHookSchema } = await import('./tmux/session.js');
     const { getDefaultSocketPath } = await import('./tmux/paths.js');
     const { attachTmux, runTmux } = await import('./tmux/binary.js');
     const socket = getDefaultSocketPath();
     const cwd = options.cwd || process.cwd();
     const idSeed = (options.sessionId ?? randomUUID()).slice(0, 8);
     const name = slugifyName(`ag-${options.agent}-${idSeed}`);
-    const execEnv = buildExecEnv(options);
+    // A native resume must not create a competing wrapper for a live session.
+    // A retained dead pane is reaped before the harness resumes normally.
+    if (options.resume && await hasSession(name, socket)) {
+        const existing = await createSession({ name, cwd, socket, source: 'cli', attachExisting: true });
+        if (options.sessionId)
+            writeSessionAliasRecord(options.sessionId, name);
+        if (!existing.pane || !(await paneExitStatus(existing.pane, socket)).dead) {
+            await attachTmux({ socket, args: ['attach-session', '-t', name] });
+            return { exitCode: 0, stderr: '', stdout: '' };
+        }
+        await killSession(name, socket);
+    }
+    // SessionStart learns some harness IDs only after launch. Carry the wrapper
+    // name into that hook so it can bind both identities durably.
+    const execEnv = { ...buildExecEnv(options), AGENT_TMUX_SESSION_NAME: name };
     // Launch with the real env (secret VALUES materialized into the pane); persist
     // only a value-redacted copy in SessionMeta.cmd so resolved secrets never hit
     // disk via the informational cmd field (RUSH-1758).
@@ -1210,6 +1241,8 @@ async function runInTmux(options, executable, args) {
         labels.sessionId = options.sessionId;
     const meta = await createSession({ name, cmd, metaCmd, cwd, socket, source: 'cli', labels });
     const pane = meta.pane;
+    if (options.sessionId)
+        writeSessionAliasRecord(options.sessionId, name);
     if (pane) {
         // When the AGENT pane dies, detach the client (don't kill) so the session
         // survives just long enough to read the dead pane's exit status below. The
@@ -1873,6 +1906,7 @@ export async function runWithFallback(options) {
             ...options,
             agent,
             version,
+            mode: options.modeWasImplicit ? implicitModeFor(agent) : options.mode,
             prompt,
             env: envOverride ? { ...(options.env ?? {}), ...envOverride } : options.env,
             sessionId: pinnedSessionId ?? (i === 0 ? options.sessionId : undefined),

package/dist/lib/feed-broadcast.d.ts

@@ -141,26 +141,7 @@ export declare function scrubOutboundDashes(text: string): string;
  * host last. Skip the uninformative default label `agent`.
  */
 export declare function composeBroadcastFooter(ctx: FeedBroadcastContext): string | undefined;
-/**
- * Human-facing body for a messaging sink (`{message}`).
- *
- * ```
- * Title in a few words
- *
- * Body of what happened or the ask.
- * Options: publish / wait          (blocks with choices)
- * Default in 15 min: wait          (blocks with a safe default)
- *
- * Sent from grok/a02da0e2 on mac-mini
- * https://…                        (optional attach URL)
- * ```
- *
- * Title first (scannable subject). Blank line. Body. Then the phone-actionable
- * choices + default (a block that has stopped for the human), then footer
- * provenance. No `agents focus <id>` line: a CLI command is unusable from a phone,
- * so the safe default is the fallback and the message carries it. Prefer `{message}`
- * over bare `{text}` in messaging sinks.
- */
+export declare function truncateBroadcastBody(body: string): string;
 export declare function composeBroadcastMessage(ctx: FeedBroadcastContext): string;
 /**
  * Substitute `{placeholder}` tokens in an argv template. Returns undefined when

package/dist/lib/feed-broadcast.js

@@ -202,9 +202,39 @@ export function composeBroadcastFooter(ctx) {
  * so the safe default is the fallback and the message carries it. Prefer `{message}`
  * over bare `{text}` in messaging sinks.
  */
+/**
+ * The phone copy is a text, not a report. A long body reaches the owner's phone
+ * as an unreadable wall, and the `feed post` forwarding path is where that has to
+ * be shaped: every sink (owner alias, in-process `channel:`, spawned `command:`)
+ * funnels through {@link composeBroadcastMessage}, which is the only seam a shell
+ * hook cannot reach. Keep the title (the scannable headline) and cap the BODY to a
+ * short excerpt, marking the cut with a plain "(full in feed)" — NOT a CLI command
+ * (unusable from a phone, see the note on composeBroadcastMessage). Nothing is
+ * lost: this shapes only the outbound sink text; the full post stays in the feed.
+ */
+const PHONE_BODY_MAX_CHARS = 500;
+const PHONE_BODY_MAX_LINES = 8;
+export function truncateBroadcastBody(body) {
+    if (!body)
+        return body;
+    let out = body;
+    let cut = false;
+    const lines = out.split('\n');
+    if (lines.length > PHONE_BODY_MAX_LINES) {
+        out = lines.slice(0, PHONE_BODY_MAX_LINES).join('\n');
+        cut = true;
+    }
+    if (out.length > PHONE_BODY_MAX_CHARS) {
+        out = out.slice(0, PHONE_BODY_MAX_CHARS);
+        cut = true;
+    }
+    if (!cut)
+        return body;
+    return `${out.trimEnd()}\n… (full in feed)`;
+}
 export function composeBroadcastMessage(ctx) {
     const title = scrubOutboundDashes(ctx.title ?? '');
-    const body = scrubOutboundDashes(ctx.text ?? '');
+    const body = truncateBroadcastBody(scrubOutboundDashes(ctx.text ?? ''));
     // Title preferred; if an older post has no title, body alone still sends.
     const head = title || body;
     const mid = title && body && title !== body ? body : undefined;

package/dist/lib/hooks.js

@@ -758,7 +758,7 @@ export function listHooksInVersionHome(agent, version) {
  * map (Gemini/Antigravity settings.json variants, Codex config.toml, the OpenCode
  * plugin, …), so it reports them unsupported rather than risk a false verdict.
  */
-const SETTINGS_JSON_HOOK_FAMILY = ['claude', 'droid'];
+const SETTINGS_JSON_HOOK_FAMILY = ['claude', 'droid', 'muse'];
 /**
  * Verify that every hook the manifest says should be wired for a (claude|droid)
  * version is actually REFERENCED in that version's native settings.json — not
@@ -1453,6 +1453,12 @@ export function registerHooksToSettings(agentId, versionHome, hookManifest, agen
         // registrar targeting `.factory/settings.json` (agentConfigDirName('droid')).
         return registerHooksForClaude(versionHome, manifest, resolveScript, managedPrefixes, agentConfigDirName('droid'));
     }
+    if (agentId === 'muse') {
+        // Muse Code: Claude-compatible hooks block in ~/.config/muse/settings.json
+        // (events SessionStart / PreToolUse / …, matcher groups, command hooks).
+        // settings.json MUST carry schema_version: 1 or Muse refuses to start.
+        return registerHooksForClaude(versionHome, manifest, resolveScript, managedPrefixes, agentConfigDirName('muse'), { schemaVersion: 1 });
+    }
     if (agentId === 'codex') {
         return registerHooksForCodex(versionHome, manifest, resolveScript, managedPrefixes);
     }
@@ -1675,7 +1681,7 @@ const ANTIGRAVITY_EVENT_MAP = {
     Stop: 'on_loop_stop',
     OnError: 'on_error',
 };
-function registerHooksForClaude(versionHome, manifest, resolveScript, managedPrefixes, configDirName = '.claude') {
+function registerHooksForClaude(versionHome, manifest, resolveScript, managedPrefixes, configDirName = '.claude', options) {
     const registered = [];
     const errors = [];
     const configDir = path.join(versionHome, configDirName);
@@ -1692,6 +1698,10 @@ function registerHooksForClaude(versionHome, manifest, resolveScript, managedPre
             return { registered, errors };
         }
     }
+    // Muse (and any future agent that pins a settings schema) requires this key.
+    if (options?.schemaVersion !== undefined && config.schema_version === undefined) {
+        config.schema_version = options.schemaVersion;
+    }
     if (!config.hooks || typeof config.hooks !== 'object') {
         config.hooks = {};
     }

package/dist/lib/mcp.js

@@ -595,6 +595,7 @@ function writeMcpConfigSupportsAgent(agentId) {
         case 'opencode':
         case 'hermes':
         case 'pi':
+        case 'muse':
             return true;
         default:
             return false;
@@ -797,6 +798,49 @@ export function writeMcpConfig(agentId, configPath, servers, mode = 'overwrite')
             fs.writeFileSync(configPath, yaml.stringify(config), 'utf-8');
             break;
         }
+        case 'muse': {
+            // Muse Code settings.json: requires schema_version: 1; MCP lives under
+            // mcp_servers with an explicit transport (stdio | streamable_http).
+            // See https://dev.meta.ai/docs/muse-code/extending#mcp
+            let config = {};
+            if (fs.existsSync(configPath)) {
+                try {
+                    config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+                }
+                catch {
+                    config = {};
+                }
+            }
+            if (config.schema_version === undefined) {
+                config.schema_version = 1;
+            }
+            const mcpServers = mode === 'merge' && config.mcp_servers && typeof config.mcp_servers === 'object' && !Array.isArray(config.mcp_servers)
+                ? { ...config.mcp_servers }
+                : {};
+            for (const server of servers) {
+                if (server.transport === 'stdio') {
+                    mcpServers[server.name] = {
+                        transport: 'stdio',
+                        command: server.command,
+                        args: server.args || [],
+                        ...(server.env && Object.keys(server.env).length > 0 ? { env: server.env } : {}),
+                        enabled: true,
+                    };
+                }
+                else {
+                    mcpServers[server.name] = {
+                        transport: 'streamable_http',
+                        url: server.url,
+                        ...(server.headers && Object.keys(server.headers).length > 0 ? { headers: server.headers } : {}),
+                        enabled: true,
+                    };
+                }
+            }
+            config.mcp_servers = mcpServers;
+            fs.mkdirSync(path.dirname(configPath), { recursive: true });
+            fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+            break;
+        }
     }
 }
 /**

package/dist/lib/menubar/MenubarHelper.app/Contents/Info.plist

@@ -7,11 +7,7 @@
     <key>CFBundleIdentifier</key>
     <string>com.phnx-labs.agents-menubar</string>
     <key>CFBundleName</key>
-    <string>AGI Menu</string>
-    <key>CFBundleDisplayName</key>
-    <string>AGI Menu</string>
-    <key>CFBundleIconFile</key>
-    <string>AppIcon</string>
+    <string>Agents Menu Bar</string>
     <key>CFBundlePackageType</key>
     <string>APPL</string>
     <key>CFBundleShortVersionString</key>

package/dist/lib/menubar/MenubarHelper.app/Contents/_CodeSignature/CodeResources

@@ -3,22 +3,9 @@
 <plist version="1.0">
 <dict>
 	<key>files</key>
-	<dict>
-		<key>Resources/AppIcon.icns</key>
-		<data>
-		jOjZVimcFRHoP2VPzgn8uM8mjkA=
-		</data>
-	</dict>
+	<dict/>
 	<key>files2</key>
-	<dict>
-		<key>Resources/AppIcon.icns</key>
-		<dict>
-			<key>hash2</key>
-			<data>
-			GFvSLeNYJ3ASxW3OzcuiB4aID0gZUBkpozmWZkbTFNw=
-			</data>
-		</dict>
-	</dict>
+	<dict/>
 	<key>rules</key>
 	<dict>
 		<key>^Resources/</key>

package/dist/lib/models.d.ts

@@ -97,11 +97,6 @@ export declare function parseGrokModelsStdout(stdout: string): {
     models: ModelInfo[];
     aliases: Record<string, string>;
 };
-/**
- * Build (or load from cache) the model catalog for a specific (agent, version).
- * Cache is keyed on source-file mtime (binary or js module), so re-extracts
- * automatically when the user upgrades or reinstalls a version.
- */
 export declare function getModelCatalog(agent: AgentId, version: string): ModelCatalog | null;
 /** The result of resolving a user-supplied model string against the catalog. */
 export interface ResolvedModel {

package/dist/lib/models.js

@@ -246,6 +246,16 @@ export function locateModelSource(agent, version) {
             return { path: pathBin, kind: 'cli' };
         return null;
     }
+    if (agent === 'muse') {
+        // Muse Code is a self-updating native binary on PATH. It has no catalog
+        // CLI; the published model IDs are fixed by Meta Model API docs. Point at
+        // the binary so the cache key moves with upgrades, and extract a static
+        // catalog in getModelCatalog.
+        const pathBin = findOnPath('muse');
+        if (pathBin)
+            return { path: pathBin, kind: 'cli' };
+        return null;
+    }
     return null;
 }
 /** Real Grok binaries are ~100MB+; failed-download stubs are tens of bytes. */
@@ -973,6 +983,36 @@ function extractPiCatalog(binaryPath) {
  * Cache is keyed on source-file mtime (binary or js module), so re-extracts
  * automatically when the user upgrades or reinstalls a version.
  */
+/**
+ * Static Muse Spark catalog. Meta Model API publishes these IDs; Muse Code
+ * has no `muse models` command. Default is muse-spark-1.2 (docs + first-run).
+ * Source: https://dev.meta.ai/docs/pricing-rate-limits and muse-code overview.
+ */
+function extractMuseCatalog() {
+    const models = [
+        {
+            id: 'muse-spark-1.2',
+            displayName: 'Muse Spark 1.2',
+            isDefault: true,
+        },
+        {
+            id: 'muse-spark-1.1',
+            displayName: 'Muse Spark 1.1',
+        },
+        {
+            id: 'muse-spark-1.2-contributor',
+            displayName: 'Muse Spark 1.2 Contributor',
+        },
+    ];
+    const aliases = {
+        spark: 'muse-spark-1.2',
+        'spark-1.2': 'muse-spark-1.2',
+        'spark-1.1': 'muse-spark-1.1',
+        contributor: 'muse-spark-1.2-contributor',
+        default: 'muse-spark-1.2',
+    };
+    return { models, aliases };
+}
 export function getModelCatalog(agent, version) {
     const src = locateModelSource(agent, version);
     if (!src)
@@ -1027,6 +1067,8 @@ export function getModelCatalog(agent, version) {
             ({ models, aliases } = extractGrokCatalog(src.path));
         else if (agent === 'pi')
             ({ models, aliases } = extractPiCatalog(src.path));
+        else if (agent === 'muse')
+            ({ models, aliases } = extractMuseCatalog());
     }
     // Attach per-token pricing where the offline table knows the model, so the
     // catalog carries $/token for the tier display and budgeting. Subscription /
@@ -1237,5 +1279,11 @@ export function buildReasoningFlags(agent, level) {
         const grokLevel = (normalized === 'xhigh' || normalized === 'max') ? 'high' : normalized;
         return ['--reasoning-effort', grokLevel];
     }
+    if (agent === 'muse') {
+        // Muse Code: `--reasoning-effort none|minimal|low|medium|high|xhigh|ultra`.
+        // Map our unified `max` to Muse's `ultra` (client-side multi-agent aggression).
+        const museLevel = normalized === 'max' ? 'ultra' : normalized;
+        return ['--reasoning-effort', museLevel];
+    }
     return [];
 }

package/dist/lib/plugin-marketplace.js

@@ -121,6 +121,11 @@ function dirExists(p) {
 }
 // ─── Per-version paths ────────────────────────────────────────────────────────
 function pluginsRootForVersion(agent, versionHome) {
+    // Muse Code keeps its plugin store under XDG data (`~/.local/share/muse/plugins`),
+    // not under the config dir. Under HOME isolation the version home is $HOME.
+    if (agent === 'muse') {
+        return path.join(versionHome, '.local', 'share', 'muse', 'plugins');
+    }
     return path.join(versionHome, agentConfigDirName(agent), 'plugins');
 }
 export function marketplaceRoot(specOrName, agent, versionHome) {
@@ -678,6 +683,10 @@ export function addPluginToSettings(pluginName, marketplaceName, agent, versionH
             settings = {};
         }
     }
+    // Muse refuses to start without schema_version: 1.
+    if (agent === 'muse' && settings.schema_version === undefined) {
+        settings.schema_version = 1;
+    }
     if (!settings.enabledPlugins || typeof settings.enabledPlugins !== 'object') {
         settings.enabledPlugins = {};
     }