@p4code/cli 0.4.11 → 0.4.13

package/dist/bin.mjs

@@ -240,7 +240,7 @@ const make$93 = () => {
 const layer$82 = Layer.sync(NetService, make$93);
 //#endregion
 //#region package.json
-var version = "0.4.11";
+var version = "0.4.13";
 //#endregion
 //#region src/config.ts
 /**
@@ -23553,8 +23553,8 @@ const removeMemoryFile = Effect.fn("memoryFile.removeMemoryFile")(function* (inp
 * config directory — the one holding `.credentials.json` — instead of a managed
 * home the user would have to log in to again. See `docs/architecture/hub.md`.
 *
-* Keyed by skills directory so a second provider home is additive rather than a
-* migration.
+* Keyed by skills directory so ownership can move safely when the configured
+* provider path migrates to the provider-neutral shared root.
 *
 * @module sync/skillManifest
 */
@@ -23596,6 +23596,20 @@ const withEntriesFor = (manifest, skillsRoot, entries) => ({
 		[skillsRoot]: [...entries].sort((left, right) => left.name.localeCompare(right.name))
 	}
 });
+const moveEntriesFor = (manifest, sourceRoot, targetRoot) => {
+	if (sourceRoot === targetRoot || manifest.directories[sourceRoot] === void 0) return manifest;
+	const { [sourceRoot]: sourceEntries, ...directories } = manifest.directories;
+	const targetEntries = directories[targetRoot] ?? [];
+	const merged = new Map(targetEntries.map((entry) => [entry.name, entry]));
+	for (const entry of sourceEntries ?? []) merged.set(entry.name, entry);
+	return {
+		version: 1,
+		directories: {
+			...directories,
+			[targetRoot]: [...merged.values()].sort((left, right) => left.name.localeCompare(right.name))
+		}
+	};
+};
 const writeSkillManifest = Effect.fn("skillManifest.write")(function* (manifestPath, manifest) {
 	yield* writeFileStringAtomically({
 		filePath: manifestPath,
@@ -23804,6 +23818,170 @@ function planSkillSync(input) {
 	};
 }
 //#endregion
+//#region src/sync/sharedSkillRoot.ts
+const SHARED_SKILL_ROOT_REFUSAL = "shared-root-migration-blocked";
+const inspectLayout = Effect.fn("sharedSkillRoot.inspectLayout")(function* (input) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const targetRoot = path.resolve(input.sharedSkillsRoot ?? path.join(NodeOS.homedir(), ".agents", "skills"));
+	const claudeRoot = path.resolve(input.claudeSkillsRoot);
+	const manifest = yield* readSkillManifest(input.manifestPath);
+	if (claudeRoot === targetRoot) return {
+		claudeRoot,
+		targetRoot,
+		manifest,
+		entries: [],
+		candidateSkillNames: [],
+		ignoredEntries: [],
+		refused: [],
+		linked: true,
+		exists: yield* fileSystem.exists(targetRoot)
+	};
+	const linkedTarget = yield* fileSystem.readLink(claudeRoot).pipe(Effect.map((target) => path.resolve(path.dirname(claudeRoot), target)), Effect.option);
+	if (linkedTarget._tag === "Some") return {
+		claudeRoot,
+		targetRoot,
+		manifest,
+		entries: [],
+		candidateSkillNames: [],
+		ignoredEntries: [],
+		refused: linkedTarget.value === targetRoot ? [] : [{
+			name: claudeRoot,
+			reason: SHARED_SKILL_ROOT_REFUSAL
+		}],
+		linked: linkedTarget.value === targetRoot,
+		exists: true
+	};
+	const exists = yield* fileSystem.exists(claudeRoot);
+	if (exists) {
+		const sourceDevice = (yield* fileSystem.stat(claudeRoot)).dev;
+		let targetProbe = targetRoot;
+		while (!(yield* fileSystem.exists(targetProbe))) {
+			const parent = path.dirname(targetProbe);
+			if (parent === targetProbe) break;
+			targetProbe = parent;
+		}
+		if (sourceDevice !== (yield* fileSystem.stat(targetProbe)).dev) return {
+			claudeRoot,
+			targetRoot,
+			manifest,
+			entries: [],
+			candidateSkillNames: [],
+			ignoredEntries: [],
+			refused: [{
+				name: claudeRoot,
+				reason: SHARED_SKILL_ROOT_REFUSAL
+			}],
+			linked: false,
+			exists
+		};
+	}
+	const entries = exists ? yield* fileSystem.readDirectory(claudeRoot) : [];
+	const managedNames = new Set(entriesFor(manifest, claudeRoot).map((entry) => entry.name));
+	const candidateSkillNames = [];
+	const ignoredEntries = [];
+	const strayEntries = [];
+	for (const entry of entries) {
+		if (isIgnoredEntry(entry)) {
+			ignoredEntries.push(entry);
+			continue;
+		}
+		const entryPath = path.join(claudeRoot, entry);
+		if ((yield* fileSystem.stat(entryPath)).type === "Directory" && (yield* fileSystem.exists(path.join(entryPath, "SKILL.md")))) candidateSkillNames.push(entry);
+		else strayEntries.push(entry);
+	}
+	return {
+		claudeRoot,
+		targetRoot,
+		manifest,
+		entries,
+		candidateSkillNames,
+		ignoredEntries,
+		refused: [...candidateSkillNames.filter((entry) => !managedNames.has(entry)), ...strayEntries].map((name) => ({
+			name,
+			reason: SHARED_SKILL_ROOT_REFUSAL
+		})),
+		linked: false,
+		exists
+	};
+});
+/** Read-only root resolution used by status and previews. */
+const inspectSharedSkillRoot = Effect.fn("sharedSkillRoot.inspect")(function* (input) {
+	const layout = yield* inspectLayout(input);
+	if (layout.refused.length > 0) return {
+		root: null,
+		refused: layout.refused
+	};
+	return {
+		root: layout.linked || !layout.exists ? layout.targetRoot : layout.claudeRoot,
+		refused: []
+	};
+});
+/**
+* Make Claude's configured skill path an alias of the provider-neutral user
+* skill root. Existing unmanaged content is never moved or replaced.
+*/
+const prepareSharedSkillRoot = Effect.fn("sharedSkillRoot.prepare")(function* (input) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const layout = yield* inspectLayout(input);
+	const { candidateSkillNames, claudeRoot, ignoredEntries, manifest, targetRoot } = layout;
+	if (layout.refused.length > 0) return {
+		root: null,
+		refused: layout.refused
+	};
+	if (layout.linked) {
+		yield* fileSystem.makeDirectory(targetRoot, { recursive: true });
+		const migrated = moveEntriesFor(manifest, claudeRoot, targetRoot);
+		if (migrated !== manifest) yield* writeSkillManifest(input.manifestPath, migrated);
+		return {
+			root: targetRoot,
+			refused: []
+		};
+	}
+	if (layout.exists) if (!(yield* fileSystem.exists(targetRoot))) {
+		yield* fileSystem.makeDirectory(path.dirname(targetRoot), { recursive: true });
+		yield* fileSystem.rename(claudeRoot, targetRoot);
+	} else {
+		const backupRoot = `${claudeRoot}.p4code-migrated`;
+		if (ignoredEntries.length > 0 && (yield* fileSystem.exists(backupRoot))) return {
+			root: null,
+			refused: [{
+				name: backupRoot,
+				reason: SHARED_SKILL_ROOT_REFUSAL
+			}]
+		};
+		const targetEntries = new Set(yield* fileSystem.readDirectory(targetRoot));
+		const collisions = candidateSkillNames.filter((entry) => targetEntries.has(entry));
+		if (collisions.length > 0) return {
+			root: null,
+			refused: collisions.map((name) => ({
+				name,
+				reason: SHARED_SKILL_ROOT_REFUSAL
+			}))
+		};
+		for (const entry of candidateSkillNames) yield* fileSystem.rename(path.join(claudeRoot, entry), path.join(targetRoot, entry));
+	}
+	else {
+		yield* fileSystem.makeDirectory(targetRoot, { recursive: true });
+		yield* fileSystem.makeDirectory(path.dirname(claudeRoot), { recursive: true });
+	}
+	const stagedLink = `${claudeRoot}.p4code-link`;
+	yield* fileSystem.remove(stagedLink, { force: true });
+	yield* fileSystem.symlink(targetRoot, stagedLink);
+	if (layout.exists && (yield* fileSystem.exists(claudeRoot))) if (ignoredEntries.length > 0) {
+		const backupRoot = `${claudeRoot}.p4code-migrated`;
+		yield* fileSystem.rename(claudeRoot, backupRoot);
+	} else yield* fileSystem.remove(claudeRoot, { recursive: true });
+	yield* fileSystem.rename(stagedLink, claudeRoot);
+	const migrated = moveEntriesFor(manifest, claudeRoot, targetRoot);
+	if (migrated !== manifest) yield* writeSkillManifest(input.manifestPath, migrated);
+	return {
+		root: targetRoot,
+		refused: []
+	};
+});
+//#endregion
 //#region src/sync/AssetSync.ts
 /**
 * Syncing user-scope agent assets between this machine and the hub.
@@ -23864,10 +24042,30 @@ const make$77 = Effect.gen(function* () {
 	const claudeHome = Effect.fn("AssetSync.claudeHome")(function* () {
 		return { homePath: (yield* settingsStore.getSettings.pipe(Effect.orElseSucceed(() => void 0)))?.providers.claudeAgent.homePath ?? "" };
 	});
+	const inspectSkillRoot = Effect.fn("AssetSync.inspectSkillRoot")(function* () {
+		const claudeSkillsRoot = yield* claudeHome().pipe(Effect.flatMap(resolveClaudeUserSkillsDir));
+		return yield* inspectSharedSkillRoot({
+			claudeSkillsRoot,
+			manifestPath
+		}).pipe(Effect.catchCause((cause) => Effect.logWarning("shared skill root inspection failed", { cause }).pipe(Effect.as({
+			root: null,
+			refused: [{
+				name: claudeSkillsRoot,
+				reason: SHARED_SKILL_ROOT_REFUSAL
+			}]
+		}))));
+	});
 	const drivers = [
 		{
 			kind: "skill",
-			resolveRoot: claudeHome().pipe(Effect.flatMap(resolveClaudeUserSkillsDir)),
+			prepareRoot: Effect.gen(function* () {
+				yield* prepareSharedSkillRoot({
+					claudeSkillsRoot: yield* claudeHome().pipe(Effect.flatMap(resolveClaudeUserSkillsDir)),
+					manifestPath
+				});
+			}).pipe(Effect.catchCause((cause) => Effect.logWarning("shared skill root migration failed", { cause }))),
+			resolveState: inspectSkillRoot(),
+			resolveRoot: inspectSkillRoot().pipe(Effect.map((result) => result.root)),
 			read: (root) => readSkillDirectory(root),
 			write: ({ root, name, files }) => writeSkillDirectory({
 				skillsRoot: root,
@@ -23925,6 +24123,19 @@ const make$77 = Effect.gen(function* () {
 		}
 	];
 	const driverFor = (kind) => drivers.find((driver) => driver.kind === kind);
+	const resolveDriverState = Effect.fn("AssetSync.resolveDriverState")(function* (driver) {
+		if (driver.resolveState) return yield* driver.resolveState;
+		return {
+			root: yield* driver.resolveRoot,
+			refused: []
+		};
+	});
+	const resolveAllDriverStates = Effect.fn("AssetSync.resolveAllDriverStates")(function* () {
+		return yield* Effect.forEach(drivers, (driver) => resolveDriverState(driver).pipe(Effect.map((state) => ({
+			driver,
+			...state
+		}))), { concurrency: "unbounded" });
+	});
 	const isConfigured = link.current.pipe(Effect.map((state) => Option.isSome(state.settings)));
 	/**
 	* The three views for one kind, gathered once.
@@ -23932,14 +24143,15 @@ const make$77 = Effect.gen(function* () {
 	* `status` and `run` both need exactly this and disagreeing about it is how a
 	* panel comes to show something the next sync does not do.
 	*/
-	const viewsFor = Effect.fn("AssetSync.viewsFor")(function* (driver, hubAssets) {
-		const root = yield* driver.resolveRoot;
+	const viewsFor = Effect.fn("AssetSync.viewsFor")(function* (driver, hubAssets, resolved) {
+		const state = resolved ?? (yield* resolveDriverState(driver));
+		const root = state.root;
 		const hub = hubAssets.filter((asset) => asset.kind === driver.kind);
 		if (root === null) return {
 			root,
 			hub,
 			local: [],
-			refused: [],
+			refused: state.refused,
 			managed: []
 		};
 		const local = yield* driver.read(root);
@@ -23952,7 +24164,11 @@ const make$77 = Effect.gen(function* () {
 			managed: entriesFor(manifest, root)
 		};
 	});
-	const rootsOf = Effect.fn("AssetSync.rootsOf")(function* () {
+	const rootsOf = Effect.fn("AssetSync.rootsOf")(function* (states) {
+		if (states) return states.map(({ driver, root }) => ({
+			kind: driver.kind,
+			path: root
+		}));
 		const roots = [];
 		for (const driver of drivers) roots.push({
 			kind: driver.kind,
@@ -23962,7 +24178,9 @@ const make$77 = Effect.gen(function* () {
 	});
 	const run = Effect.gen(function* () {
 		if (!(yield* isConfigured)) return EMPTY_REPORT;
-		const roots = yield* rootsOf();
+		for (const driver of drivers) if (driver.prepareRoot) yield* driver.prepareRoot;
+		const resolvedDrivers = yield* resolveAllDriverStates();
+		const roots = yield* rootsOf(resolvedDrivers);
 		const hubAssets = yield* client.list().pipe(Effect.option);
 		if (Option.isNone(hubAssets)) return {
 			...EMPTY_REPORT,
@@ -23977,8 +24195,9 @@ const make$77 = Effect.gen(function* () {
 		const conflicts = [];
 		const refused = [];
 		const shareMode = (yield* link.current).shareMode;
-		for (const driver of drivers) {
-			const views = yield* viewsFor(driver, hubAssets.value);
+		for (const resolved of resolvedDrivers) {
+			const driver = resolved.driver;
+			const views = yield* viewsFor(driver, hubAssets.value, resolved);
 			const kind = driver.kind;
 			for (const entry of views.refused) refused.push({
 				kind,
@@ -24128,7 +24347,8 @@ const make$77 = Effect.gen(function* () {
 	*/
 	const assetStatus = Effect.gen(function* () {
 		const state = yield* link.current;
-		const roots = yield* rootsOf();
+		const resolvedDrivers = yield* resolveAllDriverStates();
+		const roots = yield* rootsOf(resolvedDrivers);
 		const base = {
 			syncMode: state.syncMode,
 			shareMode: state.shareMode,
@@ -24138,9 +24358,10 @@ const make$77 = Effect.gen(function* () {
 		const hubAssets = Option.isNone(state.settings) ? Option.none() : yield* client.list().pipe(Effect.option);
 		const entries = [];
 		const refused = [];
-		for (const driver of drivers) {
+		for (const resolved of resolvedDrivers) {
+			const driver = resolved.driver;
 			const kind = driver.kind;
-			const views = yield* viewsFor(driver, Option.getOrElse(hubAssets, () => []));
+			const views = yield* viewsFor(driver, Option.getOrElse(hubAssets, () => []), resolved);
 			for (const entry of views.refused) refused.push({
 				kind,
 				name: entry.name,
@@ -24468,6 +24689,7 @@ const make$77 = Effect.gen(function* () {
 			path: null,
 			detail: `Unknown asset kind '${input.kind}'.`
 		};
+		if (driver.prepareRoot) yield* driver.prepareRoot;
 		const root = yield* driver.resolveRoot;
 		if (root === null) return {
 			outcome: "no-root",
@@ -28644,7 +28866,7 @@ const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand")(funct
 			updatedAt: engagement.occurredAt
 		}
 	});
-	return events.map((event) => {
+	const enrichedEvents = events.map((event) => {
 		if (event.type === "thread.created") return {
 			...event,
 			payload: {
@@ -28687,6 +28909,7 @@ const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand")(funct
 			default: return event;
 		}
 	});
+	return enrichedEvents.length === 1 ? enrichedEvents[0] : enrichedEvents;
 });
 //#endregion
 //#region src/orchestration/Services/ProjectionPipeline.ts
@@ -32546,8 +32769,11 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
           settled_at AS "settledAt",
           lifecycle AS "lifecycle",
           lifecycle_reason AS "lifecycleReason",
-          lifecycle_changed_at AS "lifecycleChangedAt",
-          last_engaged_at AS "lastEngagedAt",
+          COALESCE(lifecycle_changed_at, archived_at, settled_at, created_at) AS "lifecycleChangedAt",
+          COALESCE(last_engaged_at, MAX(created_at, COALESCE(latest_user_message_at, created_at),
+            COALESCE((SELECT MAX(message.updated_at) FROM projection_thread_messages message
+              WHERE message.thread_id = projection_threads.thread_id
+                AND message.role IN ('user', 'assistant')), created_at))) AS "lastEngagedAt",
           snoozed_until AS "snoozedUntil",
           snoozed_at AS "snoozedAt",
           pinned_at AS "pinnedAt",
@@ -32587,8 +32813,11 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
           settled_at AS "settledAt",
           lifecycle AS "lifecycle",
           lifecycle_reason AS "lifecycleReason",
-          lifecycle_changed_at AS "lifecycleChangedAt",
-          last_engaged_at AS "lastEngagedAt",
+          COALESCE(lifecycle_changed_at, archived_at, settled_at, created_at) AS "lifecycleChangedAt",
+          COALESCE(last_engaged_at, MAX(created_at, COALESCE(latest_user_message_at, created_at),
+            COALESCE((SELECT MAX(message.updated_at) FROM projection_thread_messages message
+              WHERE message.thread_id = projection_threads.thread_id
+                AND message.role IN ('user', 'assistant')), created_at))) AS "lastEngagedAt",
           snoozed_until AS "snoozedUntil",
           snoozed_at AS "snoozedAt",
           pinned_at AS "pinnedAt",
@@ -32630,8 +32859,11 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
           settled_at AS "settledAt",
           lifecycle AS "lifecycle",
           lifecycle_reason AS "lifecycleReason",
-          lifecycle_changed_at AS "lifecycleChangedAt",
-          last_engaged_at AS "lastEngagedAt",
+          COALESCE(lifecycle_changed_at, archived_at, settled_at, created_at) AS "lifecycleChangedAt",
+          COALESCE(last_engaged_at, MAX(created_at, COALESCE(latest_user_message_at, created_at),
+            COALESCE((SELECT MAX(message.updated_at) FROM projection_thread_messages message
+              WHERE message.thread_id = projection_threads.thread_id
+                AND message.role IN ('user', 'assistant')), created_at))) AS "lastEngagedAt",
           snoozed_until AS "snoozedUntil",
           snoozed_at AS "snoozedAt",
           pinned_at AS "pinnedAt",
@@ -33098,8 +33330,11 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
           settled_at AS "settledAt",
           lifecycle AS "lifecycle",
           lifecycle_reason AS "lifecycleReason",
-          lifecycle_changed_at AS "lifecycleChangedAt",
-          last_engaged_at AS "lastEngagedAt",
+          COALESCE(lifecycle_changed_at, archived_at, settled_at, created_at) AS "lifecycleChangedAt",
+          COALESCE(last_engaged_at, MAX(created_at, COALESCE(latest_user_message_at, created_at),
+            COALESCE((SELECT MAX(message.updated_at) FROM projection_thread_messages message
+              WHERE message.thread_id = projection_threads.thread_id
+                AND message.role IN ('user', 'assistant')), created_at))) AS "lastEngagedAt",
           snoozed_until AS "snoozedUntil",
           snoozed_at AS "snoozedAt",
           pinned_at AS "pinnedAt",
@@ -99965,7 +100200,7 @@ const CURSOR_PRESENTATION = {
 	badgeLabel: "Early Access",
 	showInteractionModeToggle: true
 };
-const EMPTY_CAPABILITIES$2 = createModelCapabilities({ optionDescriptors: [] });
+const EMPTY_CAPABILITIES$1 = createModelCapabilities({ optionDescriptors: [] });
 const CURSOR_ACP_MODEL_DISCOVERY_TIMEOUT_MS = 15e3;
 const CURSOR_PARAMETERIZED_MODEL_PICKER_MIN_VERSION_DATE = 20260408;
 const CURSOR_CLI_INSTALLATION_DOCS_URL = "https://cursor.com/docs/cli/installation";
@@ -100073,7 +100308,7 @@ function getBooleanCurrentValue(option) {
 	if (normalized === "false") return false;
 }
 function buildCursorCapabilitiesFromConfigOptions(configOptions) {
-	if (!configOptions || configOptions.length === 0) return EMPTY_CAPABILITIES$2;
+	if (!configOptions || configOptions.length === 0) return EMPTY_CAPABILITIES$1;
 	const reasoningConfig = findCursorEffortConfigOption(configOptions);
 	const reasoningEffortLevels = reasoningConfig?.type === "select" ? flattenSessionConfigSelectOptions(reasoningConfig).flatMap((entry) => {
 		const normalizedValue = normalizeCursorReasoningValue(entry.value);
@@ -100242,7 +100477,7 @@ const discoverCursorModelsViaListAvailableModels = (cursorSettings, environment)
 }), environment);
 const discoverCursorModelsViaAcp = (cursorSettings, environment) => discoverCursorModelsViaListAvailableModels(cursorSettings, environment);
 function getCursorFallbackModels(cursorSettings) {
-	return providerModelsFromSettings([], cursorSettings.customModels, EMPTY_CAPABILITIES$2);
+	return providerModelsFromSettings([], cursorSettings.customModels, EMPTY_CAPABILITIES$1);
 }
 /** Timeout for `agent about` — it's slower than a simple `--version` probe. */
 const ABOUT_TIMEOUT_MS = 8e3;
@@ -100278,7 +100513,7 @@ function buildCursorProviderSnapshot(input) {
 		presentation: CURSOR_PRESENTATION,
 		enabled: input.cursorSettings.enabled,
 		checkedAt: input.checkedAt,
-		models: providerModelsFromSettings(input.discoveredModels ?? [], input.cursorSettings.customModels, EMPTY_CAPABILITIES$2),
+		models: providerModelsFromSettings(input.discoveredModels ?? [], input.cursorSettings.customModels, EMPTY_CAPABILITIES$1),
 		probe: {
 			installed: true,
 			version: input.parsed.version,
@@ -103111,14 +103346,14 @@ const GROK_PRESENTATION = {
 	showInteractionModeToggle: false,
 	requiresNewThreadForModelChange: true
 };
-const EMPTY_CAPABILITIES$1 = createModelCapabilities({ optionDescriptors: [] });
+const EMPTY_CAPABILITIES = createModelCapabilities({ optionDescriptors: [] });
 const VERSION_PROBE_TIMEOUT_MS$1 = 4e3;
 const GROK_ACP_MODEL_DISCOVERY_TIMEOUT_MS = 15e3;
 const GROK_BUILT_IN_MODELS = [{
 	slug: "grok-build",
 	name: "Grok Build",
 	isCustom: false,
-	capabilities: EMPTY_CAPABILITIES$1
+	capabilities: EMPTY_CAPABILITIES
 }];
 function buildInitialGrokProviderSnapshot(grokSettings) {
 	return Effect.gen(function* () {
@@ -103153,7 +103388,7 @@ function buildInitialGrokProviderSnapshot(grokSettings) {
 	});
 }
 function grokModelsFromSettings(customModels, builtInModels = GROK_BUILT_IN_MODELS) {
-	return providerModelsFromSettings(builtInModels, customModels ?? [], EMPTY_CAPABILITIES$1);
+	return providerModelsFromSettings(builtInModels, customModels ?? [], EMPTY_CAPABILITIES);
 }
 function buildGrokDiscoveredModelsFromSessionModelState(modelState) {
 	if (!modelState || modelState.availableModels.length === 0) return [];
@@ -103166,7 +103401,7 @@ function buildGrokDiscoveredModelsFromSessionModelState(modelState) {
 			slug,
 			name: model.name.trim() || slug,
 			isCustom: false,
-			capabilities: EMPTY_CAPABILITIES$1
+			capabilities: EMPTY_CAPABILITIES
 		};
 	}).filter((model) => model !== void 0);
 }
@@ -103406,20 +103641,52 @@ const GrokDriver = {
 	})
 };
 /**
+* Reasoning levels `muse exec --reasoning-effort` accepts, in the CLI's own
+* order (`muse exec --help`, Muse Code 1.1.1). `high` is the CLI default, so
+* it is the default here too.
+*/
+const MUSE_REASONING_EFFORTS = [
+	"none",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max",
+	"ultra"
+];
+const MUSE_DEFAULT_REASONING_EFFORT = "high";
+/**
+* Keep a selection Muse cannot parse out of the argv. `reasoningEffort` is a
+* shared option id — Codex publishes one too — so a selection left over from
+* another provider can reach this driver, and an unknown level makes
+* `muse exec` reject the whole invocation.
+*/
+function museReasoningEffort(value) {
+	return value !== void 0 && MUSE_REASONING_EFFORTS.includes(value) ? value : void 0;
+}
+/**
 * Build the argument vector for one turn.
 *
-* Approval policy is the load-bearing decision here. 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:
+* Approval policy is the load-bearing decision here. Muse Code 1.1.1 does
+* express approval as a policy — `--approval-mode untrusted|on-request|never`,
+* plus named `--permission-profile` documents — but a headless `exec` run
+* still has no channel to answer a prompt: approvals are served over MSP
+* (`muse serve`), not on the `exec` stream. So the only two postures `exec`
+* can honour end to end are `--disable-approval` (keep the OS sandbox) and
+* `--yolo` (drop approval and the sandbox, and trust the workspace). P4Code
+* owns the user-facing runtime mode, so it maps onto those two:
 *
 *   - `full-access` → `--yolo`
 *   - everything else → `--disable-approval --trust-workspace`, leaving the
 *     sandbox to contain what runs.
 *
-* `approval-required` cannot be honoured; the adapter emits a
-* `config.warning` for it rather than silently pretending otherwise.
+* `approval-required` cannot be honoured over `exec`; the adapter emits a
+* `config.warning` for it rather than silently pretending otherwise. Serving
+* a real approval prompt means moving the driver onto MSP.
+*
+* Flags here were verified against Muse Code 1.1.1-R2514.1 (`muse exec
+* --help`).
 */
 function buildMuseExecArgs(input) {
 	const args = [
@@ -103463,10 +103730,15 @@ function museApprovalsUnsupported(runtimeMode) {
 * MuseExecEvents — pure translation of `muse exec --json` JSONL records into
 * canonical `ProviderRuntimeEvent`s.
 *
-* Muse Code has no ACP or app-server surface (verified against CLI
-* 0.1.0-R708.1): the only scriptable path is `muse exec --json`, which runs
-* one prompt to completion and prints one JSON object per line. Multi-turn
-* threads are rebuilt by re-invoking with `--session-id`.
+* P4Code drives Muse through `muse exec --json`, which runs one prompt to
+* completion and prints one JSON object per line; multi-turn threads are
+* rebuilt by re-invoking with `--session-id`. Muse Code 1.1.1 also serves a
+* session host over stdio (`muse serve`, the MSP wire protocol, exported by
+* `muse schema`) with approval, user-input and steering methods that `exec`
+* has no channel for. Moving onto MSP is the way to lift those limits; the
+* mapping below stays on the `exec` stream until then.
+*
+* Record shapes here were re-verified against CLI 1.1.1-R2514.1.
 *
 * Everything here is a pure function over a caller-owned state record so the
 * mapping can be tested against captured CLI output without spawning a
@@ -103760,21 +104032,19 @@ function toolCallIdFromIdempotencyKey(key) {
 	const callId = key.slice(5).trim();
 	return callId.length > 0 ? callId : void 0;
 }
+/**
+* Muse's tool names, as the CLI itself reports them (Muse Code 1.1.1). Names
+* it does not have are not listed: an unknown tool still maps to
+* `dynamic_tool_call`, which is the right answer for the memory, goal, cron,
+* skill and todo tools that have no canonical item type here.
+*/
 function itemTypeForToolName(toolName) {
 	switch (toolName) {
 		case "bash":
-		case "shell":
-		case "run_command":
-		case "unified_exec": return "command_execution";
+		case "bash_input": return "command_execution";
 		case "write_file":
-		case "edit_file":
-		case "multi_edit":
-		case "apply_patch":
-		case "delete_file":
-		case "move_file": return "file_change";
-		case "web_search":
-		case "web_fetch": return "web_search";
-		case "view_image": return "image_view";
+		case "edit_file": return "file_change";
+		case "web_search": return "web_search";
 		default:
 			if (toolName?.startsWith("subagent_")) return "collab_agent_tool_call";
 			if (toolName?.startsWith("mcp__")) return "mcp_tool_call";
@@ -103990,11 +104260,12 @@ const makeMuseTextGeneration = (museSettings, environment = process.env) => Effe
 /**
 * MuseExecRuntime — one `muse exec --json` child process per turn.
 *
-* Muse Code has no long-lived protocol surface: a turn is a process, and the
-* thread is rebuilt from the CLI's own event-sourced session log when the
-* next turn passes `--session-id`. This module owns spawning, line framing,
-* interruption, and exit classification; it knows nothing about canonical
-* runtime events.
+* On the `exec` path a turn is a process, and the thread is rebuilt from the
+* CLI's own event-sourced session log when the next turn passes
+* `--session-id`. (Muse Code 1.1.1 does have a long-lived surface —
+* `muse serve`, the MSP session host — which this driver does not use yet.)
+* This module owns spawning, line framing, interruption, and exit
+* classification; it knows nothing about canonical runtime events.
 *
 * @module provider/muse/MuseExecRuntime
 */
@@ -104238,11 +104509,12 @@ function nonNegativeInt(value) {
 *
 * Consequences that are visible to users, and deliberate:
 *
-*   - **No interactive approvals.** Headless Muse has no channel to answer an
-*     approval prompt, so the adapter runs with approval disabled and lets
-*     Muse's OS sandbox do the containing. `respondToRequest` fails rather
-*     than pretending to route a decision, and `approval-required` threads get
-*     a `config.warning`.
+*   - **No interactive approvals.** `muse exec` has no channel to answer an
+*     approval prompt — Muse Code 1.1.1 serves approvals over MSP
+*     (`muse serve`), which this adapter does not speak — so the adapter runs
+*     with approval disabled and lets Muse's OS sandbox do the containing.
+*     `respondToRequest` fails rather than pretending to route a decision, and
+*     `approval-required` threads get a `config.warning`.
 *   - **No provider-side rollback.** Muse can fork a session interactively but
 *     exposes nothing headless.
 *   - **Tool arguments are not streamed.** They exist only in the on-disk
@@ -104382,10 +104654,12 @@ function makeMuseAdapter(museSettings, options) {
 			}
 			const turnId = TurnId.make(yield* randomUUIDv4);
 			const model = input.modelSelection?.model ?? ctx.session.model;
+			const reasoningEffort = input.modelSelection?.instanceId === boundInstanceId ? museReasoningEffort(getModelSelectionStringOptionValue(input.modelSelection, "reasoningEffort")) : void 0;
 			const args = buildMuseExecArgs({
 				sessionId: ctx.museSessionId,
 				prompt,
 				model,
+				reasoningEffort,
 				baseUrl: museSettings.baseUrl || void 0,
 				runtimeMode: ctx.session.runtimeMode,
 				imagePaths
@@ -104420,54 +104694,74 @@ function makeMuseAdapter(museSettings, options) {
 				...model ? { model } : {}
 			};
 			const turnScope = yield* Scope.make();
-			const run = yield* runMuseExec({
+			let runStarted = false;
+			let settled = false;
+			let outcome;
+			/**
+			* Release everything the turn holds, exactly once, whatever ended it:
+			* a clean exit, a typed failure, a defect, or an interrupt from a
+			* stopped thread. Leaving `activeTurn` or a `running` session behind
+			* would wedge the thread — every later `sendTurn` would refuse with
+			* "a Muse turn is already running" until the server restarted — so
+			* this runs from an `ensuring` finalizer rather than the happy path.
+			*/
+			const finishTurn = Effect.suspend(() => {
+				if (settled) return Effect.void;
+				settled = true;
+				return Effect.gen(function* () {
+					ctx.activeTurn = void 0;
+					yield* Scope.close(turnScope, Exit.void);
+					if (runStarted && state.terminal === void 0) if (outcome === void 0 || outcome.kind === "interrupted") yield* publish({
+						type: "turn.aborted",
+						...yield* makeEventStamp(),
+						provider: PROVIDER$1,
+						providerInstanceId: boundInstanceId,
+						threadId: input.threadId,
+						turnId,
+						payload: { reason: "interrupted" }
+					});
+					else {
+						const detail = outcome.kind === "failed" ? outcome.stderr || `\`muse exec\` exited with code ${outcome.exitCode}.` : "`muse exec` ended without a terminal event.";
+						yield* publish({
+							type: "turn.completed",
+							...yield* makeEventStamp(),
+							provider: PROVIDER$1,
+							providerInstanceId: boundInstanceId,
+							threadId: input.threadId,
+							turnId,
+							payload: {
+								state: "failed",
+								errorMessage: detail
+							}
+						});
+					}
+					if (runStarted) yield* publishTokenUsage(ctx, turnId);
+					const updatedAt = yield* nowIso;
+					const { activeTurnId: _activeTurnId, ...readySession } = ctx.session;
+					ctx.session = {
+						...readySession,
+						status: "ready",
+						updatedAt
+					};
+				});
+			}).pipe(Effect.ignore);
+			yield* Effect.acquireUseRelease(runMuseExec({
 				threadId: input.threadId,
 				binaryPath: museSettings.binaryPath || "muse",
 				args,
 				cwd: ctx.cwd,
 				environment,
 				onLine: handleLine
-			}).pipe(Effect.provideService(Scope.Scope, turnScope), Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner), Effect.tapError(() => Scope.close(turnScope, Exit.void)));
-			ctx.activeTurn = {
-				turnId,
-				run,
-				state
-			};
-			const outcome = yield* run.awaitOutcome;
-			yield* Scope.close(turnScope, Exit.void);
-			ctx.activeTurn = void 0;
-			if (state.terminal === void 0) if (outcome.kind === "interrupted") yield* publish({
-				type: "turn.aborted",
-				...yield* makeEventStamp(),
-				provider: PROVIDER$1,
-				providerInstanceId: boundInstanceId,
-				threadId: input.threadId,
-				turnId,
-				payload: { reason: "interrupted" }
-			});
-			else {
-				const detail = outcome.kind === "failed" ? outcome.stderr || `\`muse exec\` exited with code ${outcome.exitCode}.` : "`muse exec` ended without a terminal event.";
-				yield* publish({
-					type: "turn.completed",
-					...yield* makeEventStamp(),
-					provider: PROVIDER$1,
-					providerInstanceId: boundInstanceId,
-					threadId: input.threadId,
+			}).pipe(Effect.provideService(Scope.Scope, turnScope), Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner), Effect.tapError(() => finishTurn), Effect.tap((run) => Effect.sync(() => {
+				runStarted = true;
+				ctx.activeTurn = {
 					turnId,
-					payload: {
-						state: "failed",
-						errorMessage: detail
-					}
-				});
-			}
-			yield* publishTokenUsage(ctx, turnId);
-			const updatedAt = yield* nowIso;
-			const { activeTurnId: _activeTurnId, ...readySession } = ctx.session;
-			ctx.session = {
-				...readySession,
-				status: "ready",
-				updatedAt
-			};
+					run,
+					state
+				};
+			}))), (run) => Effect.gen(function* () {
+				outcome = yield* run.awaitOutcome;
+			}), () => finishTurn);
 			return {
 				threadId: input.threadId,
 				turnId,
@@ -104596,7 +104890,17 @@ const MUSE_PRESENTATION = {
 	requiresNewThreadForModelChange: false,
 	supportedRuntimeModes: ["auto", "full-access"]
 };
-const EMPTY_CAPABILITIES = createModelCapabilities({ optionDescriptors: [] });
+const MUSE_CAPABILITIES = createModelCapabilities({ optionDescriptors: [{
+	id: "reasoningEffort",
+	label: "Reasoning",
+	type: "select",
+	options: MUSE_REASONING_EFFORTS.map((effort) => ({
+		id: effort,
+		label: effort.charAt(0).toUpperCase() + effort.slice(1),
+		...effort === "high" ? { isDefault: true } : {}
+	})),
+	currentValue: MUSE_DEFAULT_REASONING_EFFORT
+}] });
 const VERSION_PROBE_TIMEOUT_MS = 4e3;
 /** Models Meta documents for Muse Code; used until the CLI caches a catalog. */
 const MUSE_BUILT_IN_MODELS = [
@@ -104604,30 +104908,30 @@ const MUSE_BUILT_IN_MODELS = [
 		slug: "muse-spark-1.3",
 		name: "Muse Spark 1.3",
 		isCustom: false,
-		capabilities: EMPTY_CAPABILITIES
+		capabilities: MUSE_CAPABILITIES
 	},
 	{
 		slug: "muse-spark-1.3-contributor",
 		name: "Muse Spark 1.3 (contributor)",
 		isCustom: false,
 		isDefault: true,
-		capabilities: EMPTY_CAPABILITIES
+		capabilities: MUSE_CAPABILITIES
 	},
 	{
 		slug: "muse-spark-1.2",
 		name: "Muse Spark 1.2",
 		isCustom: false,
-		capabilities: EMPTY_CAPABILITIES
+		capabilities: MUSE_CAPABILITIES
 	},
 	{
 		slug: "muse-spark-1.2-contributor",
 		name: "Muse Spark 1.2 (contributor)",
 		isCustom: false,
-		capabilities: EMPTY_CAPABILITIES
+		capabilities: MUSE_CAPABILITIES
 	}
 ];
 function museModelsFromSettings(customModels, builtInModels = MUSE_BUILT_IN_MODELS) {
-	return providerModelsFromSettings(builtInModels, customModels ?? [], EMPTY_CAPABILITIES);
+	return providerModelsFromSettings(builtInModels, customModels ?? [], MUSE_CAPABILITIES);
 }
 const discoverMuseModels = Effect.fn("discoverMuseModels")(function* (environment) {
 	return (yield* readMuseModelCatalog(environment)).map((model) => ({
@@ -104635,7 +104939,7 @@ const discoverMuseModels = Effect.fn("discoverMuseModels")(function* (environmen
 		name: model.name,
 		isCustom: false,
 		...model.isDefault ? { isDefault: true } : {},
-		capabilities: EMPTY_CAPABILITIES
+		capabilities: MUSE_CAPABILITIES
 	}));
 });
 /**