@p4code/cli 0.1.16 → 0.1.18

package/dist/bin.mjs

@@ -233,7 +233,7 @@ const make$75 = () => {
 const layer$71 = Layer.sync(NetService, make$75);
 //#endregion
 //#region package.json
-var version = "0.1.16";
+var version = "0.1.18";
 //#endregion
 //#region src/config.ts
 /**
@@ -1509,6 +1509,7 @@ const CODEX_DRIVER_KIND = ProviderDriverKind.make("codex");
 const CLAUDE_DRIVER_KIND = ProviderDriverKind.make("claudeAgent");
 const CURSOR_DRIVER_KIND = ProviderDriverKind.make("cursor");
 const GROK_DRIVER_KIND$1 = ProviderDriverKind.make("grok");
+const MUSE_DRIVER_KIND = ProviderDriverKind.make("muse");
 const OPENCODE_DRIVER_KIND = ProviderDriverKind.make("opencode");
 const DEFAULT_MODEL = "gpt-5.6-sol";
 /**
@@ -1523,6 +1524,7 @@ const DEFAULT_MODEL_BY_PROVIDER = {
 	[CLAUDE_DRIVER_KIND]: "claude-sonnet-5",
 	[CURSOR_DRIVER_KIND]: "auto",
 	[GROK_DRIVER_KIND$1]: "grok-build",
+	[MUSE_DRIVER_KIND]: "muse-spark-1.2",
 	[OPENCODE_DRIVER_KIND]: "openai/gpt-5"
 };
 /** Per-provider text generation model defaults. */
@@ -1530,6 +1532,7 @@ const DEFAULT_TEXT_GENERATION_MODEL_BY_PROVIDER = {
 	[CODEX_DRIVER_KIND]: DEFAULT_TEXT_GENERATION_MODEL,
 	[CLAUDE_DRIVER_KIND]: "claude-haiku-4-5",
 	[CURSOR_DRIVER_KIND]: "composer-2",
+	[MUSE_DRIVER_KIND]: "muse-spark-1.2-contributor",
 	[OPENCODE_DRIVER_KIND]: "openai/gpt-5"
 };
 const MODEL_SLUG_ALIASES_BY_PROVIDER = {
@@ -4618,6 +4621,7 @@ const RuntimeEventRawSource = Schema$1.Union([
 	Schema$1.Literal("claude.sdk.permission"),
 	Schema$1.Literal("codex.sdk.thread-event"),
 	Schema$1.Literal("opencode.sdk.event"),
+	Schema$1.Literal("muse.exec.jsonl"),
 	Schema$1.Literal("acp.jsonrpc"),
 	Schema$1.TemplateLiteral([
 		"acp.",
@@ -4769,6 +4773,7 @@ Schema$1.Literals([
 	"config.warning",
 	"deprecation.notice",
 	"files.persisted",
+	"code.published",
 	"runtime.warning",
 	"runtime.error"
 ]);
@@ -4817,6 +4822,7 @@ const ModelReroutedType = Schema$1.Literal("model.rerouted");
 const ConfigWarningType = Schema$1.Literal("config.warning");
 const DeprecationNoticeType = Schema$1.Literal("deprecation.notice");
 const FilesPersistedType = Schema$1.Literal("files.persisted");
+const CodePublishedType = Schema$1.Literal("code.published");
 const ToolDeniedType = Schema$1.Literal("tool.denied");
 const RuntimeWarningType = Schema$1.Literal("runtime.warning");
 const RuntimeErrorType = Schema$1.Literal("runtime.error");
@@ -5119,6 +5125,12 @@ const FilesPersistedPayload = Schema$1.Struct({
 		error: TrimmedNonEmptyStringSchema$1
 	})))
 });
+const CodePublishedPayload = Schema$1.Struct({
+	hostingProvider: TrimmedNonEmptyStringSchema$1,
+	url: TrimmedNonEmptyStringSchema$1,
+	repo: Schema$1.optional(TrimmedNonEmptyStringSchema$1),
+	identifier: Schema$1.optional(TrimmedNonEmptyStringSchema$1)
+});
 const ToolDeniedPayload = Schema$1.Struct({
 	toolName: TrimmedNonEmptyStringSchema$1,
 	toolUseId: Schema$1.optional(TrimmedNonEmptyStringSchema$1),
@@ -5359,6 +5371,11 @@ const ProviderRuntimeFilesPersistedEvent = Schema$1.Struct({
 	type: FilesPersistedType,
 	payload: FilesPersistedPayload
 });
+const ProviderRuntimeCodePublishedEvent = Schema$1.Struct({
+	...ProviderRuntimeEventBase.fields,
+	type: CodePublishedType,
+	payload: CodePublishedPayload
+});
 const ProviderRuntimeToolDeniedEvent = Schema$1.Struct({
 	...ProviderRuntimeEventBase.fields,
 	type: ToolDeniedType,
@@ -5420,6 +5437,7 @@ Schema$1.Union([
 	ProviderRuntimeConfigWarningEvent,
 	ProviderRuntimeDeprecationNoticeEvent,
 	ProviderRuntimeFilesPersistedEvent,
+	ProviderRuntimeCodePublishedEvent,
 	ProviderRuntimeToolDeniedEvent,
 	ProviderRuntimeWarningEvent,
 	ProviderRuntimeErrorEvent
@@ -5712,6 +5730,26 @@ const GrokSettings = makeProviderSettingsSchema({
 	})),
 	customModels: Schema$1.Array(Schema$1.String).pipe(Schema$1.withDecodingDefault(Effect.succeed([])), Schema$1.annotateKey({ providerSettingsForm: { hidden: true } }))
 }, { order: ["binaryPath"] });
+const MuseSettings = makeProviderSettingsSchema({
+	enabled: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(false)), Schema$1.annotateKey({ providerSettingsForm: { hidden: true } })),
+	binaryPath: makeBinaryPathSetting("muse").pipe(Schema$1.annotateKey({
+		title: "Binary path",
+		description: "Path to the Muse Code binary.",
+		providerSettingsForm: {
+			placeholder: "muse",
+			clearWhenEmpty: "omit"
+		}
+	})),
+	baseUrl: TrimmedString.pipe(Schema$1.withDecodingDefault(Effect.succeed("")), Schema$1.annotateKey({
+		title: "Base URL",
+		description: "Override the Meta Model API base URL for this instance.",
+		providerSettingsForm: {
+			placeholder: "https://api.meta.ai/v1",
+			clearWhenEmpty: "omit"
+		}
+	})),
+	customModels: Schema$1.Array(Schema$1.String).pipe(Schema$1.withDecodingDefault(Effect.succeed([])), Schema$1.annotateKey({ providerSettingsForm: { hidden: true } }))
+}, { order: ["binaryPath", "baseUrl"] });
 const OpenCodeSettings = makeProviderSettingsSchema({
 	enabled: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true)), Schema$1.annotateKey({ providerSettingsForm: { hidden: true } })),
 	binaryPath: makeBinaryPathSetting("opencode").pipe(Schema$1.annotateKey({
@@ -5771,6 +5809,20 @@ const ServerSettings = Schema$1.Struct({
 	* back for sessions started by the Claude provider.
 	*/
 	enableToolCallNarration: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
+	/**
+	* Whether the model may spawn subagents without being asked to.
+	*
+	* On by default: a bounded search or review whose result is far smaller than
+	* the reading it takes to produce is exactly the work a subagent is for, and
+	* an agent that has to ask first will simply do it inline instead.
+	*
+	* Stated in the appended prompt whichever way it is set, rather than only
+	* when off. The provider's own preset prompt carries an instruction not to
+	* spawn subagents unless asked, and p4code requests that preset wholesale —
+	* so there is nothing to withhold, and only a later, more specific
+	* instruction can override an earlier general one.
+	*/
+	enableUnpromptedSubagents: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
 	automaticGitFetchInterval: Schema$1.DurationFromMillis.pipe(Schema$1.withDecodingDefault(Effect.succeed(Duration.toMillis(DEFAULT_AUTOMATIC_GIT_FETCH_INTERVAL)))),
 	defaultThreadEnvMode: ThreadEnvMode.pipe(Schema$1.withDecodingDefault(Effect.succeed("local"))),
 	newWorktreesStartFromOrigin: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
@@ -5822,6 +5874,7 @@ const ServerSettings = Schema$1.Struct({
 		claudeAgent: ClaudeSettings.pipe(Schema$1.withDecodingDefault(Effect.succeed({}))),
 		cursor: CursorSettings.pipe(Schema$1.withDecodingDefault(Effect.succeed({}))),
 		grok: GrokSettings.pipe(Schema$1.withDecodingDefault(Effect.succeed({}))),
+		muse: MuseSettings.pipe(Schema$1.withDecodingDefault(Effect.succeed({}))),
 		opencode: OpenCodeSettings.pipe(Schema$1.withDecodingDefault(Effect.succeed({})))
 	}).pipe(Schema$1.withDecodingDefault(Effect.succeed({}))),
 	providerInstances: Schema$1.Record(ProviderInstanceId, ProviderInstanceConfig).pipe(Schema$1.withDecodingDefault(Effect.succeed({}))),
@@ -5887,6 +5940,12 @@ const GrokSettingsPatch = Schema$1.Struct({
 	binaryPath: Schema$1.optionalKey(TrimmedString),
 	customModels: Schema$1.optionalKey(Schema$1.Array(Schema$1.String))
 });
+const MuseSettingsPatch = Schema$1.Struct({
+	enabled: Schema$1.optionalKey(Schema$1.Boolean),
+	binaryPath: Schema$1.optionalKey(TrimmedString),
+	baseUrl: Schema$1.optionalKey(TrimmedString),
+	customModels: Schema$1.optionalKey(Schema$1.Array(Schema$1.String))
+});
 const OpenCodeSettingsPatch = Schema$1.Struct({
 	enabled: Schema$1.optionalKey(Schema$1.Boolean),
 	binaryPath: Schema$1.optionalKey(TrimmedString),
@@ -5898,6 +5957,7 @@ const ServerSettingsPatch = Schema$1.Struct({
 	enableAssistantStreaming: Schema$1.optionalKey(Schema$1.Boolean),
 	enableProviderUpdateChecks: Schema$1.optionalKey(Schema$1.Boolean),
 	enableToolCallNarration: Schema$1.optionalKey(Schema$1.Boolean),
+	enableUnpromptedSubagents: Schema$1.optionalKey(Schema$1.Boolean),
 	automaticGitFetchInterval: Schema$1.optionalKey(Schema$1.DurationFromMillis),
 	defaultThreadEnvMode: Schema$1.optionalKey(ThreadEnvMode),
 	newWorktreesStartFromOrigin: Schema$1.optionalKey(Schema$1.Boolean),
@@ -5920,6 +5980,7 @@ const ServerSettingsPatch = Schema$1.Struct({
 		claudeAgent: Schema$1.optionalKey(ClaudeSettingsPatch),
 		cursor: Schema$1.optionalKey(CursorSettingsPatch),
 		grok: Schema$1.optionalKey(GrokSettingsPatch),
+		muse: Schema$1.optionalKey(MuseSettingsPatch),
 		opencode: Schema$1.optionalKey(OpenCodeSettingsPatch)
 	})),
 	providerInstances: Schema$1.optionalKey(Schema$1.Record(ProviderInstanceId, ProviderInstanceConfig))
@@ -6059,6 +6120,14 @@ const ServerProvider = Schema$1.Struct({
 	continuation: Schema$1.optional(ServerProviderContinuation),
 	showInteractionModeToggle: Schema$1.optional(Schema$1.Boolean),
 	requiresNewThreadForModelChange: Schema$1.optional(Schema$1.Boolean),
+	/**
+	* Runtime modes this provider can actually honour. Absent means every
+	* mode is available, which is the case for every provider that can ask
+	* the user for an approval mid-turn. A provider that only runs headless
+	* (Muse Code) lists the subset it can deliver, and clients disable the
+	* rest instead of offering a mode the driver would silently downgrade.
+	*/
+	supportedRuntimeModes: Schema$1.optional(Schema$1.Array(RuntimeMode)),
 	enabled: Schema$1.Boolean,
 	installed: Schema$1.Boolean,
 	version: Schema$1.NullOr(TrimmedNonEmptyString),
@@ -7780,11 +7849,17 @@ const AGENT_ASSET_TOTAL_MAX_BYTES = 4 * 1024 * 1024;
 *   directory rather than the provider's. The definition travels; the bearer
 *   tokens and API keys it references do not, and stay in each machine's own
 *   secret store.
+* - `agent` — a subagent definition, a single markdown file in
+*   `<configDir>/agents`. The name is the filename, as for `memory`. This is the
+*   only artifact that bounds what a subagent is handed and what it hands back,
+*   because p4code observes subagent runs rather than constructing their
+*   prompts — so the I/O contract can only ship as a file the provider reads.
 */
 const AgentAssetKind = Schema$1.Literals([
 	"skill",
 	"memory",
-	"mcp"
+	"mcp",
+	"agent"
 ]);
 /**
 * An asset's name, which for a skill is also its directory name.
@@ -15492,7 +15567,15 @@ function buildSkillOverrides(disabled, discovered) {
 * @module provider/Drivers/ClaudeSkills
 */
 const FRONTMATTER_PATTERN = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
-function parseSkillFrontmatter(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,
+* 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.
+*/
+function parseMarkdownFrontmatter(contents) {
 	const match = FRONTMATTER_PATTERN.exec(contents);
 	if (!match) return { kind: "missing" };
 	let parsed;
@@ -15543,6 +15626,19 @@ const resolveClaudeUserSkillsDir = Effect.fn("resolveClaudeUserSkillsDir")(funct
 	return path.join(configDirPath, "skills");
 });
 /**
+* The user-scope subagent directory the CLI would read.
+*
+* Same resolution as the skills directory beside it, for the same reason: the
+* sync materializes into exactly the directory the provider loads from, and
+* deriving it a second time is how the two come to disagree about where an
+* agent definition lives.
+*/
+const resolveClaudeUserAgentsDir = Effect.fn("resolveClaudeUserAgentsDir")(function* (config, environment, cwd) {
+	const path = yield* Path.Path;
+	const configDirPath = yield* resolveClaudeConfigDirPath(config, environment ?? process.env, cwd);
+	return path.join(configDirPath, "agents");
+});
+/**
 * Enumerate Claude Code skills from the user config dir and the workspace.
 * Discovery is best-effort: unreadable roots and malformed skill entries are
 * skipped so a broken skill never degrades the provider snapshot. On name
@@ -15567,7 +15663,7 @@ const discoverClaudeSkills = Effect.fn("discoverClaudeSkills")(function* (config
 			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 = parseSkillFrontmatter(contents);
+			const frontmatter = parseMarkdownFrontmatter(contents);
 			if (frontmatter.kind === "malformed") continue;
 			const name = (frontmatter.kind === "parsed" ? frontmatter.name : void 0) ?? entry.trim();
 			if (!name) continue;
@@ -16389,6 +16485,288 @@ const make$62 = Effect.gen(function* () {
 });
 const layer$57 = Layer.effect(McpRegistry, make$62);
 //#endregion
+//#region src/sync/skillDirectory.ts
+/**
+* Reading and writing skill directories on disk.
+*
+* Kept apart from the sync itself so the filesystem shape has its own tests,
+* and so the rules about what is refusable — binaries, oversized files, deep
+* trees — live in one place rather than being rediscovered at each call site.
+*
+* @module sync/skillDirectory
+*/
+/** Bounded so a stray symlink or a vendored `node_modules` cannot walk forever. */
+const MAX_SKILL_DEPTH = 4;
+/**
+* Entries that are never part of a skill, skipped rather than refused.
+*
+* The distinction matters. Refusing an asset because it cannot be represented
+* faithfully is right — a half-materialized skill loads and misbehaves. But a
+* `.DS_Store` is not part of the skill at all, and macOS drops one into any
+* directory that has been opened in Finder, so refusing on its account rejects
+* a perfectly good skill for a reason its author cannot see.
+*
+* These could not sync in any case: `AgentAssetFilePath` rejects a leading dot,
+* so a dotfile has no representable path even if it were text.
+*/
+const IGNORED_ENTRIES = /* @__PURE__ */ new Set([
+	".DS_Store",
+	"Thumbs.db",
+	".git",
+	".svn",
+	".hg",
+	"node_modules",
+	"__pycache__",
+	".venv",
+	".pytest_cache",
+	".ruff_cache",
+	".mypy_cache"
+]);
+/**
+* Anything else with a leading dot is skipped too — an editor's `.idea`, a
+* `.gitignore` that belongs to the checkout rather than the skill. The rule is
+* the same one the path schema already enforces, applied earlier so it reads as
+* "not part of the skill" instead of "this skill is broken".
+*/
+const isIgnoredEntry = (entry) => IGNORED_ENTRIES.has(entry) || entry.startsWith(".");
+/**
+* A file is binary if decoding it yields a NUL.
+*
+* Cheap, and right for what is being asked: the question is not "is this valid
+* UTF-8" but "can this round-trip through a JSON text column", and a NUL is
+* what actually breaks that on the way back out of SQLite.
+*
+* Exported so the single-file kinds ask it the same way this one does, rather
+* than each keeping a copy that could drift into a different answer.
+*/
+const looksBinary$1 = (content) => content.includes("\0");
+/**
+* Read one directory as an asset's files, or say why it cannot be one.
+*
+* Exported because memory's `global-memory/` is the same shape by a different
+* name: a directory whose whole contents are the asset. Sharing this keeps the
+* refusal rules — depth, file count, binaries, size — identical for both,
+* rather than letting a second copy drift into accepting what the first
+* rejects.
+*/
+const readSkillFiles = Effect.fn("skillDirectory.readSkillFiles")(function* (root) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const files = [];
+	const walk = Effect.fn("skillDirectory.walk")(function* (directory, prefix, depth) {
+		if (depth > MAX_SKILL_DEPTH) return "too-deep";
+		const entries = yield* fileSystem.readDirectory(directory).pipe(Effect.orElseSucceed(() => []));
+		for (const entry of [...entries].sort()) {
+			if (isIgnoredEntry(entry)) continue;
+			const absolute = path.join(directory, entry);
+			const relative = prefix === "" ? entry : `${prefix}/${entry}`;
+			const info = yield* fileSystem.stat(absolute).pipe(Effect.orElseSucceed(() => void 0));
+			if (info === void 0) return "unreadable";
+			if (info.type === "Directory") {
+				const nested = yield* walk(absolute, relative, depth + 1);
+				if (nested !== null) return nested;
+				continue;
+			}
+			if (info.type !== "File") continue;
+			if (files.length >= 512) return "too-many-files";
+			const content = yield* fileSystem.readFileString(absolute).pipe(Effect.orElseSucceed(() => void 0));
+			if (content === void 0) return "unreadable";
+			if (looksBinary$1(content)) return "binary-file";
+			if (content.length > 524288) return "file-too-large";
+			files.push({
+				path: relative,
+				content
+			});
+		}
+		return null;
+	});
+	const refusal = yield* walk(root, "", 1);
+	if (refusal !== null) return { refusal };
+	if (agentAssetTotalBytes(files) > 4194304) return { refusal: "asset-too-large" };
+	return { files };
+});
+/**
+* Read every skill directory under a user-scope `skills/` root.
+*
+* A directory with no `SKILL.md` is not a skill and is skipped silently —
+* Claude Code would ignore it too, so reporting it would be noise about
+* something that was never a skill in the first place.
+*/
+const readSkillDirectory = Effect.fn("skillDirectory.readSkillDirectory")(function* (skillsRoot) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const entries = yield* fileSystem.readDirectory(skillsRoot).pipe(Effect.orElseSucceed(() => []));
+	const skills = [];
+	const refused = [];
+	for (const entry of [...entries].sort()) {
+		if (isIgnoredEntry(entry)) continue;
+		const directory = path.join(skillsRoot, entry);
+		if ((yield* fileSystem.stat(directory).pipe(Effect.orElseSucceed(() => void 0)))?.type !== "Directory") continue;
+		if (!(yield* fileSystem.exists(path.join(directory, "SKILL.md")).pipe(Effect.orElseSucceed(() => false)))) continue;
+		const read = yield* readSkillFiles(directory);
+		if ("refusal" in read) {
+			refused.push({
+				name: entry,
+				reason: read.refusal
+			});
+			continue;
+		}
+		skills.push({
+			name: entry,
+			files: read.files
+		});
+	}
+	return {
+		skills,
+		refused
+	};
+});
+/**
+* Replace a skill directory with exactly the asset's files.
+*
+* Written to a sibling and then swapped, so a crash mid-write leaves the old
+* skill intact rather than half of the new one. A skill is loaded as a unit and
+* a partially written one is instructions with the middle missing, which an
+* agent will happily follow.
+*/
+const writeSkillDirectory = Effect.fn("skillDirectory.writeSkillDirectory")(function* (input) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const target = path.join(input.skillsRoot, input.name);
+	const staging = path.join(input.skillsRoot, `.${input.name}.p4code-staging`);
+	yield* fileSystem.makeDirectory(input.skillsRoot, { recursive: true });
+	yield* fileSystem.remove(staging, {
+		recursive: true,
+		force: true
+	});
+	yield* fileSystem.makeDirectory(staging, { recursive: true });
+	for (const file of input.files) {
+		const destination = path.join(staging, file.path);
+		yield* fileSystem.makeDirectory(path.dirname(destination), { recursive: true });
+		yield* fileSystem.writeFileString(destination, file.content);
+	}
+	yield* fileSystem.remove(target, {
+		recursive: true,
+		force: true
+	});
+	yield* fileSystem.rename(staging, target);
+});
+const removeSkillDirectory = Effect.fn("skillDirectory.removeSkillDirectory")(function* (input) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	yield* fileSystem.remove(path.join(input.skillsRoot, input.name), {
+		recursive: true,
+		force: true
+	});
+});
+/**
+* Whether this text is a definition the provider would actually load.
+*
+* Both fields, not just the header. `name` is how a subagent is addressed and
+* `description` is how the orchestrator decides to address it, so a definition
+* missing either is present on disk and unreachable in practice.
+*/
+const isLoadableAgentDefinition = (content) => {
+	const frontmatter = parseMarkdownFrontmatter(content);
+	return frontmatter.kind === "parsed" && frontmatter.name !== void 0 && frontmatter.description !== void 0;
+};
+/**
+* Every definition in the directory, as syncable assets.
+*
+* A file that will not load is refused rather than skipped, unlike a stray
+* `.DS_Store`: a `.md` in this directory is meant to be an agent, so a broken
+* header is a fault worth reporting instead of noise to ignore.
+*/
+const readAgentDefinitions = Effect.fn("agentDefinitionFiles.read")(function* (agentsRoot) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const entries = yield* fileSystem.readDirectory(agentsRoot).pipe(Effect.orElseSucceed(() => []));
+	const skills = [];
+	const refused = [];
+	for (const entry of [...entries].sort()) {
+		if (!entry.endsWith(".md") || entry.startsWith(".")) continue;
+		const absolute = path.join(agentsRoot, entry);
+		if ((yield* fileSystem.stat(absolute).pipe(Effect.orElseSucceed(() => void 0)))?.type !== "File") continue;
+		const content = yield* fileSystem.readFileString(absolute).pipe(Effect.orElseSucceed(() => void 0));
+		if (content === void 0) {
+			refused.push({
+				name: entry,
+				reason: "unreadable"
+			});
+			continue;
+		}
+		if (looksBinary$1(content)) {
+			refused.push({
+				name: entry,
+				reason: "binary-file"
+			});
+			continue;
+		}
+		if (content.length > 524288) {
+			refused.push({
+				name: entry,
+				reason: "file-too-large"
+			});
+			continue;
+		}
+		if (!isLoadableAgentDefinition(content)) {
+			refused.push({
+				name: entry,
+				reason: "unreadable"
+			});
+			continue;
+		}
+		const files = [{
+			path: entry,
+			content
+		}];
+		if (agentAssetTotalBytes(files) > 4194304) {
+			refused.push({
+				name: entry,
+				reason: "asset-too-large"
+			});
+			continue;
+		}
+		skills.push({
+			name: entry,
+			files
+		});
+	}
+	return {
+		skills,
+		refused
+	};
+});
+/**
+* Write a definition that arrived from the hub.
+*
+* Refused unless it is exactly one markdown file whose path is the asset's own
+* name and whose frontmatter would load. The last check is the one that matters
+* across machines: it is what stops a hub row edited by hand from installing a
+* file the provider quietly ignores on every machine that syncs it.
+*
+* Written atomically because a definition is read whole when a subagent starts,
+* and half of one is instructions with the contract missing.
+*/
+const writeAgentDefinition = Effect.fn("agentDefinitionFiles.write")(function* (input) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const file = input.files[0];
+	if (!input.name.endsWith(".md") || input.files.length !== 1 || file === void 0 || file.path !== input.name) return "refused";
+	if (!isLoadableAgentDefinition(file.content)) return "refused";
+	yield* fileSystem.makeDirectory(input.agentsRoot, { recursive: true }).pipe(Effect.ignore);
+	return yield* writeFileStringAtomically({
+		filePath: path.join(input.agentsRoot, input.name),
+		contents: file.content
+	}).pipe(Effect.as("written"), Effect.orElseSucceed(() => "failed"));
+});
+const removeAgentDefinition = Effect.fn("agentDefinitionFiles.remove")(function* (input) {
+	if (!input.name.endsWith(".md")) return;
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	yield* fileSystem.remove(path.join(input.agentsRoot, input.name), { force: true });
+});
+//#endregion
 //#region src/sync/HubLink.ts
 /**
 * Where this server's hub is, what it authenticates with, and whether it syncs
@@ -16762,178 +17140,6 @@ const removeMcpRegistration = Effect.fn("mcpRegistrationFiles.remove")(function*
 	yield* fileSystem.remove(path.join(input.registrationsRoot, input.name), { force: true });
 });
 //#endregion
-//#region src/sync/skillDirectory.ts
-/**
-* Reading and writing skill directories on disk.
-*
-* Kept apart from the sync itself so the filesystem shape has its own tests,
-* and so the rules about what is refusable — binaries, oversized files, deep
-* trees — live in one place rather than being rediscovered at each call site.
-*
-* @module sync/skillDirectory
-*/
-/** Bounded so a stray symlink or a vendored `node_modules` cannot walk forever. */
-const MAX_SKILL_DEPTH = 4;
-/**
-* Entries that are never part of a skill, skipped rather than refused.
-*
-* The distinction matters. Refusing an asset because it cannot be represented
-* faithfully is right — a half-materialized skill loads and misbehaves. But a
-* `.DS_Store` is not part of the skill at all, and macOS drops one into any
-* directory that has been opened in Finder, so refusing on its account rejects
-* a perfectly good skill for a reason its author cannot see.
-*
-* These could not sync in any case: `AgentAssetFilePath` rejects a leading dot,
-* so a dotfile has no representable path even if it were text.
-*/
-const IGNORED_ENTRIES = /* @__PURE__ */ new Set([
-	".DS_Store",
-	"Thumbs.db",
-	".git",
-	".svn",
-	".hg",
-	"node_modules",
-	"__pycache__",
-	".venv",
-	".pytest_cache",
-	".ruff_cache",
-	".mypy_cache"
-]);
-/**
-* Anything else with a leading dot is skipped too — an editor's `.idea`, a
-* `.gitignore` that belongs to the checkout rather than the skill. The rule is
-* the same one the path schema already enforces, applied earlier so it reads as
-* "not part of the skill" instead of "this skill is broken".
-*/
-const isIgnoredEntry = (entry) => IGNORED_ENTRIES.has(entry) || entry.startsWith(".");
-/**
-* A file is binary if decoding it yields a NUL.
-*
-* Cheap, and right for what is being asked: the question is not "is this valid
-* UTF-8" but "can this round-trip through a JSON text column", and a NUL is
-* what actually breaks that on the way back out of SQLite.
-*/
-const looksBinary$1 = (content) => content.includes("\0");
-/**
-* Read one directory as an asset's files, or say why it cannot be one.
-*
-* Exported because memory's `global-memory/` is the same shape by a different
-* name: a directory whose whole contents are the asset. Sharing this keeps the
-* refusal rules — depth, file count, binaries, size — identical for both,
-* rather than letting a second copy drift into accepting what the first
-* rejects.
-*/
-const readSkillFiles = Effect.fn("skillDirectory.readSkillFiles")(function* (root) {
-	const fileSystem = yield* FileSystem.FileSystem;
-	const path = yield* Path.Path;
-	const files = [];
-	const walk = Effect.fn("skillDirectory.walk")(function* (directory, prefix, depth) {
-		if (depth > MAX_SKILL_DEPTH) return "too-deep";
-		const entries = yield* fileSystem.readDirectory(directory).pipe(Effect.orElseSucceed(() => []));
-		for (const entry of [...entries].sort()) {
-			if (isIgnoredEntry(entry)) continue;
-			const absolute = path.join(directory, entry);
-			const relative = prefix === "" ? entry : `${prefix}/${entry}`;
-			const info = yield* fileSystem.stat(absolute).pipe(Effect.orElseSucceed(() => void 0));
-			if (info === void 0) return "unreadable";
-			if (info.type === "Directory") {
-				const nested = yield* walk(absolute, relative, depth + 1);
-				if (nested !== null) return nested;
-				continue;
-			}
-			if (info.type !== "File") continue;
-			if (files.length >= 512) return "too-many-files";
-			const content = yield* fileSystem.readFileString(absolute).pipe(Effect.orElseSucceed(() => void 0));
-			if (content === void 0) return "unreadable";
-			if (looksBinary$1(content)) return "binary-file";
-			if (content.length > 524288) return "file-too-large";
-			files.push({
-				path: relative,
-				content
-			});
-		}
-		return null;
-	});
-	const refusal = yield* walk(root, "", 1);
-	if (refusal !== null) return { refusal };
-	if (agentAssetTotalBytes(files) > 4194304) return { refusal: "asset-too-large" };
-	return { files };
-});
-/**
-* Read every skill directory under a user-scope `skills/` root.
-*
-* A directory with no `SKILL.md` is not a skill and is skipped silently —
-* Claude Code would ignore it too, so reporting it would be noise about
-* something that was never a skill in the first place.
-*/
-const readSkillDirectory = Effect.fn("skillDirectory.readSkillDirectory")(function* (skillsRoot) {
-	const fileSystem = yield* FileSystem.FileSystem;
-	const path = yield* Path.Path;
-	const entries = yield* fileSystem.readDirectory(skillsRoot).pipe(Effect.orElseSucceed(() => []));
-	const skills = [];
-	const refused = [];
-	for (const entry of [...entries].sort()) {
-		if (isIgnoredEntry(entry)) continue;
-		const directory = path.join(skillsRoot, entry);
-		if ((yield* fileSystem.stat(directory).pipe(Effect.orElseSucceed(() => void 0)))?.type !== "Directory") continue;
-		if (!(yield* fileSystem.exists(path.join(directory, "SKILL.md")).pipe(Effect.orElseSucceed(() => false)))) continue;
-		const read = yield* readSkillFiles(directory);
-		if ("refusal" in read) {
-			refused.push({
-				name: entry,
-				reason: read.refusal
-			});
-			continue;
-		}
-		skills.push({
-			name: entry,
-			files: read.files
-		});
-	}
-	return {
-		skills,
-		refused
-	};
-});
-/**
-* Replace a skill directory with exactly the asset's files.
-*
-* Written to a sibling and then swapped, so a crash mid-write leaves the old
-* skill intact rather than half of the new one. A skill is loaded as a unit and
-* a partially written one is instructions with the middle missing, which an
-* agent will happily follow.
-*/
-const writeSkillDirectory = Effect.fn("skillDirectory.writeSkillDirectory")(function* (input) {
-	const fileSystem = yield* FileSystem.FileSystem;
-	const path = yield* Path.Path;
-	const target = path.join(input.skillsRoot, input.name);
-	const staging = path.join(input.skillsRoot, `.${input.name}.p4code-staging`);
-	yield* fileSystem.makeDirectory(input.skillsRoot, { recursive: true });
-	yield* fileSystem.remove(staging, {
-		recursive: true,
-		force: true
-	});
-	yield* fileSystem.makeDirectory(staging, { recursive: true });
-	for (const file of input.files) {
-		const destination = path.join(staging, file.path);
-		yield* fileSystem.makeDirectory(path.dirname(destination), { recursive: true });
-		yield* fileSystem.writeFileString(destination, file.content);
-	}
-	yield* fileSystem.remove(target, {
-		recursive: true,
-		force: true
-	});
-	yield* fileSystem.rename(staging, target);
-});
-const removeSkillDirectory = Effect.fn("skillDirectory.removeSkillDirectory")(function* (input) {
-	const fileSystem = yield* FileSystem.FileSystem;
-	const path = yield* Path.Path;
-	yield* fileSystem.remove(path.join(input.skillsRoot, input.name), {
-		recursive: true,
-		force: true
-	});
-});
-//#endregion
 //#region src/sync/memoryFile.ts
 /**
 * Reading and writing user-scope memory files.
@@ -17214,12 +17420,20 @@ const PROCEED = { _tag: "proceed" };
 * - A skill without `SKILL.md` would be invisible to discovery: the picker
 *   skips directories without one, so the create would look like it silently
 *   failed. Refused with the reason instead.
+* - An agent definition is one markdown file whose name is the asset's own, and
+*   anything else is invisible in the same way — the provider reads `.md` in
+*   that directory and nothing else. The frontmatter check is the writer's,
+*   because it needs a YAML parse this module deliberately does without.
 * - An existing local name is never overwritten. Create means create; editing
 *   is a different operation with a different surface.
 */
 function decideCreateLocal(input) {
 	if (input.asset.kind === "mcp") return refuse("refused", "MCP registrations are created through mcp.save, not as files.");
 	if (input.asset.kind === "skill" && !input.asset.files.some((file) => file.path === "SKILL.md")) return refuse("refused", "A skill needs a SKILL.md at its root; without one, discovery skips the directory.");
+	if (input.asset.kind === "agent") {
+		const [file, ...rest] = input.asset.files;
+		if (!input.asset.name.endsWith(".md") || rest.length > 0 || file?.path !== input.asset.name) return refuse("refused", "An agent definition is a single markdown file named after the asset, for example 'reviewer.md' holding 'reviewer.md'.");
+	}
 	if (input.localNames.has(input.asset.name)) return refuse("exists", `An asset named '${input.asset.name}' already exists locally.`);
 	return PROCEED;
 }
@@ -17462,6 +17676,22 @@ const make$59 = Effect.gen(function* () {
 				name
 			}).pipe(Effect.ignore)
 		},
+		{
+			kind: "agent",
+			resolveRoot: Effect.gen(function* () {
+				return yield* resolveClaudeUserAgentsDir(yield* claudeHome());
+			}),
+			read: (root) => readAgentDefinitions(root),
+			write: ({ root, name, files }) => writeAgentDefinition({
+				agentsRoot: root,
+				name,
+				files
+			}),
+			remove: ({ root, name }) => removeAgentDefinition({
+				agentsRoot: root,
+				name
+			}).pipe(Effect.ignore)
+		},
 		{
 			kind: "mcp",
 			resolveRoot: Effect.succeed(path.join(config.stateDir, "mcp")),
@@ -18103,6 +18333,262 @@ const make$59 = Effect.gen(function* () {
 });
 const layer$54 = Layer.effect(AssetSync, make$59);
 //#endregion
+//#region src/provider/CompressPrompts.ts
+/**
+* Caveman-style response compression rulesets, adapted from the caveman
+* plugin's SKILL.md. Pre-baked per level so injection is a lookup, not a
+* runtime template. Applies to assistant prose only: code blocks, commits,
+* PRs, error strings, and safety-critical text stay uncompressed.
+*/
+const COMPRESS_SHARED_RULES = `Respond terse. All technical substance stays. Only fluff dies.
+
+## Persistence
+
+Active every response. No revert after many turns. No filler drift. Still active if unsure.
+
+## Rules
+
+Drop filler (just/really/basically/actually/simply), pleasantries (sure/certainly/of course/happy to), hedging. Short synonyms (big not extensive, fix not "implement a solution for"). No decorative tables/emoji, no dumping long raw error logs unless asked - quote shortest decisive line. Standard well-known tech acronyms OK (DB/API/HTTP); never invent new abbreviations (cfg/impl/req/res/fn) - tokenizers split them same as the full word: zero tokens saved, reader still decodes. No causal arrows (->) in prose. Technical terms exact. Code blocks unchanged. Errors quoted exact.
+
+Never drop not/never/no/only/except: flipping the meaning costs more than any token saved. Numbers and units exact.
+
+Tool calls: fire direct. No plan, no progress note between calls, never announce the next call. If the harness asks for a short lead-in before tool calls, write that one line and nothing more. Otherwise text before a call only to clarify, warn about a security or irreversible action, or resolve ambiguity.
+
+Preserve the user's dominant language: reply in the language the user writes, whatever language the examples or the surrounding context use. Compress the style, not the language. Every emitted line in that language, lead-in lines included, not just the final reply. Always keep technical terms, code, API names, CLI commands, commit-type keywords (feat/fix/...), and exact error strings verbatim unless the user explicitly asks for translation.
+
+Dropping articles applies to article languages only. Where small markers carry case or role (particles, postpositions), keep them: grammar, not filler. Compress politeness and filler instead.
+
+No self-reference. Never name or announce the style. No compressed answer plus normal recap - compressed output only. Exception: user explicitly asks what the mode is.
+
+## Auto-Clarity
+
+Drop compression and write normally when:
+- Security warnings
+- Irreversible action confirmations
+- Multi-step sequences where fragment order or omitted conjunctions risk misread
+- Compression itself creates technical ambiguity (e.g. "migrate table drop column backup first" - order unclear without articles and conjunctions)
+- User asks to clarify or repeats a question
+
+Resume compression after the clear part is done. The example below shows the format only: write the warning in the session's language, not the example's.
+
+Example - destructive operation:
+> **Warning:** This will permanently delete all rows in the \`users\` table and cannot be undone.
+> \`\`\`sql
+> DROP TABLE users;
+> \`\`\`
+> Compression resumes. Verify a backup exists first.
+
+## Boundaries
+
+Anything persisted outside the chat: write normal, uncompressed prose. Covers code, code comments, commit messages, PR and issue text, docs, memory files, and messages to third parties.`;
+const COMPRESS_RULESETS = {
+	lite: `## Response compression: lite
+
+${COMPRESS_SHARED_RULES}
+
+## Intensity: lite
+
+No filler or hedging. Keep articles and full sentences. Professional but tight.
+
+Example - "Why does my React component re-render?"
+"Your component re-renders because you create a new object reference each render. Wrap it in \`useMemo\`."
+
+Example - "Explain database connection pooling."
+"Connection pooling reuses open connections instead of creating a new one per request. Avoids repeated handshake overhead."`,
+	full: `## Response compression: full
+
+${COMPRESS_SHARED_RULES}
+
+## Intensity: full
+
+Drop articles (a/an/the), fragments OK, short synonyms. Pattern: [thing] [action] [reason]. [next step].
+
+Not: "Sure! I'd be happy to help you with that. The issue you're experiencing is likely caused by..."
+Yes: "Bug in auth middleware. Token expiry check use \`<\` not \`<=\`. Fix:"
+
+Example - "Why does my React component re-render?"
+"New object ref each render. Inline object prop = new ref = re-render. Wrap in \`useMemo\`."
+
+Example - "Explain database connection pooling."
+"Pool reuses open DB connections. No new connection per request. Skips handshake overhead."`,
+	ultra: `## Response compression: ultra
+
+${COMPRESS_SHARED_RULES}
+
+## Intensity: ultra
+
+Drop articles, fragments OK, short synonyms. Also strip conjunctions when cause-then-effect stays unambiguous. One word when one word is enough. State each fact once. Still no invented abbreviations (cfg/impl/req/res/fn/auth) and still no arrows (X -> Y): both measure as zero token saving and cost decode clarity. Code symbols, function names, API names, error strings: never touch.
+
+Example - "Why does my React component re-render?"
+"Inline object prop, new ref, re-render. \`useMemo\`."
+
+Example - "Explain database connection pooling."
+"Pool reuses open DB connections. No per-request handshake."`
+};
+const COMPRESS_TURN_REMINDERS = {
+	lite: "[response style: compressed lite - no filler/hedging, full sentences; keep negations and numbers exact; code/commits/security text normal]",
+	full: "[response style: compressed full - terse fragments, drop articles/filler; keep negations and numbers exact; code/commits/security text normal]",
+	ultra: "[response style: compressed ultra - maximum terseness, one word when enough; keep negations and numbers exact; code/commits/security text normal]"
+};
+function compressRulesetFor(mode) {
+	return mode === "off" ? void 0 : COMPRESS_RULESETS[mode];
+}
+function compressTurnReminderFor(mode) {
+	return mode === "off" ? void 0 : COMPRESS_TURN_REMINDERS[mode];
+}
+//#endregion
+//#region src/sync/agentPresets.ts
+/**
+* The row ceiling both presets impose.
+*
+* A cap rather than "be brief": an uncapped list is how a subagent turns a
+* bounded answer back into a page, and a number is the only form of that
+* instruction a model cannot negotiate with.
+*/
+const PRESET_MAX_RESULT_ROWS = 20;
+/**
+* Named `p4-*` on purpose.
+*
+* The directory is shared with whatever the user has written by hand, and
+* installing a preset must never quietly replace their own `reviewer`. The
+* prefix also makes provenance obvious in the settings list, where every kind
+* of agent definition appears in one column.
+*/
+const PRESET_NAME_PREFIX = "p4-";
+/**
+* What every preset says about what it is handed.
+*
+* Shared because it is the same contract whatever the subagent does: no
+* inherited history, exact paths, and a refusal instead of a guess. The last
+* clause is the one that earns its place — a subagent that invents the missing
+* half of an under-specified prompt returns something confident and wrong,
+* which costs more than the turn that asked for it.
+*/
+const INPUT_CONTRACT = `## What you are given
+
+You inherit no session history. The prompt is the whole of what you know: one
+request, plus whatever exact paths the orchestrator has already established.
+Treat those paths as authoritative and start from them rather than searching for
+them again.
+
+What the prompt does not say, you do not assume. If it names no request, or
+names a path that is not there, answer with the BLOCKED line below. Guessing at
+the missing half of a request produces an answer that reads as confident and is
+not checkable, which is worse than no answer.`;
+/**
+* What every preset says about the answer.
+*
+* The two sentinels matter as much as the table. Without `NONE` a clean run
+* comes back as a paragraph explaining that everything looked fine; without
+* `BLOCKED` an under-specified request comes back as an apology. Both are the
+* narrative this contract exists to remove, and both are cheap to name.
+*/
+const outputContract = (row, extra) => [
+	"## What you return",
+	"",
+	"Your final message is the result. It is the table and nothing else: no",
+	"preamble, no restatement of the request, no summary underneath it.",
+	"",
+	`One row per finding, at most ${PRESET_MAX_RESULT_ROWS}, most important first:`,
+	"",
+	`    ${row}`,
+	"",
+	"Nothing to report: the single word NONE.",
+	"Request insufficient: BLOCKED - <what is missing>, on one line.",
+	"",
+	"Paths are repository-relative and carry a line number. A row without one is",
+	"a row you have not verified: open the file and get it.",
+	...extra
+].join("\n");
+/**
+* Assemble one definition.
+*
+* The compression ruleset goes last so the contract above it is read first.
+* Both are instructions to the same model and neither overrides the other:
+* the contract fixes the shape, the ruleset fixes the prose inside it.
+*/
+const buildPreset = (input) => {
+	const name = `${PRESET_NAME_PREFIX}${input.name}`;
+	const content = [
+		"---",
+		`name: ${name}`,
+		`description: ${JSON.stringify(input.description)}`,
+		`tools: ${input.tools}`,
+		"---",
+		"",
+		input.body.trim(),
+		"",
+		compressRulesetFor("full") ?? "",
+		""
+	].join("\n");
+	const fileName = `${name}.md`;
+	return {
+		name: fileName,
+		summary: input.summary,
+		files: [{
+			path: fileName,
+			content
+		}]
+	};
+};
+/** Every preset, in the order `p4c agents presets` lists them. */
+const AGENT_PRESETS = [buildPreset({
+	name: "investigator",
+	description: "Find where something lives in the codebase. Use when the answer is a set of locations rather than a change. Returns a fixed table of path:line rows and nothing else.",
+	tools: "Read, Grep, Glob, Bash",
+	summary: "Locates code and answers with a path:line table.",
+	body: `You locate code. You do not change it, and you say no more about any location
+than the one clause that explains why it is in the list.
+
+${INPUT_CONTRACT}
+
+${outputContract("path:line - symbol - one clause on why it matters", [
+		"",
+		"Symbol is the function, type or constant the line belongs to, not a paraphrase",
+		"of the line. Where there is genuinely no symbol, name the block: a route table,",
+		"a config literal."
+	])}`
+}), buildPreset({
+	name: "reviewer",
+	description: "Review named files or a diff for defects. Use when the answer is a list of findings rather than a change. Returns a fixed table of path:line findings and nothing else.",
+	tools: "Read, Grep, Glob, Bash",
+	summary: "Reviews named files and answers with a severity-tagged finding table.",
+	body: `You review code you did not write. You do not change it, and you do not report
+what it does well - the orchestrator asked what is wrong, and a list padded with
+approval is a list that has to be re-read to find the three rows that matter.
+
+${INPUT_CONTRACT}
+
+${outputContract("path:line - severity - what is wrong, and what it breaks", [
+		"",
+		"Severity is one of three words:",
+		"",
+		"    bug   - wrong behaviour reachable in ordinary use. Name the input that reaches it.",
+		"    risk  - correct today, and depends on something the code does not state.",
+		"    nit   - style or clarity. Include only when the file is otherwise clean.",
+		"",
+		"A finding you cannot reach with a concrete input is a risk, not a bug. Saying",
+		"so is what keeps the bug rows worth reading."
+	])}`
+})];
+/**
+* Look one up by the name someone typed.
+*
+* Both spellings are accepted - `investigator` and `p4-investigator.md` - because
+* the listing shows the filename and the sentence people write is the bare word,
+* and refusing one of the two would be refusing whichever the person happened to
+* read most recently.
+*/
+const findAgentPreset = (requested) => {
+	const wanted = requested.trim().toLowerCase();
+	if (wanted.length === 0) return void 0;
+	return AGENT_PRESETS.find((preset) => {
+		const fileName = preset.name.toLowerCase();
+		const bare = fileName.slice(3, -3);
+		return wanted === fileName || wanted === bare || wanted === `${PRESET_NAME_PREFIX}${bare}`;
+	});
+};
+//#endregion
 //#region src/cli/assets.ts
 const SyncServicesLive = layer$54.pipe(Layer.provideMerge(layer$55), Layer.provideMerge(layer$56), Layer.provideMerge(layer$60.pipe(Layer.provide(layer$67))), Layer.provideMerge(layer$67), Layer.provideMerge(FetchHttpClient.layer));
 const runWithSync = (flags, run) => Effect.gen(function* () {
@@ -18146,6 +18632,14 @@ const MCP_WORDS = {
 	rootLabel: "MCP",
 	nameDescription: "Registration filename, for example linear.json."
 };
+const AGENT_WORDS = {
+	kind: "agent",
+	command: "agents",
+	singular: "agent definition",
+	plural: "agent definitions",
+	rootLabel: "Agents",
+	nameDescription: "Definition filename, for example p4-reviewer.md."
+};
 const rootFor = (status, kind) => status.roots.find((root) => root.kind === kind)?.path ?? null;
 /**
 * Exported for tests. These two are the only place a wrong report becomes a
@@ -18208,7 +18702,8 @@ const formatReport = (report) => {
 const ALL_WORDS = [
 	SKILL_WORDS,
 	MEMORY_WORDS,
-	MCP_WORDS
+	MCP_WORDS,
+	AGENT_WORDS
 ];
 /**
 * The whole picture, in one page.
@@ -18340,6 +18835,67 @@ const makeAssetCommands = (words) => {
 const skillCommands = makeAssetCommands(SKILL_WORDS);
 const memoryCommands = makeAssetCommands(MEMORY_WORDS);
 const mcpCommands = makeAssetCommands(MCP_WORDS);
+const agentCommands = makeAssetCommands(AGENT_WORDS);
+/**
+* What one install attempt did, in a sentence.
+*
+* Exported for tests: `exists` in particular must never read as success. The
+* whole point of refusing to overwrite is that someone who has edited a preset
+* keeps their edits, and a line saying "installed" would tell them the opposite.
+*/
+const formatPresetInstall = (input) => {
+	if (input.outcome === "created") return `Installed ${input.name}${input.path === null ? "" : ` at ${input.path}`}`;
+	if (input.outcome === "exists") return `Skipped ${input.name}: it already exists here, and installing would overwrite your copy.`;
+	return `Could not install ${input.name}: ${input.detail ?? input.outcome}`;
+};
+/**
+* `p4c agents presets` — what is on offer, before anything is written.
+*
+* Its own command rather than a flag on `install`, because reading the list is
+* what people do first and a listing that requires naming an install target is
+* not a listing.
+*/
+const presetsCommand = Command.make("presets", { ...authLocationFlags }).pipe(Command.withDescription("List the agent definitions p4code ships, without installing any."), Command.withHandler(() => Console.log([
+	...AGENT_PRESETS.map((preset) => `  ${preset.name.padEnd(28)} ${preset.summary}`),
+	"",
+	"Install one with:  p4c agents install <name>"
+].join("\n"))));
+/**
+* Install a shipped definition onto this machine, and only this machine.
+*
+* `createLocal` rather than a hub write, so an installed preset starts out
+* exactly like one written by hand: local, unmanaged, and shared only when
+* something explicitly publishes it. It also means this works with no hub
+* configured, which is when a fresh machine most wants it.
+*/
+const presetInstallCommand = Command.make("install", {
+	...authLocationFlags,
+	name: Argument.string("name").pipe(Argument.withDescription("Preset to install, for example investigator."), Argument.optional),
+	all: Flag.boolean("all").pipe(Flag.withDescription("Install every preset p4code ships."))
+}).pipe(Command.withDescription("Install a p4code agent definition into this machine's agents directory."), Command.withHandler((flags) => runWithSync(flags, ({ sync }) => Effect.gen(function* () {
+	const requested = Option.getOrUndefined(flags.name);
+	if (!flags.all && requested === void 0) return yield* Console.error("Name a preset, or pass --all to install every one.\nSee them with:  p4c agents presets");
+	const chosen = flags.all ? AGENT_PRESETS : (() => {
+		const found = findAgentPreset(requested ?? "");
+		return found === void 0 ? [] : [found];
+	})();
+	if (chosen.length === 0) return yield* Console.error(`No preset named ${requested ?? ""}. See them with:  p4c agents presets`);
+	const lines = [];
+	for (const preset of chosen) {
+		const result = yield* sync.createLocal({
+			kind: AGENT_WORDS.kind,
+			name: preset.name,
+			files: preset.files
+		});
+		lines.push(formatPresetInstall({
+			name: preset.name,
+			outcome: result.outcome,
+			path: result.path,
+			detail: result.detail
+		}));
+	}
+	return yield* Console.log(lines.join("\n"));
+}))));
 const shareAllCommand = Command.make("share-all", { ...authLocationFlags }).pipe(Command.withDescription("Share everything, including new items, automatically. The default."), Command.withHandler((flags) => runWithSync(flags, ({ sync, link }) => Effect.gen(function* () {
 	yield* link.setShareMode("all");
 	yield* Console.log(formatStatus(yield* sync.status));
@@ -18392,6 +18948,23 @@ const mcpCommand = Command.make("mcp", {}).pipe(Command.withDescription("Share M
 	mcpCommands.showCommand,
 	mcpCommands.removeCommand
 ]));
+/**
+* `p4c agents` — the subagent definitions this machine runs.
+*
+* The same six subcommands every kind gets, plus the two that are particular to
+* this one: p4code ships definitions, and a definition is the only place a
+* subagent's input and output contract can be stated.
+*/
+const agentsCommand = Command.make("agents", {}).pipe(Command.withDescription("Share subagent definitions across your machines, and install p4code's."), Command.withSubcommands([
+	agentCommands.statusCommand,
+	agentCommands.syncCommand,
+	agentCommands.publishCommand,
+	agentCommands.unpublishCommand,
+	agentCommands.showCommand,
+	agentCommands.removeCommand,
+	presetsCommand,
+	presetInstallCommand
+]));
 /** Exported for the hub command, which owns `connect`/`disconnect`. */
 const hubLinkCommands = [hubConnectCommand, hubDisconnectCommand];
 //#endregion
@@ -45796,12 +46369,12 @@ function decodeProviderDriverKind(providerName, operation) {
 		cause
 	})));
 }
-function isRecord$3(value) {
+function isRecord$5(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function mergeRuntimePayload(existing, next) {
 	if (next === void 0) return existing ?? null;
-	if (isRecord$3(existing) && isRecord$3(next)) return {
+	if (isRecord$5(existing) && isRecord$5(next)) return {
 		...existing,
 		...next
 	};
@@ -47066,6 +47639,7 @@ function buildServerProvider(input) {
 		...input.presentation.badgeLabel ? { badgeLabel: input.presentation.badgeLabel } : {},
 		...typeof input.presentation.showInteractionModeToggle === "boolean" ? { showInteractionModeToggle: input.presentation.showInteractionModeToggle } : {},
 		...typeof input.presentation.requiresNewThreadForModelChange === "boolean" ? { requiresNewThreadForModelChange: input.presentation.requiresNewThreadForModelChange } : {},
+		...input.presentation.supportedRuntimeModes ? { supportedRuntimeModes: input.presentation.supportedRuntimeModes } : {},
 		enabled: input.enabled,
 		installed: input.probe.installed,
 		version: input.probe.version,
@@ -47522,7 +48096,7 @@ var OpenCodeRuntime = class extends Context.Service()("@p4code/cli/provider/open
 const OpenCodeRuntimeLive = Layer.effect(OpenCodeRuntime, makeOpenCodeRuntime).pipe(Layer.provide(layer$71));
 //#endregion
 //#region src/textGeneration/TextGenerationUtils.ts
-const isTextGenerationError$2 = Schema$1.is(TextGenerationError);
+const isTextGenerationError$3 = Schema$1.is(TextGenerationError);
 /** Convert an Effect Schema to a flat JSON Schema object, inlining `$defs` when present. */
 function toJsonSchemaObject(schema) {
 	const document = Schema$1.toJsonSchemaDocument(schema);
@@ -47567,7 +48141,7 @@ function cliLabel(cliName) {
 * and Claude (and future providers) can share the same logic.
 */
 function normalizeCliError(cliName, operation, error, fallback) {
-	if (isTextGenerationError$2(error)) return error;
+	if (isTextGenerationError$3(error)) return error;
 	if (error instanceof Error) {
 		const lower = error.message.toLowerCase();
 		if (error.message.includes(`Command not found: ${cliName}`) || lower.includes(`spawn ${cliName}`) || lower.includes("enoent")) return new TextGenerationError({
@@ -49003,88 +49577,6 @@ function formatAskUserQuestionAnswers(answers) {
 	return formatted;
 }
 //#endregion
-//#region src/provider/CompressPrompts.ts
-/**
-* Caveman-style response compression rulesets, adapted from the caveman
-* plugin's SKILL.md. Pre-baked per level so injection is a lookup, not a
-* runtime template. Applies to assistant prose only: code blocks, commits,
-* PRs, error strings, and safety-critical text stay uncompressed.
-*/
-const COMPRESS_SHARED_RULES = `Respond terse. All technical substance stays. Only fluff dies.
-
-## Persistence
-
-Active every response. No revert after many turns. No filler drift. Still active if unsure.
-
-## Rules
-
-Drop filler (just/really/basically/actually/simply), pleasantries (sure/certainly/of course/happy to), hedging. Short synonyms (big not extensive, fix not "implement a solution for"). No tool-call narration, no decorative tables/emoji, no dumping long raw error logs unless asked - quote shortest decisive line. Standard well-known tech acronyms OK (DB/API/HTTP); never invent new abbreviations (cfg/impl/req/res/fn) - tokenizers split them same as the full word: zero tokens saved, reader still decodes. No causal arrows (->) in prose. Technical terms exact. Code blocks unchanged. Errors quoted exact.
-
-Preserve the user's dominant language: compress the style, not the language. Always keep technical terms, code, API names, CLI commands, commit-type keywords (feat/fix/...), and exact error strings verbatim unless the user explicitly asks for translation.
-
-No self-reference. Never name or announce the style. No compressed answer plus normal recap - compressed output only. Exception: user explicitly asks what the mode is.
-
-## Auto-Clarity
-
-Drop compression and write normally when:
-- Security warnings
-- Irreversible action confirmations
-- Multi-step sequences where fragment order or omitted conjunctions risk misread
-- Compression itself creates technical ambiguity
-- User asks to clarify or repeats a question
-
-Resume compression after the clear part is done.
-
-## Boundaries
-
-Code, commit messages, and PR descriptions: write normal, uncompressed.`;
-const COMPRESS_RULESETS = {
-	lite: `## Response compression: lite
-
-${COMPRESS_SHARED_RULES}
-
-## Intensity: lite
-
-No filler or hedging. Keep articles and full sentences. Professional but tight.
-
-Example - "Why does my React component re-render?"
-"Your component re-renders because you create a new object reference each render. Wrap it in \`useMemo\`."`,
-	full: `## Response compression: full
-
-${COMPRESS_SHARED_RULES}
-
-## Intensity: full
-
-Drop articles (a/an/the), fragments OK, short synonyms. Pattern: [thing] [action] [reason]. [next step].
-
-Not: "Sure! I'd be happy to help you with that. The issue you're experiencing is likely caused by..."
-Yes: "Bug in auth middleware. Token expiry check use \`<\` not \`<=\`. Fix:"
-
-Example - "Why does my React component re-render?"
-"New object ref each render. Inline object prop = new ref = re-render. Wrap in \`useMemo\`."`,
-	ultra: `## Response compression: ultra
-
-${COMPRESS_SHARED_RULES}
-
-## Intensity: ultra
-
-Drop articles, fragments OK, short synonyms. Also strip conjunctions when cause-then-effect stays unambiguous. One word when one word is enough. State each fact once. Code symbols, function names, API names, error strings: never touch.
-
-Example - "Why does my React component re-render?"
-"Inline object prop, new ref, re-render. \`useMemo\`."`
-};
-const COMPRESS_TURN_REMINDERS = {
-	lite: "[response style: compressed lite - no filler/hedging, full sentences; code/commits/security text normal]",
-	full: "[response style: compressed full - terse fragments, drop articles/filler; code/commits/security text normal]",
-	ultra: "[response style: compressed ultra - maximum terseness, one word when enough; code/commits/security text normal]"
-};
-function compressRulesetFor(mode) {
-	return mode === "off" ? void 0 : COMPRESS_RULESETS[mode];
-}
-function compressTurnReminderFor(mode) {
-	return mode === "off" ? void 0 : COMPRESS_TURN_REMINDERS[mode];
-}
-//#endregion
 //#region src/provider/Layers/ClaudeAdapter.ts
 /**
 * ClaudeAdapterLive - Scoped live implementation for the Claude Agent provider adapter.
@@ -49096,7 +49588,7 @@ function compressTurnReminderFor(mode) {
 */
 const encodeUnknownJsonStringExit$2 = Schema$1.encodeUnknownExit(Schema$1.UnknownFromJsonString);
 const decodeUnknownJsonStringExit = Schema$1.decodeUnknownExit(Schema$1.UnknownFromJsonString);
-const PROVIDER$5 = ProviderDriverKind.make("claudeAgent");
+const PROVIDER$6 = ProviderDriverKind.make("claudeAgent");
 function encodeJsonStringForDiagnostics$2(input) {
 	const result = encodeUnknownJsonStringExit$2(input);
 	return Exit.isSuccess(result) ? result.value : void 0;
@@ -49646,6 +50138,20 @@ const SUPPORTED_CLAUDE_IMAGE_MIME_TYPES = /* @__PURE__ */ new Set([
 /** Emitted by the CLI but absent from the SDK's `SDKMessage` union. */
 const UNTYPED_COMMAND_LIFECYCLE_MESSAGE = "command_lifecycle";
 const NARRATE_BEFORE_TOOLS_PROMPT = "Before your first tool call in a turn, write one short sentence saying what you are about to do. Keep it to a single line and skip it when you are answering without tools.";
+/**
+* Said whichever way the setting is set, and said as an override.
+*
+* The preset system prompt this adapter requests already carries an
+* instruction not to spawn subagents unless the user asked — and a preset is
+* taken wholesale, so there is no version of it with that line removed. An
+* append that merely stayed silent when subagents are allowed would therefore
+* leave the restriction standing, which is the one outcome the setting exists
+* to change. Both texts name the earlier instruction they replace, because a
+* later instruction that does not acknowledge the conflict reads as an
+* accident rather than a decision.
+*/
+const SUBAGENTS_ALLOWED_PROMPT = "You may spawn subagents with the Task tool whenever it helps, without asking the user first. This overrides any earlier instruction to use subagents only when they are requested. Prefer one for bounded search or review work whose result is much smaller than the reading it takes to produce; do the work inline when the answer is a single file or a single edit.";
+const SUBAGENTS_ON_REQUEST_PROMPT = "Do not spawn subagents with the Task tool unless the user asks for one. This overrides any earlier instruction permitting them on your own initiative. Do the work inline instead, and say so if it would have been better delegated.";
 const CLAUDE_SETTING_SOURCES = [
 	"user",
 	"project",
@@ -49704,7 +50210,7 @@ const buildUserMessageEffect = Effect.fn("buildUserMessageEffect")(function* (in
 	for (const attachment of input.attachments ?? []) {
 		if (attachment.type !== "image") continue;
 		if (!SUPPORTED_CLAUDE_IMAGE_MIME_TYPES.has(attachment.mimeType)) return yield* new ProviderAdapterRequestError({
-			provider: PROVIDER$5,
+			provider: PROVIDER$6,
 			method: "turn/start",
 			detail: `Unsupported Claude image attachment type '${attachment.mimeType}'.`
 		});
@@ -49713,12 +50219,12 @@ const buildUserMessageEffect = Effect.fn("buildUserMessageEffect")(function* (in
 			attachment
 		});
 		if (!attachmentPath) return yield* new ProviderAdapterRequestError({
-			provider: PROVIDER$5,
+			provider: PROVIDER$6,
 			method: "turn/start",
 			detail: `Invalid attachment id '${attachment.id}'.`
 		});
 		const bytes = yield* dependencies.fileSystem.readFile(attachmentPath).pipe(Effect.mapError((cause) => new ProviderAdapterRequestError({
-			provider: PROVIDER$5,
+			provider: PROVIDER$6,
 			method: "turn/start",
 			detail: "Failed to read attachment file.",
 			cause
@@ -49816,12 +50322,12 @@ function toolResultBlocksFromUserMessage(message) {
 function toSessionError(threadId, cause) {
 	const normalized = toMessage(cause, "").toLowerCase();
 	if (normalized.includes("unknown session") || normalized.includes("not found")) return new ProviderAdapterSessionNotFoundError({
-		provider: PROVIDER$5,
+		provider: PROVIDER$6,
 		threadId,
 		cause
 	});
 	if (normalized.includes("closed")) return new ProviderAdapterSessionClosedError({
-		provider: PROVIDER$5,
+		provider: PROVIDER$6,
 		threadId,
 		cause
 	});
@@ -49830,7 +50336,7 @@ function toRequestError$1(threadId, method, cause) {
 	const sessionError = toSessionError(threadId, cause);
 	if (sessionError) return sessionError;
 	return new ProviderAdapterRequestError({
-		provider: PROVIDER$5,
+		provider: PROVIDER$6,
 		method,
 		detail: `${method} failed`,
 		cause
@@ -49874,6 +50380,25 @@ function sdkNativeMethod(message) {
 *   would only duplicate a refresh that has already happened.
 */
 const CONSUMED_UNDECLARED_SYSTEM_SUBTYPES = /* @__PURE__ */ new Set(["background_tasks_changed", "vcs_state_changed"]);
+/**
+* Another undeclared-but-real subtype, emitted once the CLI has pushed the
+* turn's changes to a hosting provider:
+* `{provider: "github", url: "https://github.com/org/repo/pull/96",
+*   repo: "org/repo", identifier: "96"}`. Mapped to `code.published` so the
+* work log links the pull request instead of logging an unknown-subtype
+* warning.
+*/
+const CODE_CHANGE_PUBLISHED_SUBTYPE = "code_change_published";
+function codePublishedPayloadFromSdkMessage(message) {
+	const record = message;
+	if (typeof record.url !== "string" || record.url.length === 0) return;
+	return {
+		hostingProvider: typeof record.provider === "string" && record.provider.length > 0 ? record.provider : "unknown",
+		url: record.url,
+		...typeof record.repo === "string" && record.repo.length > 0 ? { repo: record.repo } : {},
+		...typeof record.identifier === "string" && record.identifier.length > 0 ? { identifier: record.identifier } : {}
+	};
+}
 const SDK_MESSAGE_NOISE_KEYS = /* @__PURE__ */ new Set([
 	"type",
 	"subtype",
@@ -49930,7 +50455,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 	const runtimeEventQueue = yield* Queue.unbounded();
 	const nowIso = Effect.map(DateTime.now, DateTime.formatIso);
 	const randomUUIDv4 = crypto.randomUUIDv4.pipe(Effect.mapError((cause) => new ProviderAdapterRequestError({
-		provider: PROVIDER$5,
+		provider: PROVIDER$6,
 		method: "crypto/randomUUIDv4",
 		detail: "Failed to generate Claude runtime identifier.",
 		cause
@@ -49950,7 +50475,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			event: {
 				id: "uuid" in message && typeof message.uuid === "string" ? message.uuid : yield* randomUUIDv4,
 				kind: "notification",
-				provider: PROVIDER$5,
+				provider: PROVIDER$6,
 				createdAt: observedAt,
 				method: sdkNativeMethod(message),
 				...typeof message.session_id === "string" ? { providerThreadId: message.session_id } : {},
@@ -49963,7 +50488,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 	const snapshotThread = Effect.fn("snapshotThread")(function* (context) {
 		const threadId = context.session.threadId;
 		if (!threadId) return yield* new ProviderAdapterValidationError({
-			provider: PROVIDER$5,
+			provider: PROVIDER$6,
 			operation: "readThread",
 			issue: "Session thread id is not initialized yet."
 		});
@@ -50036,7 +50561,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			yield* offerRuntimeEvent({
 				type: "content.delta",
 				eventId: deltaStamp.eventId,
-				provider: PROVIDER$5,
+				provider: PROVIDER$6,
 				createdAt: deltaStamp.createdAt,
 				threadId: context.session.threadId,
 				turnId: turnState.turnId,
@@ -50059,7 +50584,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 		yield* offerRuntimeEvent({
 			type: "item.completed",
 			eventId: stamp.eventId,
-			provider: PROVIDER$5,
+			provider: PROVIDER$6,
 			createdAt: stamp.createdAt,
 			itemId: asRuntimeItemId$1(block.itemId),
 			threadId: context.session.threadId,
@@ -50113,7 +50638,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			yield* offerRuntimeEvent({
 				type: "thread.started",
 				eventId: stamp.eventId,
-				provider: PROVIDER$5,
+				provider: PROVIDER$6,
 				createdAt: stamp.createdAt,
 				threadId: context.session.threadId,
 				payload: { providerThreadId: nextThreadId },
@@ -50133,7 +50658,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 		yield* offerRuntimeEvent({
 			type: "runtime.error",
 			eventId: stamp.eventId,
-			provider: PROVIDER$5,
+			provider: PROVIDER$6,
 			createdAt: stamp.createdAt,
 			threadId: context.session.threadId,
 			...turnState ? { turnId: asCanonicalTurnId(turnState.turnId) } : {},
@@ -50151,7 +50676,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 		yield* offerRuntimeEvent({
 			type: "runtime.warning",
 			eventId: stamp.eventId,
-			provider: PROVIDER$5,
+			provider: PROVIDER$6,
 			createdAt: stamp.createdAt,
 			threadId: context.session.threadId,
 			...turnState ? { turnId: asCanonicalTurnId(turnState.turnId) } : {},
@@ -50171,7 +50696,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 		yield* offerRuntimeEvent({
 			type: "thread.token-usage.updated",
 			eventId: stamp.eventId,
-			provider: PROVIDER$5,
+			provider: PROVIDER$6,
 			createdAt: stamp.createdAt,
 			threadId: context.session.threadId,
 			...turnState ? { turnId: turnState.turnId } : {},
@@ -50224,7 +50749,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 		yield* offerRuntimeEvent({
 			type: "turn.proposed.completed",
 			eventId: stamp.eventId,
-			provider: PROVIDER$5,
+			provider: PROVIDER$6,
 			createdAt: stamp.createdAt,
 			threadId: context.session.threadId,
 			turnId: turnState.turnId,
@@ -50244,7 +50769,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 		yield* offerRuntimeEvent({
 			type: "turn.plan.updated",
 			eventId: stamp.eventId,
-			provider: PROVIDER$5,
+			provider: PROVIDER$6,
 			createdAt: stamp.createdAt,
 			threadId: context.session.threadId,
 			...context.turnState ? { turnId: asCanonicalTurnId(context.turnState.turnId) } : {},
@@ -50292,7 +50817,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			yield* offerRuntimeEvent({
 				type: "turn.completed",
 				eventId: stamp.eventId,
-				provider: PROVIDER$5,
+				provider: PROVIDER$6,
 				createdAt: stamp.createdAt,
 				threadId: context.session.threadId,
 				payload: {
@@ -50312,7 +50837,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			yield* offerRuntimeEvent({
 				type: "item.completed",
 				eventId: toolStamp.eventId,
-				provider: PROVIDER$5,
+				provider: PROVIDER$6,
 				createdAt: toolStamp.createdAt,
 				threadId: context.session.threadId,
 				turnId: turnState.turnId,
@@ -50355,7 +50880,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 		yield* offerRuntimeEvent({
 			type: "turn.completed",
 			eventId: stamp.eventId,
-			provider: PROVIDER$5,
+			provider: PROVIDER$6,
 			createdAt: stamp.createdAt,
 			threadId: context.session.threadId,
 			turnId: turnState.turnId,
@@ -50429,7 +50954,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 		yield* offerRuntimeEvent({
 			type: "turn.started",
 			eventId: turnStartedStamp.eventId,
-			provider: PROVIDER$5,
+			provider: PROVIDER$6,
 			createdAt: turnStartedStamp.createdAt,
 			threadId: context.session.threadId,
 			turnId,
@@ -50509,7 +51034,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 				yield* offerRuntimeEvent({
 					type: "content.delta",
 					eventId: stamp.eventId,
-					provider: PROVIDER$5,
+					provider: PROVIDER$6,
 					createdAt: stamp.createdAt,
 					threadId: context.session.threadId,
 					turnId: context.turnState.turnId,
@@ -50553,7 +51078,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 				yield* offerRuntimeEvent({
 					type: "item.updated",
 					eventId: stamp.eventId,
-					provider: PROVIDER$5,
+					provider: PROVIDER$6,
 					createdAt: stamp.createdAt,
 					threadId: context.session.threadId,
 					...context.turnState ? { turnId: asCanonicalTurnId(context.turnState.turnId) } : {},
@@ -50583,7 +51108,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 						yield* offerRuntimeEvent({
 							type: "turn.plan.updated",
 							eventId: planStamp.eventId,
-							provider: PROVIDER$5,
+							provider: PROVIDER$6,
 							createdAt: planStamp.createdAt,
 							threadId: context.session.threadId,
 							...context.turnState ? { turnId: asCanonicalTurnId(context.turnState.turnId) } : {},
@@ -50623,7 +51148,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			yield* offerRuntimeEvent({
 				type: "item.started",
 				eventId: stamp.eventId,
-				provider: PROVIDER$5,
+				provider: PROVIDER$6,
 				createdAt: stamp.createdAt,
 				threadId: context.session.threadId,
 				...context.turnState ? { turnId: asCanonicalTurnId(context.turnState.turnId) } : {},
@@ -50681,7 +51206,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			yield* offerRuntimeEvent({
 				type: "item.updated",
 				eventId: updatedStamp.eventId,
-				provider: PROVIDER$5,
+				provider: PROVIDER$6,
 				createdAt: updatedStamp.createdAt,
 				threadId: context.session.threadId,
 				...context.turnState ? { turnId: asCanonicalTurnId(context.turnState.turnId) } : {},
@@ -50706,7 +51231,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 				yield* offerRuntimeEvent({
 					type: "content.delta",
 					eventId: deltaStamp.eventId,
-					provider: PROVIDER$5,
+					provider: PROVIDER$6,
 					createdAt: deltaStamp.createdAt,
 					threadId: context.session.threadId,
 					turnId: context.turnState.turnId,
@@ -50727,7 +51252,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			yield* offerRuntimeEvent({
 				type: "item.completed",
 				eventId: completedStamp.eventId,
-				provider: PROVIDER$5,
+				provider: PROVIDER$6,
 				createdAt: completedStamp.createdAt,
 				threadId: context.session.threadId,
 				...context.turnState ? { turnId: asCanonicalTurnId(context.turnState.turnId) } : {},
@@ -50779,7 +51304,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			yield* offerRuntimeEvent({
 				type: "turn.started",
 				eventId: turnStartedStamp.eventId,
-				provider: PROVIDER$5,
+				provider: PROVIDER$6,
 				createdAt: turnStartedStamp.createdAt,
 				threadId: context.session.threadId,
 				turnId,
@@ -50832,7 +51357,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 		const stamp = yield* makeEventStamp();
 		const base = {
 			eventId: stamp.eventId,
-			provider: PROVIDER$5,
+			provider: PROVIDER$6,
 			createdAt: stamp.createdAt,
 			threadId: context.session.threadId,
 			...context.turnState ? { turnId: asCanonicalTurnId(context.turnState.turnId) } : {},
@@ -50845,6 +51370,17 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			}
 		};
 		if (CONSUMED_UNDECLARED_SYSTEM_SUBTYPES.has(message.subtype)) return;
+		if (message.subtype === CODE_CHANGE_PUBLISHED_SUBTYPE) {
+			const published = codePublishedPayloadFromSdkMessage(message);
+			if (published) {
+				yield* offerRuntimeEvent({
+					...base,
+					type: "code.published",
+					payload: published
+				});
+				return;
+			}
+		}
 		switch (message.subtype) {
 			case "init":
 				yield* offerRuntimeEvent({
@@ -51035,7 +51571,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 		const stamp = yield* makeEventStamp();
 		const base = {
 			eventId: stamp.eventId,
-			provider: PROVIDER$5,
+			provider: PROVIDER$6,
 			createdAt: stamp.createdAt,
 			threadId: context.session.threadId,
 			...context.turnState ? { turnId: asCanonicalTurnId(context.turnState.turnId) } : {},
@@ -51125,12 +51661,12 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 		}
 	});
 	const runSdkStream = (context) => Stream.fromAsyncIterable(context.query, (cause) => new ProviderAdapterProcessError({
-		provider: PROVIDER$5,
+		provider: PROVIDER$6,
 		threadId: context.session.threadId,
 		detail: "Claude runtime stream failed.",
 		cause
 	})).pipe(Stream.takeWhile(() => !context.stopped), Stream.runForEach((message) => handleSdkMessage(context, message).pipe(Effect.mapError((cause) => new ProviderAdapterProcessError({
-		provider: PROVIDER$5,
+		provider: PROVIDER$6,
 		threadId: context.session.threadId,
 		detail: "Failed to process Claude runtime event.",
 		cause
@@ -51160,7 +51696,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			yield* offerRuntimeEvent({
 				type: "request.resolved",
 				eventId: stamp.eventId,
-				provider: PROVIDER$5,
+				provider: PROVIDER$6,
 				createdAt: stamp.createdAt,
 				threadId: context.session.threadId,
 				...context.turnState ? { turnId: asCanonicalTurnId(context.turnState.turnId) } : {},
@@ -51181,7 +51717,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 		yield* Effect.try({
 			try: () => context.query.close(),
 			catch: (cause) => new ProviderAdapterProcessError({
-				provider: PROVIDER$5,
+				provider: PROVIDER$6,
 				threadId: context.session.threadId,
 				detail: "Failed to close Claude runtime query.",
 				cause
@@ -51204,7 +51740,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			yield* offerRuntimeEvent({
 				type: "session.exited",
 				eventId: stamp.eventId,
-				provider: PROVIDER$5,
+				provider: PROVIDER$6,
 				createdAt: stamp.createdAt,
 				threadId: context.session.threadId,
 				payload: {
@@ -51219,20 +51755,20 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 	const requireSession = (threadId) => {
 		const context = sessions.get(threadId);
 		if (!context) return Effect.fail(new ProviderAdapterSessionNotFoundError({
-			provider: PROVIDER$5,
+			provider: PROVIDER$6,
 			threadId
 		}));
 		if (context.stopped || context.session.status === "closed") return Effect.fail(new ProviderAdapterSessionClosedError({
-			provider: PROVIDER$5,
+			provider: PROVIDER$6,
 			threadId
 		}));
 		return Effect.succeed(context);
 	};
 	const startSession = Effect.fn("startSession")(function* (input) {
-		if (input.provider !== void 0 && input.provider !== PROVIDER$5) return yield* new ProviderAdapterValidationError({
-			provider: PROVIDER$5,
+		if (input.provider !== void 0 && input.provider !== PROVIDER$6) return yield* new ProviderAdapterValidationError({
+			provider: PROVIDER$6,
 			operation: "startSession",
-			issue: `Expected provider '${PROVIDER$5}' but received '${input.provider}'.`
+			issue: `Expected provider '${PROVIDER$6}' but received '${input.provider}'.`
 		});
 		const existingContext = sessions.get(input.threadId);
 		if (existingContext) {
@@ -51288,7 +51824,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			yield* offerRuntimeEvent({
 				type: "user-input.requested",
 				eventId: requestedStamp.eventId,
-				provider: PROVIDER$5,
+				provider: PROVIDER$6,
 				createdAt: requestedStamp.createdAt,
 				threadId: context.session.threadId,
 				...context.turnState ? { turnId: asCanonicalTurnId(context.turnState.turnId) } : {},
@@ -51318,7 +51854,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			yield* offerRuntimeEvent({
 				type: "user-input.resolved",
 				eventId: resolvedStamp.eventId,
-				provider: PROVIDER$5,
+				provider: PROVIDER$6,
 				createdAt: resolvedStamp.createdAt,
 				threadId: context.session.threadId,
 				...context.turnState ? { turnId: asCanonicalTurnId(context.turnState.turnId) } : {},
@@ -51385,7 +51921,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			yield* offerRuntimeEvent({
 				type: "request.opened",
 				eventId: requestedStamp.eventId,
-				provider: PROVIDER$5,
+				provider: PROVIDER$6,
 				createdAt: requestedStamp.createdAt,
 				threadId: context.session.threadId,
 				...context.turnState ? { turnId: asCanonicalTurnId(context.turnState.turnId) } : {},
@@ -51422,7 +51958,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			yield* offerRuntimeEvent({
 				type: "request.resolved",
 				eventId: resolvedStamp.eventId,
-				provider: PROVIDER$5,
+				provider: PROVIDER$6,
 				createdAt: resolvedStamp.createdAt,
 				threadId: context.session.threadId,
 				...context.turnState ? { turnId: asCanonicalTurnId(context.turnState.turnId) } : {},
@@ -51479,8 +52015,13 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 		const mcpSession = readMcpProviderSession(input.threadId);
 		const externalMcpServers = options?.resolveMcpServers === void 0 ? {} : yield* options.resolveMcpServers;
 		const narrateBeforeTools = options?.resolveToolCallNarration === void 0 ? DEFAULT_SERVER_SETTINGS.enableToolCallNarration : yield* options.resolveToolCallNarration;
+		const unpromptedSubagents = options?.resolveUnpromptedSubagents === void 0 ? DEFAULT_SERVER_SETTINGS.enableUnpromptedSubagents : yield* options.resolveUnpromptedSubagents;
 		const compressRuleset = compressRulesetFor(input.compressMode ?? "off");
-		const systemPromptAppend = [...narrateBeforeTools ? [NARRATE_BEFORE_TOOLS_PROMPT] : [], ...compressRuleset !== void 0 ? [compressRuleset] : []].join("\n\n");
+		const systemPromptAppend = [
+			...narrateBeforeTools ? [NARRATE_BEFORE_TOOLS_PROMPT] : [],
+			unpromptedSubagents ? SUBAGENTS_ALLOWED_PROMPT : SUBAGENTS_ON_REQUEST_PROMPT,
+			...compressRuleset !== void 0 ? [compressRuleset] : []
+		].join("\n\n");
 		const queryOptions = {
 			...input.cwd ? { cwd: input.cwd } : {},
 			...apiModelId ? { model: apiModelId } : {},
@@ -51512,7 +52053,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			} } : {}
 		};
 		yield* Effect.annotateCurrentSpan({
-			"provider.kind": PROVIDER$5,
+			"provider.kind": PROVIDER$6,
 			"provider.thread_id": threadId,
 			"provider.runtime_mode": input.runtimeMode,
 			"claude.resume.source": existingResumeSessionId !== void 0 ? "resume-session" : "generated-session",
@@ -51541,7 +52082,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 				options: queryOptions
 			}),
 			catch: (cause) => new ProviderAdapterProcessError({
-				provider: PROVIDER$5,
+				provider: PROVIDER$6,
 				threadId,
 				detail: "Failed to start Claude runtime session.",
 				cause
@@ -51549,7 +52090,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 		});
 		const session = {
 			threadId,
-			provider: PROVIDER$5,
+			provider: PROVIDER$6,
 			providerInstanceId: boundInstanceId,
 			status: "ready",
 			runtimeMode: input.runtimeMode,
@@ -51596,7 +52137,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 		yield* offerRuntimeEvent({
 			type: "session.started",
 			eventId: sessionStartedStamp.eventId,
-			provider: PROVIDER$5,
+			provider: PROVIDER$6,
 			createdAt: sessionStartedStamp.createdAt,
 			threadId,
 			payload: input.resumeCursor !== void 0 ? { resume: input.resumeCursor } : {},
@@ -51606,7 +52147,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 		yield* offerRuntimeEvent({
 			type: "session.configured",
 			eventId: configuredStamp.eventId,
-			provider: PROVIDER$5,
+			provider: PROVIDER$6,
 			createdAt: configuredStamp.createdAt,
 			threadId,
 			payload: { config: {
@@ -51622,7 +52163,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 		yield* offerRuntimeEvent({
 			type: "session.state.changed",
 			eventId: readyStamp.eventId,
-			provider: PROVIDER$5,
+			provider: PROVIDER$6,
 			createdAt: readyStamp.createdAt,
 			threadId,
 			payload: { state: "ready" },
@@ -51703,7 +52244,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 		const context = yield* requireSession(threadId);
 		const pending = context.pendingApprovals.get(requestId);
 		if (!pending) return yield* new ProviderAdapterRequestError({
-			provider: PROVIDER$5,
+			provider: PROVIDER$6,
 			method: "item/requestApproval/decision",
 			detail: `Unknown pending approval request: ${requestId}`
 		});
@@ -51714,7 +52255,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 		const context = yield* requireSession(threadId);
 		const pending = context.pendingUserInputs.get(requestId);
 		if (!pending) return yield* new ProviderAdapterRequestError({
-			provider: PROVIDER$5,
+			provider: PROVIDER$6,
 			method: "item/tool/respondToUserInput",
 			detail: `Unknown pending user-input request: ${requestId}`
 		});
@@ -51733,7 +52274,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 	const stopAll = () => Effect.forEach(sessions, ([, context]) => stopSessionInternal(context, { emitExitEvent: true }), { discard: true });
 	yield* Effect.addFinalizer(() => Effect.forEach(sessions, ([, context]) => stopSessionInternal(context, { emitExitEvent: false }), { discard: true }).pipe(Effect.catch((cause) => Effect.logError("Failed to emit Claude session shutdown event.", { cause })), Effect.tap(() => Queue.shutdown(runtimeEventQueue))));
 	return {
-		provider: PROVIDER$5,
+		provider: PROVIDER$6,
 		capabilities: { sessionModelSwitch: "in-session" },
 		startSession,
 		sendTurn,
@@ -51877,15 +52418,15 @@ function makeProviderSnapshotSettingsSource(provider, serverSettings) {
 * @module provider/Drivers/ClaudeDriver
 */
 const decodeClaudeSettings = Schema$1.decodeSync(ClaudeSettings);
-const DRIVER_KIND$4 = ProviderDriverKind.make("claudeAgent");
-const SNAPSHOT_REFRESH_INTERVAL$4 = Duration.minutes(5);
+const DRIVER_KIND$5 = ProviderDriverKind.make("claudeAgent");
+const SNAPSHOT_REFRESH_INTERVAL$5 = Duration.minutes(5);
 const CAPABILITIES_PROBE_TTL = Duration.minutes(5);
 function isClaudeNativeCommandPath(commandPath) {
 	const normalized = normalizeCommandPath(commandPath);
 	return normalized.endsWith("/.local/bin/claude") || normalized.endsWith("/.local/bin/claude.exe") || normalized.includes("/.local/share/claude/");
 }
-const UPDATE$4 = makePackageManagedProviderMaintenanceResolver({
-	provider: DRIVER_KIND$4,
+const UPDATE$5 = makePackageManagedProviderMaintenanceResolver({
+	provider: DRIVER_KIND$5,
 	npmPackageName: "@anthropic-ai/claude-code",
 	homebrewFormula: "claude-code",
 	nativeUpdate: {
@@ -51895,16 +52436,16 @@ const UPDATE$4 = makePackageManagedProviderMaintenanceResolver({
 		isCommandPath: isClaudeNativeCommandPath
 	}
 });
-const withInstanceIdentity$4 = (input) => (snapshot) => ({
+const withInstanceIdentity$5 = (input) => (snapshot) => ({
 	...snapshot,
 	instanceId: input.instanceId,
-	driver: DRIVER_KIND$4,
+	driver: DRIVER_KIND$5,
 	...input.displayName ? { displayName: input.displayName } : {},
 	...input.accentColor ? { accentColor: input.accentColor } : {},
 	continuation: { groupKey: input.continuationGroupKey }
 });
 const ClaudeDriver = {
-	driverKind: DRIVER_KIND$4,
+	driverKind: DRIVER_KIND$5,
 	metadata: {
 		displayName: "Claude",
 		supportsMultipleInstances: true
@@ -51921,19 +52462,19 @@ const ClaudeDriver = {
 		const eventLoggers = yield* ProviderEventLoggers;
 		const processEnv = mergeProviderInstanceEnvironment(environment);
 		const fallbackContinuationIdentity = defaultProviderContinuationIdentity({
-			driverKind: DRIVER_KIND$4,
+			driverKind: DRIVER_KIND$5,
 			instanceId
 		});
 		const effectiveConfig = {
 			...config,
 			enabled
 		};
-		const maintenanceCapabilities = yield* resolveProviderMaintenanceCapabilitiesEffect(UPDATE$4, {
+		const maintenanceCapabilities = yield* resolveProviderMaintenanceCapabilitiesEffect(UPDATE$5, {
 			binaryPath: effectiveConfig.binaryPath,
 			env: processEnv
 		});
 		const continuationGroupKey = yield* makeClaudeContinuationGroupKey(effectiveConfig);
-		const stampIdentity = withInstanceIdentity$4({
+		const stampIdentity = withInstanceIdentity$5({
 			instanceId,
 			displayName,
 			accentColor,
@@ -51942,12 +52483,14 @@ const ClaudeDriver = {
 		const mcpRegistry = yield* McpRegistry;
 		const resolveDisabledSkills = serverSettings.getSettings.pipe(Effect.map((settings) => settings.disabledSkills), Effect.orElseSucceed(() => []));
 		const resolveToolCallNarration = serverSettings.getSettings.pipe(Effect.map((settings) => settings.enableToolCallNarration), Effect.orElseSucceed(() => DEFAULT_SERVER_SETTINGS.enableToolCallNarration));
+		const resolveUnpromptedSubagents = serverSettings.getSettings.pipe(Effect.map((settings) => settings.enableUnpromptedSubagents), Effect.orElseSucceed(() => DEFAULT_SERVER_SETTINGS.enableUnpromptedSubagents));
 		const adapter = yield* makeClaudeAdapter(effectiveConfig, {
 			instanceId,
 			environment: processEnv,
 			resolveMcpServers: mcpRegistry.resolveForSession,
 			resolveDisabledSkills,
 			resolveToolCallNarration,
+			resolveUnpromptedSubagents,
 			...eventLoggers.native ? { nativeEventLogger: eventLoggers.native } : {}
 		});
 		const textGeneration = yield* makeClaudeTextGeneration(effectiveConfig, processEnv);
@@ -51967,16 +52510,16 @@ const ClaudeDriver = {
 			initialSnapshot: (settings) => makePendingClaudeProvider(settings.provider).pipe(Effect.map(stampIdentity)),
 			checkProvider,
 			enrichSnapshot: ({ settings, snapshot, publishSnapshot }) => enrichProviderSnapshotWithVersionAdvisory(snapshot, maintenanceCapabilities, { enableProviderUpdateChecks: settings.enableProviderUpdateChecks }).pipe(Effect.provideService(HttpClient.HttpClient, httpClient), Effect.flatMap((enrichedSnapshot) => publishSnapshot(enrichedSnapshot))),
-			refreshInterval: SNAPSHOT_REFRESH_INTERVAL$4
+			refreshInterval: SNAPSHOT_REFRESH_INTERVAL$5
 		}).pipe(Effect.mapError((cause) => new ProviderDriverError({
-			driver: DRIVER_KIND$4,
+			driver: DRIVER_KIND$5,
 			instanceId,
 			detail: `Failed to build Claude snapshot: ${cause.message ?? String(cause)}`,
 			cause
 		})));
 		return {
 			instanceId,
-			driverKind: DRIVER_KIND$4,
+			driverKind: DRIVER_KIND$5,
 			continuationIdentity: {
 				...fallbackContinuationIdentity,
 				continuationKey: continuationGroupKey
@@ -70810,7 +71353,7 @@ function buildCodexDeveloperInstructions(interactionMode, runtime, compressMode)
 //#endregion
 //#region src/provider/Layers/CodexSessionRuntime.ts
 const decodeV2TurnStartResponse = Schema$1.decodeUnknownEffect(V2TurnStartResponse);
-const PROVIDER$4 = ProviderDriverKind.make("codex");
+const PROVIDER$5 = ProviderDriverKind.make("codex");
 const ANSI_ESCAPE_REGEX = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
 const CODEX_STDERR_LOG_REGEX = /^\d{4}-\d{2}-\d{2}T\S+\s+(TRACE|DEBUG|INFO|WARN|ERROR)\s+\S+:\s+(.*)$/;
 const BENIGN_ERROR_LOG_SNIPPETS = ["state db missing rollout path for thread", "state db record_discrepancy: find_thread_path_by_id_str_in_subdir, falling_back"];
@@ -71162,7 +71705,7 @@ const makeCodexSessionRuntime = (options) => Effect.gen(function* () {
 	})));
 	const sessionCreatedAt = yield* nowIso;
 	const initialSession = {
-		provider: PROVIDER$4,
+		provider: PROVIDER$5,
 		...options.providerInstanceId ? { providerInstanceId: options.providerInstanceId } : {},
 		status: "connecting",
 		runtimeMode: options.runtimeMode,
@@ -71179,7 +71722,7 @@ const makeCodexSessionRuntime = (options) => Effect.gen(function* () {
 		const id = yield* randomUUIDv4("provider-event");
 		return yield* offerEvent({
 			id: EventId.make(id),
-			provider: PROVIDER$4,
+			provider: PROVIDER$5,
 			...options.providerInstanceId ? { providerInstanceId: options.providerInstanceId } : {},
 			createdAt: yield* nowIso,
 			...event
@@ -71584,20 +72127,20 @@ const isCodexAppServerProcessExitedError = Schema$1.is(CodexAppServerProcessExit
 const isCodexAppServerTransportError = Schema$1.is(CodexAppServerTransportError);
 const isCodexSessionRuntimeThreadIdMissingError = Schema$1.is(CodexSessionRuntimeThreadIdMissingError);
 const isCodexResumeCursorSchema = Schema$1.is(CodexResumeCursorSchema);
-const PROVIDER$3 = ProviderDriverKind.make("codex");
+const PROVIDER$4 = ProviderDriverKind.make("codex");
 function mapCodexRuntimeError(threadId, method, error) {
 	if (isCodexAppServerProcessExitedError(error) || isCodexAppServerTransportError(error)) return new ProviderAdapterSessionClosedError({
-		provider: PROVIDER$3,
+		provider: PROVIDER$4,
 		threadId,
 		cause: error
 	});
 	if (isCodexSessionRuntimeThreadIdMissingError(error)) return new ProviderAdapterSessionNotFoundError({
-		provider: PROVIDER$3,
+		provider: PROVIDER$4,
 		threadId,
 		cause: error
 	});
 	return new ProviderAdapterRequestError({
-		provider: PROVIDER$3,
+		provider: PROVIDER$4,
 		method,
 		detail: error.message,
 		cause: error
@@ -72362,10 +72905,10 @@ const makeCodexAdapter = Effect.fn("makeCodexAdapter")(function* (codexConfig, o
 	const runtimeEventQueue = yield* Queue.unbounded();
 	const sessions = /* @__PURE__ */ new Map();
 	const startSession = (input) => Effect.scoped(Effect.gen(function* () {
-		if (input.provider !== void 0 && input.provider !== PROVIDER$3) return yield* new ProviderAdapterValidationError({
-			provider: PROVIDER$3,
+		if (input.provider !== void 0 && input.provider !== PROVIDER$4) return yield* new ProviderAdapterValidationError({
+			provider: PROVIDER$4,
 			operation: "startSession",
-			issue: `Expected provider '${PROVIDER$3}' but received '${input.provider}'.`
+			issue: `Expected provider '${PROVIDER$4}' but received '${input.provider}'.`
 		});
 		const existing = sessions.get(input.threadId);
 		if (existing && !existing.stopped) yield* Effect.suspend(() => stopSessionInternal(existing));
@@ -72400,7 +72943,7 @@ const makeCodexAdapter = Effect.fn("makeCodexAdapter")(function* (codexConfig, o
 		let sessionScopeTransferred = false;
 		yield* Effect.addFinalizer(() => sessionScopeTransferred ? Effect.void : Scope.close(sessionScope, Exit.void));
 		const runtime = yield* (options?.makeRuntime ?? makeCodexSessionRuntime)(runtimeInput).pipe(Effect.provideService(Scope.Scope, sessionScope), Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, childProcessSpawner), Effect.provideService(Crypto.Crypto, crypto), Effect.mapError((cause) => new ProviderAdapterProcessError({
-			provider: PROVIDER$3,
+			provider: PROVIDER$4,
 			threadId: input.threadId,
 			detail: cause.message,
 			cause
@@ -72420,7 +72963,7 @@ const makeCodexAdapter = Effect.fn("makeCodexAdapter")(function* (codexConfig, o
 			yield* Queue.offerAll(runtimeEventQueue, runtimeEvents);
 		})).pipe(Effect.forkChild);
 		const started = yield* runtime.start().pipe(Effect.mapError((cause) => new ProviderAdapterProcessError({
-			provider: PROVIDER$3,
+			provider: PROVIDER$4,
 			threadId: input.threadId,
 			detail: cause.message,
 			cause
@@ -72441,12 +72984,12 @@ const makeCodexAdapter = Effect.fn("makeCodexAdapter")(function* (codexConfig, o
 			attachment
 		});
 		if (!attachmentPath) return yield* new ProviderAdapterRequestError({
-			provider: PROVIDER$3,
+			provider: PROVIDER$4,
 			method: "turn/start",
 			detail: `Invalid attachment id '${attachment.id}'.`
 		});
 		const bytes = yield* fileSystem.readFile(attachmentPath).pipe(Effect.mapError((cause) => new ProviderAdapterRequestError({
-			provider: PROVIDER$3,
+			provider: PROVIDER$4,
 			method: "turn/start",
 			detail: `Failed to read attachment file: ${cause.message}.`,
 			cause
@@ -72474,7 +73017,7 @@ const makeCodexAdapter = Effect.fn("makeCodexAdapter")(function* (codexConfig, o
 	const requireSession = Effect.fn("requireSession")(function* (threadId) {
 		const session = sessions.get(threadId);
 		if (!session || session.stopped) return yield* new ProviderAdapterSessionNotFoundError({
-			provider: PROVIDER$3,
+			provider: PROVIDER$4,
 			threadId
 		});
 		return session;
@@ -72486,7 +73029,7 @@ const makeCodexAdapter = Effect.fn("makeCodexAdapter")(function* (codexConfig, o
 	})));
 	const rollbackThread = (threadId, numTurns) => {
 		if (!Number.isInteger(numTurns) || numTurns < 1) return Effect.fail(new ProviderAdapterValidationError({
-			provider: PROVIDER$3,
+			provider: PROVIDER$4,
 			operation: "rollbackThread",
 			issue: "numTurns must be an integer >= 1."
 		}));
@@ -72522,7 +73065,7 @@ const makeCodexAdapter = Effect.fn("makeCodexAdapter")(function* (codexConfig, o
 	}).pipe(Effect.asVoid);
 	yield* Effect.acquireRelease(Effect.void, () => stopAll().pipe(Effect.andThen(Queue.shutdown(runtimeEventQueue)), Effect.andThen(managedNativeEventLogger?.close() ?? Effect.void), Effect.ignore));
 	return {
-		provider: PROVIDER$3,
+		provider: PROVIDER$4,
 		capabilities: { sessionModelSwitch: "in-session" },
 		startSession,
 		sendTurn,
@@ -72817,8 +73360,8 @@ function codexContinuationIdentity(layout) {
 * @module provider/Drivers/CodexDriver
 */
 const decodeCodexSettings = Schema$1.decodeSync(CodexSettings);
-const DRIVER_KIND$3 = ProviderDriverKind.make("codex");
-const SNAPSHOT_REFRESH_INTERVAL$3 = Duration.minutes(5);
+const DRIVER_KIND$4 = ProviderDriverKind.make("codex");
+const SNAPSHOT_REFRESH_INTERVAL$4 = Duration.minutes(5);
 /**
 * Codex's own installer puts a launcher in `~/.local/bin` pointing at a
 * versioned release under `~/.codex/packages/standalone/`. That layout matches
@@ -72831,8 +73374,8 @@ function isCodexNativeCommandPath(commandPath) {
 	const normalized = normalizeCommandPath(commandPath);
 	return normalized.endsWith("/.local/bin/codex") || normalized.endsWith("/.local/bin/codex.exe") || normalized.includes("/.codex/packages/standalone/");
 }
-const UPDATE$3 = makePackageManagedProviderMaintenanceResolver({
-	provider: DRIVER_KIND$3,
+const UPDATE$4 = makePackageManagedProviderMaintenanceResolver({
+	provider: DRIVER_KIND$4,
 	npmPackageName: "@openai/codex",
 	homebrewFormula: "codex",
 	nativeUpdate: {
@@ -72848,16 +73391,16 @@ const UPDATE$3 = makePackageManagedProviderMaintenanceResolver({
 * `providerSnapshot.ts` is widened to accept `instanceId`/`driver`, this
 * wrapper disappears.
 */
-const withInstanceIdentity$3 = (input) => (snapshot) => ({
+const withInstanceIdentity$4 = (input) => (snapshot) => ({
 	...snapshot,
 	instanceId: input.instanceId,
-	driver: DRIVER_KIND$3,
+	driver: DRIVER_KIND$4,
 	...input.displayName ? { displayName: input.displayName } : {},
 	...input.accentColor ? { accentColor: input.accentColor } : {},
 	continuation: { groupKey: input.continuationGroupKey }
 });
 const CodexDriver = {
-	driverKind: DRIVER_KIND$3,
+	driverKind: DRIVER_KIND$4,
 	metadata: {
 		displayName: "Codex",
 		supportsMultipleInstances: true
@@ -72872,14 +73415,14 @@ const CodexDriver = {
 		const processEnv = mergeProviderInstanceEnvironment(environment);
 		const homeLayout = yield* resolveCodexHomeLayout(config);
 		const continuationIdentity = codexContinuationIdentity(homeLayout);
-		const stampIdentity = withInstanceIdentity$3({
+		const stampIdentity = withInstanceIdentity$4({
 			instanceId,
 			displayName,
 			accentColor,
 			continuationGroupKey: continuationIdentity.continuationKey
 		});
 		yield* materializeCodexShadowHome(homeLayout).pipe(Effect.mapError((cause) => new ProviderDriverError({
-			driver: DRIVER_KIND$3,
+			driver: DRIVER_KIND$4,
 			instanceId,
 			detail: cause.message,
 			cause
@@ -72889,7 +73432,7 @@ const CodexDriver = {
 			enabled,
 			homePath: homeLayout.effectiveHomePath ?? ""
 		};
-		const maintenanceCapabilities = yield* resolveProviderMaintenanceCapabilitiesEffect(UPDATE$3, {
+		const maintenanceCapabilities = yield* resolveProviderMaintenanceCapabilitiesEffect(UPDATE$4, {
 			binaryPath: effectiveConfig.binaryPath,
 			env: processEnv
 		});
@@ -72909,16 +73452,16 @@ const CodexDriver = {
 			initialSnapshot: (settings) => makePendingCodexProvider(settings.provider).pipe(Effect.map(stampIdentity)),
 			checkProvider,
 			enrichSnapshot: ({ settings, snapshot, publishSnapshot }) => enrichProviderSnapshotWithVersionAdvisory(snapshot, maintenanceCapabilities, { enableProviderUpdateChecks: settings.enableProviderUpdateChecks }).pipe(Effect.provideService(HttpClient.HttpClient, httpClient), Effect.flatMap((enrichedSnapshot) => publishSnapshot(enrichedSnapshot))),
-			refreshInterval: SNAPSHOT_REFRESH_INTERVAL$3
+			refreshInterval: SNAPSHOT_REFRESH_INTERVAL$4
 		}).pipe(Effect.mapError((cause) => new ProviderDriverError({
-			driver: DRIVER_KIND$3,
+			driver: DRIVER_KIND$4,
 			instanceId,
 			detail: `Failed to build Codex snapshot: ${cause.message ?? String(cause)}`,
 			cause
 		})));
 		return {
 			instanceId,
-			driverKind: DRIVER_KIND$3,
+			driverKind: DRIVER_KIND$4,
 			continuationIdentity,
 			displayName,
 			accentColor,
@@ -76895,18 +77438,18 @@ function deriveToolActivityPresentation(input) {
 }
 //#endregion
 //#region src/provider/acp/AcpRuntimeModel.ts
-function isRecord$2(value) {
+function isRecord$4(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isSessionModelState(value) {
-	if (!isRecord$2(value) || typeof value.currentModelId !== "string") return false;
+	if (!isRecord$4(value) || typeof value.currentModelId !== "string") return false;
 	if (!Array.isArray(value.availableModels)) return false;
-	return value.availableModels.every((model) => isRecord$2(model) && typeof model.modelId === "string" && typeof model.name === "string" && (model.description === void 0 || model.description === null || typeof model.description === "string"));
+	return value.availableModels.every((model) => isRecord$4(model) && typeof model.modelId === "string" && typeof model.name === "string" && (model.description === void 0 || model.description === null || typeof model.description === "string"));
 }
 function isSessionModeState(value) {
-	if (!isRecord$2(value) || typeof value.currentModeId !== "string") return false;
+	if (!isRecord$4(value) || typeof value.currentModeId !== "string") return false;
 	if (!Array.isArray(value.availableModes)) return false;
-	return value.availableModes.every((mode) => isRecord$2(mode) && typeof mode.id === "string" && typeof mode.name === "string" && (mode.description === void 0 || typeof mode.description === "string"));
+	return value.availableModes.every((mode) => isRecord$4(mode) && typeof mode.id === "string" && typeof mode.name === "string" && (mode.description === void 0 || typeof mode.description === "string"));
 }
 function extractModelConfigId(sessionResponse) {
 	const configOptions = sessionResponse.configOptions;
@@ -76982,7 +77525,7 @@ function extractCommandFromTitle(title) {
 	return /`([^`]+)`/.exec(title)?.[1]?.trim() || void 0;
 }
 function extractToolCallCommand(rawInput, title) {
-	if (isRecord$2(rawInput)) {
+	if (isRecord$4(rawInput)) {
 		const directCommand = normalizeCommandValue(rawInput.command);
 		if (directCommand) return directCommand;
 		const executable = typeof rawInput.executable === "string" ? rawInput.executable.trim() : "";
@@ -77104,7 +77647,7 @@ function parsePermissionRequest(params) {
 }
 function sessionUpdateIsReplay(params) {
 	const meta = params._meta;
-	return isRecord$2(meta) && meta.isReplay === true;
+	return isRecord$4(meta) && meta.isReplay === true;
 }
 const waitForSessionLoadReplayIdle = (input) => Effect.gen(function* () {
 	const pollInterval = Duration.millis(25);
@@ -77119,8 +77662,8 @@ const waitForSessionLoadReplayIdle = (input) => Effect.gen(function* () {
 });
 function syntheticLoadSessionResponseFromInitialize(initializeResult) {
 	const meta = initializeResult._meta;
-	const modelState = isRecord$2(meta) ? meta.modelState : void 0;
-	const modeState = isRecord$2(meta) ? meta.modeState : void 0;
+	const modelState = isRecord$4(meta) ? meta.modelState : void 0;
+	const modeState = isRecord$4(meta) ? meta.modeState : void 0;
 	const models = isSessionModelState(modelState) ? modelState : void 0;
 	const modes = isSessionModeState(modeState) ? modeState : void 0;
 	return {
@@ -77678,7 +78221,7 @@ const CURSOR_PRESENTATION = {
 	badgeLabel: "Early Access",
 	showInteractionModeToggle: true
 };
-const EMPTY_CAPABILITIES$1 = createModelCapabilities({ optionDescriptors: [] });
+const EMPTY_CAPABILITIES$2 = 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";
@@ -77786,7 +78329,7 @@ function getBooleanCurrentValue(option) {
 	if (normalized === "false") return false;
 }
 function buildCursorCapabilitiesFromConfigOptions(configOptions) {
-	if (!configOptions || configOptions.length === 0) return EMPTY_CAPABILITIES$1;
+	if (!configOptions || configOptions.length === 0) return EMPTY_CAPABILITIES$2;
 	const reasoningConfig = findCursorEffortConfigOption(configOptions);
 	const reasoningEffortLevels = reasoningConfig?.type === "select" ? flattenSessionConfigSelectOptions(reasoningConfig).flatMap((entry) => {
 		const normalizedValue = normalizeCursorReasoningValue(entry.value);
@@ -77955,7 +78498,7 @@ const discoverCursorModelsViaListAvailableModels = (cursorSettings, environment)
 }), environment);
 const discoverCursorModelsViaAcp = (cursorSettings, environment) => discoverCursorModelsViaListAvailableModels(cursorSettings, environment);
 function getCursorFallbackModels(cursorSettings) {
-	return providerModelsFromSettings([], cursorSettings.customModels, EMPTY_CAPABILITIES$1);
+	return providerModelsFromSettings([], cursorSettings.customModels, EMPTY_CAPABILITIES$2);
 }
 /** Timeout for `agent about` — it's slower than a simple `--version` probe. */
 const ABOUT_TIMEOUT_MS = 8e3;
@@ -77991,7 +78534,7 @@ function buildCursorProviderSnapshot(input) {
 		presentation: CURSOR_PRESENTATION,
 		enabled: input.cursorSettings.enabled,
 		checkedAt: input.checkedAt,
-		models: providerModelsFromSettings(input.discoveredModels ?? [], input.cursorSettings.customModels, EMPTY_CAPABILITIES$1),
+		models: providerModelsFromSettings(input.discoveredModels ?? [], input.cursorSettings.customModels, EMPTY_CAPABILITIES$2),
 		probe: {
 			installed: true,
 			version: input.parsed.version,
@@ -78344,7 +78887,7 @@ function applyCursorAcpModelSelection(input) {
 //#endregion
 //#region src/textGeneration/CursorTextGeneration.ts
 const CURSOR_TIMEOUT_MS = 18e4;
-const isTextGenerationError$1 = Schema$1.is(TextGenerationError);
+const isTextGenerationError$2 = Schema$1.is(TextGenerationError);
 /**
 * Build a Cursor text-generation closure bound to a specific `CursorSettings`
 * payload. See `makeCodexAdapter` for the overall per-instance rationale.
@@ -78395,7 +78938,7 @@ const makeCursorTextGeneration = Effect.fn("makeCursorTextGeneration")(function*
 				detail: "Cursor Agent request timed out."
 			})),
 			onSome: (value) => Effect.succeed(value)
-		})), Effect.mapError((cause) => isTextGenerationError$1(cause) ? cause : new TextGenerationError({
+		})), Effect.mapError((cause) => isTextGenerationError$2(cause) ? cause : new TextGenerationError({
 			operation,
 			detail: "Cursor ACP request failed.",
 			cause
@@ -78410,7 +78953,7 @@ const makeCursorTextGeneration = Effect.fn("makeCursorTextGeneration")(function*
 			detail: "Cursor Agent returned invalid structured output.",
 			cause
 		})) }));
-	}).pipe(Effect.mapError((cause) => isTextGenerationError$1(cause) ? cause : new TextGenerationError({
+	}).pipe(Effect.mapError((cause) => isTextGenerationError$2(cause) ? cause : new TextGenerationError({
 		operation,
 		detail: "Cursor ACP text generation failed.",
 		cause
@@ -78752,7 +79295,7 @@ const makeAcpNativeLoggerFactory = Effect.fn("makeAcpNativeLoggerFactory")(funct
 * @module CursorAdapterLive
 */
 const encodeUnknownJsonStringExit$1 = Schema$1.encodeUnknownExit(Schema$1.UnknownFromJsonString);
-const PROVIDER$2 = ProviderDriverKind.make("cursor");
+const PROVIDER$3 = ProviderDriverKind.make("cursor");
 const CURSOR_RESUME_VERSION = 1;
 const ACP_PLAN_MODE_ALIASES = ["plan", "architect"];
 const ACP_IMPLEMENT_MODE_ALIASES = [
@@ -78775,11 +79318,11 @@ function settlePendingUserInputsAsEmptyAnswers(pendingUserInputs) {
 	const pendingEntries = Array.from(pendingUserInputs.values());
 	return Effect.forEach(pendingEntries, (pending) => Deferred.succeed(pending.answers, {}).pipe(Effect.ignore), { discard: true });
 }
-function isRecord$1(value) {
+function isRecord$3(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseCursorResume(raw) {
-	if (!isRecord$1(raw)) return void 0;
+	if (!isRecord$3(raw)) return void 0;
 	if (raw.schemaVersion !== CURSOR_RESUME_VERSION) return void 0;
 	if (typeof raw.sessionId !== "string" || !raw.sessionId.trim()) return void 0;
 	return { sessionId: raw.sessionId.trim() };
@@ -78861,7 +79404,7 @@ function makeCursorAdapter(cursorSettings, options) {
 		const runtimeEventPubSub = yield* PubSub.unbounded();
 		const nowIso = Effect.map(DateTime.now, DateTime.formatIso);
 		const randomUUIDv4 = crypto.randomUUIDv4.pipe(Effect.mapError((cause) => new ProviderAdapterRequestError({
-			provider: PROVIDER$2,
+			provider: PROVIDER$3,
 			method: "crypto/randomUUIDv4",
 			detail: "Failed to generate Cursor runtime identifier.",
 			cause
@@ -78896,7 +79439,7 @@ function makeCursorAdapter(cursorSettings, options) {
 				event: {
 					id: yield* randomUUIDv4,
 					kind: "notification",
-					provider: PROVIDER$2,
+					provider: PROVIDER$3,
 					createdAt: observedAt,
 					method,
 					threadId,
@@ -78910,7 +79453,7 @@ function makeCursorAdapter(cursorSettings, options) {
 			ctx.lastPlanFingerprint = fingerprint;
 			yield* offerRuntimeEvent(makeAcpPlanUpdatedEvent({
 				stamp: yield* makeEventStamp(),
-				provider: PROVIDER$2,
+				provider: PROVIDER$3,
 				threadId: ctx.threadId,
 				turnId: ctx.activeTurnId,
 				payload,
@@ -78922,7 +79465,7 @@ function makeCursorAdapter(cursorSettings, options) {
 		const requireSession = (threadId) => {
 			const ctx = sessions.get(threadId);
 			if (!ctx || ctx.stopped) return Effect.fail(new ProviderAdapterSessionNotFoundError({
-				provider: PROVIDER$2,
+				provider: PROVIDER$3,
 				threadId
 			}));
 			return Effect.succeed(ctx);
@@ -78938,19 +79481,19 @@ function makeCursorAdapter(cursorSettings, options) {
 			yield* offerRuntimeEvent({
 				type: "session.exited",
 				...yield* makeEventStamp(),
-				provider: PROVIDER$2,
+				provider: PROVIDER$3,
 				threadId: ctx.threadId,
 				payload: { exitKind: "graceful" }
 			});
 		});
 		const startSession = (input) => withThreadLock(input.threadId, Effect.gen(function* () {
-			if (input.provider !== void 0 && input.provider !== PROVIDER$2) return yield* new ProviderAdapterValidationError({
-				provider: PROVIDER$2,
+			if (input.provider !== void 0 && input.provider !== PROVIDER$3) return yield* new ProviderAdapterValidationError({
+				provider: PROVIDER$3,
 				operation: "startSession",
-				issue: `Expected provider '${PROVIDER$2}' but received '${input.provider}'.`
+				issue: `Expected provider '${PROVIDER$3}' but received '${input.provider}'.`
 			});
 			if (!input.cwd?.trim()) return yield* new ProviderAdapterValidationError({
-				provider: PROVIDER$2,
+				provider: PROVIDER$3,
 				operation: "startSession",
 				issue: "cwd is required and must be non-empty."
 			});
@@ -78967,7 +79510,7 @@ function makeCursorAdapter(cursorSettings, options) {
 			const resumeSessionId = parseCursorResume(input.resumeCursor)?.sessionId;
 			const acpNativeLoggers = makeAcpNativeLoggers({
 				nativeEventLogger,
-				provider: PROVIDER$2,
+				provider: PROVIDER$3,
 				threadId: input.threadId
 			});
 			const effectiveCursorSettings = options?.resolveSettings ? yield* options.resolveSettings : cursorSettings;
@@ -78993,7 +79536,7 @@ function makeCursorAdapter(cursorSettings, options) {
 				}] } : {},
 				...acpNativeLoggers
 			}).pipe(Effect.provideService(Crypto.Crypto, crypto), Effect.provideService(Scope.Scope, sessionScope), Effect.mapError((cause) => new ProviderAdapterProcessError({
-				provider: PROVIDER$2,
+				provider: PROVIDER$3,
 				threadId: input.threadId,
 				detail: cause.message,
 				cause
@@ -79008,7 +79551,7 @@ function makeCursorAdapter(cursorSettings, options) {
 					yield* offerRuntimeEvent({
 						type: "user-input.requested",
 						...yield* makeEventStamp(),
-						provider: PROVIDER$2,
+						provider: PROVIDER$3,
 						threadId: input.threadId,
 						turnId: ctx?.activeTurnId,
 						requestId: runtimeRequestId,
@@ -79024,7 +79567,7 @@ function makeCursorAdapter(cursorSettings, options) {
 					yield* offerRuntimeEvent({
 						type: "user-input.resolved",
 						...yield* makeEventStamp(),
-						provider: PROVIDER$2,
+						provider: PROVIDER$3,
 						threadId: input.threadId,
 						turnId: ctx?.activeTurnId,
 						requestId: runtimeRequestId,
@@ -79037,7 +79580,7 @@ function makeCursorAdapter(cursorSettings, options) {
 					yield* offerRuntimeEvent({
 						type: "turn.proposed.completed",
 						...yield* makeEventStamp(),
-						provider: PROVIDER$2,
+						provider: PROVIDER$3,
 						threadId: input.threadId,
 						turnId: ctx?.activeTurnId,
 						payload: { planMarkdown: extractPlanMarkdown(params) },
@@ -79072,7 +79615,7 @@ function makeCursorAdapter(cursorSettings, options) {
 					});
 					yield* offerRuntimeEvent(makeAcpRequestOpenedEvent({
 						stamp: yield* makeEventStamp(),
-						provider: PROVIDER$2,
+						provider: PROVIDER$3,
 						threadId: input.threadId,
 						turnId: ctx?.activeTurnId,
 						requestId: runtimeRequestId,
@@ -79087,7 +79630,7 @@ function makeCursorAdapter(cursorSettings, options) {
 					pendingApprovals.delete(requestId);
 					yield* offerRuntimeEvent(makeAcpRequestResolvedEvent({
 						stamp: yield* makeEventStamp(),
-						provider: PROVIDER$2,
+						provider: PROVIDER$3,
 						threadId: input.threadId,
 						turnId: ctx?.activeTurnId,
 						requestId: runtimeRequestId,
@@ -79100,17 +79643,17 @@ function makeCursorAdapter(cursorSettings, options) {
 					} };
 				})));
 				return yield* acp.start();
-			}).pipe(Effect.mapError((error) => mapAcpToAdapterError(PROVIDER$2, input.threadId, "session/start", error)));
+			}).pipe(Effect.mapError((error) => mapAcpToAdapterError(PROVIDER$3, input.threadId, "session/start", error)));
 			yield* applyRequestedSessionConfiguration({
 				runtime: acp,
 				runtimeMode: input.runtimeMode,
 				interactionMode: void 0,
 				modelSelection: cursorModelSelection,
-				mapError: ({ cause, method }) => mapAcpToAdapterError(PROVIDER$2, input.threadId, method, cause)
+				mapError: ({ cause, method }) => mapAcpToAdapterError(PROVIDER$3, input.threadId, method, cause)
 			});
 			const now = yield* nowIso;
 			const session = {
-				provider: PROVIDER$2,
+				provider: PROVIDER$3,
 				providerInstanceId: boundInstanceId,
 				status: "ready",
 				runtimeMode: input.runtimeMode,
@@ -79147,7 +79690,7 @@ function makeCursorAdapter(cursorSettings, options) {
 					case "AssistantItemStarted":
 						yield* offerRuntimeEvent(makeAcpAssistantItemEvent({
 							stamp: yield* makeEventStamp(),
-							provider: PROVIDER$2,
+							provider: PROVIDER$3,
 							threadId: ctx.threadId,
 							turnId: ctx.activeTurnId,
 							itemId: event.itemId,
@@ -79157,7 +79700,7 @@ function makeCursorAdapter(cursorSettings, options) {
 					case "AssistantItemCompleted":
 						yield* offerRuntimeEvent(makeAcpAssistantItemEvent({
 							stamp: yield* makeEventStamp(),
-							provider: PROVIDER$2,
+							provider: PROVIDER$3,
 							threadId: ctx.threadId,
 							turnId: ctx.activeTurnId,
 							itemId: event.itemId,
@@ -79172,7 +79715,7 @@ function makeCursorAdapter(cursorSettings, options) {
 						yield* logNative(ctx.threadId, "session/update", event.rawPayload, "acp.jsonrpc");
 						yield* offerRuntimeEvent(makeAcpToolCallEvent({
 							stamp: yield* makeEventStamp(),
-							provider: PROVIDER$2,
+							provider: PROVIDER$3,
 							threadId: ctx.threadId,
 							turnId: ctx.activeTurnId,
 							toolCall: event.toolCall,
@@ -79183,7 +79726,7 @@ function makeCursorAdapter(cursorSettings, options) {
 						yield* logNative(ctx.threadId, "session/update", event.rawPayload, "acp.jsonrpc");
 						yield* offerRuntimeEvent(makeAcpContentDeltaEvent({
 							stamp: yield* makeEventStamp(),
-							provider: PROVIDER$2,
+							provider: PROVIDER$3,
 							threadId: ctx.threadId,
 							turnId: ctx.activeTurnId,
 							...event.itemId ? { itemId: event.itemId } : {},
@@ -79199,14 +79742,14 @@ function makeCursorAdapter(cursorSettings, options) {
 			yield* offerRuntimeEvent({
 				type: "session.started",
 				...yield* makeEventStamp(),
-				provider: PROVIDER$2,
+				provider: PROVIDER$3,
 				threadId: input.threadId,
 				payload: { resume: started.initializeResult }
 			});
 			yield* offerRuntimeEvent({
 				type: "session.state.changed",
 				...yield* makeEventStamp(),
-				provider: PROVIDER$2,
+				provider: PROVIDER$3,
 				threadId: input.threadId,
 				payload: {
 					state: "ready",
@@ -79216,7 +79759,7 @@ function makeCursorAdapter(cursorSettings, options) {
 			yield* offerRuntimeEvent({
 				type: "thread.started",
 				...yield* makeEventStamp(),
-				provider: PROVIDER$2,
+				provider: PROVIDER$3,
 				threadId: input.threadId,
 				payload: { providerThreadId: started.sessionId }
 			});
@@ -79239,7 +79782,7 @@ function makeCursorAdapter(cursorSettings, options) {
 						model,
 						options: turnModelSelection?.options
 					},
-					mapError: ({ cause, method }) => mapAcpToAdapterError(PROVIDER$2, input.threadId, method, cause)
+					mapError: ({ cause, method }) => mapAcpToAdapterError(PROVIDER$3, input.threadId, method, cause)
 				});
 				ctx.activeTurnId = turnId;
 				if (steeringTurnId === void 0) ctx.lastPlanFingerprint = void 0;
@@ -79251,7 +79794,7 @@ function makeCursorAdapter(cursorSettings, options) {
 				if (steeringTurnId === void 0) yield* offerRuntimeEvent({
 					type: "turn.started",
 					...yield* makeEventStamp(),
-					provider: PROVIDER$2,
+					provider: PROVIDER$3,
 					threadId: input.threadId,
 					turnId,
 					payload: { model: resolvedModel }
@@ -79267,12 +79810,12 @@ function makeCursorAdapter(cursorSettings, options) {
 						attachment
 					});
 					if (!attachmentPath) return yield* new ProviderAdapterRequestError({
-						provider: PROVIDER$2,
+						provider: PROVIDER$3,
 						method: "session/prompt",
 						detail: `Invalid attachment id '${attachment.id}'.`
 					});
 					const bytes = yield* fileSystem.readFile(attachmentPath).pipe(Effect.mapError((cause) => new ProviderAdapterRequestError({
-						provider: PROVIDER$2,
+						provider: PROVIDER$3,
 						method: "session/prompt",
 						detail: cause.message,
 						cause
@@ -79284,11 +79827,11 @@ function makeCursorAdapter(cursorSettings, options) {
 					});
 				}
 				if (promptParts.length === 0) return yield* new ProviderAdapterValidationError({
-					provider: PROVIDER$2,
+					provider: PROVIDER$3,
 					operation: "sendTurn",
 					issue: "Turn requires non-empty text or attachments."
 				});
-				const result = yield* ctx.acp.prompt({ prompt: promptParts }).pipe(Effect.mapError((error) => mapAcpToAdapterError(PROVIDER$2, input.threadId, "session/prompt", error)));
+				const result = yield* ctx.acp.prompt({ prompt: promptParts }).pipe(Effect.mapError((error) => mapAcpToAdapterError(PROVIDER$3, input.threadId, "session/prompt", error)));
 				const turnRecord = ctx.turns.find((turn) => turn.id === turnId);
 				if (turnRecord) turnRecord.items.push({
 					prompt: promptParts,
@@ -79310,7 +79853,7 @@ function makeCursorAdapter(cursorSettings, options) {
 				if (ctx.promptsInFlight === 1) yield* offerRuntimeEvent({
 					type: "turn.completed",
 					...yield* makeEventStamp(),
-					provider: PROVIDER$2,
+					provider: PROVIDER$3,
 					threadId: input.threadId,
 					turnId,
 					payload: {
@@ -79331,12 +79874,12 @@ function makeCursorAdapter(cursorSettings, options) {
 			const ctx = yield* requireSession(threadId);
 			yield* settlePendingApprovalsAsCancelled$1(ctx.pendingApprovals);
 			yield* settlePendingUserInputsAsEmptyAnswers(ctx.pendingUserInputs);
-			yield* Effect.ignore(ctx.acp.cancel.pipe(Effect.mapError((error) => mapAcpToAdapterError(PROVIDER$2, threadId, "session/cancel", error))));
+			yield* Effect.ignore(ctx.acp.cancel.pipe(Effect.mapError((error) => mapAcpToAdapterError(PROVIDER$3, threadId, "session/cancel", error))));
 		});
 		const respondToRequest = (threadId, requestId, decision) => Effect.gen(function* () {
 			const pending = (yield* requireSession(threadId)).pendingApprovals.get(requestId);
 			if (!pending) return yield* new ProviderAdapterRequestError({
-				provider: PROVIDER$2,
+				provider: PROVIDER$3,
 				method: "session/request_permission",
 				detail: `Unknown pending approval request: ${requestId}`
 			});
@@ -79345,7 +79888,7 @@ function makeCursorAdapter(cursorSettings, options) {
 		const respondToUserInput = (threadId, requestId, answers) => Effect.gen(function* () {
 			const pending = (yield* requireSession(threadId)).pendingUserInputs.get(requestId);
 			if (!pending) return yield* new ProviderAdapterRequestError({
-				provider: PROVIDER$2,
+				provider: PROVIDER$3,
 				method: "cursor/ask_question",
 				detail: `Unknown pending user-input request: ${requestId}`
 			});
@@ -79360,7 +79903,7 @@ function makeCursorAdapter(cursorSettings, options) {
 		const rollbackThread = (threadId, numTurns) => Effect.gen(function* () {
 			const ctx = yield* requireSession(threadId);
 			if (!Number.isInteger(numTurns) || numTurns < 1) return yield* new ProviderAdapterValidationError({
-				provider: PROVIDER$2,
+				provider: PROVIDER$3,
 				operation: "rollbackThread",
 				issue: "numTurns must be an integer >= 1."
 			});
@@ -79384,7 +79927,7 @@ function makeCursorAdapter(cursorSettings, options) {
 		yield* Effect.addFinalizer(() => Effect.forEach(sessions.values(), stopSessionInternal, { discard: true }).pipe(Effect.catch((cause) => Effect.logError("Failed to emit Cursor session shutdown event.", { cause })), Effect.tap(() => PubSub.shutdown(runtimeEventPubSub)), Effect.tap(() => managedNativeEventLogger?.close() ?? Effect.void)));
 		const streamEvents = Stream.fromPubSub(runtimeEventPubSub);
 		return {
-			provider: PROVIDER$2,
+			provider: PROVIDER$3,
 			capabilities: { sessionModelSwitch: "in-session" },
 			startSession,
 			sendTurn,
@@ -79417,25 +79960,25 @@ function makeCursorAdapter(cursorSettings, options) {
 * @module provider/Drivers/CursorDriver
 */
 const decodeCursorSettings = Schema$1.decodeSync(CursorSettings);
-const DRIVER_KIND$2 = ProviderDriverKind.make("cursor");
-const SNAPSHOT_REFRESH_INTERVAL$2 = Duration.minutes(5);
-const UPDATE$2 = { resolve: (options) => makeProviderMaintenanceCapabilities({
-	provider: DRIVER_KIND$2,
+const DRIVER_KIND$3 = ProviderDriverKind.make("cursor");
+const SNAPSHOT_REFRESH_INTERVAL$3 = Duration.minutes(5);
+const UPDATE$3 = { resolve: (options) => makeProviderMaintenanceCapabilities({
+	provider: DRIVER_KIND$3,
 	packageName: null,
 	updateExecutable: options?.binaryPath?.trim() || "cursor-agent",
 	updateArgs: ["update"],
 	updateLockKey: "cursor-agent"
 }) };
-const withInstanceIdentity$2 = (input) => (snapshot) => ({
+const withInstanceIdentity$3 = (input) => (snapshot) => ({
 	...snapshot,
 	instanceId: input.instanceId,
-	driver: DRIVER_KIND$2,
+	driver: DRIVER_KIND$3,
 	...input.displayName ? { displayName: input.displayName } : {},
 	...input.accentColor ? { accentColor: input.accentColor } : {},
 	continuation: { groupKey: input.continuationGroupKey }
 });
 const CursorDriver = {
-	driverKind: DRIVER_KIND$2,
+	driverKind: DRIVER_KIND$3,
 	metadata: {
 		displayName: "Cursor",
 		supportsMultipleInstances: true
@@ -79452,10 +79995,10 @@ const CursorDriver = {
 		const eventLoggers = yield* ProviderEventLoggers;
 		const processEnv = mergeProviderInstanceEnvironment(environment);
 		const continuationIdentity = defaultProviderContinuationIdentity({
-			driverKind: DRIVER_KIND$2,
+			driverKind: DRIVER_KIND$3,
 			instanceId
 		});
-		const stampIdentity = withInstanceIdentity$2({
+		const stampIdentity = withInstanceIdentity$3({
 			instanceId,
 			displayName,
 			accentColor,
@@ -79465,7 +80008,7 @@ const CursorDriver = {
 			...config,
 			enabled
 		};
-		const maintenanceCapabilities = yield* resolveProviderMaintenanceCapabilitiesEffect(UPDATE$2, {
+		const maintenanceCapabilities = yield* resolveProviderMaintenanceCapabilitiesEffect(UPDATE$3, {
 			binaryPath: effectiveConfig.binaryPath,
 			env: processEnv
 		});
@@ -79493,16 +80036,16 @@ const CursorDriver = {
 				stampIdentity,
 				httpClient
 			}),
-			refreshInterval: SNAPSHOT_REFRESH_INTERVAL$2
+			refreshInterval: SNAPSHOT_REFRESH_INTERVAL$3
 		}).pipe(Effect.mapError((cause) => new ProviderDriverError({
-			driver: DRIVER_KIND$2,
+			driver: DRIVER_KIND$3,
 			instanceId,
 			detail: `Failed to build Cursor snapshot: ${cause.message ?? String(cause)}`,
 			cause
 		})));
 		return {
 			instanceId,
-			driverKind: DRIVER_KIND$2,
+			driverKind: DRIVER_KIND$3,
 			continuationIdentity,
 			displayName,
 			accentColor,
@@ -79767,7 +80310,7 @@ function applyGrokAcpModelSelection(input) {
 //#endregion
 //#region src/textGeneration/GrokTextGeneration.ts
 const GROK_TIMEOUT_MS = 18e4;
-const isTextGenerationError = Schema$1.is(TextGenerationError);
+const isTextGenerationError$1 = Schema$1.is(TextGenerationError);
 const makeGrokTextGeneration = Effect.fn("makeGrokTextGeneration")(function* (grokSettings, environment = process.env) {
 	const crypto = yield* Crypto.Crypto;
 	const commandSpawner = yield* ChildProcessSpawner.ChildProcessSpawner;
@@ -79813,7 +80356,7 @@ const makeGrokTextGeneration = Effect.fn("makeGrokTextGeneration")(function* (gr
 				detail: "Grok ACP request timed out."
 			})),
 			onSome: (value) => Effect.succeed(value)
-		})), Effect.mapError((cause) => isTextGenerationError(cause) ? cause : new TextGenerationError({
+		})), Effect.mapError((cause) => isTextGenerationError$1(cause) ? cause : new TextGenerationError({
 			operation,
 			detail: "Grok ACP request failed.",
 			cause
@@ -79828,7 +80371,7 @@ const makeGrokTextGeneration = Effect.fn("makeGrokTextGeneration")(function* (gr
 			detail: "Grok Agent returned invalid structured output.",
 			cause
 		})) }));
-	}).pipe(Effect.mapError((cause) => isTextGenerationError(cause) ? cause : new TextGenerationError({
+	}).pipe(Effect.mapError((cause) => isTextGenerationError$1(cause) ? cause : new TextGenerationError({
 		operation,
 		detail: "Grok ACP text generation failed.",
 		cause
@@ -79908,7 +80451,7 @@ const makeGrokTextGeneration = Effect.fn("makeGrokTextGeneration")(function* (gr
 //#endregion
 //#region src/provider/Layers/GrokAdapter.ts
 const encodeUnknownJsonStringExit = Schema$1.encodeUnknownExit(Schema$1.UnknownFromJsonString);
-const PROVIDER$1 = ProviderDriverKind.make("grok");
+const PROVIDER$2 = ProviderDriverKind.make("grok");
 const GROK_RESUME_VERSION = 1;
 function encodeJsonStringForDiagnostics(input) {
 	const result = encodeUnknownJsonStringExit(input);
@@ -79935,7 +80478,7 @@ function appendPromptResultToTurn(ctx, turnId, promptParts, result) {
 		}]
 	}];
 }
-function isRecord(value) {
+function isRecord$2(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 const resolveNotificationTurnId = (ctx) => ctx.activeTurnId;
@@ -79945,7 +80488,7 @@ const resolveSessionCallbackTurnId = (sessions, threadId) => {
 	return ctx ? resolveCallbackTurnId(ctx) : void 0;
 };
 function parseGrokResume(raw) {
-	if (!isRecord(raw)) return void 0;
+	if (!isRecord$2(raw)) return void 0;
 	if (raw.schemaVersion !== GROK_RESUME_VERSION) return void 0;
 	if (typeof raw.sessionId !== "string" || !raw.sessionId.trim()) return void 0;
 	return { sessionId: raw.sessionId.trim() };
@@ -79980,7 +80523,7 @@ function makeGrokAdapter(grokSettings, options) {
 		const runtimeEventPubSub = yield* PubSub.unbounded();
 		const nowIso = Effect.map(DateTime.now, DateTime.formatIso);
 		const randomUUIDv4 = crypto.randomUUIDv4.pipe(Effect.mapError((cause) => new ProviderAdapterRequestError({
-			provider: PROVIDER$1,
+			provider: PROVIDER$2,
 			method: "crypto/randomUUIDv4",
 			detail: "Failed to generate Grok runtime identifier.",
 			cause
@@ -80022,7 +80565,7 @@ function makeGrokAdapter(grokSettings, options) {
 					if (options?.errorMessage !== void 0) yield* offerRuntimeEvent({
 						type: "turn.completed",
 						...yield* makeEventStamp(),
-						provider: PROVIDER$1,
+						provider: PROVIDER$2,
 						threadId,
 						turnId,
 						payload: {
@@ -80033,7 +80576,7 @@ function makeGrokAdapter(grokSettings, options) {
 					else if (options?.completedStopReason !== void 0) yield* offerRuntimeEvent({
 						type: "turn.completed",
 						...yield* makeEventStamp(),
-						provider: PROVIDER$1,
+						provider: PROVIDER$2,
 						threadId,
 						turnId,
 						payload: {
@@ -80087,7 +80630,7 @@ function makeGrokAdapter(grokSettings, options) {
 			if (shouldEmitFailedTurn) yield* offerRuntimeEvent({
 				type: "turn.completed",
 				...yield* makeEventStamp(),
-				provider: PROVIDER$1,
+				provider: PROVIDER$2,
 				threadId,
 				turnId: settleTurnId,
 				payload: {
@@ -80098,7 +80641,7 @@ function makeGrokAdapter(grokSettings, options) {
 			else if (shouldEmitCompletedTurn) yield* offerRuntimeEvent({
 				type: "turn.completed",
 				...yield* makeEventStamp(),
-				provider: PROVIDER$1,
+				provider: PROVIDER$2,
 				threadId,
 				turnId: settleTurnId,
 				payload: {
@@ -80115,7 +80658,7 @@ function makeGrokAdapter(grokSettings, options) {
 				event: {
 					id: yield* randomUUIDv4,
 					kind: "notification",
-					provider: PROVIDER$1,
+					provider: PROVIDER$2,
 					createdAt: observedAt,
 					method,
 					threadId,
@@ -80133,7 +80676,7 @@ function makeGrokAdapter(grokSettings, options) {
 			ctx.lastPlanFingerprint = fingerprint;
 			yield* offerRuntimeEvent(makeAcpPlanUpdatedEvent({
 				stamp,
-				provider: PROVIDER$1,
+				provider: PROVIDER$2,
 				threadId: ctx.threadId,
 				turnId,
 				payload,
@@ -80145,7 +80688,7 @@ function makeGrokAdapter(grokSettings, options) {
 		const requireSession = (threadId) => {
 			const ctx = sessions.get(threadId);
 			if (!ctx || ctx.stopped) return Effect.fail(new ProviderAdapterSessionNotFoundError({
-				provider: PROVIDER$1,
+				provider: PROVIDER$2,
 				threadId
 			}));
 			return Effect.succeed(ctx);
@@ -80161,19 +80704,19 @@ function makeGrokAdapter(grokSettings, options) {
 			yield* offerRuntimeEvent({
 				type: "session.exited",
 				...yield* makeEventStamp(),
-				provider: PROVIDER$1,
+				provider: PROVIDER$2,
 				threadId: ctx.threadId,
 				payload: { exitKind: "graceful" }
 			});
 		});
 		const startSession = (input) => withThreadLock(input.threadId, Effect.gen(function* () {
-			if (input.provider !== void 0 && input.provider !== PROVIDER$1) return yield* new ProviderAdapterValidationError({
-				provider: PROVIDER$1,
+			if (input.provider !== void 0 && input.provider !== PROVIDER$2) return yield* new ProviderAdapterValidationError({
+				provider: PROVIDER$2,
 				operation: "startSession",
-				issue: `Expected provider '${PROVIDER$1}' but received '${input.provider}'.`
+				issue: `Expected provider '${PROVIDER$2}' but received '${input.provider}'.`
 			});
 			if (!input.cwd?.trim()) return yield* new ProviderAdapterValidationError({
-				provider: PROVIDER$1,
+				provider: PROVIDER$2,
 				operation: "startSession",
 				issue: "cwd is required and must be non-empty."
 			});
@@ -80189,7 +80732,7 @@ function makeGrokAdapter(grokSettings, options) {
 			const resumeSessionId = parseGrokResume(input.resumeCursor)?.sessionId;
 			const acpNativeLoggers = makeAcpNativeLoggers({
 				nativeEventLogger,
-				provider: PROVIDER$1,
+				provider: PROVIDER$2,
 				threadId: input.threadId
 			});
 			const mcpSession = readMcpProviderSession(input.threadId);
@@ -80214,7 +80757,7 @@ function makeGrokAdapter(grokSettings, options) {
 				}] } : {},
 				...acpNativeLoggers
 			}).pipe(Effect.provideService(Crypto.Crypto, crypto), Effect.provideService(Scope.Scope, sessionScope), Effect.mapError((cause) => new ProviderAdapterProcessError({
-				provider: PROVIDER$1,
+				provider: PROVIDER$2,
 				threadId: input.threadId,
 				detail: cause.message,
 				cause
@@ -80230,7 +80773,7 @@ function makeGrokAdapter(grokSettings, options) {
 					yield* offerRuntimeEvent({
 						type: "user-input.requested",
 						...yield* makeEventStamp(),
-						provider: PROVIDER$1,
+						provider: PROVIDER$2,
 						threadId: input.threadId,
 						turnId,
 						requestId: runtimeRequestId,
@@ -80247,7 +80790,7 @@ function makeGrokAdapter(grokSettings, options) {
 					yield* offerRuntimeEvent({
 						type: "user-input.resolved",
 						...yield* makeEventStamp(),
-						provider: PROVIDER$1,
+						provider: PROVIDER$2,
 						threadId: input.threadId,
 						turnId,
 						requestId: runtimeRequestId,
@@ -80280,7 +80823,7 @@ function makeGrokAdapter(grokSettings, options) {
 					pendingApprovals.set(requestId, { decision });
 					yield* offerRuntimeEvent(makeAcpRequestOpenedEvent({
 						stamp: yield* makeEventStamp(),
-						provider: PROVIDER$1,
+						provider: PROVIDER$2,
 						threadId: input.threadId,
 						turnId,
 						requestId: runtimeRequestId,
@@ -80295,7 +80838,7 @@ function makeGrokAdapter(grokSettings, options) {
 					pendingApprovals.delete(requestId);
 					yield* offerRuntimeEvent(makeAcpRequestResolvedEvent({
 						stamp: yield* makeEventStamp(),
-						provider: PROVIDER$1,
+						provider: PROVIDER$2,
 						threadId: input.threadId,
 						turnId,
 						requestId: runtimeRequestId,
@@ -80309,17 +80852,17 @@ function makeGrokAdapter(grokSettings, options) {
 					} : { outcome: "cancelled" } };
 				})));
 				return yield* acp.start();
-			}).pipe(Effect.mapError((error) => mapAcpToAdapterError(PROVIDER$1, input.threadId, "session/start", error)));
+			}).pipe(Effect.mapError((error) => mapAcpToAdapterError(PROVIDER$2, input.threadId, "session/start", error)));
 			const requestedStartModelId = grokModelSelection?.model ? resolveGrokAcpBaseModelId(grokModelSelection.model) : void 0;
 			const boundModelId = yield* applyGrokAcpModelSelection({
 				runtime: acp,
 				currentModelId: currentGrokModelIdFromSessionSetup(started.sessionSetupResult),
 				requestedModelId: requestedStartModelId,
-				mapError: (cause) => mapAcpToAdapterError(PROVIDER$1, input.threadId, "session/set_model", cause)
+				mapError: (cause) => mapAcpToAdapterError(PROVIDER$2, input.threadId, "session/set_model", cause)
 			});
 			const now = yield* nowIso;
 			const session = {
-				provider: PROVIDER$1,
+				provider: PROVIDER$2,
 				providerInstanceId: boundInstanceId,
 				status: "ready",
 				runtimeMode: input.runtimeMode,
@@ -80364,7 +80907,7 @@ function makeGrokAdapter(grokSettings, options) {
 					case "AssistantItemStarted":
 						yield* offerRuntimeEvent(makeAcpAssistantItemEvent({
 							stamp,
-							provider: PROVIDER$1,
+							provider: PROVIDER$2,
 							threadId: ctx.threadId,
 							turnId: notificationTurnId,
 							itemId: event.itemId,
@@ -80374,7 +80917,7 @@ function makeGrokAdapter(grokSettings, options) {
 					case "AssistantItemCompleted":
 						yield* offerRuntimeEvent(makeAcpAssistantItemEvent({
 							stamp,
-							provider: PROVIDER$1,
+							provider: PROVIDER$2,
 							threadId: ctx.threadId,
 							turnId: notificationTurnId,
 							itemId: event.itemId,
@@ -80387,7 +80930,7 @@ function makeGrokAdapter(grokSettings, options) {
 					case "ToolCallUpdated":
 						yield* offerRuntimeEvent(makeAcpToolCallEvent({
 							stamp,
-							provider: PROVIDER$1,
+							provider: PROVIDER$2,
 							threadId: ctx.threadId,
 							turnId: notificationTurnId,
 							toolCall: event.toolCall,
@@ -80397,7 +80940,7 @@ function makeGrokAdapter(grokSettings, options) {
 					case "ContentDelta":
 						yield* offerRuntimeEvent(makeAcpContentDeltaEvent({
 							stamp,
-							provider: PROVIDER$1,
+							provider: PROVIDER$2,
 							threadId: ctx.threadId,
 							turnId: notificationTurnId,
 							...event.itemId ? { itemId: event.itemId } : {},
@@ -80412,14 +80955,14 @@ function makeGrokAdapter(grokSettings, options) {
 			yield* offerRuntimeEvent({
 				type: "session.started",
 				...yield* makeEventStamp(),
-				provider: PROVIDER$1,
+				provider: PROVIDER$2,
 				threadId: input.threadId,
 				payload: { resume: started.initializeResult }
 			});
 			yield* offerRuntimeEvent({
 				type: "session.state.changed",
 				...yield* makeEventStamp(),
-				provider: PROVIDER$1,
+				provider: PROVIDER$2,
 				threadId: input.threadId,
 				payload: {
 					state: "ready",
@@ -80429,7 +80972,7 @@ function makeGrokAdapter(grokSettings, options) {
 			yield* offerRuntimeEvent({
 				type: "thread.started",
 				...yield* makeEventStamp(),
-				provider: PROVIDER$1,
+				provider: PROVIDER$2,
 				threadId: input.threadId,
 				payload: { providerThreadId: started.sessionId }
 			});
@@ -80455,7 +80998,7 @@ function makeGrokAdapter(grokSettings, options) {
 						runtime: ctx.acp,
 						currentModelId: ctx.currentModelId,
 						requestedModelId: requestedTurnModelId,
-						mapError: (cause) => mapAcpToAdapterError(PROVIDER$1, input.threadId, "session/set_model", cause)
+						mapError: (cause) => mapAcpToAdapterError(PROVIDER$2, input.threadId, "session/set_model", cause)
 					});
 					const text = input.input?.trim();
 					const imagePromptParts = yield* Effect.forEach(input.attachments ?? [], (attachment) => Effect.gen(function* () {
@@ -80464,12 +81007,12 @@ function makeGrokAdapter(grokSettings, options) {
 							attachment
 						});
 						if (!attachmentPath) return yield* new ProviderAdapterRequestError({
-							provider: PROVIDER$1,
+							provider: PROVIDER$2,
 							method: "session/prompt",
 							detail: `Invalid attachment id '${attachment.id}'.`
 						});
 						const bytes = yield* fileSystem.readFile(attachmentPath).pipe(Effect.mapError((cause) => new ProviderAdapterRequestError({
-							provider: PROVIDER$1,
+							provider: PROVIDER$2,
 							method: "session/prompt",
 							detail: cause.message,
 							cause
@@ -80485,7 +81028,7 @@ function makeGrokAdapter(grokSettings, options) {
 						text
 					}] : [], ...imagePromptParts];
 					if (promptParts.length === 0) return yield* new ProviderAdapterValidationError({
-						provider: PROVIDER$1,
+						provider: PROVIDER$2,
 						operation: "sendTurn",
 						issue: "Turn requires non-empty text or attachments."
 					});
@@ -80499,7 +81042,7 @@ function makeGrokAdapter(grokSettings, options) {
 							settleAllPrompts: true
 						});
 						return yield* new ProviderAdapterRequestError({
-							provider: PROVIDER$1,
+							provider: PROVIDER$2,
 							method: "session/prompt",
 							detail: "Grok prompt was interrupted during preparation."
 						});
@@ -80515,7 +81058,7 @@ function makeGrokAdapter(grokSettings, options) {
 					if (steeringTurnId === void 0) yield* offerRuntimeEvent({
 						type: "turn.started",
 						...yield* makeEventStamp(),
-						provider: PROVIDER$1,
+						provider: PROVIDER$2,
 						threadId: input.threadId,
 						turnId,
 						payload: displayModel ? { model: displayModel } : {}
@@ -80541,7 +81084,7 @@ function makeGrokAdapter(grokSettings, options) {
 			const promptResultRef = yield* Ref.make(void 0);
 			const promptFailureMessageRef = yield* Ref.make(void 0);
 			return yield* Effect.gen(function* () {
-				const result = yield* prepared.acp.prompt({ prompt: prepared.promptParts }).pipe(Effect.tap((promptResult) => Effect.all([Ref.set(promptRpcSucceeded, true), Ref.set(promptResultRef, promptResult)])), Effect.tapError((error) => Ref.set(promptFailureMessageRef, mapAcpToAdapterError(PROVIDER$1, input.threadId, "session/prompt", error).message).pipe(Effect.andThen(prepared.acp.drainEvents))), Effect.mapError((error) => mapAcpToAdapterError(PROVIDER$1, input.threadId, "session/prompt", error)));
+				const result = yield* prepared.acp.prompt({ prompt: prepared.promptParts }).pipe(Effect.tap((promptResult) => Effect.all([Ref.set(promptRpcSucceeded, true), Ref.set(promptResultRef, promptResult)])), Effect.tapError((error) => Ref.set(promptFailureMessageRef, mapAcpToAdapterError(PROVIDER$2, input.threadId, "session/prompt", error).message).pipe(Effect.andThen(prepared.acp.drainEvents))), Effect.mapError((error) => mapAcpToAdapterError(PROVIDER$2, input.threadId, "session/prompt", error)));
 				return yield* withThreadLock(input.threadId, Effect.gen(function* () {
 					const ctx = yield* requireSession(input.threadId);
 					if (ctx.acpSessionId !== prepared.acpSessionId) {
@@ -80551,7 +81094,7 @@ function makeGrokAdapter(grokSettings, options) {
 						});
 						yield* Ref.set(promptSettled, true);
 						return yield* new ProviderAdapterRequestError({
-							provider: PROVIDER$1,
+							provider: PROVIDER$2,
 							method: "session/prompt",
 							detail: "Grok session changed before the turn completed."
 						});
@@ -80606,7 +81149,7 @@ function makeGrokAdapter(grokSettings, options) {
 						yield* offerRuntimeEvent({
 							type: "turn.completed",
 							...yield* makeEventStamp(),
-							provider: PROVIDER$1,
+							provider: PROVIDER$2,
 							threadId: input.threadId,
 							turnId: prepared.turnId,
 							payload: {
@@ -80676,7 +81219,7 @@ function makeGrokAdapter(grokSettings, options) {
 				const interruptedTurnId = observed.interruptedTurnId ?? turnId ?? activeTurnId ?? ctx.session.activeTurnId;
 				yield* settlePendingApprovalsAsCancelled(ctx.pendingApprovals);
 				yield* settlePendingUserInputsAsCancelled(ctx.pendingUserInputs);
-				yield* Effect.ignore(ctx.acp.cancel.pipe(Effect.mapError((error) => mapAcpToAdapterError(PROVIDER$1, threadId, "session/cancel", error))));
+				yield* Effect.ignore(ctx.acp.cancel.pipe(Effect.mapError((error) => mapAcpToAdapterError(PROVIDER$2, threadId, "session/cancel", error))));
 				if (interruptedTurnId) {
 					ctx.interruptedTurnIds.add(interruptedTurnId);
 					yield* settlePromptInFlight(threadId, interruptedTurnId, ctx.acpSessionId, {
@@ -80699,7 +81242,7 @@ function makeGrokAdapter(grokSettings, options) {
 		const respondToRequest = (threadId, requestId, decision) => Effect.gen(function* () {
 			const pending = (yield* requireSession(threadId)).pendingApprovals.get(requestId);
 			if (!pending) return yield* new ProviderAdapterRequestError({
-				provider: PROVIDER$1,
+				provider: PROVIDER$2,
 				method: "session/request_permission",
 				detail: `Unknown pending approval request: ${requestId}`
 			});
@@ -80708,7 +81251,7 @@ function makeGrokAdapter(grokSettings, options) {
 		const respondToUserInput = (threadId, requestId, answers) => Effect.gen(function* () {
 			const pending = (yield* requireSession(threadId)).pendingUserInputs.get(requestId);
 			if (!pending) return yield* new ProviderAdapterRequestError({
-				provider: PROVIDER$1,
+				provider: PROVIDER$2,
 				method: "_x.ai/ask_user_question",
 				detail: `Unknown pending user-input request: ${requestId}`
 			});
@@ -80726,12 +81269,12 @@ function makeGrokAdapter(grokSettings, options) {
 		const rollbackThread = (threadId, numTurns) => Effect.gen(function* () {
 			yield* requireSession(threadId);
 			if (!Number.isInteger(numTurns) || numTurns < 1) return yield* new ProviderAdapterValidationError({
-				provider: PROVIDER$1,
+				provider: PROVIDER$2,
 				operation: "rollbackThread",
 				issue: "numTurns must be an integer >= 1."
 			});
 			return yield* new ProviderAdapterRequestError({
-				provider: PROVIDER$1,
+				provider: PROVIDER$2,
 				method: "thread/rollback",
 				detail: "Grok ACP sessions do not support provider-side rollback yet."
 			});
@@ -80749,7 +81292,7 @@ function makeGrokAdapter(grokSettings, options) {
 		yield* Effect.addFinalizer(() => Effect.ignore(stopAll()).pipe(Effect.tap(() => PubSub.shutdown(runtimeEventPubSub)), Effect.tap(() => managedNativeEventLogger?.close() ?? Effect.void)));
 		const streamEvents = Stream.fromPubSub(runtimeEventPubSub);
 		return {
-			provider: PROVIDER$1,
+			provider: PROVIDER$2,
 			capabilities: { sessionModelSwitch: "in-session" },
 			startSession,
 			sendTurn,
@@ -80774,14 +81317,14 @@ const GROK_PRESENTATION = {
 	showInteractionModeToggle: false,
 	requiresNewThreadForModelChange: true
 };
-const EMPTY_CAPABILITIES = createModelCapabilities({ optionDescriptors: [] });
-const VERSION_PROBE_TIMEOUT_MS = 4e3;
+const EMPTY_CAPABILITIES$1 = 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
+	capabilities: EMPTY_CAPABILITIES$1
 }];
 function buildInitialGrokProviderSnapshot(grokSettings) {
 	return Effect.gen(function* () {
@@ -80816,7 +81359,7 @@ function buildInitialGrokProviderSnapshot(grokSettings) {
 	});
 }
 function grokModelsFromSettings(customModels, builtInModels = GROK_BUILT_IN_MODELS) {
-	return providerModelsFromSettings(builtInModels, customModels ?? [], EMPTY_CAPABILITIES);
+	return providerModelsFromSettings(builtInModels, customModels ?? [], EMPTY_CAPABILITIES$1);
 }
 function buildGrokDiscoveredModelsFromSessionModelState(modelState) {
 	if (!modelState || modelState.availableModels.length === 0) return [];
@@ -80829,7 +81372,7 @@ function buildGrokDiscoveredModelsFromSessionModelState(modelState) {
 			slug,
 			name: model.name.trim() || slug,
 			isCustom: false,
-			capabilities: EMPTY_CAPABILITIES
+			capabilities: EMPTY_CAPABILITIES$1
 		};
 	}).filter((model) => model !== void 0);
 }
@@ -80869,7 +81412,7 @@ const checkGrokProviderStatus = Effect.fn("checkGrokProviderStatus")(function* (
 			message: "Grok is disabled in P4Code settings."
 		}
 	});
-	const versionResult = yield* runGrokVersionCommand(grokSettings, environment).pipe(Effect.timeoutOption(VERSION_PROBE_TIMEOUT_MS), Effect.result);
+	const versionResult = yield* runGrokVersionCommand(grokSettings, environment).pipe(Effect.timeoutOption(VERSION_PROBE_TIMEOUT_MS$1), Effect.result);
 	if (Result.isFailure(versionResult)) {
 		const error = versionResult.failure;
 		const missing = isCommandMissingCause(error);
@@ -80978,22 +81521,22 @@ const enrichGrokSnapshot = (input) => {
 //#endregion
 //#region src/provider/Drivers/GrokDriver.ts
 const decodeGrokSettings = Schema$1.decodeSync(GrokSettings);
-const DRIVER_KIND$1 = ProviderDriverKind.make("grok");
-const SNAPSHOT_REFRESH_INTERVAL$1 = Duration.minutes(5);
-const UPDATE$1 = makeStaticProviderMaintenanceResolver(makeManualOnlyProviderMaintenanceCapabilities({
-	provider: DRIVER_KIND$1,
+const DRIVER_KIND$2 = ProviderDriverKind.make("grok");
+const SNAPSHOT_REFRESH_INTERVAL$2 = Duration.minutes(5);
+const UPDATE$2 = makeStaticProviderMaintenanceResolver(makeManualOnlyProviderMaintenanceCapabilities({
+	provider: DRIVER_KIND$2,
 	packageName: null
 }));
-const withInstanceIdentity$1 = (input) => (snapshot) => ({
+const withInstanceIdentity$2 = (input) => (snapshot) => ({
 	...snapshot,
 	instanceId: input.instanceId,
-	driver: DRIVER_KIND$1,
+	driver: DRIVER_KIND$2,
 	...input.displayName ? { displayName: input.displayName } : {},
 	...input.accentColor ? { accentColor: input.accentColor } : {},
 	continuation: { groupKey: input.continuationGroupKey }
 });
 const GrokDriver = {
-	driverKind: DRIVER_KIND$1,
+	driverKind: DRIVER_KIND$2,
 	metadata: {
 		displayName: "Grok",
 		supportsMultipleInstances: true
@@ -81008,10 +81551,10 @@ const GrokDriver = {
 		const eventLoggers = yield* ProviderEventLoggers;
 		const processEnv = mergeProviderInstanceEnvironment(environment);
 		const continuationIdentity = defaultProviderContinuationIdentity({
-			driverKind: DRIVER_KIND$1,
+			driverKind: DRIVER_KIND$2,
 			instanceId
 		});
-		const stampIdentity = withInstanceIdentity$1({
+		const stampIdentity = withInstanceIdentity$2({
 			instanceId,
 			displayName,
 			accentColor,
@@ -81021,7 +81564,7 @@ const GrokDriver = {
 			...config,
 			enabled
 		};
-		const maintenanceCapabilities = yield* resolveProviderMaintenanceCapabilitiesEffect(UPDATE$1, {
+		const maintenanceCapabilities = yield* resolveProviderMaintenanceCapabilitiesEffect(UPDATE$2, {
 			binaryPath: effectiveConfig.binaryPath,
 			env: processEnv
 		});
@@ -81047,11 +81590,1467 @@ const GrokDriver = {
 				publishSnapshot,
 				httpClient
 			}),
+			refreshInterval: SNAPSHOT_REFRESH_INTERVAL$2
+		}).pipe(Effect.mapError((cause) => new ProviderDriverError({
+			driver: DRIVER_KIND$2,
+			instanceId,
+			detail: `Failed to build Grok snapshot: ${cause.message ?? String(cause)}`,
+			cause
+		})));
+		return {
+			instanceId,
+			driverKind: DRIVER_KIND$2,
+			continuationIdentity,
+			displayName,
+			accentColor,
+			enabled,
+			snapshot,
+			adapter,
+			textGeneration
+		};
+	})
+};
+/**
+* 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`.
+*
+* 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
+* process. Process ownership lives in `MuseExecRuntime`.
+*
+* @module provider/muse/MuseExecEvents
+*/
+/** Longest tool result text carried on an `item.completed` detail. */
+const MAX_TOOL_DETAIL_CHARS = 2e3;
+function makeMuseExecTurnState() {
+	return {
+		modelId: void 0,
+		assistantItemStarted: false,
+		assistantText: "",
+		toolNameByTaskId: /* @__PURE__ */ new Map(),
+		taskIdByCallId: /* @__PURE__ */ new Map(),
+		settledToolTaskIds: /* @__PURE__ */ new Set(),
+		terminal: void 0
+	};
+}
+/**
+* Decode one line of `muse exec --json`. Returns `undefined` for blank lines
+* and for anything that is not a JSON object with a string `payload_type`, so
+* a stray line can never abort a turn.
+*/
+function parseMuseExecLine(line) {
+	const trimmed = line.trim();
+	if (trimmed.length === 0) return void 0;
+	let decoded;
+	try {
+		decoded = JSON.parse(trimmed);
+	} catch {
+		return;
+	}
+	if (!isRecord$1(decoded)) return void 0;
+	const payloadType = decoded["payload_type"];
+	if (typeof payloadType !== "string") return void 0;
+	const payload = isRecord$1(decoded["payload"]) ? decoded["payload"] : {};
+	const stream = isRecord$1(decoded["stream"]) ? decoded["stream"] : void 0;
+	const streamId = stream?.["id"];
+	const sequence = decoded["sequence"];
+	return {
+		payloadType,
+		payload,
+		sequence: typeof sequence === "number" ? sequence : void 0,
+		sessionId: stream?.["kind"] === "session" && typeof streamId === "string" ? streamId : void 0
+	};
+}
+/**
+* Map one CLI record onto zero or more event drafts, mutating `state`.
+*
+* The CLI stream is deliberately lossy compared with the persisted session
+* log: tool call *arguments* and token usage never appear on stdout. Those
+* are recovered separately from `session.jsonl` (see `MuseSessionLog`).
+*/
+function mapMuseExecRecord(input) {
+	const { record, state, context } = input;
+	const payload = record.payload;
+	switch (record.payloadType) {
+		case "run.model.configured": {
+			const modelId = stringField(payload, "model_id");
+			if (modelId) state.modelId = modelId;
+			return [(stamp) => ({
+				type: "session.configured",
+				...stamp,
+				...base(context),
+				payload: { config: payload },
+				raw: rawFrom(record)
+			})];
+		}
+		case "run.lifecycle.started": return [(stamp) => ({
+			type: "turn.started",
+			...stamp,
+			...base(context),
+			payload: state.modelId ? { model: state.modelId } : {},
+			raw: rawFrom(record)
+		})];
+		case "run.output.delta": {
+			const text = stringField(payload, "text");
+			if (text === void 0 || text.length === 0) return [];
+			return appendAssistantText({
+				text,
+				state,
+				context,
+				record
+			});
+		}
+		case "task.lifecycle.proposed": {
+			const event = eventField(payload);
+			const taskId = stringField(event, "task_id");
+			const toolName = toolNameFromTaskKind(stringField(event, "task_kind"));
+			if (!taskId || !toolName) return [];
+			state.toolNameByTaskId.set(taskId, toolName);
+			return [(stamp) => ({
+				type: "item.started",
+				...stamp,
+				...base(context),
+				itemId: RuntimeItemId.make(taskId),
+				payload: {
+					itemType: itemTypeForToolName(toolName),
+					status: "inProgress",
+					title: toolName
+				},
+				raw: rawFrom(record)
+			})];
+		}
+		case "task.lifecycle.side_effect_intent": {
+			const event = eventField(payload);
+			const taskId = stringField(event, "task_id");
+			const callId = toolCallIdFromIdempotencyKey(stringField(event, "idempotency_key"));
+			if (taskId && callId) state.taskIdByCallId.set(callId, taskId);
+			return [];
+		}
+		case "task.lifecycle.output": {
+			const event = eventField(payload);
+			const taskId = stringField(event, "task_id");
+			const chunk = stringField(event, "chunk");
+			if (!taskId || !chunk) return [];
+			const toolName = state.toolNameByTaskId.get(taskId);
+			if (!toolName) return [];
+			const streamKind = itemTypeForToolName(toolName) === "command_execution" ? "command_output" : "file_change_output";
+			return [(stamp) => ({
+				type: "content.delta",
+				...stamp,
+				...base(context),
+				itemId: RuntimeItemId.make(taskId),
+				payload: {
+					streamKind,
+					delta: chunk
+				},
+				raw: rawFrom(record)
+			})];
+		}
+		case "tool.result": {
+			const callId = stringField(payload, "call_id");
+			const taskId = callId ? state.taskIdByCallId.get(callId) : void 0;
+			if (!taskId) return [];
+			const toolName = state.toolNameByTaskId.get(taskId);
+			state.settledToolTaskIds.add(taskId);
+			const failed = stringField(recordField(payload, "correlation_facts"), "outcome") === "error";
+			const detail = truncate(stringField(payload, "text"), MAX_TOOL_DETAIL_CHARS);
+			const editFacts = recordField(payload, "edit_facts");
+			return [(stamp) => ({
+				type: "item.completed",
+				...stamp,
+				...base(context),
+				itemId: RuntimeItemId.make(taskId),
+				payload: {
+					itemType: itemTypeForToolName(toolName),
+					status: failed ? "failed" : "completed",
+					...toolName ? { title: toolName } : {},
+					...detail ? { detail } : {},
+					...editFacts ? { data: editFacts } : {}
+				},
+				raw: rawFrom(record)
+			})];
+		}
+		case "task.lifecycle.failed": {
+			const event = eventField(payload);
+			const taskId = stringField(event, "task_id");
+			if (!taskId) return [];
+			const toolName = state.toolNameByTaskId.get(taskId);
+			if (!toolName || state.settledToolTaskIds.has(taskId)) return [];
+			state.settledToolTaskIds.add(taskId);
+			const detail = truncate(stringField(event, "reason"), MAX_TOOL_DETAIL_CHARS);
+			return [(stamp) => ({
+				type: "item.completed",
+				...stamp,
+				...base(context),
+				itemId: RuntimeItemId.make(taskId),
+				payload: {
+					itemType: itemTypeForToolName(toolName),
+					status: "failed",
+					title: toolName,
+					...detail ? { detail } : {}
+				},
+				raw: rawFrom(record)
+			})];
+		}
+		default: break;
+	}
+	if (record.payloadType.startsWith("run.terminal.")) return mapTerminalRecord({
+		record,
+		state,
+		context
+	});
+	return [];
+}
+/**
+* Terminal record handling. The final `text` is the authoritative assistant
+* message and is a superset of the streamed deltas (Muse streams the visible
+* prefix only), so any remainder is flushed as one last delta before the
+* assistant item closes.
+*/
+function mapTerminalRecord(input) {
+	const { record, state, context } = input;
+	const terminalState = turnStateFromTerminal(stringField(record.payload, "terminal") ?? record.payloadType.slice(13));
+	state.terminal = terminalState;
+	const drafts = [];
+	const remainder = assistantTextRemainder(state.assistantText, stringField(record.payload, "text"));
+	if (remainder) drafts.push(...appendAssistantText({
+		text: remainder,
+		state,
+		context,
+		record
+	}));
+	if (state.assistantItemStarted) drafts.push((stamp) => ({
+		type: "item.completed",
+		...stamp,
+		...base(context),
+		itemId: RuntimeItemId.make(context.assistantItemId),
+		payload: {
+			itemType: "assistant_message",
+			status: "completed"
+		}
+	}));
+	const reason = stringField(record.payload, "reason");
+	drafts.push((stamp) => ({
+		type: "turn.completed",
+		...stamp,
+		...base(context),
+		payload: {
+			state: terminalState,
+			...reason ? { stopReason: reason } : {},
+			...terminalState === "failed" && reason ? { errorMessage: reason } : {}
+		},
+		raw: rawFrom(record)
+	}));
+	return drafts;
+}
+function appendAssistantText(input) {
+	const { text, state, context, record } = input;
+	const drafts = [];
+	if (!state.assistantItemStarted) {
+		state.assistantItemStarted = true;
+		drafts.push((stamp) => ({
+			type: "item.started",
+			...stamp,
+			...base(context),
+			itemId: RuntimeItemId.make(context.assistantItemId),
+			payload: {
+				itemType: "assistant_message",
+				status: "inProgress"
+			}
+		}));
+	}
+	state.assistantText += text;
+	drafts.push((stamp) => ({
+		type: "content.delta",
+		...stamp,
+		...base(context),
+		itemId: RuntimeItemId.make(context.assistantItemId),
+		payload: {
+			streamKind: "assistant_text",
+			delta: text
+		},
+		raw: rawFrom(record)
+	}));
+	return drafts;
+}
+/**
+* The tail of `finalText` that was never streamed. Returns `undefined` when
+* the streamed text already covers it, or when the two diverge — a divergent
+* final text is dropped rather than duplicated into the transcript.
+*/
+function assistantTextRemainder(streamed, finalText) {
+	if (finalText === void 0 || finalText.length === 0) return void 0;
+	if (streamed.length === 0) return finalText;
+	if (!finalText.startsWith(streamed)) return void 0;
+	const remainder = finalText.slice(streamed.length);
+	return remainder.length > 0 ? remainder : void 0;
+}
+function turnStateFromTerminal(terminal) {
+	switch (terminal) {
+		case "completed": return "completed";
+		case "cancelled":
+		case "canceled": return "cancelled";
+		case "interrupted": return "interrupted";
+		default: return "failed";
+	}
+}
+/** `tool.write_file` → `write_file`; anything else is not a tool task. */
+function toolNameFromTaskKind(taskKind) {
+	if (!taskKind || !taskKind.startsWith("tool.")) return void 0;
+	const name = taskKind.slice(5).trim();
+	return name.length > 0 ? name : void 0;
+}
+/** `tool:call_019f…` → `call_019f…`. */
+function toolCallIdFromIdempotencyKey(key) {
+	if (!key || !key.startsWith("tool:")) return void 0;
+	const callId = key.slice(5).trim();
+	return callId.length > 0 ? callId : void 0;
+}
+function itemTypeForToolName(toolName) {
+	switch (toolName) {
+		case "bash":
+		case "shell":
+		case "run_command":
+		case "unified_exec": 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";
+		default:
+			if (toolName?.startsWith("subagent_")) return "collab_agent_tool_call";
+			if (toolName?.startsWith("mcp__")) return "mcp_tool_call";
+			return "dynamic_tool_call";
+	}
+}
+function base(context) {
+	return {
+		provider: context.provider,
+		...context.providerInstanceId ? { providerInstanceId: context.providerInstanceId } : {},
+		threadId: context.threadId,
+		turnId: context.turnId
+	};
+}
+function rawFrom(record) {
+	return {
+		source: "muse.exec.jsonl",
+		method: record.payloadType,
+		payload: record.payload
+	};
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringField(source, key) {
+	const value = source?.[key];
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function recordField(source, key) {
+	const value = source?.[key];
+	return isRecord$1(value) ? value : void 0;
+}
+function eventField(payload) {
+	return recordField(payload, "event");
+}
+function truncate(value, max) {
+	if (value === void 0) return void 0;
+	const trimmed = value.trim();
+	if (trimmed.length === 0) return void 0;
+	return trimmed.length <= max ? trimmed : `${trimmed.slice(0, max)}…`;
+}
+//#endregion
+//#region src/textGeneration/MuseTextGeneration.ts
+/**
+* MuseTextGeneration — commit messages, PR text, branch names and thread
+* titles through Muse Code.
+*
+* Muse has no lightweight completion endpoint behind the CLI, so each request
+* is one headless `muse exec --json` run with the session log disabled: a
+* throwaway agent turn whose final text we parse as JSON. Reasoning effort is
+* pinned low because these are short structured-output tasks and Muse Spark
+* bills reasoning as output tokens.
+*
+* @module textGeneration/MuseTextGeneration
+*/
+const MUSE_TIMEOUT_MS = 18e4;
+const MUSE_TEXT_REASONING_EFFORT = "low";
+/** A structured-output turn should never need to loop; cap it cheaply. */
+const MUSE_TEXT_MAX_MODEL_STEPS = "8";
+const isTextGenerationError = Schema$1.is(TextGenerationError);
+/** Final assistant text from a `muse exec --json` stdout stream. */
+function museTerminalTextFromJsonl(stdout) {
+	let terminalText;
+	let streamed = "";
+	for (const line of stdout.split("\n")) {
+		const record = parseMuseExecLine(line);
+		if (!record) continue;
+		if (record.payloadType === "run.output.delta") {
+			const delta = record.payload["text"];
+			if (typeof delta === "string") streamed += delta;
+			continue;
+		}
+		if (record.payloadType.startsWith("run.terminal.")) {
+			const text = record.payload["text"];
+			if (typeof text === "string" && text.length > 0) terminalText = text;
+		}
+	}
+	const resolved = terminalText ?? streamed;
+	return resolved.trim().length > 0 ? resolved : void 0;
+}
+const makeMuseTextGeneration = (museSettings, environment = process.env) => Effect.sync(() => {
+	const runMuseJson = ({ operation, cwd, prompt, outputSchemaJson, modelSelection }) => Effect.gen(function* () {
+		const binaryPath = museSettings.binaryPath || "muse";
+		const spawnCommand = yield* resolveSpawnCommand(binaryPath, [
+			"exec",
+			"--json",
+			"--no-session-log",
+			"--reasoning-effort",
+			MUSE_TEXT_REASONING_EFFORT,
+			"--max-model-steps",
+			MUSE_TEXT_MAX_MODEL_STEPS,
+			"--disable-approval",
+			"--disable-write",
+			"--disable-shell",
+			...modelSelection.model ? ["--model", modelSelection.model] : [],
+			...museSettings.baseUrl ? ["--base-url", museSettings.baseUrl] : [],
+			prompt
+		], { env: environment });
+		const result = yield* spawnAndCollect(binaryPath, ChildProcess.make(spawnCommand.command, spawnCommand.args, {
+			cwd,
+			env: environment,
+			shell: spawnCommand.shell
+		})).pipe(Effect.timeoutOption(MUSE_TIMEOUT_MS), Effect.flatMap(Option.match({
+			onNone: () => Effect.fail(new TextGenerationError({
+				operation,
+				detail: "Muse Code request timed out."
+			})),
+			onSome: Effect.succeed
+		})), Effect.mapError((cause) => isTextGenerationError(cause) ? cause : new TextGenerationError({
+			operation,
+			detail: "Muse Code request failed.",
+			cause
+		})));
+		const output = museTerminalTextFromJsonl(result.stdout);
+		if (!output) return yield* new TextGenerationError({
+			operation,
+			detail: result.code === 0 ? "Muse Code returned empty output." : `Muse Code exited with code ${result.code}.`
+		});
+		return yield* Schema$1.decodeEffect(Schema$1.fromJsonString(outputSchemaJson))(extractJsonObject(output)).pipe(Effect.catchTags({ SchemaError: (cause) => Effect.fail(new TextGenerationError({
+			operation,
+			detail: "Muse Code returned invalid structured output.",
+			cause
+		})) }));
+	}).pipe(Effect.mapError((cause) => isTextGenerationError(cause) ? cause : new TextGenerationError({
+		operation,
+		detail: "Muse Code text generation failed.",
+		cause
+	})));
+	return {
+		generateCommitMessage: Effect.fn("MuseTextGeneration.generateCommitMessage")(function* (input) {
+			const { prompt, outputSchema } = buildCommitMessagePrompt({
+				branch: input.branch,
+				stagedSummary: input.stagedSummary,
+				stagedPatch: input.stagedPatch,
+				includeBranch: input.includeBranch === true,
+				policy: input.policy
+			});
+			const generated = yield* runMuseJson({
+				operation: "generateCommitMessage",
+				cwd: input.cwd,
+				prompt,
+				outputSchemaJson: outputSchema,
+				modelSelection: input.modelSelection
+			});
+			return {
+				subject: sanitizeCommitSubject(generated.subject),
+				body: generated.body.trim(),
+				..."branch" in generated && typeof generated.branch === "string" ? { branch: sanitizeFeatureBranchName(generated.branch) } : {}
+			};
+		}),
+		generatePrContent: Effect.fn("MuseTextGeneration.generatePrContent")(function* (input) {
+			const { prompt, outputSchema } = buildPrContentPrompt({
+				baseBranch: input.baseBranch,
+				headBranch: input.headBranch,
+				commitSummary: input.commitSummary,
+				diffSummary: input.diffSummary,
+				diffPatch: input.diffPatch,
+				policy: input.policy,
+				changeRequestTemplate: input.changeRequestTemplate
+			});
+			const generated = yield* runMuseJson({
+				operation: "generatePrContent",
+				cwd: input.cwd,
+				prompt,
+				outputSchemaJson: outputSchema,
+				modelSelection: input.modelSelection
+			});
+			return {
+				title: sanitizePrTitle(generated.title),
+				body: generated.body.trim()
+			};
+		}),
+		generateBranchName: Effect.fn("MuseTextGeneration.generateBranchName")(function* (input) {
+			const { prompt, outputSchema } = buildBranchNamePrompt({
+				message: input.message,
+				attachments: input.attachments
+			});
+			return { branch: sanitizeBranchFragment((yield* runMuseJson({
+				operation: "generateBranchName",
+				cwd: input.cwd,
+				prompt,
+				outputSchemaJson: outputSchema,
+				modelSelection: input.modelSelection
+			})).branch) };
+		}),
+		generateThreadTitle: Effect.fn("MuseTextGeneration.generateThreadTitle")(function* (input) {
+			const { prompt, outputSchema } = buildThreadTitlePrompt({
+				message: input.message,
+				attachments: input.attachments
+			});
+			return { title: sanitizeThreadTitle((yield* runMuseJson({
+				operation: "generateThreadTitle",
+				cwd: input.cwd,
+				prompt,
+				outputSchemaJson: outputSchema,
+				modelSelection: input.modelSelection
+			})).title) };
+		})
+	};
+});
+//#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.
+*
+* @module provider/muse/MuseExecRuntime
+*/
+/** Exit code Muse uses for a turn that failed or was cancelled. */
+const MUSE_EXIT_FAILED = 1;
+/** Exit codes produced by SIGINT / SIGTERM. */
+const MUSE_EXIT_SIGINT = 130;
+const MUSE_EXIT_SIGTERM = 143;
+/**
+* Spawn one turn. The child is bound to the caller's scope, so closing the
+* scope kills it; `awaitOutcome` is how a caller waits for a clean end.
+*/
+const runMuseExec = Effect.fn("runMuseExec")(function* (input) {
+	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+	const runScope = yield* Scope.Scope;
+	const spawnCommand = yield* resolveSpawnCommand(input.binaryPath, [...input.args], { env: input.environment }).pipe(Effect.mapError((cause) => new ProviderAdapterProcessError({
+		provider: "muse",
+		threadId: input.threadId,
+		detail: `Failed to resolve the Muse Code binary (${input.binaryPath}).`,
+		cause
+	})));
+	const child = yield* spawner.spawn(ChildProcess.make(spawnCommand.command, spawnCommand.args, {
+		cwd: input.cwd,
+		env: input.environment,
+		shell: spawnCommand.shell
+	})).pipe(Effect.provideService(Scope.Scope, runScope), Effect.mapError((cause) => new ProviderAdapterProcessError({
+		provider: "muse",
+		threadId: input.threadId,
+		detail: "Failed to spawn `muse exec`.",
+		cause
+	})));
+	const stderrRef = yield* Ref.make("");
+	const interruptedRef = yield* Ref.make(false);
+	const stdoutFiber = yield* child.stdout.pipe(Stream.decodeText(), Stream.splitLines, Stream.runForEach(input.onLine), Effect.ignore, Effect.forkIn(runScope));
+	const stderrFiber = yield* child.stderr.pipe(Stream.decodeText(), Stream.runForEach((chunk) => Ref.update(stderrRef, (stderr) => `${stderr}${chunk}`.slice(-4e3))), Effect.ignore, Effect.forkIn(runScope));
+	return {
+		awaitOutcome: Effect.gen(function* () {
+			const code = yield* child.exitCode.pipe(Effect.orElseSucceed(() => MUSE_EXIT_FAILED));
+			yield* Fiber.await(stdoutFiber).pipe(Effect.ignore);
+			yield* Fiber.await(stderrFiber).pipe(Effect.ignore);
+			const exitCode = Number(code);
+			const interrupted = yield* Ref.get(interruptedRef);
+			if (exitCode === 0) return { kind: "completed" };
+			if (interrupted || exitCode === MUSE_EXIT_SIGINT || exitCode === MUSE_EXIT_SIGTERM) return { kind: "interrupted" };
+			return {
+				kind: "failed",
+				exitCode,
+				stderr: (yield* Ref.get(stderrRef)).trim()
+			};
+		}),
+		interrupt: Ref.set(interruptedRef, true).pipe(Effect.andThen(child.kill({
+			killSignal: "SIGINT",
+			forceKillAfter: "5 seconds"
+		}).pipe(Effect.ignore)), Effect.asVoid)
+	};
+});
+//#endregion
+//#region src/provider/muse/MuseSessionLog.ts
+/** Root directory holding Muse Code's per-session event logs. */
+const museDataRoot = Effect.fn("museDataRoot")(function* (environment = process.env) {
+	const path = yield* Path.Path;
+	const xdgDataHome = environment["XDG_DATA_HOME"]?.trim();
+	const base = xdgDataHome && xdgDataHome.length > 0 ? xdgDataHome : path.join(NodeOS.homedir(), ".local", "share");
+	return path.join(base, "muse");
+});
+/**
+* Locate a session log by id. The CLI files logs under the date the session
+* was created, which we do not know for a resumed session, so the year /
+* month / day levels are walked. Returns `undefined` when the session has no
+* log yet (a `--no-session-log` run, or a run that died before its first
+* flush).
+*/
+const findMuseSessionLog = Effect.fn("findMuseSessionLog")(function* (input) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const sessionsRoot = path.join(yield* museDataRoot(input.environment ?? process.env), "sessions");
+	const listing = (directory) => fileSystem.readDirectory(directory).pipe(Effect.orElseSucceed(() => []));
+	const descending = (entries) => [...entries].sort().reverse();
+	for (const year of descending(yield* listing(sessionsRoot))) {
+		const yearPath = path.join(sessionsRoot, year);
+		for (const month of descending(yield* listing(yearPath))) {
+			const monthPath = path.join(yearPath, month);
+			for (const day of descending(yield* listing(monthPath))) {
+				const candidate = path.join(monthPath, day, input.sessionId, "session.jsonl");
+				if (yield* fileSystem.exists(candidate).pipe(Effect.orElseSucceed(() => false))) return candidate;
+			}
+		}
+	}
+});
+/**
+* Sum the token usage recorded in a session log.
+*
+* Muse attributes usage per model call (`goal_usage_attribution`), including
+* the background observer agents, so the totals here cover everything the
+* session spent — which is what a user reading a token counter expects.
+*/
+function parseMuseTokenUsage(contents) {
+	let total = {
+		inputTokens: 0,
+		outputTokens: 0,
+		cachedTokens: 0,
+		reasoningTokens: 0
+	};
+	let last;
+	let seen = false;
+	for (const line of contents.split("\n")) {
+		const quantity = usageQuantityFromLine(line);
+		if (!quantity) continue;
+		seen = true;
+		last = quantity;
+		total = {
+			inputTokens: total.inputTokens + quantity.inputTokens,
+			outputTokens: total.outputTokens + quantity.outputTokens,
+			cachedTokens: total.cachedTokens + quantity.cachedTokens,
+			reasoningTokens: total.reasoningTokens + quantity.reasoningTokens
+		};
+	}
+	if (!seen) return void 0;
+	return {
+		usedTokens: total.inputTokens + total.outputTokens,
+		inputTokens: total.inputTokens,
+		cachedInputTokens: total.cachedTokens,
+		outputTokens: total.outputTokens,
+		reasoningOutputTokens: total.reasoningTokens,
+		...last ? {
+			lastUsedTokens: last.inputTokens + last.outputTokens,
+			lastInputTokens: last.inputTokens,
+			lastCachedInputTokens: last.cachedTokens,
+			lastOutputTokens: last.outputTokens,
+			lastReasoningOutputTokens: last.reasoningTokens
+		} : {},
+		compactsAutomatically: true
+	};
+}
+function usageQuantityFromLine(line) {
+	const trimmed = line.trim();
+	if (trimmed.length === 0 || !trimmed.includes("goal_usage_attribution")) return void 0;
+	let decoded;
+	try {
+		decoded = JSON.parse(trimmed);
+	} catch {
+		return;
+	}
+	const quantity = readPath(decoded, [
+		"payload",
+		"event",
+		"record",
+		"quantity"
+	]);
+	if (!isRecord(quantity)) return void 0;
+	return {
+		inputTokens: nonNegativeInt(quantity["input_tokens"]),
+		outputTokens: nonNegativeInt(quantity["output_tokens"]),
+		cachedTokens: nonNegativeInt(quantity["cached_tokens"]),
+		reasoningTokens: nonNegativeInt(quantity["reasoning_tokens"])
+	};
+}
+/** Read a session's cumulative usage, or `undefined` when unavailable. */
+const readMuseSessionUsage = Effect.fn("readMuseSessionUsage")(function* (input) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const logPath = yield* findMuseSessionLog(input);
+	if (logPath === void 0) return void 0;
+	const contents = yield* fileSystem.readFileString(logPath).pipe(Effect.orElseSucceed(() => void 0));
+	return contents === void 0 ? void 0 : parseMuseTokenUsage(contents);
+});
+/**
+* Parse one `model-catalog/*.json` document. Hidden rows are dropped: the CLI
+* marks a row `visibility: "visible"` when it should appear in `/models`.
+*/
+function parseMuseModelCatalog(contents) {
+	let decoded;
+	try {
+		decoded = JSON.parse(contents);
+	} catch {
+		return [];
+	}
+	const rows = isRecord(decoded) ? decoded["rows"] : void 0;
+	if (!Array.isArray(rows)) return [];
+	const models = [];
+	for (const row of rows) {
+		if (!isRecord(row)) continue;
+		const slug = typeof row["model_id"] === "string" ? row["model_id"].trim() : "";
+		if (slug.length === 0) continue;
+		if (typeof row["visibility"] === "string" && row["visibility"] !== "visible") continue;
+		const label = typeof row["display_label"] === "string" ? row["display_label"].trim() : "";
+		const contextLimit = row["context_limit"];
+		models.push({
+			slug,
+			name: label.length > 0 ? label : slug,
+			contextLimit: typeof contextLimit === "number" && contextLimit > 0 ? contextLimit : void 0,
+			isDefault: row["is_default"] === true
+		});
+	}
+	return models;
+}
+/** Read every model row the CLI has cached on disk. */
+const readMuseModelCatalog = Effect.fn("readMuseModelCatalog")(function* (environment = process.env) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const catalogRoot = path.join(yield* museDataRoot(environment), "model-catalog");
+	const entries = yield* fileSystem.readDirectory(catalogRoot).pipe(Effect.orElseSucceed(() => []));
+	const bySlug = /* @__PURE__ */ new Map();
+	for (const entry of [...entries].sort()) {
+		if (!entry.endsWith(".json")) continue;
+		const contents = yield* fileSystem.readFileString(path.join(catalogRoot, entry)).pipe(Effect.orElseSucceed(() => void 0));
+		if (contents === void 0) continue;
+		for (const model of parseMuseModelCatalog(contents)) if (!bySlug.has(model.slug)) bySlug.set(model.slug, model);
+	}
+	return [...bySlug.values()];
+});
+function readPath(source, keys) {
+	let current = source;
+	for (const key of keys) {
+		if (!isRecord(current)) return void 0;
+		current = current[key];
+	}
+	return current;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonNegativeInt(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.trunc(value) : 0;
+}
+//#endregion
+//#region src/provider/Layers/MuseAdapter.ts
+/**
+* MuseAdapter — Meta Muse Code as a P4Code provider.
+*
+* Muse Code (beta, CLI 0.1.0) exposes no ACP or app-server protocol; the only
+* scriptable surface is `muse exec --json`, which runs one prompt to
+* completion and streams JSONL events on stdout. A P4Code thread therefore
+* maps onto a Muse *session id*: every turn spawns a fresh `muse exec` with
+* `--session-id`, and Muse replays its own event-sourced session log to
+* recover the conversation.
+*
+* 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 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
+*     session log; items carry the tool name, its result text, and Muse's
+*     `edit_facts`.
+*
+* @module provider/Layers/MuseAdapter
+*/
+const PROVIDER$1 = ProviderDriverKind.make("muse");
+const MUSE_RESUME_VERSION = 1;
+function museResumeCursor(museSessionId) {
+	return {
+		version: MUSE_RESUME_VERSION,
+		sessionId: museSessionId
+	};
+}
+/** Recover a Muse session id from a persisted resume cursor. */
+function parseMuseResume(raw) {
+	if (typeof raw !== "object" || raw === null) return void 0;
+	const candidate = raw;
+	if (candidate.version !== MUSE_RESUME_VERSION) return void 0;
+	return typeof candidate.sessionId === "string" && candidate.sessionId.length > 0 ? { sessionId: candidate.sessionId } : void 0;
+}
+function makeMuseAdapter(museSettings, options) {
+	return Effect.gen(function* () {
+		const boundInstanceId = options?.instanceId ?? ProviderInstanceId.make("muse");
+		const environment = options?.environment ?? process.env;
+		const crypto = yield* Crypto.Crypto;
+		const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+		const fileSystem = yield* FileSystem.FileSystem;
+		const path = yield* Path.Path;
+		const serverConfig = yield* Effect.service(ServerConfig$1);
+		const sessions = /* @__PURE__ */ new Map();
+		const runtimeEventPubSub = yield* PubSub.unbounded();
+		const nowIso = Effect.map(DateTime.now, DateTime.formatIso);
+		const randomUUIDv4 = crypto.randomUUIDv4.pipe(Effect.mapError((cause) => new ProviderAdapterRequestError({
+			provider: PROVIDER$1,
+			method: "crypto/randomUUIDv4",
+			detail: "Failed to generate a Muse runtime identifier.",
+			cause
+		})));
+		const makeEventStamp = () => Effect.all({
+			eventId: Effect.map(randomUUIDv4, EventId.make),
+			createdAt: nowIso
+		});
+		const publish = (event) => PubSub.publish(runtimeEventPubSub, event).pipe(Effect.asVoid);
+		const requireSession = (threadId) => Effect.suspend(() => {
+			const ctx = sessions.get(threadId);
+			return ctx === void 0 || ctx.stopped ? Effect.fail(new ProviderAdapterSessionNotFoundError({
+				provider: PROVIDER$1,
+				threadId
+			})) : Effect.succeed(ctx);
+		});
+		const startSession = (input) => Effect.gen(function* () {
+			const existing = sessions.get(input.threadId);
+			if (existing && !existing.stopped) return { ...existing.session };
+			const resumed = parseMuseResume(input.resumeCursor);
+			const museSessionId = resumed?.sessionId ?? (yield* randomUUIDv4);
+			const cwd = input.cwd ?? process.cwd();
+			const createdAt = yield* nowIso;
+			const session = {
+				provider: PROVIDER$1,
+				providerInstanceId: boundInstanceId,
+				status: "ready",
+				runtimeMode: input.runtimeMode,
+				cwd,
+				...input.modelSelection?.model ? { model: input.modelSelection.model } : {},
+				threadId: input.threadId,
+				resumeCursor: museResumeCursor(museSessionId),
+				createdAt,
+				updatedAt: createdAt
+			};
+			const ctx = {
+				threadId: input.threadId,
+				museSessionId,
+				cwd,
+				session,
+				activeTurn: void 0,
+				turns: [],
+				stopped: false
+			};
+			sessions.set(input.threadId, ctx);
+			yield* publish({
+				type: "session.started",
+				...yield* makeEventStamp(),
+				provider: PROVIDER$1,
+				providerInstanceId: boundInstanceId,
+				threadId: input.threadId,
+				payload: resumed ? { resume: input.resumeCursor } : {}
+			});
+			yield* publish({
+				type: "thread.started",
+				...yield* makeEventStamp(),
+				provider: PROVIDER$1,
+				providerInstanceId: boundInstanceId,
+				threadId: input.threadId,
+				payload: { providerThreadId: museSessionId }
+			});
+			if (museApprovalsUnsupported(input.runtimeMode)) yield* publish({
+				type: "config.warning",
+				...yield* makeEventStamp(),
+				provider: PROVIDER$1,
+				providerInstanceId: boundInstanceId,
+				threadId: input.threadId,
+				payload: {
+					summary: "Muse Code cannot ask for approvals in headless runs.",
+					details: "This thread runs with approvals disabled and Muse's OS sandbox enabled; `muse exec` has no channel to answer an approval prompt."
+				}
+			});
+			return { ...session };
+		});
+		const sendTurn = (input) => Effect.gen(function* () {
+			const ctx = yield* requireSession(input.threadId);
+			if (ctx.activeTurn) return yield* new ProviderAdapterRequestError({
+				provider: PROVIDER$1,
+				method: "muse/exec",
+				detail: "A Muse turn is already running on this thread. `muse exec` runs one prompt per process, so turns cannot overlap."
+			});
+			const prompt = input.input?.trim();
+			if (!prompt) return yield* new ProviderAdapterValidationError({
+				provider: PROVIDER$1,
+				operation: "sendTurn",
+				issue: "Muse Code requires prompt text; attachments alone cannot start a turn."
+			});
+			const imagePaths = [];
+			for (const attachment of input.attachments ?? []) {
+				const attachmentPath = resolveAttachmentPath({
+					attachmentsDir: serverConfig.attachmentsDir,
+					attachment
+				});
+				if (!attachmentPath) return yield* new ProviderAdapterRequestError({
+					provider: PROVIDER$1,
+					method: "muse/exec",
+					detail: `Invalid attachment id '${attachment.id}'.`
+				});
+				imagePaths.push(attachmentPath);
+			}
+			const turnId = TurnId.make(yield* randomUUIDv4);
+			const model = input.modelSelection?.model ?? ctx.session.model;
+			const args = buildMuseExecArgs({
+				sessionId: ctx.museSessionId,
+				prompt,
+				model,
+				baseUrl: museSettings.baseUrl || void 0,
+				runtimeMode: ctx.session.runtimeMode,
+				imagePaths
+			});
+			const state = makeMuseExecTurnState();
+			const mappingContext = {
+				provider: PROVIDER$1,
+				providerInstanceId: boundInstanceId,
+				threadId: input.threadId,
+				turnId,
+				assistantItemId: `${turnId}:assistant`
+			};
+			const handleLine = (line) => Effect.gen(function* () {
+				const record = parseMuseExecLine(line);
+				if (!record) return;
+				const drafts = mapMuseExecRecord({
+					record,
+					state,
+					context: mappingContext
+				});
+				for (const draft of drafts) yield* publish(draft(yield* makeEventStamp()));
+			}).pipe(Effect.orElseSucceed(() => void 0));
+			ctx.turns.push({
+				id: turnId,
+				items: []
+			});
+			ctx.session = {
+				...ctx.session,
+				status: "running",
+				activeTurnId: turnId,
+				updatedAt: yield* nowIso,
+				...model ? { model } : {}
+			};
+			const turnScope = yield* Scope.make();
+			const run = yield* runMuseExec({
+				threadId: input.threadId,
+				binaryPath: museSettings.binaryPath || "muse",
+				args,
+				cwd: ctx.cwd,
+				environment,
+				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,
+					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
+			};
+			return {
+				threadId: input.threadId,
+				turnId,
+				resumeCursor: museResumeCursor(ctx.museSessionId)
+			};
+		});
+		/**
+		* Token usage never reaches stdout; it is written to the session log. One
+		* read after the turn keeps the counter honest without tailing the file.
+		*/
+		const publishTokenUsage = (ctx, turnId) => Effect.gen(function* () {
+			const usage = yield* readMuseSessionUsage({
+				sessionId: ctx.museSessionId,
+				environment
+			}).pipe(Effect.provideService(FileSystem.FileSystem, fileSystem), Effect.provideService(Path.Path, path), Effect.orElseSucceed(() => void 0));
+			if (!usage) return;
+			yield* publish({
+				type: "thread.token-usage.updated",
+				...yield* makeEventStamp(),
+				provider: PROVIDER$1,
+				providerInstanceId: boundInstanceId,
+				threadId: ctx.threadId,
+				turnId,
+				payload: { usage }
+			});
+		}).pipe(Effect.orElseSucceed(() => void 0));
+		const interruptTurn = (threadId, turnId) => Effect.gen(function* () {
+			const active = (yield* requireSession(threadId)).activeTurn;
+			if (!active) return;
+			if (turnId !== void 0 && turnId !== active.turnId) return;
+			yield* active.run.interrupt;
+		});
+		const respondToRequest = (threadId) => Effect.gen(function* () {
+			yield* requireSession(threadId);
+			return yield* new ProviderAdapterRequestError({
+				provider: PROVIDER$1,
+				method: "muse/approval",
+				detail: "Muse Code has no approval channel in headless runs, so it never opens an approval request."
+			});
+		});
+		const respondToUserInput = (threadId) => Effect.gen(function* () {
+			yield* requireSession(threadId);
+			return yield* new ProviderAdapterRequestError({
+				provider: PROVIDER$1,
+				method: "muse/user-input",
+				detail: "Muse Code does not ask structured questions in headless runs."
+			});
+		});
+		const readThread = (threadId) => Effect.gen(function* () {
+			return {
+				threadId,
+				turns: (yield* requireSession(threadId)).turns
+			};
+		});
+		const rollbackThread = (threadId, numTurns) => Effect.gen(function* () {
+			yield* requireSession(threadId);
+			if (!Number.isInteger(numTurns) || numTurns < 1) return yield* new ProviderAdapterValidationError({
+				provider: PROVIDER$1,
+				operation: "rollbackThread",
+				issue: "numTurns must be an integer >= 1."
+			});
+			return yield* new ProviderAdapterRequestError({
+				provider: PROVIDER$1,
+				method: "muse/rollback",
+				detail: "Muse Code exposes no headless rollback for a session."
+			});
+		});
+		const stopSessionInternal = (ctx) => Effect.gen(function* () {
+			if (ctx.stopped) return;
+			ctx.stopped = true;
+			if (ctx.activeTurn) {
+				yield* ctx.activeTurn.run.interrupt.pipe(Effect.ignore);
+				ctx.activeTurn = void 0;
+			}
+			const updatedAt = yield* nowIso;
+			ctx.session = {
+				...ctx.session,
+				status: "closed",
+				updatedAt
+			};
+			sessions.delete(ctx.threadId);
+			yield* publish({
+				type: "session.exited",
+				...yield* makeEventStamp(),
+				provider: PROVIDER$1,
+				providerInstanceId: boundInstanceId,
+				threadId: ctx.threadId,
+				payload: {
+					reason: "stopped",
+					exitKind: "graceful"
+				}
+			});
+		});
+		const stopSession = (threadId) => Effect.flatMap(requireSession(threadId), stopSessionInternal);
+		const listSessions = () => Effect.sync(() => Array.from(sessions.values(), (ctx) => ({ ...ctx.session })));
+		const hasSession = (threadId) => Effect.sync(() => {
+			const ctx = sessions.get(threadId);
+			return ctx !== void 0 && !ctx.stopped;
+		});
+		const stopAll = () => Effect.forEach(Array.from(sessions.values()), stopSessionInternal, { discard: true });
+		yield* Effect.addFinalizer(() => Effect.ignore(stopAll()).pipe(Effect.tap(() => PubSub.shutdown(runtimeEventPubSub))));
+		return {
+			provider: PROVIDER$1,
+			capabilities: { sessionModelSwitch: "in-session" },
+			startSession,
+			sendTurn,
+			interruptTurn,
+			readThread,
+			rollbackThread,
+			respondToRequest,
+			respondToUserInput,
+			stopSession,
+			listSessions,
+			hasSession,
+			stopAll,
+			streamEvents: Stream.fromPubSub(runtimeEventPubSub)
+		};
+	});
+}
+//#endregion
+//#region src/provider/Layers/MuseProvider.ts
+const MUSE_PRESENTATION = {
+	displayName: "Muse Code",
+	badgeLabel: "Early Access",
+	showInteractionModeToggle: false,
+	requiresNewThreadForModelChange: false,
+	supportedRuntimeModes: ["auto", "full-access"]
+};
+const EMPTY_CAPABILITIES = createModelCapabilities({ optionDescriptors: [] });
+const VERSION_PROBE_TIMEOUT_MS = 4e3;
+/** Models Meta documents for Muse Code; used until the CLI caches a catalog. */
+const MUSE_BUILT_IN_MODELS = [{
+	slug: "muse-spark-1.2",
+	name: "Muse Spark 1.2",
+	isCustom: false,
+	capabilities: EMPTY_CAPABILITIES
+}, {
+	slug: "muse-spark-1.2-contributor",
+	name: "Muse Spark 1.2 (contributor)",
+	isCustom: false,
+	isDefault: true,
+	capabilities: EMPTY_CAPABILITIES
+}];
+function museModelsFromSettings(customModels, builtInModels = MUSE_BUILT_IN_MODELS) {
+	return providerModelsFromSettings(builtInModels, customModels ?? [], EMPTY_CAPABILITIES);
+}
+const discoverMuseModels = Effect.fn("discoverMuseModels")(function* (environment) {
+	return (yield* readMuseModelCatalog(environment)).map((model) => ({
+		slug: model.slug,
+		name: model.name,
+		isCustom: false,
+		...model.isDefault ? { isDefault: true } : {},
+		capabilities: EMPTY_CAPABILITIES
+	}));
+});
+/**
+* What P4Code can tell about Muse credentials without running the CLI.
+*
+* `META_API_KEY` takes priority inside Muse itself, then a stored key or
+* browser session in `~/.config/muse/auth.json`. Neither says whether the
+* credential is still valid, so a present credential reports
+* `authenticated` with the source as its label and a missing one reports
+* `unauthenticated`.
+*/
+const checkMuseAuth = Effect.fn("checkMuseAuth")(function* (environment) {
+	if (environment["META_API_KEY"]?.trim()) return {
+		status: "authenticated",
+		type: "api-key",
+		label: "META_API_KEY"
+	};
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const configHome = environment["XDG_CONFIG_HOME"]?.trim();
+	const authPath = path.join(configHome && configHome.length > 0 ? configHome : path.join(NodeOS.homedir(), ".config"), "muse", "auth.json");
+	return (yield* fileSystem.exists(authPath).pipe(Effect.orElseSucceed(() => false))) ? {
+		status: "authenticated",
+		type: "cli",
+		label: "muse login"
+	} : { status: "unauthenticated" };
+});
+function buildInitialMuseProviderSnapshot(museSettings) {
+	return Effect.gen(function* () {
+		const checkedAt = yield* Effect.map(DateTime.now, DateTime.formatIso);
+		const models = museModelsFromSettings(museSettings.customModels);
+		return buildServerProvider({
+			presentation: MUSE_PRESENTATION,
+			enabled: museSettings.enabled,
+			checkedAt,
+			models,
+			probe: museSettings.enabled ? {
+				installed: true,
+				version: null,
+				status: "warning",
+				auth: { status: "unknown" },
+				message: "Checking Muse Code CLI availability..."
+			} : {
+				installed: false,
+				version: null,
+				status: "warning",
+				auth: { status: "unknown" },
+				message: "Muse Code is disabled in P4Code settings."
+			}
+		});
+	});
+}
+const runMuseVersionCommand = (museSettings, environment) => Effect.gen(function* () {
+	const command = museSettings.binaryPath || "muse";
+	const spawnCommand = yield* resolveSpawnCommand(command, [...MUSE_VERSION_ARGS], { env: environment });
+	return yield* spawnAndCollect(command, ChildProcess.make(spawnCommand.command, spawnCommand.args, {
+		env: environment,
+		shell: spawnCommand.shell
+	}));
+});
+const checkMuseProviderStatus = Effect.fn("checkMuseProviderStatus")(function* (museSettings, environment = process.env) {
+	const checkedAt = DateTime.formatIso(yield* DateTime.now);
+	const fallbackModels = museModelsFromSettings(museSettings.customModels);
+	if (!museSettings.enabled) return buildServerProvider({
+		presentation: MUSE_PRESENTATION,
+		enabled: false,
+		checkedAt,
+		models: fallbackModels,
+		probe: {
+			installed: false,
+			version: null,
+			status: "warning",
+			auth: { status: "unknown" },
+			message: "Muse Code is disabled in P4Code settings."
+		}
+	});
+	const versionResult = yield* runMuseVersionCommand(museSettings, environment).pipe(Effect.timeoutOption(VERSION_PROBE_TIMEOUT_MS), Effect.result);
+	if (Result.isFailure(versionResult)) {
+		const error = versionResult.failure;
+		const missing = isCommandMissingCause(error);
+		yield* (missing ? Effect.logDebug : Effect.logWarning)("Muse Code CLI health check failed.", { errorTag: error._tag });
+		return buildServerProvider({
+			presentation: MUSE_PRESENTATION,
+			enabled: true,
+			checkedAt,
+			models: fallbackModels,
+			probe: {
+				installed: !missing,
+				version: null,
+				status: "error",
+				auth: { status: "unknown" },
+				message: missing ? "Muse Code CLI (`muse`) is not installed or not on PATH. Install it with `curl -fsSL https://dev.meta.ai/install.sh | sh`." : "Failed to execute the Muse Code CLI health check."
+			}
+		});
+	}
+	if (Option.isNone(versionResult.success)) return buildServerProvider({
+		presentation: MUSE_PRESENTATION,
+		enabled: true,
+		checkedAt,
+		models: fallbackModels,
+		probe: {
+			installed: true,
+			version: null,
+			status: "error",
+			auth: { status: "unknown" },
+			message: "Muse Code CLI is installed but timed out while running `muse --version`."
+		}
+	});
+	const versionOutput = versionResult.success.value;
+	const version = parseGenericCliVersion(`${versionOutput.stdout}\n${versionOutput.stderr}`);
+	const auth = yield* checkMuseAuth(environment);
+	if (versionOutput.code !== 0) {
+		yield* Effect.logWarning("Muse Code CLI version probe exited with a non-zero status.", {
+			exitCode: versionOutput.code,
+			stdoutLength: versionOutput.stdout.length,
+			stderrLength: versionOutput.stderr.length
+		});
+		return buildServerProvider({
+			presentation: MUSE_PRESENTATION,
+			enabled: true,
+			checkedAt,
+			models: fallbackModels,
+			probe: {
+				installed: true,
+				version,
+				status: "error",
+				auth,
+				message: "Muse Code CLI is installed but failed to run."
+			}
+		});
+	}
+	const discovered = yield* discoverMuseModels(environment);
+	const models = discovered.length > 0 ? museModelsFromSettings(museSettings.customModels, discovered) : fallbackModels;
+	if (auth.status !== "authenticated") return buildServerProvider({
+		presentation: MUSE_PRESENTATION,
+		enabled: true,
+		checkedAt,
+		models,
+		probe: {
+			installed: true,
+			version,
+			status: "warning",
+			auth,
+			message: "Muse Code is installed but not signed in. Run `muse login`, or set META_API_KEY."
+		}
+	});
+	return buildServerProvider({
+		presentation: MUSE_PRESENTATION,
+		enabled: true,
+		checkedAt,
+		models,
+		probe: {
+			installed: true,
+			version,
+			status: "ready",
+			auth
+		}
+	});
+});
+const enrichMuseSnapshot = (input) => enrichProviderSnapshotWithVersionAdvisory(input.snapshot, input.maintenanceCapabilities, { enableProviderUpdateChecks: input.enableProviderUpdateChecks }).pipe(Effect.provideService(HttpClient.HttpClient, input.httpClient), Effect.flatMap((enrichedSnapshot) => input.publishSnapshot(enrichedSnapshot)), Effect.catchCause((cause) => Effect.logWarning("Muse version advisory enrichment failed", { errorTag: causeErrorTag(cause) })), Effect.asVoid);
+//#endregion
+//#region src/provider/Drivers/MuseDriver.ts
+/**
+* MuseDriver — first-party driver for Meta's Muse Code CLI.
+*
+* @module provider/Drivers/MuseDriver
+*/
+const decodeMuseSettings = Schema$1.decodeSync(MuseSettings);
+const DRIVER_KIND$1 = ProviderDriverKind.make("muse");
+const SNAPSHOT_REFRESH_INTERVAL$1 = Duration.minutes(5);
+const UPDATE$1 = makeStaticProviderMaintenanceResolver(makeManualOnlyProviderMaintenanceCapabilities({
+	provider: DRIVER_KIND$1,
+	packageName: null
+}));
+const withInstanceIdentity$1 = (input) => (snapshot) => ({
+	...snapshot,
+	instanceId: input.instanceId,
+	driver: DRIVER_KIND$1,
+	...input.displayName ? { displayName: input.displayName } : {},
+	...input.accentColor ? { accentColor: input.accentColor } : {},
+	continuation: { groupKey: input.continuationGroupKey }
+});
+const MuseDriver = {
+	driverKind: DRIVER_KIND$1,
+	metadata: {
+		displayName: "Muse Code",
+		supportsMultipleInstances: true
+	},
+	configSchema: MuseSettings,
+	defaultConfig: () => decodeMuseSettings({}),
+	create: ({ instanceId, displayName, accentColor, environment, enabled, config }) => Effect.gen(function* () {
+		const httpClient = yield* HttpClient.HttpClient;
+		const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+		const fileSystem = yield* FileSystem.FileSystem;
+		const path = yield* Path.Path;
+		const serverSettings = yield* ServerSettingsService;
+		const processEnv = mergeProviderInstanceEnvironment(environment);
+		const continuationIdentity = defaultProviderContinuationIdentity({
+			driverKind: DRIVER_KIND$1,
+			instanceId
+		});
+		const stampIdentity = withInstanceIdentity$1({
+			instanceId,
+			displayName,
+			accentColor,
+			continuationGroupKey: continuationIdentity.continuationKey
+		});
+		const effectiveConfig = {
+			...config,
+			enabled
+		};
+		const maintenanceCapabilities = yield* resolveProviderMaintenanceCapabilitiesEffect(UPDATE$1, {
+			binaryPath: effectiveConfig.binaryPath,
+			env: processEnv
+		});
+		const adapter = yield* makeMuseAdapter(effectiveConfig, {
+			environment: processEnv,
+			instanceId
+		});
+		const textGeneration = yield* makeMuseTextGeneration(effectiveConfig, processEnv);
+		const snapshotSettings = makeProviderSnapshotSettingsSource(effectiveConfig, serverSettings);
+		const snapshot = yield* makeManagedServerProvider({
+			maintenanceCapabilities,
+			getSettings: snapshotSettings.getSettings,
+			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)),
+			enrichSnapshot: ({ settings, snapshot: currentSnapshot, publishSnapshot }) => enrichMuseSnapshot({
+				snapshot: currentSnapshot,
+				maintenanceCapabilities,
+				enableProviderUpdateChecks: settings.enableProviderUpdateChecks,
+				publishSnapshot,
+				httpClient
+			}),
 			refreshInterval: SNAPSHOT_REFRESH_INTERVAL$1
 		}).pipe(Effect.mapError((cause) => new ProviderDriverError({
 			driver: DRIVER_KIND$1,
 			instanceId,
-			detail: `Failed to build Grok snapshot: ${cause.message ?? String(cause)}`,
+			detail: `Failed to build Muse snapshot: ${cause.message ?? String(cause)}`,
 			cause
 		})));
 		return {
@@ -82737,6 +84736,7 @@ const BUILT_IN_DRIVERS = [
 	ClaudeDriver,
 	CursorDriver,
 	GrokDriver,
+	MuseDriver,
 	{
 		driverKind: DRIVER_KIND,
 		metadata: {
@@ -84135,6 +86135,24 @@ function runtimeEventToActivities(event, taskTitle) {
 			turnId: toTurnId$1(event.turnId) ?? null,
 			...maybeSequence
 		}];
+		case "code.published": {
+			const label = event.payload.repo ? event.payload.identifier ? `${event.payload.repo}#${event.payload.identifier}` : event.payload.repo : event.payload.url;
+			return [{
+				id: event.eventId,
+				createdAt: event.createdAt,
+				tone: "info",
+				kind: "code.published",
+				summary: `Published ${label}`,
+				payload: {
+					hostingProvider: event.payload.hostingProvider,
+					url: event.payload.url,
+					...event.payload.repo ? { repo: event.payload.repo } : {},
+					...event.payload.identifier ? { identifier: event.payload.identifier } : {}
+				},
+				turnId: toTurnId$1(event.turnId) ?? null,
+				...maybeSequence
+			}];
+		}
 		case "turn.plan.updated": return [{
 			id: event.eventId,
 			createdAt: event.createdAt,
@@ -87266,6 +89284,7 @@ const reportUpdateAvailable = Effect.gen(function* () {
 const makeCli = () => Command.make("p4c", { ...sharedServerCommandFlags }).pipe(Command.withDescription("Run the P4Code server."), Command.withHandler((flags) => runServerCommand(flags)), Command.withSubcommands([
 	startCommand,
 	serveCommand,
+	agentsCommand,
 	authCommand,
 	hubCommand,
 	mcpCommand,