@p4code/cli 0.4.12 → 0.4.14

package/dist/bin.mjs

@@ -240,7 +240,7 @@ const make$93 = () => {
 const layer$82 = Layer.sync(NetService, make$93);
 //#endregion
 //#region package.json
-var version = "0.4.12";
+var version = "0.4.14";
 //#endregion
 //#region src/config.ts
 /**
@@ -21599,6 +21599,90 @@ function expandHomePath$3(value) {
 	if (value.startsWith("~/") || value.startsWith("~\\")) return NodePath.join(NodeOS.homedir(), value.slice(2));
 	return value;
 }
+/**
+* Reasoning levels `muse exec --reasoning-effort` accepts, in the CLI's own
+* order (`muse exec --help`, Muse Code 1.1.1). `high` is the CLI default, so
+* it is the default here too.
+*/
+const MUSE_REASONING_EFFORTS = [
+	"none",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max",
+	"ultra"
+];
+const MUSE_DEFAULT_REASONING_EFFORT = "high";
+/**
+* Keep a selection Muse cannot parse out of the argv. `reasoningEffort` is a
+* shared option id — Codex publishes one too — so a selection left over from
+* another provider can reach this driver, and an unknown level makes
+* `muse exec` reject the whole invocation.
+*/
+function museReasoningEffort(value) {
+	return value !== void 0 && MUSE_REASONING_EFFORTS.includes(value) ? value : void 0;
+}
+/**
+* Build the argument vector for one turn.
+*
+* Approval policy is the load-bearing decision here. Muse Code 1.1.1 does
+* express approval as a policy — `--approval-mode untrusted|on-request|never`,
+* plus named `--permission-profile` documents — but a headless `exec` run
+* still has no channel to answer a prompt: approvals are served over MSP
+* (`muse serve`), not on the `exec` stream. So the only two postures `exec`
+* can honour end to end are `--disable-approval` (keep the OS sandbox) and
+* `--yolo` (drop approval and the sandbox, and trust the workspace). P4Code
+* owns the user-facing runtime mode, so it maps onto those two:
+*
+*   - `full-access` → `--yolo`
+*   - everything else → `--disable-approval --trust-workspace`, leaving the
+*     sandbox to contain what runs.
+*
+* `approval-required` cannot be honoured over `exec`; the adapter emits a
+* `config.warning` for it rather than silently pretending otherwise. Serving
+* a real approval prompt means moving the driver onto MSP.
+*
+* Flags here were verified against Muse Code 1.1.1-R2514.1 (`muse exec
+* --help`).
+*/
+function buildMuseExecArgs(input) {
+	const args = [
+		"exec",
+		"--json",
+		"--session-id",
+		input.sessionId
+	];
+	if (input.model) args.push("--model", input.model);
+	if (input.reasoningEffort) args.push("--reasoning-effort", input.reasoningEffort);
+	if (input.baseUrl) args.push("--base-url", input.baseUrl);
+	if (input.runtimeMode === "full-access") args.push("--yolo");
+	else {
+		args.push("--disable-approval", "--trust-workspace");
+		switch (input.sandboxMode) {
+			case "danger-full-access":
+				args.push("--disable-sandbox");
+				break;
+			case "read-only":
+				args.push("--disable-write", "--disable-shell");
+				break;
+			default: break;
+		}
+	}
+	for (const imagePath of input.imagePaths ?? []) args.push("--image", imagePath);
+	args.push(input.prompt);
+	return args;
+}
+/** `muse --version` argv, used by the provider status probe. */
+const MUSE_VERSION_ARGS = ["--version"];
+/**
+* Whether a runtime mode asks for interactive approvals that Muse Code
+* cannot deliver headlessly.
+*/
+function museApprovalsUnsupported(runtimeMode) {
+	return runtimeMode === "approval-required";
+}
 //#endregion
 //#region src/provider/skillOverrides.ts
 /**
@@ -21680,19 +21764,7 @@ function buildSkillOverrides(disabled, discovered) {
 	return Object.keys(overrides).length === 0 ? void 0 : overrides;
 }
 //#endregion
-//#region src/provider/Drivers/ClaudeSkills.ts
-/**
-* ClaudeSkills — filesystem discovery of Claude Code skills for the `$` picker.
-*
-* Claude Code loads skills from `<config dir>/skills` (user scope) and
-* `<cwd>/.claude/skills` (project scope), one directory per skill with a
-* `SKILL.md` carrying YAML frontmatter. The Agent SDK init handshake surfaces
-* skills only as slash commands without their filesystem paths, so the
-* provider snapshot scans the same locations directly, mirroring how the
-* Codex app-server reports its skills.
-*
-* @module provider/Drivers/ClaudeSkills
-*/
+//#region src/provider/Drivers/skillFrontmatter.ts
 const FRONTMATTER_PATTERN$1 = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
 /** The `true` spellings the CLI accepts for a boolean frontmatter field. */
 const TRUTHY_FRONTMATTER_VALUES = /* @__PURE__ */ new Set([
@@ -21727,10 +21799,10 @@ function stripMarkdownFrontmatter(contents) {
 /**
 * The `name`/`description` header a skill and a subagent definition both carry.
 *
-* Exported because agent definitions are the same header in a different file,
+* Shared because agent definitions are the same header in a different file,
 * and the sync validates them before publishing one. A second copy of this
 * would be a second answer to "does this load in the provider", which is the
-* one question both callers are asking.
+* one question every caller is asking.
 */
 function parseMarkdownFrontmatter(contents) {
 	const match = FRONTMATTER_PATTERN$1.exec(contents);
@@ -21755,6 +21827,245 @@ function parseMarkdownFrontmatter(contents) {
 		...requiredInteractionMode === void 0 ? {} : { requiredInteractionMode }
 	};
 }
+//#endregion
+//#region src/provider/Drivers/SharedSkills.ts
+/**
+* SharedSkills — the skills a provider can reach, whichever provider it is.
+*
+* A skill is a directory holding `SKILL.md`, and by now every CLI P4Code drives
+* loads them from the *same* provider-neutral user root — `~/.agents/skills` —
+* on top of its own. That is why the sync materializes there
+* (`sync/sharedSkillRoot.ts`): one copy of a skill, visible to all of them.
+*
+* What was still Claude- and Codex-only is the *reporting*: the composer's `$`
+* picker and the transcript's skill chips read `ServerProvider.skills`, and a
+* provider that never filled that array looked like it had no skills at all
+* while its CLI was happily loading them. So discovery is done here once,
+* against the roots each CLI documents, and every driver fills the same field.
+*
+* **Reported, not enforced.** `enabled` mirrors P4Code's own disabled-skill
+* setting so a skill switched off disappears from the picker everywhere. Only
+* Claude can additionally be told to withhold it from the model
+* (`skillOverrides`); the other CLIs own their listing, so the toggle is a
+* P4Code-surface toggle there, exactly as the flag's name in discovery says.
+*
+* Roots per CLI, from each vendor's own documentation:
+*   - Cursor: `~/.agents/skills`, `~/.cursor/skills`, `.agents/skills`,
+*     `.cursor/skills` — https://cursor.com/docs/skills
+*   - Grok: `~/.agents/skills`, `~/.grok/skills`, `.agents/skills`,
+*     `.grok/skills` — https://docs.x.ai/build/features/skills-plugins-marketplaces
+*   - OpenCode: `~/.agents/skills`, `~/.claude/skills`,
+*     `<XDG config>/opencode/skills`, and the project mirrors of all three —
+*     https://opencode.ai/docs/skills/
+*   - Muse: `~/.agents/skills`, `<XDG config>/muse/skills`, `.agents/skills`,
+*     plus the foreign personal roots it reads unless `--no-foreign-personal-context`
+*     is passed (`~/.claude/skills`, `~/.codex/skills`), which `muse skills list`
+*     reports as user-scope entries. Those two are gated on
+*     `MUSE_EXEC_LOADS_FOREIGN_PERSONAL_SKILLS`, which the argv builder owns,
+*     so the claim tracks the flag the adapter actually spawns with.
+*
+* Claude and Codex are absent on purpose: each already reports its own skills
+* from a source that knows more than the filesystem does — Claude's config
+* directory may be redirected per instance, and Codex answers a `skills/list`
+* RPC that includes skills no directory scan would find.
+*
+* @module provider/Drivers/SharedSkills
+*/
+/** `SKILL.md` is the only file a skill is required to have. */
+const SKILL_FILENAME$1 = "SKILL.md";
+/** The provider-neutral user skill root the sync materializes into. */
+const SHARED_USER_SKILL_DIRNAME = ".agents";
+/**
+* Enumerate skills across roots, least specific first.
+*
+* Discovery is best-effort: unreadable roots and malformed skill entries are
+* skipped so a broken skill never degrades the provider snapshot. On name
+* collisions the later root wins, matching the most-specific-wins resolution
+* every one of these CLIs uses — which is also why the shared root is listed
+* before the provider's own.
+*/
+const discoverSkillsInRoots = Effect.fn("discoverSkillsInRoots")(function* (roots, disabledSkills) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const skillsByName = /* @__PURE__ */ new Map();
+	for (const root of roots) {
+		const entries = yield* fileSystem.readDirectory(root.directory).pipe(Effect.orElseSucceed(() => []));
+		for (const entry of [...entries].sort()) {
+			const skillPath = path.join(root.directory, entry, SKILL_FILENAME$1);
+			const contents = yield* fileSystem.readFileString(skillPath).pipe(Effect.orElseSucceed(() => void 0));
+			if (contents === void 0) continue;
+			const frontmatter = parseMarkdownFrontmatter(contents);
+			if (frontmatter.kind === "malformed") continue;
+			const name = (frontmatter.kind === "parsed" ? frontmatter.name : void 0) ?? entry.trim();
+			if (!name) continue;
+			skillsByName.set(name, {
+				name,
+				path: skillPath,
+				enabled: !isSkillDisabled({
+					name,
+					path: skillPath
+				}, disabledSkills ?? []),
+				scope: root.scope,
+				...frontmatter.kind === "parsed" && frontmatter.description ? { description: frontmatter.description } : {},
+				...frontmatter.kind === "parsed" && frontmatter.requiredInteractionMode ? { requiredInteractionMode: frontmatter.requiredInteractionMode } : {}
+			});
+		}
+	}
+	return [...skillsByName.values()].sort((left, right) => left.name.localeCompare(right.name));
+});
+/**
+* The config home a CLI following the XDG convention reads, matching what the
+* spawned process would see: its own `XDG_CONFIG_HOME` when set, else
+* `~/.config`. Read from the provider environment rather than `process.env`
+* because an instance may be configured with a different one.
+*/
+function xdgConfigHome$1(environment) {
+	const configured = environment.XDG_CONFIG_HOME?.trim() ?? "";
+	return configured.length > 0 ? configured : `${homeDirectory(environment)}/.config`;
+}
+/**
+* The home the spawned CLI would resolve: the provider instance's own `HOME`
+* when it sets one, else this process's. A provider configured with a separate
+* home keeps its own skills, which is the point of configuring one.
+*/
+function homeDirectory(environment) {
+	const configured = environment.HOME?.trim() ?? "";
+	return configured.length > 0 ? configured : NodeOS.homedir();
+}
+/**
+* The provider-neutral roots every CLI reads, least specific first.
+*
+* For callers that act on a skill without knowing which provider will run it —
+* the server-side expansion of a user-invoked skill, which happens before the
+* turn reaches an adapter.
+*/
+const sharedSkillDirectories = Effect.fn("sharedSkillDirectories")(function* (cwd, environment) {
+	const path = yield* Path.Path;
+	const user = path.join(homeDirectory(environment ?? process.env), SHARED_USER_SKILL_DIRNAME, "skills");
+	return cwd === void 0 ? [user] : [user, path.join(cwd, SHARED_USER_SKILL_DIRNAME, "skills")];
+});
+/** User-scope roots per driver, shared root first. */
+function userSkillDirectories(driver, environment) {
+	const home = homeDirectory(environment);
+	const shared = [
+		home,
+		SHARED_USER_SKILL_DIRNAME,
+		"skills"
+	];
+	switch (driver) {
+		case "cursor": return [shared, [
+			home,
+			".cursor",
+			"skills"
+		]];
+		case "grok": return [shared, [
+			home,
+			".grok",
+			"skills"
+		]];
+		case "opencode": return [
+			shared,
+			[
+				home,
+				".claude",
+				"skills"
+			],
+			[
+				xdgConfigHome$1(environment),
+				"opencode",
+				"skills"
+			]
+		];
+		case "muse": return [
+			shared,
+			...[[
+				home,
+				".claude",
+				"skills"
+			], [
+				home,
+				".codex",
+				"skills"
+			]],
+			[
+				xdgConfigHome$1(environment),
+				"muse",
+				"skills"
+			]
+		];
+		default: return [shared];
+	}
+}
+/** Project-scope roots per driver, relative to the workspace. */
+function projectSkillDirectories(driver) {
+	const shared = [SHARED_USER_SKILL_DIRNAME, "skills"];
+	switch (driver) {
+		case "cursor": return [shared, [".cursor", "skills"]];
+		case "grok": return [shared, [".grok", "skills"]];
+		case "opencode": return [
+			shared,
+			[".claude", "skills"],
+			[".opencode", "skills"]
+		];
+		default: return [shared];
+	}
+}
+/** Every root a driver's CLI reads, least specific first. */
+const providerSkillRoots = Effect.fn("providerSkillRoots")(function* (input) {
+	const path = yield* Path.Path;
+	const environment = input.environment ?? process.env;
+	const user = userSkillDirectories(input.driver, environment).map((segments) => ({
+		directory: path.join(...segments),
+		scope: "user"
+	}));
+	const cwd = input.cwd;
+	if (cwd === void 0) return user;
+	return [...user, ...projectSkillDirectories(input.driver).map((segments) => ({
+		directory: path.join(cwd, ...segments),
+		scope: "project"
+	}))];
+});
+/**
+* A snapshot draft carrying the skills its CLI can reach.
+*
+* Applied after the probe rather than inside it: what a CLI reports about
+* itself — version, auth, models — and what it loads off disk are independent,
+* and a provider that is failing its probe still has the skills sitting there
+* for the picker.
+*/
+const withProviderSkills = Effect.fn("withProviderSkills")(function* (draft, input) {
+	const skills = yield* discoverProviderSkills(input);
+	return {
+		...draft,
+		skills
+	};
+});
+/**
+* The skills a provider snapshot should report for a driver that loads them
+* from disk. Drivers call this instead of leaving `skills` empty.
+*/
+const discoverProviderSkills = Effect.fn("discoverProviderSkills")(function* (input) {
+	const roots = yield* providerSkillRoots({
+		driver: input.driver,
+		cwd: input.cwd,
+		environment: input.environment
+	});
+	return yield* discoverSkillsInRoots(roots, input.disabledSkills);
+});
+//#endregion
+//#region src/provider/Drivers/ClaudeSkills.ts
+/**
+* ClaudeSkills — filesystem discovery of Claude Code skills for the `$` picker.
+*
+* Claude Code loads skills from `<config dir>/skills` (user scope) and
+* `<cwd>/.claude/skills` (project scope), one directory per skill with a
+* `SKILL.md` carrying YAML frontmatter. The Agent SDK init handshake surfaces
+* skills only as slash commands without their filesystem paths, so the
+* provider snapshot scans the same locations directly, mirroring how the
+* Codex app-server reports its skills.
+*
+* @module provider/Drivers/ClaudeSkills
+*/
 /**
 * Resolve the Claude config directory the CLI would use, matching the
 * precedence the spawned CLI sees: the instance's `homePath` (exported as
@@ -21807,41 +22118,15 @@ const resolveClaudeUserAgentsDir = Effect.fn("resolveClaudeUserAgentsDir")(funct
 * most-specific-wins resolution.
 */
 const discoverClaudeSkills = Effect.fn("discoverClaudeSkills")(function* (config, cwd, environment, disabledSkills) {
-	const fileSystem = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const configDirPath = yield* resolveClaudeConfigDirPath(config, environment ?? process.env, cwd);
-	const roots = [{
+	return yield* discoverSkillsInRoots([{
 		directory: path.join(configDirPath, "skills"),
 		scope: "user"
 	}, ...cwd ? [{
 		directory: path.join(cwd, ".claude", "skills"),
 		scope: "project"
-	}] : []];
-	const skillsByName = /* @__PURE__ */ new Map();
-	for (const root of roots) {
-		const entries = yield* fileSystem.readDirectory(root.directory).pipe(Effect.orElseSucceed(() => []));
-		for (const entry of [...entries].sort()) {
-			const skillPath = path.join(root.directory, entry, "SKILL.md");
-			const contents = yield* fileSystem.readFileString(skillPath).pipe(Effect.orElseSucceed(() => void 0));
-			if (contents === void 0) continue;
-			const frontmatter = parseMarkdownFrontmatter(contents);
-			if (frontmatter.kind === "malformed") continue;
-			const name = (frontmatter.kind === "parsed" ? frontmatter.name : void 0) ?? entry.trim();
-			if (!name) continue;
-			skillsByName.set(name, {
-				name,
-				path: skillPath,
-				enabled: !isSkillDisabled({
-					name,
-					path: skillPath
-				}, disabledSkills ?? []),
-				scope: root.scope,
-				...frontmatter.kind === "parsed" && frontmatter.description ? { description: frontmatter.description } : {},
-				...frontmatter.kind === "parsed" && frontmatter.requiredInteractionMode ? { requiredInteractionMode: frontmatter.requiredInteractionMode } : {}
-			});
-		}
-	}
-	return [...skillsByName.values()].sort((left, right) => left.name.localeCompare(right.name));
+	}] : []], disabledSkills);
 });
 //#endregion
 //#region src/mcp/ClaudeMcpFiles.ts
@@ -23818,6 +24103,138 @@ function planSkillSync(input) {
 	};
 }
 //#endregion
+//#region src/sync/assetMirrorOps.ts
+/**
+* Whether this machine may write the asset into a mirror root.
+*
+* `foreign` covers the case that matters: a file someone else wrote, or a
+* symlink a user set up between two providers, whose content matches neither
+* what is being written nor what P4Code last wrote from here. Overwriting it
+* would silently replace a configuration the user owns.
+*/
+function decideMirrorWrite(input) {
+	if (input.existing === void 0) return "write";
+	if (input.existing === input.next) return "up-to-date";
+	if (input.previous !== void 0 && input.existing === input.previous) return "write";
+	return "foreign";
+}
+/**
+* Whether a mirrored copy may be removed.
+*
+* Only a copy that still matches what P4Code wrote. An edited mirror is the
+* user's, and a deletion upstream is not a reason to throw their edit away.
+*/
+function shouldRemoveMirror(input) {
+	return input.existing !== void 0 && input.managed !== void 0 && input.existing === input.managed;
+}
+//#endregion
+//#region src/sync/providerAssetRoots.ts
+/**
+* providerAssetRoots — where a memory file or a subagent definition has to
+* land for a provider other than Claude to read it.
+*
+* Skills needed none of this: every CLI P4Code drives loads
+* `~/.agents/skills`, so one directory serves them all. Memory and subagent
+* definitions have no such shared root — there is a proposal to standardize a
+* user-level `AGENTS.md` location and nothing shipped — so each provider reads
+* its own path, and an asset that exists only in Claude's config directory is
+* an asset the other providers never see.
+*
+* Verified on this machine rather than taken from documentation:
+*   - Codex keeps user instructions at `$CODEX_HOME/AGENTS.md` (default
+*     `~/.codex`) and its subagent definitions at `$CODEX_HOME/agents/*.toml`.
+*   - OpenCode keeps user instructions at `<XDG config>/opencode/AGENTS.md`
+*     and its subagent definitions at `<XDG config>/opencode/agents/*.md`,
+*     markdown with the same `name`/`description` frontmatter Claude uses.
+*   - Cursor reads subagent definitions from `~/.cursor/agents`, and its own
+*     documentation says it also reads `~/.claude/agents` and `~/.codex/agents`
+*     for cross-tool compatibility.
+*   - Muse reads the other CLIs' personal rules — `~/.claude/CLAUDE.md` and
+*     `~/.codex/AGENTS.md` — unless a run passes
+*     `--no-foreign-personal-context`, which P4Code never does
+*     (`MUSE_EXEC_LOADS_FOREIGN_PERSONAL_SKILLS`). It therefore needs no
+*     mirror of its own.
+*
+* Deliberately absent:
+*   - **Codex subagents.** They are TOML with `developer_instructions`, not
+*     markdown with frontmatter. Mirroring one would mean converting a
+*     definition rather than copying it, and a lossy conversion of the file
+*     that decides what a subagent is handed is worse than not having it.
+*   - **Cursor user rules.** Cursor keeps cross-project prose in its own
+*     settings store, not in a file on disk, so there is nothing to write.
+*   - **Grok.** Its skills root is confirmed (`~/.agents/skills`); a
+*     user-level instructions file is not, and x.ai's own documentation does
+*     not name one. Writing a guessed path is worse than writing nothing.
+*
+* @module sync/providerAssetRoots
+*/
+/**
+* The filename every non-Claude provider here reads its user instructions from.
+*
+* Codex and OpenCode read `AGENTS.md` and nothing else, so a `CLAUDE.md` asset
+* — the default, and what most machines actually hold — reaches them only
+* under this name. That rename is the one place in the sync where the asset's
+* name and the file on disk differ, and it is narrow on purpose: it happens for
+* this one pair of names, into these roots, and only when there is no
+* `AGENTS.md` asset of its own to mirror instead.
+*/
+const SHARED_MEMORY_FILE_NAME = "AGENTS.md";
+/**
+* The config home of a CLI following the XDG convention, as the CLI itself
+* would resolve it.
+*/
+function xdgConfigHome(environment) {
+	const configured = environment.XDG_CONFIG_HOME?.trim() ?? "";
+	if (configured.length > 0) return configured;
+	const home = environment.HOME?.trim() ?? "";
+	return `${home.length > 0 ? home : NodeOS.homedir()}/.config`;
+}
+/** Codex's home, matching the CLI's own `CODEX_HOME` precedence. */
+function codexHome(environment) {
+	const configured = environment.CODEX_HOME?.trim() ?? "";
+	return configured.length > 0 ? configured : `${NodeOS.homedir()}/.codex`;
+}
+/**
+* Directories that should hold a copy of a shared memory file.
+*
+* Directories rather than file paths because the sync writes an asset by name
+* into a root, and the name *is* the filename.
+*/
+const memoryMirrorRoots = Effect.fn("memoryMirrorRoots")(function* (environment) {
+	const path = yield* Path.Path;
+	const resolved = environment ?? process.env;
+	return [path.resolve(codexHome(resolved)), path.join(path.resolve(xdgConfigHome(resolved)), "opencode")];
+});
+/**
+* Where a memory asset should be copied, and under which name.
+*
+* `AGENTS.md` maps to itself. `CLAUDE.md` maps to `AGENTS.md`, but only when no
+* `AGENTS.md` asset exists: with both in play the destination would otherwise
+* flip between two sources depending on which one synced last, and a file whose
+* content depends on ordering is worse than one provider missing a mirror.
+*/
+const memoryMirrorTargets = Effect.fn("memoryMirrorTargets")(function* (input) {
+	if (!(input.name === "AGENTS.md" || input.name === "CLAUDE.md" && !input.siblingNames.has("AGENTS.md"))) return [];
+	return (yield* memoryMirrorRoots(input.environment)).map((root) => ({
+		root,
+		name: SHARED_MEMORY_FILE_NAME
+	}));
+});
+/** Directories that should hold a copy of a markdown subagent definition. */
+const agentDefinitionMirrorRoots = Effect.fn("agentDefinitionMirrorRoots")(function* (environment) {
+	const path = yield* Path.Path;
+	const resolved = environment ?? process.env;
+	const home = resolved.HOME?.trim() ?? "";
+	return [path.join(home.length > 0 ? home : NodeOS.homedir(), ".cursor", "agents"), path.join(path.resolve(xdgConfigHome(resolved)), "opencode", "agents")];
+});
+/** Where a markdown subagent definition should be copied, under its own name. */
+const agentDefinitionMirrorTargets = Effect.fn("agentDefinitionMirrorTargets")(function* (input) {
+	return (yield* agentDefinitionMirrorRoots(input.environment)).map((root) => ({
+		root,
+		name: input.name
+	}));
+});
+//#endregion
 //#region src/sync/sharedSkillRoot.ts
 const SHARED_SKILL_ROOT_REFUSAL = "shared-root-migration-blocked";
 const inspectLayout = Effect.fn("sharedSkillRoot.inspectLayout")(function* (input) {
@@ -24055,15 +24472,70 @@ const make$77 = Effect.gen(function* () {
 			}]
 		}))));
 	});
+	const prepareSkillRoot = Effect.gen(function* () {
+		yield* prepareSharedSkillRoot({
+			claudeSkillsRoot: yield* claudeHome().pipe(Effect.flatMap(resolveClaudeUserSkillsDir)),
+			manifestPath
+		});
+	}).pipe(Effect.catchCause((cause) => Effect.logWarning("shared skill root migration failed", { cause })));
+	/** What a mirror root currently holds under that name, if anything. */
+	const mirrorDigest = Effect.fn("AssetSync.mirrorDigest")(function* (driver, root, name) {
+		const existing = (yield* driver.read(root)).skills.find((entry) => entry.name === name);
+		return existing ? digestSkillFiles(existing.files) : void 0;
+	});
+	/**
+	* Copy a managed asset into the roots other providers read.
+	*
+	* Nothing P4Code did not put there is ever overwritten: a mirror holding
+	* content that matches neither what is being written nor what was last
+	* written from here belongs to someone else, and it is left alone. That is
+	* the whole guard — a file the user wrote by hand, or a symlink they set up
+	* between two providers, survives a sync untouched.
+	*/
+	const mirrorWrite = Effect.fn("AssetSync.mirrorWrite")(function* (input) {
+		const mirrors = input.driver.mirrors;
+		if (mirrors === void 0) return;
+		const nextDigest = digestSkillFiles(input.files);
+		const targets = yield* mirrors({
+			name: input.name,
+			siblingNames: input.siblingNames
+		});
+		for (const target of targets) {
+			if (decideMirrorWrite({
+				existing: yield* mirrorDigest(input.driver, target.root, target.name),
+				next: nextDigest,
+				previous: input.previousDigest
+			}) !== "write") continue;
+			yield* input.driver.write({
+				root: target.root,
+				name: target.name,
+				files: input.files
+			});
+		}
+	});
+	/** Drop a mirrored copy, and only a copy that still matches what we wrote. */
+	const mirrorRemove = Effect.fn("AssetSync.mirrorRemove")(function* (input) {
+		const mirrors = input.driver.mirrors;
+		if (mirrors === void 0) return;
+		const targets = yield* mirrors({
+			name: input.name,
+			siblingNames: input.siblingNames
+		});
+		for (const target of targets) {
+			if (!shouldRemoveMirror({
+				existing: yield* mirrorDigest(input.driver, target.root, target.name),
+				managed: input.digest
+			})) continue;
+			yield* input.driver.remove({
+				root: target.root,
+				name: target.name
+			});
+		}
+	});
 	const drivers = [
 		{
 			kind: "skill",
-			prepareRoot: Effect.gen(function* () {
-				yield* prepareSharedSkillRoot({
-					claudeSkillsRoot: yield* claudeHome().pipe(Effect.flatMap(resolveClaudeUserSkillsDir)),
-					manifestPath
-				});
-			}).pipe(Effect.catchCause((cause) => Effect.logWarning("shared skill root migration failed", { cause }))),
+			prepareRoot: prepareSkillRoot,
 			resolveState: inspectSkillRoot(),
 			resolveRoot: inspectSkillRoot().pipe(Effect.map((result) => result.root)),
 			read: (root) => readSkillDirectory(root),
@@ -24091,7 +24563,11 @@ const make$77 = Effect.gen(function* () {
 				memoryRoot: root,
 				sharedMemoryRoot,
 				name
-			}).pipe(Effect.ignore)
+			}).pipe(Effect.ignore),
+			mirrors: ({ name, siblingNames }) => memoryMirrorTargets({
+				name,
+				siblingNames
+			})
 		},
 		{
 			kind: "agent",
@@ -24105,7 +24581,8 @@ const make$77 = Effect.gen(function* () {
 			remove: ({ root, name }) => removeAgentDefinition({
 				agentsRoot: root,
 				name
-			}).pipe(Effect.ignore)
+			}).pipe(Effect.ignore),
+			mirrors: ({ name }) => agentDefinitionMirrorTargets({ name })
 		},
 		{
 			kind: "mcp",
@@ -24212,6 +24689,11 @@ const make$77 = Effect.gen(function* () {
 				manifest: views.managed
 			});
 			const entries = new Map(views.managed.map((entry) => [entry.name, entry]));
+			/**
+			* Every asset of this kind in play, which the memory driver reads to
+			* decide whether a `CLAUDE.md` may stand in for a missing `AGENTS.md`.
+			*/
+			const assetNames = /* @__PURE__ */ new Set([...views.hub.map((asset) => asset.name), ...views.local.map((asset) => asset.name)]);
 			/** One manifest for the whole run, re-read per kind so roots do not clobber. */
 			const commit = Effect.fn("AssetSync.commit")(function* () {
 				const manifest = yield* readSkillManifest(manifestPath);
@@ -24232,6 +24714,13 @@ const make$77 = Effect.gen(function* () {
 						});
 						break;
 					}
+					yield* mirrorWrite({
+						driver,
+						name: action.asset.name,
+						siblingNames: assetNames,
+						files: action.asset.files,
+						previousDigest: entries.get(action.asset.name)?.digest
+					});
 					entries.set(action.asset.name, {
 						name: action.asset.name,
 						version: action.asset.version,
@@ -24274,6 +24763,12 @@ const make$77 = Effect.gen(function* () {
 						root,
 						name: action.name
 					});
+					yield* mirrorRemove({
+						driver,
+						name: action.name,
+						siblingNames: assetNames,
+						digest: entries.get(action.name)?.digest
+					});
 					entries.delete(action.name);
 					removed.push({
 						kind,
@@ -24711,6 +25206,13 @@ const make$77 = Effect.gen(function* () {
 			name: input.name,
 			files: input.files
 		});
+		if (written === "written") yield* mirrorWrite({
+			driver,
+			name: input.name,
+			siblingNames: new Set(local.skills.map((asset) => asset.name)),
+			files: input.files,
+			previousDigest: void 0
+		});
 		if (written !== "written") return {
 			outcome: written,
 			path: null,
@@ -24747,10 +25249,17 @@ const make$77 = Effect.gen(function* () {
 			path: null,
 			detail: decision.detail
 		};
+		const removedDigest = local.skills.find((entry) => entry.name === ref.name);
 		yield* driver.remove({
 			root,
 			name: ref.name
 		});
+		yield* mirrorRemove({
+			driver,
+			name: ref.name,
+			siblingNames: new Set(local.skills.map((asset) => asset.name)),
+			digest: removedDigest ? digestSkillFiles(removedDigest.files) : void 0
+		});
 		return {
 			outcome: "removed",
 			path: null,
@@ -100200,7 +100709,7 @@ const CURSOR_PRESENTATION = {
 	badgeLabel: "Early Access",
 	showInteractionModeToggle: true
 };
-const EMPTY_CAPABILITIES$2 = createModelCapabilities({ optionDescriptors: [] });
+const EMPTY_CAPABILITIES$1 = createModelCapabilities({ optionDescriptors: [] });
 const CURSOR_ACP_MODEL_DISCOVERY_TIMEOUT_MS = 15e3;
 const CURSOR_PARAMETERIZED_MODEL_PICKER_MIN_VERSION_DATE = 20260408;
 const CURSOR_CLI_INSTALLATION_DOCS_URL = "https://cursor.com/docs/cli/installation";
@@ -100308,7 +100817,7 @@ function getBooleanCurrentValue(option) {
 	if (normalized === "false") return false;
 }
 function buildCursorCapabilitiesFromConfigOptions(configOptions) {
-	if (!configOptions || configOptions.length === 0) return EMPTY_CAPABILITIES$2;
+	if (!configOptions || configOptions.length === 0) return EMPTY_CAPABILITIES$1;
 	const reasoningConfig = findCursorEffortConfigOption(configOptions);
 	const reasoningEffortLevels = reasoningConfig?.type === "select" ? flattenSessionConfigSelectOptions(reasoningConfig).flatMap((entry) => {
 		const normalizedValue = normalizeCursorReasoningValue(entry.value);
@@ -100477,7 +100986,7 @@ const discoverCursorModelsViaListAvailableModels = (cursorSettings, environment)
 }), environment);
 const discoverCursorModelsViaAcp = (cursorSettings, environment) => discoverCursorModelsViaListAvailableModels(cursorSettings, environment);
 function getCursorFallbackModels(cursorSettings) {
-	return providerModelsFromSettings([], cursorSettings.customModels, EMPTY_CAPABILITIES$2);
+	return providerModelsFromSettings([], cursorSettings.customModels, EMPTY_CAPABILITIES$1);
 }
 /** Timeout for `agent about` — it's slower than a simple `--version` probe. */
 const ABOUT_TIMEOUT_MS = 8e3;
@@ -100513,7 +101022,7 @@ function buildCursorProviderSnapshot(input) {
 		presentation: CURSOR_PRESENTATION,
 		enabled: input.cursorSettings.enabled,
 		checkedAt: input.checkedAt,
-		models: providerModelsFromSettings(input.discoveredModels ?? [], input.cursorSettings.customModels, EMPTY_CAPABILITIES$2),
+		models: providerModelsFromSettings(input.discoveredModels ?? [], input.cursorSettings.customModels, EMPTY_CAPABILITIES$1),
 		probe: {
 			installed: true,
 			version: input.parsed.version,
@@ -102007,6 +102516,7 @@ const CursorDriver = {
 		const fileSystem = yield* FileSystem.FileSystem;
 		const path = yield* Path.Path;
 		const httpClient = yield* HttpClient.HttpClient;
+		const serverConfig = yield* ServerConfig$1;
 		const serverSettings = yield* ServerSettingsService;
 		const eventLoggers = yield* ProviderEventLoggers;
 		const processEnv = mergeProviderInstanceEnvironment(environment);
@@ -102035,7 +102545,12 @@ const CursorDriver = {
 			instanceId
 		});
 		const textGeneration = yield* makeCursorTextGeneration(effectiveConfig, processEnv);
-		const checkProvider = checkCursorProviderStatus(effectiveConfig, processEnv).pipe(Effect.map(stampIdentity), Effect.provideService(Crypto.Crypto, crypto), Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner), Effect.provideService(FileSystem.FileSystem, fileSystem), Effect.provideService(Path.Path, path));
+		const checkProvider = serverSettings.getSettings.pipe(Effect.map((settings) => settings.disabledSkills), Effect.orElseSucceed(() => [])).pipe(Effect.flatMap((disabledSkills) => checkCursorProviderStatus(effectiveConfig, processEnv).pipe(Effect.flatMap((draft) => withProviderSkills(draft, {
+			driver: DRIVER_KIND$3,
+			cwd: serverConfig.cwd,
+			environment: processEnv,
+			disabledSkills
+		})))), Effect.map(stampIdentity), Effect.provideService(Crypto.Crypto, crypto), Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner), Effect.provideService(FileSystem.FileSystem, fileSystem), Effect.provideService(Path.Path, path));
 		const snapshotSettings = makeProviderSnapshotSettingsSource(effectiveConfig, serverSettings);
 		const snapshot = yield* makeManagedServerProvider({
 			maintenanceCapabilities,
@@ -103346,14 +103861,14 @@ const GROK_PRESENTATION = {
 	showInteractionModeToggle: false,
 	requiresNewThreadForModelChange: true
 };
-const EMPTY_CAPABILITIES$1 = createModelCapabilities({ optionDescriptors: [] });
+const EMPTY_CAPABILITIES = createModelCapabilities({ optionDescriptors: [] });
 const VERSION_PROBE_TIMEOUT_MS$1 = 4e3;
 const GROK_ACP_MODEL_DISCOVERY_TIMEOUT_MS = 15e3;
 const GROK_BUILT_IN_MODELS = [{
 	slug: "grok-build",
 	name: "Grok Build",
 	isCustom: false,
-	capabilities: EMPTY_CAPABILITIES$1
+	capabilities: EMPTY_CAPABILITIES
 }];
 function buildInitialGrokProviderSnapshot(grokSettings) {
 	return Effect.gen(function* () {
@@ -103388,7 +103903,7 @@ function buildInitialGrokProviderSnapshot(grokSettings) {
 	});
 }
 function grokModelsFromSettings(customModels, builtInModels = GROK_BUILT_IN_MODELS) {
-	return providerModelsFromSettings(builtInModels, customModels ?? [], EMPTY_CAPABILITIES$1);
+	return providerModelsFromSettings(builtInModels, customModels ?? [], EMPTY_CAPABILITIES);
 }
 function buildGrokDiscoveredModelsFromSessionModelState(modelState) {
 	if (!modelState || modelState.availableModels.length === 0) return [];
@@ -103401,7 +103916,7 @@ function buildGrokDiscoveredModelsFromSessionModelState(modelState) {
 			slug,
 			name: model.name.trim() || slug,
 			isCustom: false,
-			capabilities: EMPTY_CAPABILITIES$1
+			capabilities: EMPTY_CAPABILITIES
 		};
 	}).filter((model) => model !== void 0);
 }
@@ -103576,6 +104091,9 @@ const GrokDriver = {
 		const crypto = yield* Crypto.Crypto;
 		const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
 		const httpClient = yield* HttpClient.HttpClient;
+		const fileSystem = yield* FileSystem.FileSystem;
+		const path = yield* Path.Path;
+		const serverConfig = yield* ServerConfig$1;
 		const serverSettings = yield* ServerSettingsService;
 		const eventLoggers = yield* ProviderEventLoggers;
 		const processEnv = mergeProviderInstanceEnvironment(environment);
@@ -103604,7 +104122,12 @@ const GrokDriver = {
 			instanceId
 		});
 		const textGeneration = yield* makeGrokTextGeneration(effectiveConfig, processEnv);
-		const checkProvider = checkGrokProviderStatus(effectiveConfig, processEnv).pipe(Effect.map(stampIdentity), Effect.provideService(Crypto.Crypto, crypto), Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner));
+		const checkProvider = serverSettings.getSettings.pipe(Effect.map((settings) => settings.disabledSkills), Effect.orElseSucceed(() => [])).pipe(Effect.flatMap((disabledSkills) => checkGrokProviderStatus(effectiveConfig, processEnv).pipe(Effect.flatMap((draft) => withProviderSkills(draft, {
+			driver: DRIVER_KIND$2,
+			cwd: serverConfig.cwd,
+			environment: processEnv,
+			disabledSkills
+		})))), Effect.map(stampIdentity), Effect.provideService(Crypto.Crypto, crypto), Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner), Effect.provideService(FileSystem.FileSystem, fileSystem), Effect.provideService(Path.Path, path));
 		const snapshotSettings = makeProviderSnapshotSettingsSource(effectiveConfig, serverSettings);
 		const snapshot = yield* makeManagedServerProvider({
 			maintenanceCapabilities,
@@ -103640,68 +104163,21 @@ const GrokDriver = {
 		};
 	})
 };
-/**
-* Build the argument vector for one turn.
-*
-* Approval policy is the load-bearing decision here. A headless Muse run has
-* no channel to answer an approval prompt — the CLI only offers
-* `--disable-approval` (keep the OS sandbox) and `--yolo` (drop approval and
-* the sandbox, and trust the workspace). P4Code owns the user-facing runtime
-* mode, so it maps onto those two postures:
-*
-*   - `full-access` → `--yolo`
-*   - everything else → `--disable-approval --trust-workspace`, leaving the
-*     sandbox to contain what runs.
-*
-* `approval-required` cannot be honoured; the adapter emits a
-* `config.warning` for it rather than silently pretending otherwise.
-*/
-function buildMuseExecArgs(input) {
-	const args = [
-		"exec",
-		"--json",
-		"--session-id",
-		input.sessionId
-	];
-	if (input.model) args.push("--model", input.model);
-	if (input.reasoningEffort) args.push("--reasoning-effort", input.reasoningEffort);
-	if (input.baseUrl) args.push("--base-url", input.baseUrl);
-	if (input.runtimeMode === "full-access") args.push("--yolo");
-	else {
-		args.push("--disable-approval", "--trust-workspace");
-		switch (input.sandboxMode) {
-			case "danger-full-access":
-				args.push("--disable-sandbox");
-				break;
-			case "read-only":
-				args.push("--disable-write", "--disable-shell");
-				break;
-			default: break;
-		}
-	}
-	for (const imagePath of input.imagePaths ?? []) args.push("--image", imagePath);
-	args.push(input.prompt);
-	return args;
-}
-/** `muse --version` argv, used by the provider status probe. */
-const MUSE_VERSION_ARGS = ["--version"];
-/**
-* Whether a runtime mode asks for interactive approvals that Muse Code
-* cannot deliver headlessly.
-*/
-function museApprovalsUnsupported(runtimeMode) {
-	return runtimeMode === "approval-required";
-}
 //#endregion
 //#region src/provider/muse/MuseExecEvents.ts
 /**
 * MuseExecEvents — pure translation of `muse exec --json` JSONL records into
 * canonical `ProviderRuntimeEvent`s.
 *
-* Muse Code has no ACP or app-server surface (verified against CLI
-* 0.1.0-R708.1): the only scriptable path is `muse exec --json`, which runs
-* one prompt to completion and prints one JSON object per line. Multi-turn
-* threads are rebuilt by re-invoking with `--session-id`.
+* P4Code drives Muse through `muse exec --json`, which runs one prompt to
+* completion and prints one JSON object per line; multi-turn threads are
+* rebuilt by re-invoking with `--session-id`. Muse Code 1.1.1 also serves a
+* session host over stdio (`muse serve`, the MSP wire protocol, exported by
+* `muse schema`) with approval, user-input and steering methods that `exec`
+* has no channel for. Moving onto MSP is the way to lift those limits; the
+* mapping below stays on the `exec` stream until then.
+*
+* Record shapes here were re-verified against CLI 1.1.1-R2514.1.
 *
 * Everything here is a pure function over a caller-owned state record so the
 * mapping can be tested against captured CLI output without spawning a
@@ -103995,21 +104471,19 @@ function toolCallIdFromIdempotencyKey(key) {
 	const callId = key.slice(5).trim();
 	return callId.length > 0 ? callId : void 0;
 }
+/**
+* Muse's tool names, as the CLI itself reports them (Muse Code 1.1.1). Names
+* it does not have are not listed: an unknown tool still maps to
+* `dynamic_tool_call`, which is the right answer for the memory, goal, cron,
+* skill and todo tools that have no canonical item type here.
+*/
 function itemTypeForToolName(toolName) {
 	switch (toolName) {
 		case "bash":
-		case "shell":
-		case "run_command":
-		case "unified_exec": return "command_execution";
+		case "bash_input": return "command_execution";
 		case "write_file":
-		case "edit_file":
-		case "multi_edit":
-		case "apply_patch":
-		case "delete_file":
-		case "move_file": return "file_change";
-		case "web_search":
-		case "web_fetch": return "web_search";
-		case "view_image": return "image_view";
+		case "edit_file": return "file_change";
+		case "web_search": return "web_search";
 		default:
 			if (toolName?.startsWith("subagent_")) return "collab_agent_tool_call";
 			if (toolName?.startsWith("mcp__")) return "mcp_tool_call";
@@ -104220,16 +104694,174 @@ const makeMuseTextGeneration = (museSettings, environment = process.env) => Effe
 		})
 	};
 });
+/** The one file the overlay owns; everything else links back to the source. */
+const MUSE_SETTINGS_FILENAME = "settings.json";
+/** The credential the launcher and the binary both read through this variable. */
+const MUSE_AUTH_FILENAME = "auth.json";
+/** The config subdirectory Muse keeps under an XDG config home. */
+const MUSE_CONFIG_DIRNAME = "muse";
+/**
+* The generated settings file carries this session's bearer token, so the
+* overlay is private to the account running the server.
+*/
+const OVERLAY_DIRECTORY_MODE = 448;
+const OVERLAY_SETTINGS_MODE = 384;
+/**
+* Registered servers as Muse settings entries.
+*
+* SSE has no spelling here — Muse reads an entry carrying `type: "sse"` as no
+* entry at all — so those are reported as skipped instead of written and
+* quietly ignored. The reserved names are dropped for the reason every other
+* adapter drops them: a registration called `p4-code` must not displace the
+* built-in one and take the session's own tools with it.
+*/
+function toMuseMcpServers(resolved, reservedNames) {
+	const entries = {};
+	const skipped = [];
+	for (const [name, server] of Object.entries(resolved)) {
+		if (reservedNames.has(name)) continue;
+		if (server.type === "stdio") {
+			entries[name] = {
+				type: "stdio",
+				command: server.command,
+				...server.args.length > 0 ? { args: [...server.args] } : {},
+				...Object.keys(server.env).length > 0 ? { env: { ...server.env } } : {}
+			};
+			continue;
+		}
+		if (server.type === "sse") {
+			skipped.push(name);
+			continue;
+		}
+		entries[name] = {
+			type: "http",
+			url: server.url,
+			...Object.keys(server.headers).length > 0 ? { headers: { ...server.headers } } : {}
+		};
+	}
+	return {
+		entries,
+		skipped
+	};
+}
+/**
+* The config home a CLI following the XDG convention reads, matching what the
+* spawned process would see: its own `XDG_CONFIG_HOME` when set, else
+* `~/.config` under the environment's own `HOME`.
+*/
+function resolveXdgConfigHome(environment) {
+	const configured = environment.XDG_CONFIG_HOME?.trim() ?? "";
+	if (configured.length > 0) return configured;
+	const home = environment.HOME?.trim() ?? "";
+	return `${home.length > 0 ? home : NodeOS.homedir()}/.config`;
+}
+/**
+* The settings document as this module needs to see it: the one key it owns,
+* with every other key carried through untouched, so an overlay never quietly
+* drops a model default or a TUI preference the user set.
+*/
+const MuseSettingsFile = Schema$1.StructWithRest(Schema$1.Struct({
+	schema_version: Schema$1.optional(Schema$1.Number),
+	mcpServers: Schema$1.optional(Schema$1.Unknown)
+}), [Schema$1.Record(Schema$1.String, Schema$1.Unknown)]);
+const MuseSettingsFileFromJson = Schema$1.fromJsonString(MuseSettingsFile);
+const decodeSettingsFile = Schema$1.decodeUnknownExit(MuseSettingsFileFromJson);
+const encodeSettingsFile = Schema$1.encodeSync(MuseSettingsFileFromJson);
+/** The user's settings document, or an empty one when there is nothing usable to read. */
+const readSourceSettings = Effect.fnUntraced(function* (settingsPath) {
+	const contents = yield* (yield* FileSystem.FileSystem).readFileString(settingsPath).pipe(Effect.orElseSucceed(() => void 0));
+	if (contents === void 0) return {};
+	const decoded = decodeSettingsFile(contents);
+	return decoded._tag === "Success" ? decoded.value : {};
+});
+/**
+* Prepare the overlay and return the environment a turn must add to reach it.
+*
+* Rebuilt every turn: the endpoint and the bearer token are per session, and a
+* stale settings file would point the CLI at a credential that no longer
+* authorizes anything.
+*/
+const prepareMuseConfigOverlay = Effect.fn("prepareMuseConfigOverlay")(function* (input) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const sourceMuseDir = path.join(input.sourceConfigHome, MUSE_CONFIG_DIRNAME);
+	const overlayMuseDir = path.join(input.overlayRoot, MUSE_CONFIG_DIRNAME);
+	yield* fileSystem.makeDirectory(overlayMuseDir, {
+		recursive: true,
+		mode: OVERLAY_DIRECTORY_MODE
+	});
+	yield* fileSystem.chmod(input.overlayRoot, OVERLAY_DIRECTORY_MODE).pipe(Effect.ignore);
+	yield* fileSystem.chmod(overlayMuseDir, OVERLAY_DIRECTORY_MODE).pipe(Effect.ignore);
+	const sourceEntries = yield* fileSystem.readDirectory(sourceMuseDir).pipe(Effect.orElseSucceed(() => []));
+	for (const entry of sourceEntries) {
+		if (entry === MUSE_SETTINGS_FILENAME) continue;
+		const link = path.join(overlayMuseDir, entry);
+		if (!(yield* fileSystem.readLink(link).pipe(Effect.as(true), Effect.orElseSucceed(() => false))) && (yield* fileSystem.exists(link))) continue;
+		yield* fileSystem.remove(link, {
+			recursive: true,
+			force: true
+		});
+		yield* fileSystem.symlink(path.join(sourceMuseDir, entry), link).pipe(Effect.ignore);
+	}
+	const sourceSettings = yield* readSourceSettings(path.join(sourceMuseDir, MUSE_SETTINGS_FILENAME));
+	const sourceServers = sourceSettings.mcpServers;
+	const mergedServers = typeof sourceServers === "object" && sourceServers !== null && !Array.isArray(sourceServers) ? { ...sourceServers } : {};
+	const external = toMuseMcpServers(input.externalServers ?? {}, /* @__PURE__ */ new Set([input.mcpServer.name]));
+	Object.assign(mergedServers, external.entries);
+	mergedServers[input.mcpServer.name] = {
+		type: "http",
+		url: input.mcpServer.url,
+		headers: { Authorization: input.mcpServer.authorizationHeader }
+	};
+	const settings = {
+		...sourceSettings,
+		schema_version: sourceSettings.schema_version ?? 1,
+		mcpServers: mergedServers
+	};
+	const settingsPath = path.join(overlayMuseDir, MUSE_SETTINGS_FILENAME);
+	yield* fileSystem.writeFileString(settingsPath, `${encodeSettingsFile(settings)}\n`, { mode: OVERLAY_SETTINGS_MODE });
+	yield* fileSystem.chmod(settingsPath, OVERLAY_SETTINGS_MODE).pipe(Effect.ignore);
+	return {
+		skippedServers: external.skipped,
+		environment: {
+			XDG_CONFIG_HOME: input.overlayRoot,
+			MUSE_AUTH_PATH: path.join(sourceMuseDir, MUSE_AUTH_FILENAME)
+		}
+	};
+});
+/**
+* Drop what the overlay generated, and nothing else.
+*
+* The links are P4Code's to remove; a real file under the overlay is something
+* Muse wrote during the session — a trust decision, an OAuth token — and it
+* stays, so the next session on this thread still has it. The directory goes
+* only when removing the generated file and the links leaves it empty.
+*/
+const clearMuseConfigOverlay = Effect.fn("clearMuseConfigOverlay")(function* (overlayRoot) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const overlayMuseDir = path.join(overlayRoot, MUSE_CONFIG_DIRNAME);
+	yield* fileSystem.remove(path.join(overlayMuseDir, MUSE_SETTINGS_FILENAME), { force: true }).pipe(Effect.ignore);
+	const entries = yield* fileSystem.readDirectory(overlayMuseDir).pipe(Effect.orElseSucceed(() => []));
+	for (const entry of entries) {
+		const entryPath = path.join(overlayMuseDir, entry);
+		if (!(yield* fileSystem.readLink(entryPath).pipe(Effect.as(true), Effect.orElseSucceed(() => false)))) continue;
+		yield* fileSystem.remove(entryPath, { force: true }).pipe(Effect.ignore);
+	}
+	yield* fileSystem.remove(overlayMuseDir).pipe(Effect.ignore);
+	yield* fileSystem.remove(overlayRoot).pipe(Effect.ignore);
+});
 //#endregion
 //#region src/provider/muse/MuseExecRuntime.ts
 /**
 * MuseExecRuntime — one `muse exec --json` child process per turn.
 *
-* Muse Code has no long-lived protocol surface: a turn is a process, and the
-* thread is rebuilt from the CLI's own event-sourced session log when the
-* next turn passes `--session-id`. This module owns spawning, line framing,
-* interruption, and exit classification; it knows nothing about canonical
-* runtime events.
+* On the `exec` path a turn is a process, and the thread is rebuilt from the
+* CLI's own event-sourced session log when the next turn passes
+* `--session-id`. (Muse Code 1.1.1 does have a long-lived surface —
+* `muse serve`, the MSP session host — which this driver does not use yet.)
+* This module owns spawning, line framing, interruption, and exit
+* classification; it knows nothing about canonical runtime events.
 *
 * @module provider/muse/MuseExecRuntime
 */
@@ -104473,11 +105105,12 @@ function nonNegativeInt(value) {
 *
 * Consequences that are visible to users, and deliberate:
 *
-*   - **No interactive approvals.** Headless Muse has no channel to answer an
-*     approval prompt, so the adapter runs with approval disabled and lets
-*     Muse's OS sandbox do the containing. `respondToRequest` fails rather
-*     than pretending to route a decision, and `approval-required` threads get
-*     a `config.warning`.
+*   - **No interactive approvals.** `muse exec` has no channel to answer an
+*     approval prompt — Muse Code 1.1.1 serves approvals over MSP
+*     (`muse serve`), which this adapter does not speak — so the adapter runs
+*     with approval disabled and lets Muse's OS sandbox do the containing.
+*     `respondToRequest` fails rather than pretending to route a decision, and
+*     `approval-required` threads get a `config.warning`.
 *   - **No provider-side rollback.** Muse can fork a session interactively but
 *     exposes nothing headless.
 *   - **Tool arguments are not streamed.** They exist only in the on-disk
@@ -104510,6 +105143,11 @@ function makeMuseAdapter(museSettings, options) {
 		const fileSystem = yield* FileSystem.FileSystem;
 		const path = yield* Path.Path;
 		const serverConfig = yield* Effect.service(ServerConfig$1);
+		/**
+		* Where a thread's generated Muse configuration lives. One directory per
+		* thread because the bearer token inside it is per session.
+		*/
+		const overlayRootFor = (threadId) => path.join(serverConfig.stateDir, "muse", "config", threadId);
 		const sessions = /* @__PURE__ */ new Map();
 		const runtimeEventPubSub = yield* PubSub.unbounded();
 		const nowIso = Effect.map(DateTime.now, DateTime.formatIso);
@@ -104617,14 +105255,36 @@ function makeMuseAdapter(museSettings, options) {
 			}
 			const turnId = TurnId.make(yield* randomUUIDv4);
 			const model = input.modelSelection?.model ?? ctx.session.model;
+			const reasoningEffort = input.modelSelection?.instanceId === boundInstanceId ? museReasoningEffort(getModelSelectionStringOptionValue(input.modelSelection, "reasoningEffort")) : void 0;
 			const args = buildMuseExecArgs({
 				sessionId: ctx.museSessionId,
 				prompt,
 				model,
+				reasoningEffort,
 				baseUrl: museSettings.baseUrl || void 0,
 				runtimeMode: ctx.session.runtimeMode,
 				imagePaths
 			});
+			const mcpSession = readMcpProviderSession(input.threadId);
+			const overlay = mcpSession ? yield* prepareMuseConfigOverlay({
+				overlayRoot: overlayRootFor(input.threadId),
+				sourceConfigHome: resolveXdgConfigHome(environment),
+				mcpServer: {
+					name: P4CODE_MCP_SERVER_NAME,
+					url: mcpSession.endpoint,
+					authorizationHeader: mcpSession.authorizationHeader
+				},
+				externalServers: options?.resolveMcpServers === void 0 ? {} : yield* options.resolveMcpServers
+			}).pipe(Effect.provideService(FileSystem.FileSystem, fileSystem), Effect.provideService(Path.Path, path), Effect.orElseSucceed(() => void 0)) : void 0;
+			if (overlay && overlay.skippedServers.length > 0) yield* Effect.logWarning("Muse cannot express these MCP servers", {
+				threadId: input.threadId,
+				servers: overlay.skippedServers,
+				transport: "sse"
+			});
+			const turnEnvironment = {
+				...environment,
+				...overlay?.environment
+			};
 			const state = makeMuseExecTurnState();
 			const mappingContext = {
 				provider: PROVIDER$1,
@@ -104655,54 +105315,74 @@ function makeMuseAdapter(museSettings, options) {
 				...model ? { model } : {}
 			};
 			const turnScope = yield* Scope.make();
-			const run = yield* runMuseExec({
+			let runStarted = false;
+			let settled = false;
+			let outcome;
+			/**
+			* Release everything the turn holds, exactly once, whatever ended it:
+			* a clean exit, a typed failure, a defect, or an interrupt from a
+			* stopped thread. Leaving `activeTurn` or a `running` session behind
+			* would wedge the thread — every later `sendTurn` would refuse with
+			* "a Muse turn is already running" until the server restarted — so
+			* this runs from an `ensuring` finalizer rather than the happy path.
+			*/
+			const finishTurn = Effect.suspend(() => {
+				if (settled) return Effect.void;
+				settled = true;
+				return Effect.gen(function* () {
+					ctx.activeTurn = void 0;
+					yield* Scope.close(turnScope, Exit.void);
+					if (runStarted && state.terminal === void 0) if (outcome === void 0 || outcome.kind === "interrupted") yield* publish({
+						type: "turn.aborted",
+						...yield* makeEventStamp(),
+						provider: PROVIDER$1,
+						providerInstanceId: boundInstanceId,
+						threadId: input.threadId,
+						turnId,
+						payload: { reason: "interrupted" }
+					});
+					else {
+						const detail = outcome.kind === "failed" ? outcome.stderr || `\`muse exec\` exited with code ${outcome.exitCode}.` : "`muse exec` ended without a terminal event.";
+						yield* publish({
+							type: "turn.completed",
+							...yield* makeEventStamp(),
+							provider: PROVIDER$1,
+							providerInstanceId: boundInstanceId,
+							threadId: input.threadId,
+							turnId,
+							payload: {
+								state: "failed",
+								errorMessage: detail
+							}
+						});
+					}
+					if (runStarted) yield* publishTokenUsage(ctx, turnId);
+					const updatedAt = yield* nowIso;
+					const { activeTurnId: _activeTurnId, ...readySession } = ctx.session;
+					ctx.session = {
+						...readySession,
+						status: "ready",
+						updatedAt
+					};
+				});
+			}).pipe(Effect.ignore);
+			yield* Effect.acquireUseRelease(runMuseExec({
 				threadId: input.threadId,
 				binaryPath: museSettings.binaryPath || "muse",
 				args,
 				cwd: ctx.cwd,
-				environment,
+				environment: turnEnvironment,
 				onLine: handleLine
-			}).pipe(Effect.provideService(Scope.Scope, turnScope), Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner), Effect.tapError(() => Scope.close(turnScope, Exit.void)));
-			ctx.activeTurn = {
-				turnId,
-				run,
-				state
-			};
-			const outcome = yield* run.awaitOutcome;
-			yield* Scope.close(turnScope, Exit.void);
-			ctx.activeTurn = void 0;
-			if (state.terminal === void 0) if (outcome.kind === "interrupted") yield* publish({
-				type: "turn.aborted",
-				...yield* makeEventStamp(),
-				provider: PROVIDER$1,
-				providerInstanceId: boundInstanceId,
-				threadId: input.threadId,
-				turnId,
-				payload: { reason: "interrupted" }
-			});
-			else {
-				const detail = outcome.kind === "failed" ? outcome.stderr || `\`muse exec\` exited with code ${outcome.exitCode}.` : "`muse exec` ended without a terminal event.";
-				yield* publish({
-					type: "turn.completed",
-					...yield* makeEventStamp(),
-					provider: PROVIDER$1,
-					providerInstanceId: boundInstanceId,
-					threadId: input.threadId,
+			}).pipe(Effect.provideService(Scope.Scope, turnScope), Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner), Effect.tapError(() => finishTurn), Effect.tap((run) => Effect.sync(() => {
+				runStarted = true;
+				ctx.activeTurn = {
 					turnId,
-					payload: {
-						state: "failed",
-						errorMessage: detail
-					}
-				});
-			}
-			yield* publishTokenUsage(ctx, turnId);
-			const updatedAt = yield* nowIso;
-			const { activeTurnId: _activeTurnId, ...readySession } = ctx.session;
-			ctx.session = {
-				...readySession,
-				status: "ready",
-				updatedAt
-			};
+					run,
+					state
+				};
+			}))), (run) => Effect.gen(function* () {
+				outcome = yield* run.awaitOutcome;
+			}), () => finishTurn);
 			return {
 				threadId: input.threadId,
 				turnId,
@@ -104777,6 +105457,7 @@ function makeMuseAdapter(museSettings, options) {
 				yield* ctx.activeTurn.run.interrupt.pipe(Effect.ignore);
 				ctx.activeTurn = void 0;
 			}
+			yield* clearMuseConfigOverlay(overlayRootFor(ctx.threadId)).pipe(Effect.provideService(FileSystem.FileSystem, fileSystem), Effect.provideService(Path.Path, path), Effect.ignore);
 			const updatedAt = yield* nowIso;
 			ctx.session = {
 				...ctx.session,
@@ -104831,7 +105512,17 @@ const MUSE_PRESENTATION = {
 	requiresNewThreadForModelChange: false,
 	supportedRuntimeModes: ["auto", "full-access"]
 };
-const EMPTY_CAPABILITIES = createModelCapabilities({ optionDescriptors: [] });
+const MUSE_CAPABILITIES = createModelCapabilities({ optionDescriptors: [{
+	id: "reasoningEffort",
+	label: "Reasoning",
+	type: "select",
+	options: MUSE_REASONING_EFFORTS.map((effort) => ({
+		id: effort,
+		label: effort.charAt(0).toUpperCase() + effort.slice(1),
+		...effort === "high" ? { isDefault: true } : {}
+	})),
+	currentValue: MUSE_DEFAULT_REASONING_EFFORT
+}] });
 const VERSION_PROBE_TIMEOUT_MS = 4e3;
 /** Models Meta documents for Muse Code; used until the CLI caches a catalog. */
 const MUSE_BUILT_IN_MODELS = [
@@ -104839,30 +105530,30 @@ const MUSE_BUILT_IN_MODELS = [
 		slug: "muse-spark-1.3",
 		name: "Muse Spark 1.3",
 		isCustom: false,
-		capabilities: EMPTY_CAPABILITIES
+		capabilities: MUSE_CAPABILITIES
 	},
 	{
 		slug: "muse-spark-1.3-contributor",
 		name: "Muse Spark 1.3 (contributor)",
 		isCustom: false,
 		isDefault: true,
-		capabilities: EMPTY_CAPABILITIES
+		capabilities: MUSE_CAPABILITIES
 	},
 	{
 		slug: "muse-spark-1.2",
 		name: "Muse Spark 1.2",
 		isCustom: false,
-		capabilities: EMPTY_CAPABILITIES
+		capabilities: MUSE_CAPABILITIES
 	},
 	{
 		slug: "muse-spark-1.2-contributor",
 		name: "Muse Spark 1.2 (contributor)",
 		isCustom: false,
-		capabilities: EMPTY_CAPABILITIES
+		capabilities: MUSE_CAPABILITIES
 	}
 ];
 function museModelsFromSettings(customModels, builtInModels = MUSE_BUILT_IN_MODELS) {
-	return providerModelsFromSettings(builtInModels, customModels ?? [], EMPTY_CAPABILITIES);
+	return providerModelsFromSettings(builtInModels, customModels ?? [], MUSE_CAPABILITIES);
 }
 const discoverMuseModels = Effect.fn("discoverMuseModels")(function* (environment) {
 	return (yield* readMuseModelCatalog(environment)).map((model) => ({
@@ -104870,7 +105561,7 @@ const discoverMuseModels = Effect.fn("discoverMuseModels")(function* (environmen
 		name: model.name,
 		isCustom: false,
 		...model.isDefault ? { isDefault: true } : {},
-		capabilities: EMPTY_CAPABILITIES
+		capabilities: MUSE_CAPABILITIES
 	}));
 });
 /**
@@ -105066,6 +105757,7 @@ const MuseDriver = {
 		const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
 		const fileSystem = yield* FileSystem.FileSystem;
 		const path = yield* Path.Path;
+		const serverConfig = yield* ServerConfig$1;
 		const serverSettings = yield* ServerSettingsService;
 		const processEnv = mergeProviderInstanceEnvironment(environment);
 		const continuationIdentity = defaultProviderContinuationIdentity({
@@ -105088,9 +105780,16 @@ const MuseDriver = {
 		});
 		const adapter = yield* makeMuseAdapter(effectiveConfig, {
 			environment: processEnv,
-			instanceId
+			instanceId,
+			resolveMcpServers: (yield* McpRegistry).resolveForSession
 		});
 		const textGeneration = yield* makeMuseTextGeneration(effectiveConfig, processEnv);
+		const checkProvider = serverSettings.getSettings.pipe(Effect.map((settings) => settings.disabledSkills), Effect.orElseSucceed(() => [])).pipe(Effect.flatMap((disabledSkills) => checkMuseProviderStatus(effectiveConfig, processEnv).pipe(Effect.flatMap((draft) => withProviderSkills(draft, {
+			driver: DRIVER_KIND$1,
+			cwd: serverConfig.cwd,
+			environment: processEnv,
+			disabledSkills
+		})))));
 		const snapshotSettings = makeProviderSnapshotSettingsSource(effectiveConfig, serverSettings);
 		const snapshot = yield* makeManagedServerProvider({
 			maintenanceCapabilities,
@@ -105098,7 +105797,7 @@ const MuseDriver = {
 			streamSettings: snapshotSettings.streamSettings,
 			haveSettingsChanged: haveProviderSnapshotSettingsChanged,
 			initialSnapshot: (settings) => buildInitialMuseProviderSnapshot(settings.provider).pipe(Effect.map(stampIdentity)),
-			checkProvider: checkMuseProviderStatus(effectiveConfig, processEnv).pipe(Effect.map(stampIdentity), Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner), Effect.provideService(FileSystem.FileSystem, fileSystem), Effect.provideService(Path.Path, path)),
+			checkProvider: checkProvider.pipe(Effect.map(stampIdentity), Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner), Effect.provideService(FileSystem.FileSystem, fileSystem), Effect.provideService(Path.Path, path)),
 			enrichSnapshot: ({ settings, snapshot: currentSnapshot, publishSnapshot }) => enrichMuseSnapshot({
 				snapshot: currentSnapshot,
 				maintenanceCapabilities,
@@ -106849,6 +107548,8 @@ const BUILT_IN_DRIVERS = [
 		defaultConfig: () => decodeOpenCodeSettings({}),
 		create: ({ instanceId, displayName, accentColor, environment, enabled, config }) => Effect.gen(function* () {
 			const openCodeRuntime = yield* OpenCodeRuntime;
+			const fileSystem = yield* FileSystem.FileSystem;
+			const path = yield* Path.Path;
 			const serverConfig = yield* ServerConfig$1;
 			const httpClient = yield* HttpClient.HttpClient;
 			const serverSettings = yield* ServerSettingsService;
@@ -106879,7 +107580,12 @@ const BUILT_IN_DRIVERS = [
 				...eventLoggers.native ? { nativeEventLogger: eventLoggers.native } : {}
 			});
 			const textGeneration = yield* makeOpenCodeTextGeneration(effectiveConfig, processEnv);
-			const checkProvider = checkOpenCodeProviderStatus(effectiveConfig, serverConfig.cwd, processEnv).pipe(Effect.map(stampIdentity), Effect.provideService(OpenCodeRuntime, openCodeRuntime));
+			const checkProvider = serverSettings.getSettings.pipe(Effect.map((settings) => settings.disabledSkills), Effect.orElseSucceed(() => [])).pipe(Effect.flatMap((disabledSkills) => checkOpenCodeProviderStatus(effectiveConfig, serverConfig.cwd, processEnv).pipe(Effect.flatMap((draft) => withProviderSkills(draft, {
+				driver: DRIVER_KIND,
+				cwd: serverConfig.cwd,
+				environment: processEnv,
+				disabledSkills
+			})))), Effect.map(stampIdentity), Effect.provideService(OpenCodeRuntime, openCodeRuntime), Effect.provideService(FileSystem.FileSystem, fileSystem), Effect.provideService(Path.Path, path));
 			const snapshotSettings = makeProviderSnapshotSettingsSource(effectiveConfig, serverSettings);
 			const snapshot = yield* makeManagedServerProvider({
 				maintenanceCapabilities,
@@ -111039,7 +111745,13 @@ const make$4 = Effect.gen(function* () {
 			projects: project ? [project] : [],
 			chatWorkspaceDir: serverConfig.chatWorkspaceDir
 		});
-		return [userSkillsDir, ...cwd ? [path.join(cwd, ".claude", "skills")] : []];
+		const [sharedUserDir, sharedProjectDir] = yield* sharedSkillDirectories(cwd ?? void 0);
+		return [
+			...sharedUserDir !== void 0 && sharedUserDir !== userSkillsDir ? [sharedUserDir] : [],
+			userSkillsDir,
+			...sharedProjectDir === void 0 ? [] : [sharedProjectDir],
+			...cwd ? [path.join(cwd, ".claude", "skills")] : []
+		];
 	});
 	const resolveThread = Effect.fnUntraced(function* (threadId) {
 		return yield* projectionSnapshotQuery.getThreadDetailById(threadId).pipe(Effect.map(Option.getOrUndefined));