@p4code/cli 0.0.41 → 0.0.43

package/dist/bin.mjs

@@ -7,6 +7,7 @@ import * as Console from "effect/Console";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import { Argument, Command, Flag, GlobalFlag, Prompt } from "effect/unstable/cli";
+import * as CliError from "effect/unstable/cli/CliError";
 import { FetchHttpClient, Headers, HttpBody, HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse, HttpRouter, HttpServer, HttpServerRequest, HttpServerRespondable, HttpServerResponse } from "effect/unstable/http";
 import * as Context from "effect/Context";
 import * as NodeOS from "node:os";
@@ -54,13 +55,11 @@ import * as Exit from "effect/Exit";
 import * as SchemaGetter from "effect/SchemaGetter";
 import * as Config from "effect/Config";
 import * as NodeReadline from "node:readline";
-import * as Scope from "effect/Scope";
-import * as ChildProcess$1 from "effect/unstable/process/ChildProcess";
-import * as ChildProcessSpawner$1 from "effect/unstable/process/ChildProcessSpawner";
 import * as Cache from "effect/Cache";
 import * as Deferred from "effect/Deferred";
 import * as Equal from "effect/Equal";
 import * as Semaphore from "effect/Semaphore";
+import * as Scope from "effect/Scope";
 import { parse } from "yaml";
 import * as HttpApiClient from "effect/unstable/httpapi/HttpApiClient";
 import * as Clock from "effect/Clock";
@@ -69,6 +68,8 @@ import * as Queue from "effect/Queue";
 import { cast, dual } from "effect/Function";
 import Mime from "@effect/platform-node/Mime";
 import * as Arr from "effect/Array";
+import * as ChildProcess$1 from "effect/unstable/process/ChildProcess";
+import * as ChildProcessSpawner$1 from "effect/unstable/process/ChildProcessSpawner";
 import * as Schedule from "effect/Schedule";
 import * as HttpClient$1 from "effect/unstable/http/HttpClient";
 import * as HttpClientRequest$1 from "effect/unstable/http/HttpClientRequest";
@@ -120,7 +121,7 @@ const closeServer = (server) => {
 * NetService - Service tag for startup networking helpers.
 */
 var NetService = class extends Context.Service()("@p4code/shared/Net/NetService") {};
-const make$70 = () => {
+const make$71 = () => {
 	/**
 	* Returns true when a TCP server can bind to {host, port}.
 	* `EADDRNOTAVAIL` is treated as available so IPv6-absent hosts don't fail
@@ -229,10 +230,10 @@ const make$70 = () => {
 		})
 	};
 };
-const layer$66 = Layer.sync(NetService, make$70);
+const layer$67 = Layer.sync(NetService, make$71);
 //#endregion
 //#region package.json
-var version = "0.0.40";
+var version = "0.0.43";
 //#endregion
 //#region src/config.ts
 /**
@@ -253,8 +254,8 @@ var ServerConfig$1 = class extends Context.Service()("@p4code/cli/config/ServerC
 	/** @deprecated Import and use `layerTest` from this module. */
 	static layerTest = (cwd, baseDirOrPrefix) => layerTest$2(cwd, baseDirOrPrefix);
 };
-const make$69 = (config) => ServerConfig$1.of(config);
-const layer$65 = (config) => Layer.succeed(ServerConfig$1, make$69(config));
+const make$70 = (config) => ServerConfig$1.of(config);
+const layer$66 = (config) => Layer.succeed(ServerConfig$1, make$70(config));
 const deriveServerPaths = Effect.fn(function* (baseDir, devUrl, options = {}) {
 	const { join } = yield* Path.Path;
 	const stateDir = join(baseDir, devUrl !== void 0 && !options.baseDirIsExplicit ? "dev" : "userdata");
@@ -922,7 +923,7 @@ const resolveLatestVersion = Effect.fn("cli.updateCheck.resolve")(function* (sta
 * `service update` restarts it onto the new one.
 */
 function formatUpdateReminder(input) {
-	return [`Update available: ${PACKAGE_NAME}@${input.latestVersion} (running ${input.currentVersion}).`, `  npm i -g ${PACKAGE_NAME}@latest && p4 service update`].join("\n");
+	return [`Update available: ${PACKAGE_NAME}@${input.latestVersion} (running ${input.currentVersion}).`, `  npm i -g ${PACKAGE_NAME}@latest && p4c service update`].join("\n");
 }
 /**
 * The reminder line, or null when there is nothing to say. Callers print it;
@@ -6177,7 +6178,7 @@ var ServerProviderUpdateError = class extends Schema$1.TaggedErrorClass()("Serve
 	}
 };
 const ServerSelfUpdateInput = Schema$1.Struct({ 
-/** Exact npm version of the `p4` package to install (never a dist-tag, so
+/** Exact npm version of the `p4c` package to install (never a dist-tag, so
 the server and the acknowledging client agree on what was requested). */
 targetVersion: TrimmedNonEmptyString });
 /** Acknowledgement that the update artifact is installed and the server is
@@ -7312,10 +7313,26 @@ const AGENT_ASSET_TOTAL_MAX_BYTES = 4 * 1024 * 1024;
 * What kind of thing this is.
 *
 * A literal union rather than free text because the kind decides where the
-* asset lands on disk, and an unknown kind has no answer to that. Adding
-* `memory` here is the next step, and it needs a materializer to go with it.
+* asset lands on disk, and an unknown kind has no answer to that. Each kind
+* needs a materializer, which is what stops this from being a place to add a
+* string.
+*
+* - `skill` — a directory under `<configDir>/skills`, named by the asset.
+* - `memory` — a single file directly in `<configDir>`, named by the asset.
+*   The name is the filename, and only the allowlisted ones exist: that
+*   directory also holds `settings.json` and `.credentials.json`, so "write the
+*   file this asset names" has to be bounded by something narrower than the
+*   path schema.
+* - `mcp` — an external MCP server registration, in p4code's own state
+*   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.
 */
-const AgentAssetKind = Schema$1.Literals(["skill"]);
+const AgentAssetKind = Schema$1.Literals([
+	"skill",
+	"memory",
+	"mcp"
+]);
 /**
 * An asset's name, which for a skill is also its directory name.
 *
@@ -7331,6 +7348,18 @@ const AgentAssetName = TrimmedNonEmptyString.check(Schema$1.isMaxLength(AGENT_AS
 	description: "Letters, digits, dot, dash and underscore; must not start with a separator."
 }));
 /**
+* Which asset, across every kind.
+*
+* Kind and name together, because name alone stopped being unique the moment a
+* second kind existed: `AgentAssetName` permits dots, so a skill directory may
+* legitimately be called `CLAUDE.md`. A report saying only "published
+* CLAUDE.md" would be ambiguous about what had just been sent where.
+*/
+const AgentAssetRef = Schema$1.Struct({
+	kind: AgentAssetKind,
+	name: AgentAssetName
+});
+/**
 * A path inside the asset, relative to the asset's own directory.
 *
 * Same reasoning as the name and the same threat, in a more tempting form:
@@ -7428,56 +7457,77 @@ const HubLinkSource = Schema$1.Literals([
 	"none"
 ]);
 /**
-* What a skill's three views add up to.
+* What an asset's three views add up to.
 *
 * `pending` means the next sync will act; `local-edit` means it will publish
 * this machine's copy; `conflict` means it will do nothing and wants a person.
 * `unmanaged` is the important one — p4code did not write it, so it is neither
 * uploaded nor written over.
+*
+* `hub-only` is the one that has no local half: the hub holds it and this
+* machine does not materialize it. That is normal for a memory file belonging
+* to a provider this machine does not run, and it is the state that makes
+* hub-side editing worth having — otherwise the only way to reach such an asset
+* would be to install the provider first.
 */
-const SkillSyncEntryState = Schema$1.Literals([
+const AgentSyncEntryState = Schema$1.Literals([
 	"synced",
 	"pending",
 	"local-edit",
 	"conflict",
-	"unmanaged"
+	"unmanaged",
+	"hub-only"
 ]);
-const SkillSyncEntry = Schema$1.Struct({
+const AgentSyncEntry = Schema$1.Struct({
+	kind: AgentAssetKind,
 	name: Schema$1.String,
-	state: SkillSyncEntryState,
+	state: AgentSyncEntryState,
 	version: Schema$1.NullOr(Schema$1.Int),
 	/** Conflict reason or pending action, for a caller that wants to explain. */
 	detail: Schema$1.NullOr(Schema$1.String)
 });
-const SkillSyncRefusal = Schema$1.Struct({
+const AgentSyncRefusal = Schema$1.Struct({
+	kind: AgentAssetKind,
 	name: Schema$1.String,
 	reason: Schema$1.String
 });
-const SkillSyncConflictReport = Schema$1.Struct({
+const AgentSyncConflictReport = Schema$1.Struct({
+	kind: AgentAssetKind,
 	name: Schema$1.String,
 	reason: Schema$1.String
 });
-const SkillSyncStatus = Schema$1.Struct({
+/**
+* Where one kind materializes on this machine.
+*
+* A list rather than a field per kind, so adding the third kind is data rather
+* than another optional string every reader has to learn about. Null when the
+* root cannot be resolved — a provider that is not configured here.
+*/
+const AgentSyncRoot = Schema$1.Struct({
+	kind: AgentAssetKind,
+	path: Schema$1.NullOr(Schema$1.String)
+});
+const AgentSyncStatus = Schema$1.Struct({
 	configured: Schema$1.Boolean,
 	hubUrl: Schema$1.NullOr(Schema$1.String),
 	syncMode: HubSyncMode,
 	shareMode: HubShareMode,
 	source: HubLinkSource,
-	skillsRoot: Schema$1.NullOr(Schema$1.String),
-	entries: Schema$1.Array(SkillSyncEntry),
-	refused: Schema$1.Array(SkillSyncRefusal),
+	roots: Schema$1.Array(AgentSyncRoot),
+	entries: Schema$1.Array(AgentSyncEntry),
+	refused: Schema$1.Array(AgentSyncRefusal),
 	/** Set when the hub could not be reached. Local state is still reported. */
 	unavailable: Schema$1.NullOr(Schema$1.String)
 });
-const SkillSyncReport = Schema$1.Struct({
+const AgentSyncReport = Schema$1.Struct({
 	ran: Schema$1.Boolean,
-	skillsRoot: Schema$1.NullOr(Schema$1.String),
-	materialized: Schema$1.Array(Schema$1.String),
-	published: Schema$1.Array(Schema$1.String),
-	removed: Schema$1.Array(Schema$1.String),
-	conflicts: Schema$1.Array(SkillSyncConflictReport),
-	unmanaged: Schema$1.Array(Schema$1.String),
-	refused: Schema$1.Array(SkillSyncRefusal),
+	roots: Schema$1.Array(AgentSyncRoot),
+	materialized: Schema$1.Array(AgentAssetRef),
+	published: Schema$1.Array(AgentAssetRef),
+	removed: Schema$1.Array(AgentAssetRef),
+	conflicts: Schema$1.Array(AgentSyncConflictReport),
+	unmanaged: Schema$1.Array(AgentAssetRef),
+	refused: Schema$1.Array(AgentSyncRefusal),
 	unavailable: Schema$1.NullOr(Schema$1.String)
 });
 const HubConnectInput = Schema$1.Struct({
@@ -7497,7 +7547,57 @@ const HubMintedToken = Schema$1.Struct({
 	token: Schema$1.String,
 	digest: Schema$1.String
 });
-const SkillNameInput = Schema$1.Struct({ name: AgentAssetName });
+const AgentAssetRefInput = AgentAssetRef;
+/**
+* One asset as the hub holds it, for editing.
+*
+* Answered as `found: false` rather than as an error, because "the hub does not
+* have this" is a normal answer to a panel that is showing a row another
+* machine may have deleted a moment ago. `version` is carried back out so the
+* save that follows can be a compare-and-set rather than a blind overwrite.
+*/
+const AgentAssetContent = Schema$1.Struct({
+	found: Schema$1.Boolean,
+	kind: AgentAssetKind,
+	name: AgentAssetName,
+	files: Schema$1.Array(AgentAssetFile),
+	version: Schema$1.NullOr(Schema$1.Int),
+	updatedAt: Schema$1.NullOr(IsoDateTime),
+	/** Set when the hub could not be reached, so a caller can say why it is blank. */
+	unavailable: Schema$1.NullOr(Schema$1.String)
+});
+/**
+* Edit an asset in the hub, rather than on disk and upward.
+*
+* The hub is the shared copy, so this is the edit that reaches every machine
+* including ones that are asleep — and the only way to reach an asset this
+* machine does not materialize. `expectedVersion` is required, not optional:
+* an unconditional overwrite of shared state is exactly the operation that
+* loses another machine's edit without telling anyone.
+*/
+const AgentAssetSaveInput = Schema$1.Struct({
+	kind: AgentAssetKind,
+	name: AgentAssetName,
+	files: AgentAssetFiles,
+	expectedVersion: PositiveInt
+});
+/**
+* Delete an asset from the hub and so from every machine that syncs it.
+*
+* Distinct from unpublishing, which only ends *this* machine's share and keeps
+* the local copy. This one is the destructive one, and it does not require the
+* asset to be managed here — that restriction is what made a stale row from a
+* decommissioned machine impossible to clear.
+*
+* `expectedVersion` is optional here alone: someone deleting a row they can see
+* in a list has usually never held a version for it, and refusing on that basis
+* would make the operation unreachable in exactly the case it exists for.
+*/
+const AgentAssetDeleteInput = Schema$1.Struct({
+	kind: AgentAssetKind,
+	name: AgentAssetName,
+	expectedVersion: Schema$1.optional(PositiveInt)
+});
 /**
 * Changing the hub link failed.
 *
@@ -7522,6 +7622,143 @@ const encoder$3 = new TextEncoder();
 */
 const agentAssetTotalBytes = (files) => files.reduce((total, file) => total + encoder$3.encode(file.content).length + encoder$3.encode(file.path).length, 0);
 //#endregion
+//#region ../../packages/contracts/src/mcpServer.ts
+/**
+* External MCP server registrations.
+*
+* The servers a person adds themselves — a ticket tracker, a search index, a
+* build system — as opposed to p4code's own toolkit, which the adapters inject
+* on every session and which is not registered anywhere.
+*
+* **These are p4code's own data, not the provider's.** The obvious place to put
+* them is `~/.claude.json` under `mcpServers`, which is where the Claude CLI
+* keeps its own. p4code does not write that file: it also holds `oauthAccount`,
+* `machineID` and a `projects` map of per-path trust decisions, so owning one
+* key inside it means round-tripping all of that. The SDK takes `mcpServers` as
+* a session option and the adapter already passes it, so a registration p4code
+* stores itself reaches the agent by the same door its own toolkit uses —
+* without touching the provider's file at all.
+*
+* **Secret values are not in here, and that is the point.** A registration
+* routinely needs a bearer token in a header or an API key in the environment.
+* Those are named here and stored per machine in `ServerSecretStore`; the
+* registration itself carries only the name of the slot. That is what lets the
+* whole registration sync through the hub — which stores asset files verbatim —
+* without a working credential ever leaving the machine that holds it.
+*
+* @module contracts/mcpServer
+*/
+/**
+* A server's name, reused from asset names rather than defined again.
+*
+* It is the key in the SDK's `mcpServers` record *and* a path segment in
+* p4code's own store, so it needs exactly the constraint an asset name already
+* has. Two definitions of the same rule is how one of them ends up laxer.
+*/
+const McpServerName = AgentAssetName;
+/**
+* Where a secret goes when it is resolved.
+*
+* The slot, not the value. `header` fills one entry of an http server's
+* `headers`; `env` fills one entry of a stdio server's environment.
+*/
+const McpSecretTarget = Schema$1.Literals(["header", "env"]);
+/**
+* One secret this server needs, named but not carried.
+*
+* There is no `secretName` field: the storage name is derived from the server,
+* the target and the key. A caller-supplied name would be one more thing to get
+* wrong, and two servers could name the same slot differently or — worse — the
+* same name for different slots.
+*/
+const McpSecretSlot = Schema$1.Struct({
+	target: McpSecretTarget,
+	key: TrimmedNonEmptyString
+});
+/**
+* The storage name for one slot's value.
+*
+* Derived in the contract so both ends agree without either importing the
+* other's helper: the server resolving a session and the panel writing a value
+* have to compute the same string or the value is written where nothing looks.
+*/
+const mcpSecretStorageName = (input) => `mcp.${input.server}.${input.target}.${input.key}`;
+const commonFields = {
+	name: McpServerName,
+	/**
+	* Off means registered and not injected.
+	*
+	* Kept rather than deleted because turning a server off to test something is
+	* the common case, and re-entering a command line and four headers to turn it
+	* back on is how people stop turning it off.
+	*/
+	enabled: Schema$1.Boolean,
+	secrets: Schema$1.optional(Schema$1.Array(McpSecretSlot))
+};
+/**
+* A server p4code launches as a child process.
+*
+* `env` holds only values that are not secret. Anything that is goes in
+* `secrets` and is resolved from this machine's own store at session start.
+*/
+const McpStdioServer = Schema$1.Struct({
+	...commonFields,
+	transport: Schema$1.Literal("stdio"),
+	command: TrimmedNonEmptyString,
+	args: Schema$1.optional(Schema$1.Array(Schema$1.String)),
+	env: Schema$1.optional(Schema$1.Record(Schema$1.String, Schema$1.String))
+});
+/** A server reached over HTTP. `headers` holds only non-secret values. */
+const McpRemoteServer = Schema$1.Struct({
+	...commonFields,
+	transport: Schema$1.Literals(["http", "sse"]),
+	url: TrimmedNonEmptyString,
+	headers: Schema$1.optional(Schema$1.Record(Schema$1.String, Schema$1.String))
+});
+/**
+* A registration, as a union rather than one struct of optional fields.
+*
+* A stdio server with a `url` and no `command` is not a thing, and a struct
+* with both optional would let one be stored and then fail at session start —
+* on a machine that may not be the one where it was typed.
+*/
+const McpServerRegistration = Schema$1.Union([McpStdioServer, McpRemoteServer]);
+/**
+* What a panel needs to show, including what this machine cannot run.
+*
+* `missingSecrets` is the field that earns this type. A registration syncs
+* everywhere; its secrets do not. So a server can be perfectly valid and still
+* unusable *here*, and saying which slot is empty is the difference between a
+* fixable state and a mystery.
+*/
+const McpServerStatus = Schema$1.Struct({
+	registration: McpServerRegistration,
+	missingSecrets: Schema$1.Array(McpSecretSlot),
+	/** True when this machine holds everything needed to start it. */
+	ready: Schema$1.Boolean
+});
+const McpServerList = Schema$1.Struct({ servers: Schema$1.Array(McpServerStatus) });
+const McpServerSaveInput = Schema$1.Struct({ registration: McpServerRegistration });
+const McpServerNameInput = Schema$1.Struct({ name: McpServerName });
+/**
+* Setting one secret value, on this machine only.
+*
+* Separate from saving the registration because they go to different places and
+* only one of them travels. Bundling them would make the panel's save button
+* the thing that decides whether a credential syncs, which is not a decision to
+* leave to a button.
+*/
+const McpServerSecretInput = Schema$1.Struct({
+	name: McpServerName,
+	slot: McpSecretSlot,
+	value: Schema$1.String
+});
+var McpRegistryError = class extends Schema$1.TaggedErrorClass()("McpRegistryError", { detail: Schema$1.String }) {
+	get message() {
+		return this.detail;
+	}
+};
+//#endregion
 //#region ../../packages/contracts/src/filesystem.ts
 const FILESYSTEM_PATH_MAX_LENGTH = 512;
 const FilesystemBrowseInput = Schema$1.Struct({
@@ -7777,6 +8014,13 @@ const WS_METHODS = {
 	skillsPublish: "skills.publish",
 	skillsPublishAll: "skills.publishAll",
 	skillsUnpublish: "skills.unpublish",
+	assetsRead: "assets.read",
+	assetsSave: "assets.save",
+	assetsDelete: "assets.delete",
+	mcpList: "mcp.list",
+	mcpSave: "mcp.save",
+	mcpRemove: "mcp.remove",
+	mcpSetSecret: "mcp.setSecret",
 	sourceControlLookupRepository: "sourceControl.lookupRepository",
 	sourceControlCloneRepository: "sourceControl.cloneRepository",
 	sourceControlPublishRepository: "sourceControl.publishRepository",
@@ -7846,36 +8090,36 @@ const WsTasksDeleteRpc = Rpc.make(WS_METHODS.tasksDelete, {
 const HubRpcError = Schema$1.Union([HubLinkError, EnvironmentAuthorizationError]);
 const WsHubGetSyncStatusRpc = Rpc.make(WS_METHODS.hubGetSyncStatus, {
 	payload: Schema$1.Struct({}),
-	success: SkillSyncStatus,
+	success: AgentSyncStatus,
 	error: Schema$1.Union([EnvironmentAuthorizationError])
 });
 const WsHubConnectRpc = Rpc.make(WS_METHODS.hubConnect, {
 	payload: HubConnectInput,
-	success: SkillSyncStatus,
+	success: AgentSyncStatus,
 	error: HubRpcError
 });
 const WsHubDisconnectRpc = Rpc.make(WS_METHODS.hubDisconnect, {
 	payload: Schema$1.Struct({}),
-	success: SkillSyncStatus,
+	success: AgentSyncStatus,
 	error: HubRpcError
 });
 const WsHubSetSyncModeRpc = Rpc.make(WS_METHODS.hubSetSyncMode, {
 	payload: HubSyncModeInput,
-	success: SkillSyncStatus,
+	success: AgentSyncStatus,
 	error: HubRpcError
 });
 /**
 * Mint a bearer token for a hub, without contacting one.
 *
 * A hub issues nothing — it only ever holds digests — so this is local
-* generation, the same thing `p4 hub token add` does. It exists as an RPC
+* generation, the same thing `p4c hub token add` does. It exists as an RPC
 * rather than in the browser because a client reached over plain HTTP on a LAN
 * has no `crypto.subtle`, and a token generator that silently degrades is not
 * a thing to ship.
 */
 const WsHubSetShareModeRpc = Rpc.make(WS_METHODS.hubSetShareMode, {
 	payload: HubShareModeInput,
-	success: SkillSyncStatus,
+	success: AgentSyncStatus,
 	error: HubRpcError
 });
 const WsHubMintTokenRpc = Rpc.make(WS_METHODS.hubMintToken, {
@@ -7886,36 +8130,99 @@ const WsHubMintTokenRpc = Rpc.make(WS_METHODS.hubMintToken, {
 const WsSkillsSyncRpc = Rpc.make(WS_METHODS.skillsSync, {
 	payload: Schema$1.Struct({}),
 	success: Schema$1.Struct({
-		report: SkillSyncReport,
-		status: SkillSyncStatus
+		report: AgentSyncReport,
+		status: AgentSyncStatus
 	}),
 	error: Schema$1.Union([EnvironmentAuthorizationError])
 });
 const WsSkillsPublishRpc = Rpc.make(WS_METHODS.skillsPublish, {
-	payload: SkillNameInput,
+	payload: AgentAssetRefInput,
 	success: Schema$1.Struct({
-		report: SkillSyncReport,
-		status: SkillSyncStatus
+		report: AgentSyncReport,
+		status: AgentSyncStatus
 	}),
 	error: Schema$1.Union([EnvironmentAuthorizationError])
 });
 const WsSkillsPublishAllRpc = Rpc.make(WS_METHODS.skillsPublishAll, {
 	payload: Schema$1.Struct({}),
 	success: Schema$1.Struct({
-		report: SkillSyncReport,
-		status: SkillSyncStatus
+		report: AgentSyncReport,
+		status: AgentSyncStatus
 	}),
 	error: Schema$1.Union([EnvironmentAuthorizationError])
 });
 const WsSkillsUnpublishRpc = Rpc.make(WS_METHODS.skillsUnpublish, {
-	payload: SkillNameInput,
+	payload: AgentAssetRefInput,
 	success: Schema$1.Struct({
-		report: SkillSyncReport,
-		status: SkillSyncStatus
+		report: AgentSyncReport,
+		status: AgentSyncStatus
 	}),
 	error: Schema$1.Union([EnvironmentAuthorizationError])
 });
 /**
+* Reading, editing and deleting an asset in the hub itself.
+*
+* The hub is the shared copy, so these reach every machine — including ones
+* that are asleep, and including assets this machine does not materialize at
+* all. Without them the only way to change a shared asset was to edit the local
+* file and wait for it to propagate, which is no way at all when the asset
+* belongs to a provider this machine does not run or to a machine you no longer
+* have.
+*/
+const WsAssetsReadRpc = Rpc.make(WS_METHODS.assetsRead, {
+	payload: AgentAssetRefInput,
+	success: AgentAssetContent,
+	error: Schema$1.Union([EnvironmentAuthorizationError])
+});
+const WsAssetsSaveRpc = Rpc.make(WS_METHODS.assetsSave, {
+	payload: AgentAssetSaveInput,
+	success: Schema$1.Struct({
+		report: AgentSyncReport,
+		status: AgentSyncStatus
+	}),
+	error: Schema$1.Union([EnvironmentAuthorizationError])
+});
+const WsAssetsDeleteRpc = Rpc.make(WS_METHODS.assetsDelete, {
+	payload: AgentAssetDeleteInput,
+	success: Schema$1.Struct({
+		report: AgentSyncReport,
+		status: AgentSyncStatus
+	}),
+	error: Schema$1.Union([EnvironmentAuthorizationError])
+});
+/**
+* Registering the user's own MCP servers.
+*
+* Every one of these answers with the whole list, for the same reason the sync
+* calls answer with the whole status: a panel that had to re-read after each
+* write would show a stale row in between.
+*
+* `setSecret` is deliberately its own call rather than a field on `save`. The
+* two go to different places — one to a file that syncs between machines, one
+* to a store that never leaves this one — and folding them together would make
+* a save button the thing that decides whether a credential travels.
+*/
+const WsMcpListRpc = Rpc.make(WS_METHODS.mcpList, {
+	payload: Schema$1.Struct({}),
+	success: McpServerList,
+	error: Schema$1.Union([EnvironmentAuthorizationError])
+});
+const WsMcpSaveRpc = Rpc.make(WS_METHODS.mcpSave, {
+	payload: McpServerSaveInput,
+	success: McpServerList,
+	error: Schema$1.Union([McpRegistryError, EnvironmentAuthorizationError])
+});
+const WsMcpRemoveRpc = Rpc.make(WS_METHODS.mcpRemove, {
+	payload: McpServerNameInput,
+	success: McpServerList,
+	error: Schema$1.Union([McpRegistryError, EnvironmentAuthorizationError])
+});
+const WsMcpSetSecretRpc = Rpc.make(WS_METHODS.mcpSetSecret, {
+	payload: McpServerSecretInput,
+	success: McpServerList,
+	error: Schema$1.Union([McpRegistryError, EnvironmentAuthorizationError])
+});
+/**
 * The board, then every change to it, for as long as the client stays
 * subscribed. The leading snapshot is what makes this sufficient on its own —
 * a client does not list first, so there is no window between the two in which
@@ -8283,7 +8590,7 @@ const WsSubscribeAuthAccessRpc = Rpc.make(WS_METHODS.subscribeAuthAccess, {
 	error: Schema$1.Union([AuthAccessStreamError, EnvironmentAuthorizationError]),
 	stream: true
 });
-const WsRpcGroup = RpcGroup.make(WsServerProbeRpc, WsServerGetConfigRpc, WsServerRefreshProvidersRpc, WsServerUpdateProviderRpc, WsServerUpdateServerRpc, WsServerUpsertKeybindingRpc, WsServerRemoveKeybindingRpc, WsServerGetSettingsRpc, WsServerUpdateSettingsRpc, WsServerDiscoverSourceControlRpc, WsServerGetTraceDiagnosticsRpc, WsServerGetProcessDiagnosticsRpc, WsServerGetProcessResourceHistoryRpc, WsServerSignalProcessRpc, WsSourceControlLookupRepositoryRpc, WsSourceControlCloneRepositoryRpc, WsSourceControlPublishRepositoryRpc, WsProjectsListEntriesRpc, WsProjectsReadFileRpc, WsProjectsSearchEntriesRpc, WsProjectsWriteFileRpc, WsShellOpenInEditorRpc, WsFilesystemBrowseRpc, WsAssetsCreateUrlRpc, WsSubscribeVcsStatusRpc, WsVcsPullRpc, WsVcsRefreshStatusRpc, WsGitRunStackedActionRpc, WsGitResolvePullRequestRpc, WsGitPreparePullRequestThreadRpc, WsVcsListRefsRpc, WsVcsCreateWorktreeRpc, WsVcsRemoveWorktreeRpc, WsVcsCreateRefRpc, WsVcsSwitchRefRpc, WsVcsInitRpc, WsReviewGetDiffPreviewRpc, WsTerminalOpenRpc, WsTerminalAttachRpc, WsTerminalWriteRpc, WsTerminalResizeRpc, WsTerminalClearRpc, WsTerminalRestartRpc, WsTerminalCloseRpc, WsSubscribeTerminalEventsRpc, WsSubscribeTerminalMetadataRpc, WsPreviewOpenRpc, WsPreviewNavigateRpc, WsPreviewResizeRpc, WsPreviewRefreshRpc, WsPreviewCloseRpc, WsPreviewListRpc, WsPreviewReportStatusRpc, WsPreviewAutomationConnectRpc, WsPreviewAutomationRespondRpc, WsPreviewAutomationFocusHostRpc, WsSubscribePreviewEventsRpc, WsSubscribeDiscoveredLocalServersRpc, WsSubscribeServerConfigRpc, WsSubscribeServerLifecycleRpc, WsSubscribeAuthAccessRpc, WsTasksListRpc, WsTasksGetRpc, WsTasksCreateRpc, WsTasksUpdateRpc, WsTasksDeleteRpc, WsSubscribeTasksRpc, WsHubGetSyncStatusRpc, WsHubConnectRpc, WsHubDisconnectRpc, WsHubSetSyncModeRpc, WsHubSetShareModeRpc, WsHubMintTokenRpc, WsSkillsSyncRpc, WsSkillsPublishRpc, WsSkillsPublishAllRpc, WsSkillsUnpublishRpc, WsOrchestrationDispatchCommandRpc, WsOrchestrationGetTurnDiffRpc, WsOrchestrationGetFullThreadDiffRpc, WsOrchestrationGetArchivedShellSnapshotRpc, WsOrchestrationSubscribeShellRpc, WsOrchestrationSubscribeThreadRpc);
+const WsRpcGroup = RpcGroup.make(WsServerProbeRpc, WsServerGetConfigRpc, WsServerRefreshProvidersRpc, WsServerUpdateProviderRpc, WsServerUpdateServerRpc, WsServerUpsertKeybindingRpc, WsServerRemoveKeybindingRpc, WsServerGetSettingsRpc, WsServerUpdateSettingsRpc, WsServerDiscoverSourceControlRpc, WsServerGetTraceDiagnosticsRpc, WsServerGetProcessDiagnosticsRpc, WsServerGetProcessResourceHistoryRpc, WsServerSignalProcessRpc, WsSourceControlLookupRepositoryRpc, WsSourceControlCloneRepositoryRpc, WsSourceControlPublishRepositoryRpc, WsProjectsListEntriesRpc, WsProjectsReadFileRpc, WsProjectsSearchEntriesRpc, WsProjectsWriteFileRpc, WsShellOpenInEditorRpc, WsFilesystemBrowseRpc, WsAssetsCreateUrlRpc, WsSubscribeVcsStatusRpc, WsVcsPullRpc, WsVcsRefreshStatusRpc, WsGitRunStackedActionRpc, WsGitResolvePullRequestRpc, WsGitPreparePullRequestThreadRpc, WsVcsListRefsRpc, WsVcsCreateWorktreeRpc, WsVcsRemoveWorktreeRpc, WsVcsCreateRefRpc, WsVcsSwitchRefRpc, WsVcsInitRpc, WsReviewGetDiffPreviewRpc, WsTerminalOpenRpc, WsTerminalAttachRpc, WsTerminalWriteRpc, WsTerminalResizeRpc, WsTerminalClearRpc, WsTerminalRestartRpc, WsTerminalCloseRpc, WsSubscribeTerminalEventsRpc, WsSubscribeTerminalMetadataRpc, WsPreviewOpenRpc, WsPreviewNavigateRpc, WsPreviewResizeRpc, WsPreviewRefreshRpc, WsPreviewCloseRpc, WsPreviewListRpc, WsPreviewReportStatusRpc, WsPreviewAutomationConnectRpc, WsPreviewAutomationRespondRpc, WsPreviewAutomationFocusHostRpc, WsSubscribePreviewEventsRpc, WsSubscribeDiscoveredLocalServersRpc, WsSubscribeServerConfigRpc, WsSubscribeServerLifecycleRpc, WsSubscribeAuthAccessRpc, WsTasksListRpc, WsTasksGetRpc, WsTasksCreateRpc, WsTasksUpdateRpc, WsTasksDeleteRpc, WsSubscribeTasksRpc, WsHubGetSyncStatusRpc, WsHubConnectRpc, WsHubDisconnectRpc, WsHubSetSyncModeRpc, WsHubSetShareModeRpc, WsHubMintTokenRpc, WsSkillsSyncRpc, WsSkillsPublishRpc, WsSkillsPublishAllRpc, WsSkillsUnpublishRpc, WsAssetsReadRpc, WsAssetsSaveRpc, WsAssetsDeleteRpc, WsMcpListRpc, WsMcpSaveRpc, WsMcpRemoveRpc, WsMcpSetSecretRpc, WsOrchestrationDispatchCommandRpc, WsOrchestrationGetTurnDiffRpc, WsOrchestrationGetFullThreadDiffRpc, WsOrchestrationGetArchivedShellSnapshotRpc, WsOrchestrationSubscribeShellRpc, WsOrchestrationSubscribeThreadRpc);
 //#endregion
 //#region ../../packages/shared/src/oauthScope.ts
 const OAUTH_SCOPE_TOKEN = /^[\u0021\u0023-\u005b\u005d-\u007e]+$/u;
@@ -8429,7 +8736,7 @@ function deriveAuthClientMetadata(input) {
 //#endregion
 //#region src/auth/EnvironmentAuthPolicy.ts
 var EnvironmentAuthPolicy = class extends Context.Service()("@p4code/cli/auth/EnvironmentAuthPolicy") {};
-const make$68 = Effect.gen(function* () {
+const make$69 = Effect.gen(function* () {
 	const config = yield* ServerConfig$1;
 	const isRemoteReachable = isRemoteReachableHost(config.host);
 	const policy = config.mode === "desktop" ? isRemoteReachable ? "remote-reachable" : "desktop-managed-local" : isRemoteReachable ? "remote-reachable" : "loopback-browser";
@@ -8447,7 +8754,7 @@ const make$68 = Effect.gen(function* () {
 	};
 	return EnvironmentAuthPolicy.of({ getDescriptor: () => Effect.succeed(descriptor).pipe(Effect.withSpan("EnvironmentAuthPolicy.getDescriptor")) });
 });
-const layer$64 = Layer.effect(EnvironmentAuthPolicy, make$68);
+const layer$65 = Layer.effect(EnvironmentAuthPolicy, make$69);
 //#endregion
 //#region src/persistence/Errors.ts
 function summarizeSchemaIssue(issue) {
@@ -8628,7 +8935,7 @@ function toPersistenceSqlOrDecodeError$6(sqlOperation, decodeOperation, correlat
 		cause
 	});
 }
-const make$67 = Effect.gen(function* () {
+const make$68 = Effect.gen(function* () {
 	const sql = yield* SqlClient.SqlClient;
 	const createSessionRow = SqlSchema.void({
 		Request: CreateAuthSessionInput,
@@ -8762,7 +9069,7 @@ const make$67 = Effect.gen(function* () {
 		setLastConnectedAt
 	};
 });
-const layer$63 = Layer.effect(AuthSessionRepository, make$67);
+const layer$64 = Layer.effect(AuthSessionRepository, make$68);
 //#endregion
 //#region src/auth/ServerSecretStore.ts
 const secretStoreErrorContext = {
@@ -8829,7 +9136,7 @@ const isSecretStoreError = Schema$1.is(SecretStoreError);
 const isPlatformError = (value) => Predicate.isTagged(value, "PlatformError");
 const isSecretAlreadyExistsError = (error) => "cause" in error && isPlatformError(error.cause) && error.cause.reason._tag === "AlreadyExists";
 var ServerSecretStore = class extends Context.Service()("@p4code/cli/auth/ServerSecretStore") {};
-const make$66 = Effect.gen(function* () {
+const make$67 = Effect.gen(function* () {
 	const crypto = yield* Crypto.Crypto;
 	const fileSystem = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
@@ -8899,7 +9206,7 @@ const make$66 = Effect.gen(function* () {
 		remove
 	});
 });
-const layer$62 = Layer.effect(ServerSecretStore, make$66);
+const layer$63 = Layer.effect(ServerSecretStore, make$67);
 //#endregion
 //#region src/auth/SessionStore.ts
 var MalformedSessionTokenError = class extends Schema$1.TaggedErrorClass()("MalformedSessionTokenError", {}) {
@@ -9137,7 +9444,7 @@ function toAuthClientSession(input) {
 		current: false
 	};
 }
-const make$65 = Effect.gen(function* () {
+const make$66 = Effect.gen(function* () {
 	const crypto = yield* Crypto.Crypto;
 	const serverConfig = yield* ServerConfig$1;
 	const secretStore = yield* ServerSecretStore;
@@ -9451,7 +9758,7 @@ const make$65 = Effect.gen(function* () {
 		markDisconnected
 	});
 });
-const layer$61 = Layer.effect(SessionStore, make$65).pipe(Layer.provideMerge(layer$63));
+const layer$62 = Layer.effect(SessionStore, make$66).pipe(Layer.provideMerge(layer$64));
 //#endregion
 //#region src/persistence/AuthPairingLinks.ts
 const AuthPairingLinkRecord = Schema$1.Struct({
@@ -9512,7 +9819,7 @@ function toPersistenceSqlOrDecodeError$5(sqlOperation, decodeOperation, correlat
 		cause
 	});
 }
-const make$64 = Effect.gen(function* () {
+const make$65 = Effect.gen(function* () {
 	const sql = yield* SqlClient.SqlClient;
 	const createPairingLinkRow = SqlSchema.void({
 		Request: CreateAuthPairingLinkInput,
@@ -9647,7 +9954,7 @@ const make$64 = Effect.gen(function* () {
 		getByCredential
 	};
 });
-const layer$60 = Layer.effect(AuthPairingLinkRepository, make$64);
+const layer$61 = Layer.effect(AuthPairingLinkRepository, make$65);
 //#endregion
 //#region src/auth/PairingGrantStore.ts
 var UnknownBootstrapCredentialError = class extends Schema$1.TaggedErrorClass()("UnknownBootstrapCredentialError", {}) {
@@ -9742,7 +10049,7 @@ const DEV_STARTUP_TTL_HOURS = Duration.hours(24);
 const PAIRING_TOKEN_ALPHABET = "23456789ABCDEFGHJKLMNPQRSTUVWXYZ";
 const PAIRING_TOKEN_LENGTH = 12;
 const PAIRING_TOKEN_REJECTION_LIMIT = Math.floor(256 / 32) * 32;
-const make$63 = Effect.gen(function* () {
+const make$64 = Effect.gen(function* () {
 	const crypto = yield* Crypto.Crypto;
 	const config = yield* ServerConfig$1;
 	const pairingLinks = yield* AuthPairingLinkRepository;
@@ -9940,7 +10247,7 @@ const make$63 = Effect.gen(function* () {
 		consume
 	});
 });
-const layer$59 = Layer.effect(PairingGrantStore, make$63).pipe(Layer.provideMerge(layer$60));
+const layer$60 = Layer.effect(PairingGrantStore, make$64).pipe(Layer.provideMerge(layer$61));
 //#endregion
 //#region src/persistence/Migrations/001_OrchestrationEvents.ts
 var _001_OrchestrationEvents_default = Effect.gen(function* () {
@@ -11555,7 +11862,7 @@ Layer.effectDiscard(runMigrations());
 //#region src/persistence/Layers/Sqlite.ts
 const defaultSqliteClientLoaders = {
 	bun: () => import("@effect/sql-sqlite-bun/SqliteClient"),
-	node: () => import("./NodeSqliteClient-DGAB9NWW.mjs")
+	node: () => import("./NodeSqliteClient-CRS7rg24.mjs")
 };
 const makeRuntimeSqliteLayer = Effect.fn("makeRuntimeSqliteLayer")(function* (config) {
 	const runtime = process.versions.bun !== void 0 ? "bun" : "node";
@@ -11713,7 +12020,7 @@ function parseBearerToken(request) {
 	const token = header.slice(7).trim();
 	return token.length > 0 ? token : null;
 }
-const make$62 = Effect.gen(function* () {
+const make$63 = Effect.gen(function* () {
 	const policy = yield* EnvironmentAuthPolicy;
 	const bootstrapCredentials = yield* PairingGrantStore;
 	const sessions = yield* SessionStore;
@@ -11908,9 +12215,9 @@ const make$62 = Effect.gen(function* () {
 		issueStartupPairingUrl
 	});
 });
-const layer$58 = Layer.effect(EnvironmentAuth, make$62).pipe(Layer.provideMerge(layer$59), Layer.provideMerge(layer$61), Layer.provideMerge(layer$64));
-const storageLayer = Layer.mergeAll(layer$62, layerConfig);
-const runtimeLayer = layer$58.pipe(Layer.provideMerge(storageLayer));
+const layer$59 = Layer.effect(EnvironmentAuth, make$63).pipe(Layer.provideMerge(layer$60), Layer.provideMerge(layer$62), Layer.provideMerge(layer$65));
+const storageLayer = Layer.mergeAll(layer$63, layerConfig);
+const runtimeLayer = layer$59.pipe(Layer.provideMerge(storageLayer));
 //#endregion
 //#region src/cliAuthFormat.ts
 const newline = "\n";
@@ -12665,7 +12972,7 @@ const runWithEnvironmentAuth = (flags, run, options) => Effect.gen(function* ()
 	}
 	return yield* Effect.gen(function* () {
 		return yield* run(yield* EnvironmentAuth);
-	}).pipe(Effect.provide(Layer.mergeAll(runtimeLayer).pipe(Layer.provide(layer$65(config)), Layer.provide(Layer.succeed(References.MinimumLogLevel, minimumLogLevel)))));
+	}).pipe(Effect.provide(Layer.mergeAll(runtimeLayer).pipe(Layer.provide(layer$66(config)), Layer.provide(Layer.succeed(References.MinimumLogLevel, minimumLogLevel)))));
 });
 const ttlFlag = Flag.string("ttl").pipe(Flag.withSchema(DurationFromString), Flag.withDescription("TTL, for example `5m`, `1h`, `30d`, or `15 minutes`."), Flag.optional);
 const jsonFlag = Flag.boolean("json").pipe(Flag.withDescription("Emit JSON instead of human-readable output."), Flag.withDefault(false));
@@ -12750,422 +13057,6 @@ const sessionCommand = Command.make("session").pipe(Command.withDescription("Man
 ]));
 const authCommand = Command.make("auth").pipe(Command.withDescription("Manage the local auth control plane for headless deployments."), Command.withSubcommands([pairingCommand, sessionCommand]));
 //#endregion
-//#region src/stream/collectUint8StreamText.ts
-const collectUint8StreamText = (input) => {
-	const maxBytes = input.maxBytes ?? Number.POSITIVE_INFINITY;
-	const truncatedMarker = input.truncatedMarker ?? "";
-	return input.stream.pipe(Stream.runFold(() => ({
-		chunks: [],
-		bytes: 0,
-		truncated: false
-	}), (state, chunk) => {
-		if (state.truncated) return state;
-		const remainingBytes = maxBytes - state.bytes;
-		if (remainingBytes <= 0) return {
-			...state,
-			truncated: true
-		};
-		const nextChunk = chunk.byteLength > remainingBytes ? chunk.slice(0, remainingBytes) : chunk;
-		state.chunks.push(nextChunk);
-		const bytes = state.bytes + nextChunk.byteLength;
-		const truncated = chunk.byteLength > remainingBytes;
-		return {
-			chunks: state.chunks,
-			bytes,
-			truncated
-		};
-	}), Effect.map((state) => {
-		const text = Buffer.concat(state.chunks, state.bytes).toString("utf8");
-		return {
-			text: state.truncated && truncatedMarker.length > 0 ? `${text}${truncatedMarker}` : text,
-			bytes: state.bytes,
-			truncated: state.truncated
-		};
-	}));
-};
-//#endregion
-//#region src/processRunner.ts
-const ProcessInvocationFields = {
-	command: Schema$1.String,
-	argumentCount: Schema$1.Number,
-	cwd: Schema$1.optional(Schema$1.String),
-	spawnCwd: Schema$1.optional(Schema$1.String)
-};
-const formatProcessInvocation = (input) => {
-	const executionCwd = input.spawnCwd ?? input.cwd;
-	return executionCwd === void 0 ? `'${input.command}'` : `'${input.command}' in '${executionCwd}'`;
-};
-var ProcessSpawnError = class extends Schema$1.TaggedErrorClass()("ProcessSpawnError", {
-	...ProcessInvocationFields,
-	resolvedCommand: Schema$1.optional(Schema$1.String),
-	resolvedArgumentCount: Schema$1.optional(Schema$1.Number),
-	shell: Schema$1.optional(Schema$1.Boolean),
-	cause: Schema$1.Defect()
-}) {
-	get message() {
-		return `Failed to spawn process ${formatProcessInvocation(this)}`;
-	}
-};
-var ProcessStdinError = class extends Schema$1.TaggedErrorClass()("ProcessStdinError", {
-	...ProcessInvocationFields,
-	stdinBytes: Schema$1.Number,
-	cause: Schema$1.Defect()
-}) {
-	get message() {
-		return `Failed to write stdin for process ${formatProcessInvocation(this)}`;
-	}
-};
-var ProcessOutputLimitError = class extends Schema$1.TaggedErrorClass()("ProcessOutputLimitError", {
-	...ProcessInvocationFields,
-	stream: Schema$1.Literals(["stdout", "stderr"]),
-	maxBytes: Schema$1.Number,
-	observedBytes: Schema$1.Number
-}) {
-	get message() {
-		return `Process ${formatProcessInvocation(this)} ${this.stream} produced ${this.observedBytes} bytes, exceeding the ${this.maxBytes} byte limit`;
-	}
-};
-var ProcessReadError = class extends Schema$1.TaggedErrorClass()("ProcessReadError", {
-	...ProcessInvocationFields,
-	stream: Schema$1.Literals([
-		"stdout",
-		"stderr",
-		"exitCode"
-	]),
-	cause: Schema$1.Defect()
-}) {
-	get message() {
-		return `Failed to read ${this.stream} for process ${formatProcessInvocation(this)}`;
-	}
-};
-var ProcessTimeoutError = class extends Schema$1.TaggedErrorClass()("ProcessTimeoutError", {
-	...ProcessInvocationFields,
-	timeoutMs: Schema$1.Number
-}) {
-	get message() {
-		return `Process ${formatProcessInvocation(this)} timed out after ${this.timeoutMs}ms`;
-	}
-};
-Schema$1.Union([
-	ProcessSpawnError,
-	ProcessStdinError,
-	ProcessOutputLimitError,
-	ProcessReadError,
-	ProcessTimeoutError
-]);
-var ProcessRunner = class extends Context.Service()("@p4code/cli/processRunner") {};
-const DEFAULT_TIMEOUT = "60 seconds";
-const DEFAULT_MAX_OUTPUT_BYTES$2 = 8 * 1024 * 1024;
-const WINDOWS_COMMAND_NOT_FOUND_PATTERNS = [
-	/is not recognized as an internal or external command/i,
-	/n.o . reconhecido como um comando interno/i,
-	/non . riconosciuto come comando interno o esterno/i,
-	/n.est pas reconnu en tant que commande interne/i,
-	/no se reconoce como un comando interno o externo/i,
-	/wird nicht als interner oder externer befehl/i
-];
-function hasWindowsCommandNotFoundMessage(output) {
-	return WINDOWS_COMMAND_NOT_FOUND_PATTERNS.some((pattern) => pattern.test(output));
-}
-const isWindowsCommandNotFound = Effect.fn("processRunner.isWindowsCommandNotFound")(function* (code, stderr) {
-	if ((yield* HostProcessPlatform) !== "win32") return false;
-	if (code === 9009) return true;
-	return hasWindowsCommandNotFoundMessage(stderr);
-});
-const collectText = Effect.fn("processRunner.collectText")(function* (input) {
-	const stream = input.stream.pipe(Stream.mapError((cause) => new ProcessReadError({
-		command: input.command,
-		argumentCount: input.args.length,
-		cwd: input.cwd,
-		spawnCwd: input.spawnCwd,
-		stream: input.streamName,
-		cause
-	})));
-	if (input.outputMode === "truncate") return yield* collectUint8StreamText({
-		stream,
-		maxBytes: input.maxOutputBytes,
-		truncatedMarker: input.truncatedMarker
-	});
-	return yield* stream.pipe(Stream.runFoldEffect(() => ({
-		chunks: [],
-		bytes: 0
-	}), (state, chunk) => {
-		const remainingBytes = input.maxOutputBytes - state.bytes;
-		if (chunk.byteLength > remainingBytes) return Effect.fail(new ProcessOutputLimitError({
-			command: input.command,
-			argumentCount: input.args.length,
-			cwd: input.cwd,
-			spawnCwd: input.spawnCwd,
-			stream: input.streamName,
-			maxBytes: input.maxOutputBytes,
-			observedBytes: state.bytes + chunk.byteLength
-		}));
-		state.chunks.push(chunk);
-		return Effect.succeed({
-			chunks: state.chunks,
-			bytes: state.bytes + chunk.byteLength
-		});
-	}), Effect.map((state) => ({
-		text: Buffer.concat(state.chunks, state.bytes).toString("utf8"),
-		bytes: state.bytes,
-		truncated: false
-	})));
-});
-function finalizeRunProcess(effect, input) {
-	const timeout = Duration.fromInputUnsafe(input.timeout ?? DEFAULT_TIMEOUT);
-	const timeoutBehavior = input.timeoutBehavior ?? "error";
-	return effect.pipe(Effect.scoped, Effect.timeoutOption(timeout), Effect.flatMap((result) => {
-		if (Option.isSome(result)) return Effect.succeed(result.value);
-		if (timeoutBehavior === "timedOutResult") return Effect.succeed({
-			stdout: "",
-			stderr: "",
-			code: null,
-			timedOut: true,
-			stdoutTruncated: false,
-			stderrTruncated: false
-		});
-		return Effect.fail(new ProcessTimeoutError({
-			command: input.command,
-			argumentCount: input.args.length,
-			cwd: input.cwd,
-			spawnCwd: input.spawnCwd,
-			timeoutMs: Duration.toMillis(timeout)
-		}));
-	}));
-}
-const runProcessCore = Effect.fn("processRunner.runProcessCore")(function* (spawner, input) {
-	const maxOutputBytes = input.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES$2;
-	const outputMode = input.outputMode ?? "error";
-	const truncatedMarker = input.truncatedMarker ?? "";
-	const extendEnv = input.env !== void 0;
-	const spawnCommand = yield* resolveSpawnCommand(input.command, input.args, input.env === void 0 ? {} : {
-		env: input.env,
-		extendEnv
-	});
-	const child = yield* spawner.spawn(ChildProcess$1.make(spawnCommand.command, spawnCommand.args, {
-		...input.spawnCwd ?? input.cwd ? { cwd: input.spawnCwd ?? input.cwd } : {},
-		...input.env !== void 0 ? {
-			env: input.env,
-			extendEnv
-		} : {},
-		shell: spawnCommand.shell
-	})).pipe(Effect.mapError((cause) => new ProcessSpawnError({
-		command: input.command,
-		argumentCount: input.args.length,
-		cwd: input.cwd,
-		spawnCwd: input.spawnCwd,
-		resolvedCommand: spawnCommand.command,
-		resolvedArgumentCount: spawnCommand.args.length,
-		shell: spawnCommand.shell,
-		cause
-	})));
-	const stdin = input.stdin;
-	const writeStdin = stdin === void 0 ? Effect.void : Stream.run(Stream.encodeText(Stream.make(stdin)), child.stdin).pipe(Effect.mapError((cause) => new ProcessStdinError({
-		command: input.command,
-		argumentCount: input.args.length,
-		cwd: input.cwd,
-		spawnCwd: input.spawnCwd,
-		stdinBytes: Buffer.byteLength(stdin),
-		cause
-	})));
-	const [stdout, stderr] = yield* Effect.all([
-		collectText({
-			command: input.command,
-			args: input.args,
-			cwd: input.cwd,
-			spawnCwd: input.spawnCwd,
-			streamName: "stdout",
-			stream: child.stdout,
-			maxOutputBytes,
-			outputMode,
-			truncatedMarker
-		}),
-		collectText({
-			command: input.command,
-			args: input.args,
-			cwd: input.cwd,
-			spawnCwd: input.spawnCwd,
-			streamName: "stderr",
-			stream: child.stderr,
-			maxOutputBytes,
-			outputMode,
-			truncatedMarker
-		}),
-		writeStdin
-	], { concurrency: "unbounded" });
-	const exitCode = yield* child.exitCode.pipe(Effect.mapError((cause) => new ProcessReadError({
-		command: input.command,
-		argumentCount: input.args.length,
-		cwd: input.cwd,
-		spawnCwd: input.spawnCwd,
-		stream: "exitCode",
-		cause
-	})));
-	return {
-		stdout: stdout.text,
-		stderr: stderr.text,
-		code: exitCode,
-		timedOut: false,
-		stdoutTruncated: stdout.truncated,
-		stderrTruncated: stderr.truncated
-	};
-});
-const make$61 = Effect.fn("ProcessRunner.make")(function* () {
-	const spawner = yield* ChildProcessSpawner$1.ChildProcessSpawner;
-	const run = (input) => finalizeRunProcess(runProcessCore(spawner, input), input);
-	return ProcessRunner.of({ run });
-});
-const layer$57 = Layer.effect(ProcessRunner, make$61());
-//#endregion
-//#region src/cli/completions.ts
-/**
-* Installs the zsh completion script for the `p4` command.
-*
-* zsh ships `_perforce` with `#compdef p4 p4d`, so out of the box tabbing
-* through our subcommands prints "unhandled perforce command: …" from its
-* fallback message. `compinit` resolves duplicate `#compdef` claims by fpath
-* order — first match wins — and `_perforce` lives in the *last* fpath entry
-* (`/usr/share/zsh/<ver>/functions`). Writing our own `_p4` into any earlier
-* directory therefore replaces it outright, with no shell-config edit.
-*/
-const COMPLETION_FILE = "_p4";
-const GENERATE_TIMEOUT_MS = 1e4;
-/**
-* Ordered by how reliably zsh actually scans them.
-*
-* oh-my-zsh comes first and is created on demand: it adds
-* `custom/completions` to fpath unconditionally, it is user-owned so
-* `compinit -i` never skips it as insecure, and it does not depend on a package
-* manager's prefix. The Homebrew and /usr/local directories are only used when
-* they already exist, and even then are not guaranteed to be on fpath —
-* `brew shellenv` contributes Homebrew's, and a plugin that rebuilds fpath can
-* drop it, which is exactly how a completion file lands somewhere zsh never
-* reads.
-*/
-function candidateDirectories(input) {
-	return [
-		{
-			dir: input.join(input.homeDir, ".oh-my-zsh", "custom", "completions"),
-			createWhenPresent: input.join(input.homeDir, ".oh-my-zsh")
-		},
-		{ dir: "/opt/homebrew/share/zsh/site-functions" },
-		{ dir: "/usr/local/share/zsh/site-functions" },
-		{
-			dir: input.join(input.homeDir, ".zfunc"),
-			requiresFpathEntry: true
-		}
-	];
-}
-/**
-* Asks the running CLI for its own completion script rather than rendering one
-* here, so the output cannot drift from what `--completions` produces.
-*/
-const generateZshCompletionScript = Effect.fn("cli.completions.generate")(function* () {
-	const runner = yield* ProcessRunner;
-	const execPath = yield* HostProcessExecutablePath;
-	const entryPath = (yield* HostProcessArguments)[1] ?? "";
-	if (entryPath === "") return null;
-	const result = yield* runner.run({
-		command: execPath,
-		args: [
-			entryPath,
-			"--completions",
-			"zsh"
-		],
-		timeout: GENERATE_TIMEOUT_MS
-	});
-	if (result.code !== 0) return null;
-	const script = result.stdout.trim();
-	return script.length === 0 ? null : `${script}\n`;
-});
-/**
-* Best-effort: returns null when completions are not applicable (Windows, no
-* writable directory) rather than failing the command that asked for them.
-* Installing completions is never the reason an install should fail.
-*/
-const installZshCompletion = Effect.fn("cli.completions.install")(function* () {
-	if ((yield* HostProcessPlatform) === "win32") return null;
-	const fs = yield* FileSystem.FileSystem;
-	const path = yield* Path.Path;
-	const homeDir = (yield* HostProcessEnvironment).HOME ?? "";
-	if (homeDir === "") return null;
-	const script = yield* generateZshCompletionScript();
-	if (script === null) return null;
-	for (const candidate of candidateDirectories({
-		homeDir,
-		join: path.join
-	})) {
-		if (candidate.requiresFpathEntry === true || candidate.createWhenPresent !== void 0 && (yield* fs.exists(candidate.createWhenPresent).pipe(Effect.orElseSucceed(() => false)))) {
-			if (!(yield* fs.makeDirectory(candidate.dir, { recursive: true }).pipe(Effect.as(true), Effect.orElseSucceed(() => false)))) continue;
-		} else if (!(yield* fs.exists(candidate.dir).pipe(Effect.orElseSucceed(() => false)))) continue;
-		const target = path.join(candidate.dir, COMPLETION_FILE);
-		if (!(yield* fs.writeFileString(target, script).pipe(Effect.as(true), Effect.orElseSucceed(() => false)))) continue;
-		return {
-			path: target,
-			requiresFpathEntry: candidate.requiresFpathEntry === true
-		};
-	}
-	return null;
-});
-const HINT_MARKER_FILE = "completions-hint";
-const HINT_INTERVAL_MS = 1440 * 60 * 1e3;
-const COMPLETIONS_HINT = "Shell completions are not installed, so tab completion shows Perforce's. Run `p4 completions install`.";
-/**
-* A hint when no `_p4` is on the fpath, at most once a day.
-*
-* A stat of a few directories, deliberately not the install itself: generating
-* the script spawns a subprocess, which is far too much to do on every command
-* just in case. Throttled through a marker file so an unactioned hint does not
-* become noise on every invocation.
-*/
-const resolveMissingCompletionsHint = Effect.fn("cli.completions.hint")(function* (input) {
-	if ((yield* HostProcessPlatform) === "win32") return null;
-	const fs = yield* FileSystem.FileSystem;
-	const path = yield* Path.Path;
-	const homeDir = (yield* HostProcessEnvironment).HOME ?? "";
-	if (homeDir === "") return null;
-	for (const candidate of candidateDirectories({
-		homeDir,
-		join: path.join
-	})) if (yield* fs.exists(path.join(candidate.dir, COMPLETION_FILE)).pipe(Effect.orElseSucceed(() => false))) return null;
-	const markerPath = path.join(input.stateDir, HINT_MARKER_FILE);
-	const marker = yield* fs.stat(markerPath).pipe(Effect.asSome, Effect.orElseSucceed(() => null));
-	const nowMs = DateTime.toEpochMillis(yield* DateTime.now);
-	if (marker !== null && Option.isSome(marker)) {
-		const mtime = marker.value.mtime;
-		if (Option.isSome(mtime) && nowMs - mtime.value.getTime() < HINT_INTERVAL_MS) return null;
-	}
-	yield* fs.makeDirectory(input.stateDir, { recursive: true }).pipe(Effect.ignore);
-	yield* fs.writeFileString(markerPath, "").pipe(Effect.ignore);
-	return COMPLETIONS_HINT;
-});
-/**
-* Standalone so completions never depend on the service. A laptop that only
-* runs clients has no service to install, and a host whose `service install`
-* fails still deserves working completions.
-*/
-const completionsCommand = Command.make("completions").pipe(Command.withDescription("Manage shell completions for the p4 command."), Command.withSubcommands([Command.make("install").pipe(Command.withDescription("Install zsh completions, replacing the Perforce completion that claims `p4`."), Command.withHandler(() => Effect.gen(function* () {
-	const install = yield* installZshCompletion();
-	if (install === null) {
-		yield* Console.error([
-			"Could not install completions automatically.",
-			"Write them yourself with:",
-			"  p4 --completions zsh > <a directory on your fpath>/_p4"
-		].join("\n"));
-		return;
-	}
-	yield* Console.log(formatZshCompletionInstall(install));
-}).pipe(Effect.provide(layer$57))))]));
-function formatZshCompletionInstall(install) {
-	const installed = `Installed zsh completions at ${install.path}.`;
-	if (!install.requiresFpathEntry) return `${installed} Open a new shell to use them.`;
-	return [
-		installed,
-		`Add this to ~/.zshrc before compinit runs, then open a new shell:`,
-		`  fpath=(${install.path.replace(/\/[^/]+$/u, "")} $fpath)`
-	].join("\n");
-}
-//#endregion
 //#region src/hub/HubConfig.ts
 /**
 * Configuration for the hub process.
@@ -13427,7 +13318,7 @@ const makeAgentAssetRepository = Effect.gen(function* () {
 		};
 		const existing = yield* findByKey(key);
 		if (Option.isNone(existing)) return { _tag: "deleted" };
-		if (existing.value.version !== request.expectedVersion) return {
+		if (request.expectedVersion !== void 0 && existing.value.version !== request.expectedVersion) return {
 			_tag: "conflict",
 			current: Option.some(existing.value)
 		};
@@ -13809,29 +13700,34 @@ const putAssetRoute = HttpRouter.add("PUT", "/assets", respondToHubFailures(Effe
 	return HttpServerResponse.jsonUnsafe(outcome.asset, { status: outcome.created ? 201 : 200 });
 })));
 /**
-* Deletion is conditional too, unlike a task's. Two machines can both hold a
-* skill and both decide to remove it, and one may be acting on a copy that
-* predates the other's edit — an unconditional delete discards that edit with
-* nothing to notice it by.
+* Deletion is conditional when `expectedVersion` is supplied, which the sync
+* always does. Two machines can both hold a skill and both decide to remove it,
+* and one may be acting on a copy that predates the other's edit — deleting on
+* that basis discards the edit with nothing to notice it by.
+*
+* Omitting it deletes unconditionally, and that is deliberate: a person
+* clearing a row they can only see in a listing has never held a version for
+* it. Requiring one would leave an asset published by a decommissioned machine
+* permanently stuck, which is a worse failure than the race it would prevent.
 */
 const deleteAssetRoute = HttpRouter.add("DELETE", "/assets/:kind/:name", respondToHubFailures(Effect.gen(function* () {
 	yield* authenticateHubRequest();
 	const params = yield* HttpRouter.params;
 	const request = yield* HttpServerRequest.HttpServerRequest;
-	const url = new URL(request.url, "http://hub.invalid");
+	const rawExpectedVersion = new URL(request.url, "http://hub.invalid").searchParams.get("expectedVersion");
 	const requested = yield* decodeOrInvalid(Schema$1.Struct({
 		kind: AgentAssetKind,
 		name: AgentAssetName,
-		expectedVersion: Schema$1.FiniteFromString.check(Schema$1.isGreaterThanOrEqualTo(1))
+		expectedVersion: Schema$1.optional(Schema$1.FiniteFromString.check(Schema$1.isGreaterThanOrEqualTo(1)))
 	}), "Path or expectedVersion query parameter is not valid.")({
 		kind: params.kind,
 		name: params.name,
-		expectedVersion: url.searchParams.get("expectedVersion")
+		...rawExpectedVersion === null ? {} : { expectedVersion: rawExpectedVersion }
 	});
 	const outcome = yield* (yield* AgentAssetRepository).deleteByName(requested);
 	return outcome._tag === "conflict" ? assetConflict(Option.getOrNull(outcome.current)) : HttpServerResponse.empty({ status: 204 });
 })));
-const layer$56 = Layer.mergeAll(healthRoute, listTasksRoute, getTaskRoute, createTaskRoute, updateTaskRoute, deleteTaskRoute, listAssetsRoute, getAssetRoute, putAssetRoute, deleteAssetRoute);
+const layer$58 = Layer.mergeAll(healthRoute, listTasksRoute, getTaskRoute, createTaskRoute, updateTaskRoute, deleteTaskRoute, listAssetsRoute, getAssetRoute, putAssetRoute, deleteAssetRoute);
 //#endregion
 //#region src/hub/Migrations/001_Tasks.ts
 /**
@@ -13978,7 +13874,7 @@ const runHubMigrations = Effect.fn("runHubMigrations")(function* () {
 //#region src/hub/Sqlite.ts
 const sqliteClientLoaders = {
 	bun: () => import("@effect/sql-sqlite-bun/SqliteClient"),
-	node: () => import("./NodeSqliteClient-DGAB9NWW.mjs")
+	node: () => import("./NodeSqliteClient-CRS7rg24.mjs")
 };
 const makeHubSqliteLayer = Effect.fn("makeHubSqliteLayer")(function* (config) {
 	const runtime = process.versions.bun !== void 0 ? "bun" : "node";
@@ -14045,7 +13941,7 @@ const announce = Layer.effectDiscard(Effect.gen(function* () {
 	});
 	if (isRemoteReachableHost(config.host)) yield* Effect.logWarning("Hub is bound beyond loopback; the bearer token and your tailnet ACL are the only controls.", { host: config.host });
 }));
-const makeHubLayer = HttpRouter.serve(layer$56).pipe(Layer.provideMerge(announce), Layer.provideMerge(HubHttpServerLive), Layer.provideMerge(TaskRepositoryLive), Layer.provideMerge(AgentAssetRepositoryLive), Layer.provideMerge(HubPersistenceLive));
+const makeHubLayer = HttpRouter.serve(layer$58).pipe(Layer.provideMerge(announce), Layer.provideMerge(HubHttpServerLive), Layer.provideMerge(TaskRepositoryLive), Layer.provideMerge(AgentAssetRepositoryLive), Layer.provideMerge(HubPersistenceLive));
 const runHub = Layer.launch(makeHubLayer);
 //#endregion
 //#region src/atomicWrite.ts
@@ -14169,7 +14065,7 @@ function stripDefaultServerSettings(current, defaults) {
 	}
 	return Object.is(current, defaults) ? void 0 : current;
 }
-const make$60 = Effect.gen(function* () {
+const make$62 = Effect.gen(function* () {
 	const { settingsPath } = yield* ServerConfig$1;
 	const fs = yield* FileSystem.FileSystem;
 	const pathService = yield* Path.Path;
@@ -14390,7 +14286,252 @@ const make$60 = Effect.gen(function* () {
 		}
 	};
 });
-const layer$55 = Layer.effect(ServerSettingsService, make$60);
+const layer$57 = Layer.effect(ServerSettingsService, make$62);
+//#endregion
+//#region src/pathExpansion.ts
+/**
+* Expand a leading `~` (or `~/…`, `~\…`) in a user-supplied path to the
+* current user's home directory. Spawned processes don't get shell
+* expansion, so env vars like `CODEX_HOME=~/.codex-work` would be passed
+* verbatim and treated as relative paths by the receiver.
+*
+* Matches the behavior of the other `expandHomePath` helpers in the
+* workspace layers and CLI bootstrap: `~` alone and both `~/` and `~\`
+* separators are handled. Returns the input unchanged if it doesn't
+* start with `~` or is empty. Does not handle `~user` (other-user)
+* expansion.
+*/
+function expandHomePath$3(value) {
+	if (!value) return value;
+	if (value === "~") return NodeOS.homedir();
+	if (value.startsWith("~/") || value.startsWith("~\\")) return NodePath.join(NodeOS.homedir(), value.slice(2));
+	return value;
+}
+//#endregion
+//#region src/provider/Drivers/ClaudeSkills.ts
+/**
+* ClaudeSkills — filesystem discovery of Claude Code skills for the `$` picker.
+*
+* Claude Code loads skills from `<config dir>/skills` (user scope) and
+* `<cwd>/.claude/skills` (project scope), one directory per skill with a
+* `SKILL.md` carrying YAML frontmatter. The Agent SDK init handshake surfaces
+* skills only as slash commands without their filesystem paths, so the
+* provider snapshot scans the same locations directly, mirroring how the
+* Codex app-server reports its skills.
+*
+* @module provider/Drivers/ClaudeSkills
+*/
+const FRONTMATTER_PATTERN = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
+function parseSkillFrontmatter(contents) {
+	const match = FRONTMATTER_PATTERN.exec(contents);
+	if (!match) return { kind: "missing" };
+	let parsed;
+	try {
+		parsed = parse(match[1] ?? "");
+	} catch {
+		return { kind: "malformed" };
+	}
+	if (typeof parsed !== "object" || parsed === null) return { kind: "malformed" };
+	const record = parsed;
+	const name = typeof record.name === "string" ? record.name.trim() : "";
+	const description = typeof record.description === "string" ? record.description.trim() : "";
+	return {
+		kind: "parsed",
+		...name ? { name } : {},
+		...description ? { description } : {}
+	};
+}
+/**
+* Resolve the Claude config directory the CLI would use, matching the
+* precedence the spawned CLI sees: the instance's `homePath` (exported as
+* `CLAUDE_CONFIG_DIR` by `makeClaudeEnvironment`), then a `CLAUDE_CONFIG_DIR`
+* already present in the process environment, then `~/.claude`.
+*
+* Exported for the memory sync, which materializes `CLAUDE.md` directly into
+* this directory. Same reasoning as the skills root below: resolving it a
+* second time somewhere else is how the sync and the runtime come to disagree
+* about which config directory they are talking about.
+*/
+const resolveClaudeConfigDirPath = Effect.fn("resolveClaudeConfigDirPath")(function* (config, environment, cwd) {
+	const path = yield* Path.Path;
+	const homePath = config.homePath.trim();
+	if (homePath.length > 0) return path.resolve(expandHomePath$3(homePath));
+	const environmentConfigDir = environment.CLAUDE_CONFIG_DIR?.trim() ?? "";
+	if (environmentConfigDir.length > 0) return cwd ? path.resolve(cwd, environmentConfigDir) : path.resolve(environmentConfigDir);
+	return path.join(NodeOS.homedir(), ".claude");
+});
+/**
+* The user-scope skills directory the CLI would read.
+*
+* Exported for the hub sync, which materializes into exactly this directory —
+* the same resolution the discovery below uses, so a synced skill is one the
+* `$` picker can see. Deriving it a second time is how the two would drift.
+*/
+const resolveClaudeUserSkillsDir = Effect.fn("resolveClaudeUserSkillsDir")(function* (config, environment, cwd) {
+	const path = yield* Path.Path;
+	const configDirPath = yield* resolveClaudeConfigDirPath(config, environment ?? process.env, cwd);
+	return path.join(configDirPath, "skills");
+});
+/**
+* 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
+* collisions the project-scoped skill wins, matching Claude Code's
+* most-specific-wins resolution.
+*/
+const discoverClaudeSkills = Effect.fn("discoverClaudeSkills")(function* (config, cwd, environment) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const configDirPath = yield* resolveClaudeConfigDirPath(config, environment ?? process.env, cwd);
+	const roots = [{
+		directory: path.join(configDirPath, "skills"),
+		scope: "user"
+	}, ...cwd ? [{
+		directory: path.join(cwd, ".claude", "skills"),
+		scope: "project"
+	}] : []];
+	const skillsByName = /* @__PURE__ */ new Map();
+	for (const root of roots) {
+		const entries = yield* fileSystem.readDirectory(root.directory).pipe(Effect.orElseSucceed(() => []));
+		for (const entry of [...entries].sort()) {
+			const skillPath = path.join(root.directory, entry, "SKILL.md");
+			const contents = yield* fileSystem.readFileString(skillPath).pipe(Effect.orElseSucceed(() => void 0));
+			if (contents === void 0) continue;
+			const frontmatter = parseSkillFrontmatter(contents);
+			if (frontmatter.kind === "malformed") continue;
+			const name = (frontmatter.kind === "parsed" ? frontmatter.name : void 0) ?? entry.trim();
+			if (!name) continue;
+			skillsByName.set(name, {
+				name,
+				path: skillPath,
+				enabled: true,
+				scope: root.scope,
+				...frontmatter.kind === "parsed" && frontmatter.description ? { description: frontmatter.description } : {}
+			});
+		}
+	}
+	return [...skillsByName.values()].sort((left, right) => left.name.localeCompare(right.name));
+});
+/** Extension for a registration file, so the sync's asset name is `<server>.json`. */
+const MCP_REGISTRATION_SUFFIX = ".json";
+const RegistrationFromJson$1 = Schema$1.fromJsonString(McpServerRegistration);
+const decodeRegistration$1 = Schema$1.decodeUnknownExit(RegistrationFromJson$1);
+const encodeRegistration = Schema$1.encodeSync(RegistrationFromJson$1);
+var McpRegistry = class extends Context.Service()("@p4code/cli/mcp/McpRegistry") {};
+const slotsOf = (registration) => registration.secrets ?? [];
+const make$61 = Effect.gen(function* () {
+	const config = yield* ServerConfig$1;
+	const secrets = yield* ServerSecretStore;
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const services = yield* Effect.context();
+	const root = path.join(config.stateDir, "mcp");
+	const fileFor = (name) => path.join(root, `${name}${MCP_REGISTRATION_SUFFIX}`);
+	const readSecret = Effect.fn("McpRegistry.readSecret")(function* (server, slot) {
+		const stored = yield* secrets.get(mcpSecretStorageName({
+			server,
+			target: slot.target,
+			key: slot.key
+		})).pipe(Effect.orElseSucceed(() => Option.none()));
+		return Option.map(stored, (bytes) => new TextDecoder().decode(bytes));
+	});
+	/**
+	* Every readable registration.
+	*
+	* A file that will not parse is skipped rather than failing the read. One
+	* corrupt registration should cost that one server, not every server and the
+	* panel that lists them.
+	*/
+	const readAll = Effect.fn("McpRegistry.readAll")(function* () {
+		const entries = yield* fileSystem.readDirectory(root).pipe(Effect.orElseSucceed(() => []));
+		const found = [];
+		for (const entry of [...entries].sort()) {
+			if (!entry.endsWith(".json")) continue;
+			const raw = yield* fileSystem.readFileString(path.join(root, entry)).pipe(Effect.orElseSucceed(() => void 0));
+			if (raw === void 0) continue;
+			const decoded = decodeRegistration$1(raw);
+			if (decoded._tag !== "Success") continue;
+			found.push(decoded.value);
+		}
+		return found;
+	});
+	const list = Effect.gen(function* () {
+		const registrations = yield* readAll();
+		const statuses = [];
+		for (const registration of registrations) {
+			const missingSecrets = [];
+			for (const slot of slotsOf(registration)) {
+				const value = yield* readSecret(registration.name, slot);
+				if (Option.isNone(value)) missingSecrets.push(slot);
+			}
+			statuses.push({
+				registration,
+				missingSecrets,
+				ready: registration.enabled && missingSecrets.length === 0
+			});
+		}
+		return statuses;
+	}).pipe(Effect.provide(services), Effect.catchCause((cause) => Effect.logWarning("mcp registry list failed", { cause }).pipe(Effect.as([]))));
+	const save = (registration) => Effect.gen(function* () {
+		yield* fileSystem.makeDirectory(root, { recursive: true }).pipe(Effect.ignore);
+		yield* writeFileStringAtomically({
+			filePath: fileFor(registration.name),
+			contents: `${encodeRegistration(registration)}\n`
+		});
+	}).pipe(Effect.provide(services), Effect.catchCause((cause) => Effect.logWarning("mcp registry save failed", { cause }).pipe(Effect.asVoid)));
+	const remove = (name) => Effect.gen(function* () {
+		const removed = (yield* readAll()).find((entry) => entry.name === name);
+		yield* fileSystem.remove(fileFor(name), { force: true });
+		for (const slot of removed === void 0 ? [] : slotsOf(removed)) yield* secrets.remove(mcpSecretStorageName({
+			server: name,
+			target: slot.target,
+			key: slot.key
+		})).pipe(Effect.ignore);
+	}).pipe(Effect.provide(services), Effect.catchCause((cause) => Effect.logWarning("mcp registry remove failed", { cause }).pipe(Effect.asVoid)));
+	const setSecret = ({ name, slot, value }) => secrets.set(mcpSecretStorageName({
+		server: name,
+		target: slot.target,
+		key: slot.key
+	}), new TextEncoder().encode(value)).pipe(Effect.catchCause((cause) => Effect.logWarning("mcp secret write failed", { cause }).pipe(Effect.asVoid)));
+	return {
+		list,
+		save,
+		remove,
+		setSecret,
+		resolveForSession: Effect.gen(function* () {
+			const registrations = yield* readAll();
+			const resolved = {};
+			for (const registration of registrations) {
+				if (!registration.enabled) continue;
+				const headers = { ...registration.transport === "stdio" ? {} : registration.headers ?? {} };
+				const env = { ...registration.transport === "stdio" ? registration.env ?? {} : {} };
+				let complete = true;
+				for (const slot of slotsOf(registration)) {
+					const value = yield* readSecret(registration.name, slot);
+					if (Option.isNone(value)) {
+						complete = false;
+						break;
+					}
+					if (slot.target === "header") headers[slot.key] = value.value;
+					else env[slot.key] = value.value;
+				}
+				if (!complete) continue;
+				resolved[registration.name] = registration.transport === "stdio" ? {
+					type: "stdio",
+					command: registration.command,
+					args: registration.args ?? [],
+					env
+				} : {
+					type: registration.transport,
+					url: registration.url,
+					headers
+				};
+			}
+			return resolved;
+		}).pipe(Effect.provide(services), Effect.catchCause((cause) => Effect.logWarning("mcp registry resolve failed", { cause }).pipe(Effect.as({}))))
+	};
+});
+const layer$56 = Layer.effect(McpRegistry, make$61);
 //#endregion
 //#region src/sync/HubLink.ts
 /**
@@ -14487,7 +14628,7 @@ const formatHubLink = (input) => encodeStoredHubLink({
 	shareMode: input.shareMode
 });
 const fromEnvironment = (environment) => validateHubLink(environment.P4CODE_HUB_URL ?? "", environment.P4CODE_HUB_TOKEN ?? "");
-const make$59 = Effect.fn("HubLink.make")(function* (environment) {
+const make$60 = Effect.fn("HubLink.make")(function* (environment) {
 	const secrets = yield* ServerSecretStore;
 	const env = environment ?? process.env;
 	const fromEnv = fromEnvironment(env);
@@ -14553,7 +14694,7 @@ const make$59 = Effect.fn("HubLink.make")(function* (environment) {
 		})
 	};
 });
-const layer$54 = Layer.effect(HubLink, make$59());
+const layer$55 = Layer.effect(HubLink, make$60());
 //#endregion
 //#region src/sync/HubAssetClient.ts
 /**
@@ -14586,7 +14727,7 @@ const decodeAssetListPage = Schema$1.decodeUnknownEffect(AssetListPage);
 const decodeConflictBody = Schema$1.decodeUnknownEffect(ConflictBody);
 const decodeAsset = Schema$1.decodeUnknownEffect(AgentAsset);
 var HubAssetClient = class extends Context.Service()("@p4code/cli/sync/HubAssetClient") {};
-const make$58 = Effect.gen(function* () {
+const make$59 = Effect.gen(function* () {
 	const http = yield* HttpClient.HttpClient;
 	const link = yield* HubLink;
 	const requireSettings = Effect.gen(function* () {
@@ -14623,13 +14764,24 @@ const make$58 = Effect.gen(function* () {
 	});
 	const list = (kind) => Effect.gen(function* () {
 		const settings = yield* requireSettings;
-		const response = yield* send("list", settings, HttpClientRequest.get(`${settings.baseUrl}/assets?kind=${encodeURIComponent(kind)}`));
+		const query = kind === void 0 ? "" : `?kind=${encodeURIComponent(kind)}`;
+		const response = yield* send("list", settings, HttpClientRequest.get(`${settings.baseUrl}/assets${query}`));
 		if (response.status !== 200) return yield* new HubUnavailable({
 			operation: "list",
 			detail: `status ${response.status}`
 		});
 		return (yield* decodeBody("list", decodeAssetListPage, response)).assets;
 	});
+	const get = ({ kind, name }) => Effect.gen(function* () {
+		const settings = yield* requireSettings;
+		const response = yield* send("get", settings, HttpClientRequest.get(`${settings.baseUrl}/assets/${encodeURIComponent(kind)}/${encodeURIComponent(name)}`));
+		if (response.status === 404) return Option.none();
+		if (response.status !== 200) return yield* new HubUnavailable({
+			operation: "get",
+			detail: `status ${response.status}`
+		});
+		return Option.some(yield* decodeBody("get", decodeAsset, response));
+	});
 	const write = (input) => Effect.gen(function* () {
 		const settings = yield* requireSettings;
 		const response = yield* send("write", settings, HttpClientRequest.bodyJsonUnsafe(HttpClientRequest.put(`${settings.baseUrl}/assets`), input));
@@ -14642,7 +14794,8 @@ const make$58 = Effect.gen(function* () {
 	});
 	const remove = ({ kind, name, expectedVersion }) => Effect.gen(function* () {
 		const settings = yield* requireSettings;
-		const response = yield* send("remove", settings, HttpClientRequest.delete(`${settings.baseUrl}/assets/${encodeURIComponent(kind)}/${encodeURIComponent(name)}?expectedVersion=${expectedVersion}`));
+		const query = expectedVersion === void 0 ? "" : `?expectedVersion=${expectedVersion}`;
+		const response = yield* send("remove", settings, HttpClientRequest.delete(`${settings.baseUrl}/assets/${encodeURIComponent(kind)}/${encodeURIComponent(name)}${query}`));
 		if (response.status === 409) return yield* yield* conflictFrom(name, response);
 		if (response.status !== 204 && response.status !== 404) return yield* new HubUnavailable({
 			operation: "remove",
@@ -14651,130 +14804,248 @@ const make$58 = Effect.gen(function* () {
 	});
 	return {
 		list,
+		get,
 		write,
 		remove
 	};
 });
-const layer$53 = Layer.effect(HubAssetClient, make$58);
+const layer$54 = Layer.effect(HubAssetClient, make$59);
 //#endregion
-//#region src/pathExpansion.ts
+//#region src/sync/mcpRegistrationFiles.ts
 /**
-* Expand a leading `~` (or `~/…`, `~\…`) in a user-supplied path to the
-* current user's home directory. Spawned processes don't get shell
-* expansion, so env vars like `CODEX_HOME=~/.codex-work` would be passed
-* verbatim and treated as relative paths by the receiver.
+* Reading and writing MCP registration files for the sync.
 *
-* Matches the behavior of the other `expandHomePath` helpers in the
-* workspace layers and CLI bootstrap: `~` alone and both `~/` and `~\`
-* separators are handled. Returns the input unchanged if it doesn't
-* start with `~` or is empty. Does not handle `~user` (other-user)
-* expansion.
+* The third asset driver's filesystem half. Unlike memory, the directory is
+* p4code's own — nothing else lives in `<stateDir>/mcp` — so there is no
+* allowlist to police and the rules are about shape rather than about which
+* neighbours must not be touched.
+*
+* **What is not here is the point.** A registration references its bearer
+* tokens and API keys by slot name; the values live in `ServerSecretStore` and
+* are never written into these files. So a registration can travel through a
+* hub that stores asset files verbatim without a working credential leaving the
+* machine that holds it. This module enforces the file shape; `McpRegistry`
+* enforces the split.
+*
+* @module sync/mcpRegistrationFiles
 */
-function expandHomePath$3(value) {
-	if (!value) return value;
-	if (value === "~") return NodeOS.homedir();
-	if (value.startsWith("~/") || value.startsWith("~\\")) return NodePath.join(NodeOS.homedir(), value.slice(2));
-	return value;
-}
-//#endregion
-//#region src/provider/Drivers/ClaudeSkills.ts
+const RegistrationFromJson = Schema$1.fromJsonString(McpServerRegistration);
+const decodeRegistration = Schema$1.decodeUnknownExit(RegistrationFromJson);
 /**
-* ClaudeSkills — filesystem discovery of Claude Code skills for the `$` picker.
+* Every registration in the directory, as syncable assets.
 *
-* Claude Code loads skills from `<config dir>/skills` (user scope) and
-* `<cwd>/.claude/skills` (project scope), one directory per skill with a
-* `SKILL.md` carrying YAML frontmatter. The Agent SDK init handshake surfaces
-* skills only as slash commands without their filesystem paths, so the
-* provider snapshot scans the same locations directly, mirroring how the
-* Codex app-server reports its skills.
+* The asset name is the filename — `linear.json` — for the same reason memory's
+* is: one string is both the hub key and the path, so there is no mapping to
+* get wrong in one direction and not the other.
 *
-* @module provider/Drivers/ClaudeSkills
+* A file that will not parse is refused rather than skipped. Unlike a stray
+* `.DS_Store`, a malformed `.json` in this directory is something p4code wrote
+* or something the sync brought in, so it is a fault worth reporting rather
+* than noise to ignore.
 */
-const FRONTMATTER_PATTERN = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
-function parseSkillFrontmatter(contents) {
-	const match = FRONTMATTER_PATTERN.exec(contents);
-	if (!match) return { kind: "missing" };
-	let parsed;
-	try {
-		parsed = parse(match[1] ?? "");
-	} catch {
-		return { kind: "malformed" };
+const readMcpRegistrations = Effect.fn("mcpRegistrationFiles.read")(function* (registrationsRoot) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const entries = yield* fileSystem.readDirectory(registrationsRoot).pipe(Effect.orElseSucceed(() => []));
+	const skills = [];
+	const refused = [];
+	for (const entry of [...entries].sort()) {
+		if (!entry.endsWith(".json") || entry.startsWith(".")) continue;
+		const content = yield* fileSystem.readFileString(path.join(registrationsRoot, entry)).pipe(Effect.orElseSucceed(() => void 0));
+		if (content === void 0) {
+			refused.push({
+				name: entry,
+				reason: "unreadable"
+			});
+			continue;
+		}
+		if (decodeRegistration(content)._tag !== "Success") {
+			refused.push({
+				name: entry,
+				reason: "unreadable"
+			});
+			continue;
+		}
+		skills.push({
+			name: entry,
+			files: [{
+				path: entry,
+				content
+			}]
+		});
 	}
-	if (typeof parsed !== "object" || parsed === null) return { kind: "malformed" };
-	const record = parsed;
-	const name = typeof record.name === "string" ? record.name.trim() : "";
-	const description = typeof record.description === "string" ? record.description.trim() : "";
 	return {
-		kind: "parsed",
-		...name ? { name } : {},
-		...description ? { description } : {}
+		skills,
+		refused
 	};
-}
+});
 /**
-* Resolve the Claude config directory the CLI would use, matching the
-* precedence the spawned CLI sees: the instance's `homePath` (exported as
-* `CLAUDE_CONFIG_DIR` by `makeClaudeEnvironment`), then a `CLAUDE_CONFIG_DIR`
-* already present in the process environment, then `~/.claude`.
+* Write a registration that arrived from the hub.
+*
+* Refused unless it is exactly one file whose path is the asset's own name and
+* whose content decodes as a registration. The last check is what stops another
+* machine — or a hub row edited by hand — from installing something this server
+* would then feed to an agent as a tool source.
 */
-const resolveClaudeConfigDirPath = Effect.fn("resolveClaudeConfigDirPath")(function* (config, environment, cwd) {
+const writeMcpRegistration = Effect.fn("mcpRegistrationFiles.write")(function* (input) {
+	const fileSystem = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
-	const homePath = config.homePath.trim();
-	if (homePath.length > 0) return path.resolve(expandHomePath$3(homePath));
-	const environmentConfigDir = environment.CLAUDE_CONFIG_DIR?.trim() ?? "";
-	if (environmentConfigDir.length > 0) return cwd ? path.resolve(cwd, environmentConfigDir) : path.resolve(environmentConfigDir);
-	return path.join(NodeOS.homedir(), ".claude");
+	const file = input.files[0];
+	if (!input.name.endsWith(".json") || input.files.length !== 1 || file === void 0 || file.path !== input.name) return "refused";
+	if (decodeRegistration(file.content)._tag !== "Success") return "refused";
+	yield* fileSystem.makeDirectory(input.registrationsRoot, { recursive: true }).pipe(Effect.ignore);
+	return yield* writeFileStringAtomically({
+		filePath: path.join(input.registrationsRoot, input.name),
+		contents: file.content
+	}).pipe(Effect.as("written"), Effect.orElseSucceed(() => "failed"));
+});
+const removeMcpRegistration = Effect.fn("mcpRegistrationFiles.remove")(function* (input) {
+	if (!input.name.endsWith(".json")) return;
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	yield* fileSystem.remove(path.join(input.registrationsRoot, input.name), { force: true });
 });
+//#endregion
+//#region src/sync/memoryFile.ts
 /**
-* The user-scope skills directory the CLI would read.
+* Reading and writing user-scope memory files.
 *
-* Exported for the hub sync, which materializes into exactly this directory —
-* the same resolution the discovery below uses, so a synced skill is one the
-* `$` picker can see. Deriving it a second time is how the two would drift.
+* Memory is the instruction file an agent reads before anything else, so a
+* machine whose `CLAUDE.md` differs is a machine whose agent behaves
+* differently — which is the whole reason the hub exists. Unlike a skill it is
+* a single file, and it sits *directly* in the provider's config directory
+* rather than in a subdirectory the sync could own outright.
+*
+* That last part is the entire design constraint. `<configDir>` also holds
+* `settings.json`, `.claude.json` and `.credentials.json`. "Write the file this
+* asset names" is therefore not safe on its own: an authorized machine — or a
+* hub row someone wrote by hand — could name `settings.json` and have every
+* other machine overwrite its own configuration on the next sync. The path
+* schema does not save us here, because `settings.json` is a perfectly valid
+* asset path.
+*
+* So the allowlist below is the boundary, and it is checked on the way in as
+* well as on the way out: a file this module will not write is also one it will
+* not read, so nothing outside it can reach the hub in the first place.
+*
+* @module sync/memoryFile
 */
-const resolveClaudeUserSkillsDir = Effect.fn("resolveClaudeUserSkillsDir")(function* (config, environment, cwd) {
-	const path = yield* Path.Path;
-	const configDirPath = yield* resolveClaudeConfigDirPath(config, environment ?? process.env, cwd);
-	return path.join(configDirPath, "skills");
-});
 /**
-* 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
-* collisions the project-scoped skill wins, matching Claude Code's
-* most-specific-wins resolution.
+* The only files in the provider config directory this sync will ever touch.
+*
+* Both names, not one: Claude Code reads `CLAUDE.md`, Codex reads `AGENTS.md`,
+* and a machine that syncs both is the ordinary case rather than a special one.
+* Nothing else in that directory is memory, and everything else in it is either
+* a credential or a per-machine setting.
+*
+* The asset's name *is* the filename. That keeps the hub key and the on-disk
+* path the same string, so there is no mapping table to get wrong, and it makes
+* the allowlist checkable at the boundary rather than after a join.
 */
-const discoverClaudeSkills = Effect.fn("discoverClaudeSkills")(function* (config, cwd, environment) {
+const MEMORY_FILE_NAMES = ["CLAUDE.md", "AGENTS.md"];
+/**
+* Whether this name is one of the memory files.
+*
+* Exact match, deliberately. Not a suffix test and not case-insensitive: a
+* check that accepted `claude.md` on a case-insensitive filesystem and rejected
+* it on a case-sensitive one would make the same hub row materialize on one
+* machine and refuse on another.
+*/
+const isMemoryAssetName = (name) => MEMORY_FILE_NAMES.includes(name);
+/** The same test the skill reader uses: a NUL is what breaks a JSON text column. */
+const looksBinary$1 = (content) => content.includes("\0");
+/**
+* Read whichever memory files exist in this machine's config directory.
+*
+* Only the allowlisted names are even stat'd. A missing file is not a refusal:
+* most machines have a `CLAUDE.md` and no `AGENTS.md`, and reporting the second
+* as a problem would be reporting the normal case.
+*/
+const readMemoryFiles = Effect.fn("memoryFile.readMemoryFiles")(function* (memoryRoot) {
 	const fileSystem = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
-	const configDirPath = yield* resolveClaudeConfigDirPath(config, environment ?? process.env, cwd);
-	const roots = [{
-		directory: path.join(configDirPath, "skills"),
-		scope: "user"
-	}, ...cwd ? [{
-		directory: path.join(cwd, ".claude", "skills"),
-		scope: "project"
-	}] : []];
-	const skillsByName = /* @__PURE__ */ new Map();
-	for (const root of roots) {
-		const entries = yield* fileSystem.readDirectory(root.directory).pipe(Effect.orElseSucceed(() => []));
-		for (const entry of [...entries].sort()) {
-			const skillPath = path.join(root.directory, entry, "SKILL.md");
-			const contents = yield* fileSystem.readFileString(skillPath).pipe(Effect.orElseSucceed(() => void 0));
-			if (contents === void 0) continue;
-			const frontmatter = parseSkillFrontmatter(contents);
-			if (frontmatter.kind === "malformed") continue;
-			const name = (frontmatter.kind === "parsed" ? frontmatter.name : void 0) ?? entry.trim();
-			if (!name) continue;
-			skillsByName.set(name, {
+	const skills = [];
+	const refused = [];
+	for (const name of MEMORY_FILE_NAMES) {
+		const absolute = path.join(memoryRoot, name);
+		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,
-				path: skillPath,
-				enabled: true,
-				scope: root.scope,
-				...frontmatter.kind === "parsed" && frontmatter.description ? { description: frontmatter.description } : {}
+				reason: "unreadable"
+			});
+			continue;
+		}
+		if (looksBinary$1(content)) {
+			refused.push({
+				name,
+				reason: "binary-file"
+			});
+			continue;
+		}
+		if (content.length > 524288) {
+			refused.push({
+				name,
+				reason: "file-too-large"
+			});
+			continue;
+		}
+		const files = [{
+			path: name,
+			content
+		}];
+		if (agentAssetTotalBytes(files) > 4194304) {
+			refused.push({
+				name,
+				reason: "asset-too-large"
 			});
+			continue;
 		}
+		skills.push({
+			name,
+			files
+		});
 	}
-	return [...skillsByName.values()].sort((left, right) => left.name.localeCompare(right.name));
+	return {
+		skills,
+		refused
+	};
+});
+/**
+* Whether an asset from the hub is a memory file this machine will write.
+*
+* Both halves are checked. The name has to be allowlisted, and the files have
+* to be exactly the one file that name refers to — an asset named `CLAUDE.md`
+* carrying a second file called `settings.json` would otherwise write it, which
+* is the same escape by a longer route.
+*/
+const isWritableMemoryAsset = (input) => isMemoryAssetName(input.name) && input.files.length === 1 && input.files[0]?.path === input.name;
+/**
+* Write a memory file, or refuse.
+*
+* Answers rather than failing, because the caller's response to "this asset is
+* not writable here" is to report it alongside the other refusals, not to
+* abandon the sync. Written atomically: memory is read at the start of every
+* agent turn, and a half-written instruction file is instructions with the end
+* missing, which an agent will follow without noticing.
+*/
+const writeMemoryFile = Effect.fn("memoryFile.writeMemoryFile")(function* (input) {
+	if (!isWritableMemoryAsset(input)) return "refused";
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const contents = input.files[0]?.content ?? "";
+	yield* fileSystem.makeDirectory(input.memoryRoot, { recursive: true }).pipe(Effect.ignore);
+	return yield* writeFileStringAtomically({
+		filePath: path.join(input.memoryRoot, input.name),
+		contents
+	}).pipe(Effect.as("written"), Effect.orElseSucceed(() => "failed"));
+});
+const removeMemoryFile = Effect.fn("memoryFile.removeMemoryFile")(function* (input) {
+	if (!isMemoryAssetName(input.name)) return;
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	yield* fileSystem.remove(path.join(input.memoryRoot, input.name), { force: true });
 });
 //#endregion
 //#region src/sync/skillManifest.ts
@@ -15151,10 +15422,10 @@ function planSkillSync(input) {
 	};
 }
 //#endregion
-//#region src/sync/SkillSync.ts
+//#region src/sync/AssetSync.ts
 const EMPTY_REPORT = {
 	ran: false,
-	skillsRoot: null,
+	roots: [],
 	materialized: [],
 	published: [],
 	removed: [],
@@ -15163,13 +15434,12 @@ const EMPTY_REPORT = {
 	refused: [],
 	unavailable: null
 };
-var SkillSync = class extends Context.Service()("@p4code/cli/sync/SkillSync") {};
-const make$57 = Effect.gen(function* () {
+var AssetSync = class extends Context.Service()("@p4code/cli/sync/AssetSync") {};
+const make$58 = Effect.gen(function* () {
 	const client = yield* HubAssetClient;
 	const link = yield* HubLink;
 	const settingsStore = yield* ServerSettingsService;
 	const config = yield* ServerConfig$1;
-	const fileSystem = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	/**
 	* Captured here rather than left in each method's requirements, so the
@@ -15178,267 +15448,446 @@ const make$57 = Effect.gen(function* () {
 	* neither should have to carry a filesystem to ask for a sync.
 	*/
 	const services = yield* Effect.context();
+	/**
+	* Still `skill-sync-manifest.json`.
+	*
+	* Renaming it would be tidier and would also declare every skill this machine
+	* manages to be unmanaged, which on the next sync means re-publishing all of
+	* them into collisions. The manifest is keyed by root directory, and the two
+	* kinds have different roots, so one file holds both without ambiguity.
+	*/
 	const manifestPath = path.join(config.stateDir, "skill-sync-manifest.json");
-	const resolveSkillsRoot = Effect.fn("SkillSync.resolveSkillsRoot")(function* () {
-		return yield* resolveClaudeUserSkillsDir({ homePath: (yield* settingsStore.getSettings.pipe(Effect.orElseSucceed(() => void 0)))?.providers.claudeAgent.homePath ?? "" });
+	const claudeHome = Effect.fn("AssetSync.claudeHome")(function* () {
+		return { homePath: (yield* settingsStore.getSettings.pipe(Effect.orElseSucceed(() => void 0)))?.providers.claudeAgent.homePath ?? "" };
 	});
+	const drivers = [
+		{
+			kind: "skill",
+			resolveRoot: Effect.gen(function* () {
+				return yield* resolveClaudeUserSkillsDir(yield* claudeHome());
+			}),
+			read: (root) => readSkillDirectory(root),
+			write: ({ root, name, files }) => writeSkillDirectory({
+				skillsRoot: root,
+				name,
+				files
+			}).pipe(Effect.as("written"), Effect.orElseSucceed(() => "failed")),
+			remove: ({ root, name }) => removeSkillDirectory({
+				skillsRoot: root,
+				name
+			}).pipe(Effect.ignore)
+		},
+		{
+			kind: "memory",
+			resolveRoot: Effect.gen(function* () {
+				return yield* resolveClaudeConfigDirPath(yield* claudeHome(), process.env);
+			}),
+			read: (root) => readMemoryFiles(root),
+			write: ({ root, name, files }) => writeMemoryFile({
+				memoryRoot: root,
+				name,
+				files
+			}).pipe(Effect.map((outcome) => outcome)),
+			remove: ({ root, name }) => removeMemoryFile({
+				memoryRoot: root,
+				name
+			}).pipe(Effect.ignore)
+		},
+		{
+			kind: "mcp",
+			resolveRoot: Effect.succeed(path.join(config.stateDir, "mcp")),
+			read: (root) => readMcpRegistrations(root),
+			write: ({ root, name, files }) => writeMcpRegistration({
+				registrationsRoot: root,
+				name,
+				files
+			}),
+			remove: ({ root, name }) => removeMcpRegistration({
+				registrationsRoot: root,
+				name
+			}).pipe(Effect.ignore)
+		}
+	];
+	const driverFor = (kind) => drivers.find((driver) => driver.kind === kind);
 	const isConfigured = link.current.pipe(Effect.map((state) => Option.isSome(state.settings)));
+	/**
+	* The three views for one kind, gathered once.
+	*
+	* `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 hub = hubAssets.filter((asset) => asset.kind === driver.kind);
+		if (root === null) return {
+			root,
+			hub,
+			local: [],
+			refused: [],
+			managed: []
+		};
+		const local = yield* driver.read(root);
+		const manifest = yield* readSkillManifest(manifestPath);
+		return {
+			root,
+			hub,
+			local: local.skills,
+			refused: local.refused,
+			managed: entriesFor(manifest, root)
+		};
+	});
+	const rootsOf = Effect.fn("AssetSync.rootsOf")(function* () {
+		const roots = [];
+		for (const driver of drivers) roots.push({
+			kind: driver.kind,
+			path: yield* driver.resolveRoot
+		});
+		return roots;
+	});
 	const run = Effect.gen(function* () {
 		if (!(yield* isConfigured)) return EMPTY_REPORT;
-		const skillsRoot = yield* resolveSkillsRoot();
-		const hub = yield* client.list("skill").pipe(Effect.option);
-		if (Option.isNone(hub)) return {
+		const roots = yield* rootsOf();
+		const hubAssets = yield* client.list().pipe(Effect.option);
+		if (Option.isNone(hubAssets)) return {
 			...EMPTY_REPORT,
 			ran: true,
-			skillsRoot,
+			roots,
 			unavailable: "hub is unreachable"
 		};
-		const local = yield* readSkillDirectory(skillsRoot);
-		const manifest = yield* readSkillManifest(manifestPath);
-		const plan = planSkillSync({
-			hub: hub.value,
-			local: local.skills,
-			manifest: entriesFor(manifest, skillsRoot)
-		});
-		const entries = new Map(entriesFor(manifest, skillsRoot).map((entry) => [entry.name, entry]));
 		const materialized = [];
 		const published = [];
 		const removed = [];
-		const conflicts = [...plan.conflicts];
-		for (const action of plan.actions) switch (action._tag) {
-			case "materialize":
-				yield* writeSkillDirectory({
-					skillsRoot,
-					name: action.asset.name,
-					files: action.asset.files
-				});
-				entries.set(action.asset.name, {
-					name: action.asset.name,
-					version: action.asset.version,
-					digest: digestSkillFiles(action.asset.files)
-				});
-				materialized.push(action.asset.name);
-				break;
-			case "publish": {
-				const written = yield* client.write({
-					kind: "skill",
-					name: action.name,
-					files: action.files,
-					expectedVersion: action.expectedVersion
-				}).pipe(Effect.option);
-				if (Option.isNone(written)) {
-					conflicts.push({
+		const unmanaged = [];
+		const conflicts = [];
+		const refused = [];
+		const shareMode = (yield* link.current).shareMode;
+		for (const driver of drivers) {
+			const views = yield* viewsFor(driver, hubAssets.value);
+			const kind = driver.kind;
+			for (const entry of views.refused) refused.push({
+				kind,
+				name: entry.name,
+				reason: entry.reason
+			});
+			if (views.root === null) continue;
+			const root = views.root;
+			const plan = planSkillSync({
+				hub: views.hub,
+				local: views.local,
+				manifest: views.managed
+			});
+			const entries = new Map(views.managed.map((entry) => [entry.name, entry]));
+			/** One manifest for the whole run, re-read per kind so roots do not clobber. */
+			const commit = Effect.fn("AssetSync.commit")(function* () {
+				const manifest = yield* readSkillManifest(manifestPath);
+				yield* writeSkillManifest(manifestPath, withEntriesFor(manifest, root, [...entries.values()]));
+			});
+			for (const action of plan.actions) switch (action._tag) {
+				case "materialize": {
+					const outcome = yield* driver.write({
+						root,
+						name: action.asset.name,
+						files: action.asset.files
+					});
+					if (outcome !== "written") {
+						refused.push({
+							kind,
+							name: action.asset.name,
+							reason: outcome === "refused" ? "not-writable-here" : "write-failed"
+						});
+						break;
+					}
+					entries.set(action.asset.name, {
+						name: action.asset.name,
+						version: action.asset.version,
+						digest: digestSkillFiles(action.asset.files)
+					});
+					materialized.push({
+						kind,
+						name: action.asset.name
+					});
+					break;
+				}
+				case "publish": {
+					const written = yield* client.write({
+						kind,
+						name: action.name,
+						files: action.files,
+						expectedVersion: action.expectedVersion
+					}).pipe(Effect.option);
+					if (Option.isNone(written)) {
+						conflicts.push({
+							kind,
+							name: action.name,
+							reason: "edited-both-sides"
+						});
+						break;
+					}
+					entries.set(action.name, {
 						name: action.name,
-						reason: "edited-both-sides"
+						version: written.value.version,
+						digest: digestSkillFiles(written.value.files)
+					});
+					published.push({
+						kind,
+						name: action.name
 					});
 					break;
 				}
-				entries.set(action.name, {
-					name: action.name,
-					version: written.value.version,
-					digest: digestSkillFiles(written.value.files)
-				});
-				published.push(action.name);
-				break;
+				case "removeLocal":
+					yield* driver.remove({
+						root,
+						name: action.name
+					});
+					entries.delete(action.name);
+					removed.push({
+						kind,
+						name: action.name
+					});
+					break;
+				case "forget":
+					entries.delete(action.name);
+					break;
 			}
-			case "removeLocal":
-				yield* removeSkillDirectory({
-					skillsRoot,
-					name: action.name
-				});
-				entries.delete(action.name);
-				removed.push(action.name);
-				break;
-			case "forget":
-				entries.delete(action.name);
-				break;
-		}
-		yield* writeSkillManifest(manifestPath, withEntriesFor(manifest, skillsRoot, [...entries.values()]));
-		const shareMode = (yield* link.current).shareMode;
-		const autoShared = [];
-		if (shareMode === "all") {
-			for (const name of plan.unmanaged) {
-				const skill = local.skills.find((entry) => entry.name === name);
-				if (skill === void 0) continue;
-				const written = yield* client.write({
-					kind: "skill",
-					name,
-					files: skill.files
-				}).pipe(Effect.option);
-				if (Option.isNone(written)) {
-					conflicts.push({
+			for (const conflict of plan.conflicts) conflicts.push({
+				kind,
+				name: conflict.name,
+				reason: conflict.reason
+			});
+			yield* commit();
+			const autoShared = /* @__PURE__ */ new Set();
+			if (shareMode === "all") {
+				for (const name of plan.unmanaged) {
+					const local = views.local.find((entry) => entry.name === name);
+					if (local === void 0) continue;
+					const written = yield* client.write({
+						kind,
 						name,
-						reason: "unmanaged-local-collision"
+						files: local.files
+					}).pipe(Effect.option);
+					if (Option.isNone(written)) {
+						conflicts.push({
+							kind,
+							name,
+							reason: "unmanaged-local-collision"
+						});
+						continue;
+					}
+					entries.set(name, {
+						name,
+						version: written.value.version,
+						digest: digestSkillFiles(written.value.files)
 					});
-					continue;
+					published.push({
+						kind,
+						name
+					});
+					autoShared.add(name);
 				}
-				entries.set(name, {
-					name,
-					version: written.value.version,
-					digest: digestSkillFiles(written.value.files)
-				});
-				autoShared.push(name);
+				yield* commit();
 			}
-			yield* writeSkillManifest(manifestPath, withEntriesFor(manifest, skillsRoot, [...entries.values()]));
+			for (const name of plan.unmanaged) if (!autoShared.has(name)) unmanaged.push({
+				kind,
+				name
+			});
 		}
 		return {
 			ran: true,
-			skillsRoot,
+			roots,
 			materialized,
-			published: [...published, ...autoShared],
+			published,
 			removed,
 			conflicts,
-			unmanaged: plan.unmanaged.filter((name) => !autoShared.includes(name)),
-			refused: local.refused,
+			unmanaged,
+			refused,
 			unavailable: null
 		};
-	}).pipe(Effect.provide(services), Effect.catchCause((cause) => Effect.logWarning("skill sync failed", { cause }).pipe(Effect.as(EMPTY_REPORT))));
+	}).pipe(Effect.provide(services), Effect.catchCause((cause) => Effect.logWarning("asset sync failed", { cause }).pipe(Effect.as(EMPTY_REPORT))));
 	/**
-	* The same three views the sync reads, rendered rather than acted on.
+	* The same views the sync reads, rendered rather than acted on.
 	*
 	* Deliberately its own pass instead of a dry-run flag on `run`: a dry run
 	* sharing the executing code path is one `if` away from writing during a
 	* preview, and this is the call a panel makes every time it opens.
 	*/
-	const skillStatus = Effect.gen(function* () {
+	const assetStatus = Effect.gen(function* () {
 		const state = yield* link.current;
-		const skillsRoot = yield* resolveSkillsRoot();
-		const local = yield* readSkillDirectory(skillsRoot);
-		const managed = entriesFor(yield* readSkillManifest(manifestPath), skillsRoot);
+		const roots = yield* rootsOf();
 		const base = {
 			syncMode: state.syncMode,
 			shareMode: state.shareMode,
 			source: state.source,
-			skillsRoot,
-			refused: local.refused
+			roots
 		};
-		if (Option.isNone(state.settings)) return {
-			...base,
-			configured: false,
-			hubUrl: null,
-			entries: local.skills.map((skill) => ({
-				name: skill.name,
-				state: "unmanaged",
-				version: null,
-				detail: null
-			})),
-			unavailable: null
-		};
-		const hubUrl = state.settings.value.baseUrl;
-		const hub = yield* client.list("skill").pipe(Effect.option);
-		if (Option.isNone(hub)) return {
-			...base,
-			configured: true,
-			hubUrl,
-			entries: managed.map((entry) => ({
+		const hubAssets = Option.isNone(state.settings) ? Option.none() : yield* client.list().pipe(Effect.option);
+		const entries = [];
+		const refused = [];
+		for (const driver of drivers) {
+			const kind = driver.kind;
+			const views = yield* viewsFor(driver, Option.getOrElse(hubAssets, () => []));
+			for (const entry of views.refused) refused.push({
+				kind,
 				name: entry.name,
-				state: "synced",
-				version: entry.version,
-				detail: null
-			})),
-			unavailable: "hub is unreachable"
-		};
-		const plan = planSkillSync({
-			hub: hub.value,
-			local: local.skills,
-			manifest: managed
-		});
-		const conflictByName = new Map(plan.conflicts.map((entry) => [entry.name, entry.reason]));
-		const pendingByName = new Map(plan.actions.map((action) => [action._tag === "materialize" ? action.asset.name : action.name, action._tag]));
-		const managedByName = new Map(managed.map((entry) => [entry.name, entry]));
-		const hubByName = new Map(hub.value.map((asset) => [asset.name, asset]));
-		const entries = [.../* @__PURE__ */ new Set([
-			...hubByName.keys(),
-			...local.skills.map((skill) => skill.name),
-			...managedByName.keys()
-		])].sort().map((name) => {
-			const version = hubByName.get(name)?.version ?? managedByName.get(name)?.version ?? null;
-			const conflict = conflictByName.get(name);
-			if (conflict !== void 0) return {
-				name,
-				state: "conflict",
-				version,
-				detail: conflict
-			};
-			const action = pendingByName.get(name);
-			if (action === "publish") return {
-				name,
-				state: "local-edit",
-				version,
-				detail: null
-			};
-			if (action === "materialize" || action === "removeLocal") return {
-				name,
-				state: "pending",
-				version,
-				detail: action
-			};
-			const isManaged = managedByName.has(name);
-			return {
-				name,
-				state: isManaged ? "synced" : "unmanaged",
-				version: isManaged ? version : null,
-				detail: null
-			};
-		});
+				reason: entry.reason
+			});
+			if (Option.isNone(hubAssets)) {
+				for (const entry of views.managed) entries.push({
+					kind,
+					name: entry.name,
+					state: "synced",
+					version: entry.version,
+					detail: null
+				});
+				for (const local of views.local) {
+					if (views.managed.some((entry) => entry.name === local.name)) continue;
+					entries.push({
+						kind,
+						name: local.name,
+						state: "unmanaged",
+						version: null,
+						detail: null
+					});
+				}
+				continue;
+			}
+			const plan = planSkillSync({
+				hub: views.hub,
+				local: views.local,
+				manifest: views.managed
+			});
+			const conflictByName = new Map(plan.conflicts.map((entry) => [entry.name, entry.reason]));
+			const pendingByName = new Map(plan.actions.map((action) => [action._tag === "materialize" ? action.asset.name : action.name, action._tag]));
+			const managedByName = new Map(views.managed.map((entry) => [entry.name, entry]));
+			const hubByName = new Map(views.hub.map((asset) => [asset.name, asset]));
+			const localNames = new Set(views.local.map((entry) => entry.name));
+			const names = [.../* @__PURE__ */ new Set([
+				...hubByName.keys(),
+				...localNames,
+				...managedByName.keys()
+			])].sort();
+			for (const name of names) {
+				const version = hubByName.get(name)?.version ?? managedByName.get(name)?.version ?? null;
+				const conflict = conflictByName.get(name);
+				if (conflict !== void 0) {
+					entries.push({
+						kind,
+						name,
+						state: "conflict",
+						version,
+						detail: conflict
+					});
+					continue;
+				}
+				if (views.root === null) {
+					entries.push({
+						kind,
+						name,
+						state: "hub-only",
+						version,
+						detail: null
+					});
+					continue;
+				}
+				const action = pendingByName.get(name);
+				if (action === "publish") {
+					entries.push({
+						kind,
+						name,
+						state: "local-edit",
+						version,
+						detail: null
+					});
+					continue;
+				}
+				if (action === "materialize" || action === "removeLocal") {
+					entries.push({
+						kind,
+						name,
+						state: "pending",
+						version,
+						detail: action
+					});
+					continue;
+				}
+				const isManaged = managedByName.has(name);
+				entries.push({
+					kind,
+					name,
+					state: isManaged ? "synced" : "unmanaged",
+					version: isManaged ? version : null,
+					detail: null
+				});
+			}
+		}
 		return {
 			...base,
-			configured: true,
-			hubUrl,
+			configured: Option.isSome(state.settings),
+			hubUrl: Option.match(state.settings, {
+				onNone: () => null,
+				onSome: (settings) => settings.baseUrl
+			}),
 			entries,
-			unavailable: null
+			refused,
+			unavailable: Option.isSome(state.settings) && Option.isNone(hubAssets) ? "hub is unreachable" : null
 		};
-	}).pipe(Effect.provide(services), Effect.catchCause((cause) => Effect.logWarning("skill sync status failed", { cause }).pipe(Effect.as({
+	}).pipe(Effect.provide(services), Effect.catchCause((cause) => Effect.logWarning("asset sync status failed", { cause }).pipe(Effect.as({
 		configured: false,
 		hubUrl: null,
 		syncMode: "auto",
 		shareMode: "all",
 		source: "none",
-		skillsRoot: null,
+		roots: [],
 		entries: [],
 		refused: [],
-		unavailable: "could not read local skills"
+		unavailable: "could not read local assets"
 	}))));
-	const publish = (name) => Effect.gen(function* () {
+	const publish = ({ kind, name }) => Effect.gen(function* () {
 		if (!(yield* isConfigured)) return EMPTY_REPORT;
-		const skillsRoot = yield* resolveSkillsRoot();
-		const directory = path.join(skillsRoot, name);
-		if (!(yield* fileSystem.exists(directory).pipe(Effect.orElseSucceed(() => false)))) return {
+		const driver = driverFor(kind);
+		if (driver === void 0) return EMPTY_REPORT;
+		const root = yield* driver.resolveRoot;
+		const roots = yield* rootsOf();
+		if (root === null) return {
 			...EMPTY_REPORT,
 			ran: true,
-			skillsRoot
+			roots
 		};
-		const local = yield* readSkillDirectory(skillsRoot);
-		const refused = local.refused.filter((entry) => entry.name === name);
+		const local = yield* driver.read(root);
+		const refused = local.refused.filter((entry) => entry.name === name).map((entry) => ({
+			kind,
+			name: entry.name,
+			reason: entry.reason
+		}));
 		if (refused.length > 0) return {
 			...EMPTY_REPORT,
 			ran: true,
-			skillsRoot,
+			roots,
 			refused
 		};
-		const skill = local.skills.find((entry) => entry.name === name);
-		if (skill === void 0) return {
+		const asset = local.skills.find((entry) => entry.name === name);
+		if (asset === void 0) return {
 			...EMPTY_REPORT,
 			ran: true,
-			skillsRoot
+			roots
 		};
 		const written = yield* client.write({
-			kind: "skill",
+			kind,
 			name,
-			files: skill.files
+			files: asset.files
 		}).pipe(Effect.option);
 		if (Option.isNone(written)) return {
 			...EMPTY_REPORT,
 			ran: true,
-			skillsRoot,
+			roots,
 			conflicts: [{
+				kind,
 				name,
 				reason: "unmanaged-local-collision"
 			}]
 		};
 		const manifest = yield* readSkillManifest(manifestPath);
-		const entries = entriesFor(manifest, skillsRoot).filter((entry) => entry.name !== name);
-		yield* writeSkillManifest(manifestPath, withEntriesFor(manifest, skillsRoot, [...entries, {
+		const entries = entriesFor(manifest, root).filter((entry) => entry.name !== name);
+		yield* writeSkillManifest(manifestPath, withEntriesFor(manifest, root, [...entries, {
 			name,
 			version: written.value.version,
 			digest: digestSkillFiles(written.value.files)
@@ -15446,134 +15895,261 @@ const make$57 = Effect.gen(function* () {
 		return {
 			...EMPTY_REPORT,
 			ran: true,
-			skillsRoot,
-			published: [name]
+			roots,
+			published: [{
+				kind,
+				name
+			}]
 		};
-	}).pipe(Effect.provide(services), Effect.catchCause((cause) => Effect.logWarning("skill publish failed", { cause }).pipe(Effect.as(EMPTY_REPORT))));
+	}).pipe(Effect.provide(services), Effect.catchCause((cause) => Effect.logWarning("asset publish failed", { cause }).pipe(Effect.as(EMPTY_REPORT))));
 	const publishAll = Effect.gen(function* () {
 		if (!(yield* isConfigured)) return EMPTY_REPORT;
-		const skillsRoot = yield* resolveSkillsRoot();
-		const status = yield* skillStatus;
-		const candidates = status.entries.filter((entry) => entry.state === "unmanaged").map((entry) => entry.name);
+		const status = yield* assetStatus;
+		const candidates = status.entries.filter((entry) => entry.state === "unmanaged");
 		const published = [];
 		const conflicts = [];
-		for (const name of candidates) {
-			const report = yield* publish(name);
+		for (const candidate of candidates) {
+			const report = yield* publish({
+				kind: candidate.kind,
+				name: candidate.name
+			});
 			published.push(...report.published);
 			conflicts.push(...report.conflicts);
 		}
 		return {
 			...EMPTY_REPORT,
 			ran: true,
-			skillsRoot,
+			roots: status.roots,
 			published,
 			conflicts,
 			refused: status.refused
 		};
-	}).pipe(Effect.provide(services), Effect.catchCause((cause) => Effect.logWarning("skill publish-all failed", { cause }).pipe(Effect.as(EMPTY_REPORT))));
-	const unpublish = (name) => Effect.gen(function* () {
+	}).pipe(Effect.provide(services), Effect.catchCause((cause) => Effect.logWarning("asset publish-all failed", { cause }).pipe(Effect.as(EMPTY_REPORT))));
+	const unpublish = ({ kind, name }) => Effect.gen(function* () {
 		if (!(yield* isConfigured)) return EMPTY_REPORT;
-		const skillsRoot = yield* resolveSkillsRoot();
+		const driver = driverFor(kind);
+		if (driver === void 0) return EMPTY_REPORT;
+		const roots = yield* rootsOf();
+		const root = yield* driver.resolveRoot;
+		if (root === null) return {
+			...EMPTY_REPORT,
+			ran: true,
+			roots
+		};
 		const manifest = yield* readSkillManifest(manifestPath);
-		const managed = entriesFor(manifest, skillsRoot);
+		const managed = entriesFor(manifest, root);
 		const entry = managed.find((candidate) => candidate.name === name);
 		if (entry === void 0) return {
 			...EMPTY_REPORT,
 			ran: true,
-			skillsRoot
+			roots
 		};
 		const removedFromHub = yield* client.remove({
-			kind: "skill",
+			kind,
 			name,
 			expectedVersion: entry.version
 		}).pipe(Effect.option);
 		if (Option.isNone(removedFromHub)) return {
 			...EMPTY_REPORT,
 			ran: true,
-			skillsRoot,
+			roots,
 			conflicts: [{
+				kind,
 				name,
 				reason: "edited-both-sides"
 			}]
 		};
-		yield* writeSkillManifest(manifestPath, withEntriesFor(manifest, skillsRoot, managed.filter((candidate) => candidate.name !== name)));
+		yield* writeSkillManifest(manifestPath, withEntriesFor(manifest, root, managed.filter((candidate) => candidate.name !== name)));
 		return {
 			...EMPTY_REPORT,
 			ran: true,
-			skillsRoot,
-			removed: [name]
+			roots,
+			removed: [{
+				kind,
+				name
+			}]
+		};
+	}).pipe(Effect.provide(services), Effect.catchCause((cause) => Effect.logWarning("asset unpublish failed", { cause }).pipe(Effect.as(EMPTY_REPORT))));
+	const read = ({ kind, name }) => client.get({
+		kind,
+		name
+	}).pipe(Effect.map((asset) => Option.match(asset, {
+		onNone: () => ({
+			found: false,
+			kind,
+			name,
+			files: [],
+			version: null,
+			updatedAt: null,
+			unavailable: null
+		}),
+		onSome: (found) => ({
+			found: true,
+			kind,
+			name,
+			files: found.files,
+			version: found.version,
+			updatedAt: found.updatedAt,
+			unavailable: null
+		})
+	})), Effect.catchCause((cause) => Effect.logWarning("asset read failed", { cause }).pipe(Effect.as({
+		found: false,
+		kind,
+		name,
+		files: [],
+		version: null,
+		updatedAt: null,
+		unavailable: "hub is unreachable"
+	}))));
+	const save = ({ kind, name, files, expectedVersion }) => Effect.gen(function* () {
+		if (!(yield* isConfigured)) return EMPTY_REPORT;
+		const written = yield* client.write({
+			kind,
+			name,
+			files,
+			expectedVersion
+		}).pipe(Effect.option);
+		if (Option.isNone(written)) return {
+			...EMPTY_REPORT,
+			ran: true,
+			roots: yield* rootsOf(),
+			conflicts: [{
+				kind,
+				name,
+				reason: "edited-both-sides"
+			}]
+		};
+		return yield* run;
+	}).pipe(Effect.provide(services), Effect.catchCause((cause) => Effect.logWarning("asset save failed", { cause }).pipe(Effect.as(EMPTY_REPORT))));
+	const deleteFromHub = ({ kind, name, expectedVersion }) => Effect.gen(function* () {
+		if (!(yield* isConfigured)) return EMPTY_REPORT;
+		const removed = yield* client.remove({
+			kind,
+			name,
+			...expectedVersion === void 0 ? {} : { expectedVersion }
+		}).pipe(Effect.option);
+		if (Option.isNone(removed)) return {
+			...EMPTY_REPORT,
+			ran: true,
+			roots: yield* rootsOf(),
+			conflicts: [{
+				kind,
+				name,
+				reason: "edited-both-sides"
+			}]
 		};
-	}).pipe(Effect.provide(services), Effect.catchCause((cause) => Effect.logWarning("skill unpublish failed", { cause }).pipe(Effect.as(EMPTY_REPORT))));
+		return yield* run;
+	}).pipe(Effect.provide(services), Effect.catchCause((cause) => Effect.logWarning("asset delete failed", { cause }).pipe(Effect.as(EMPTY_REPORT))));
 	return {
 		run,
-		status: skillStatus,
+		status: assetStatus,
 		publish,
 		publishAll,
-		unpublish
+		unpublish,
+		read,
+		save,
+		deleteFromHub
 	};
 });
-const layer$52 = Layer.effect(SkillSync, make$57);
+const layer$53 = Layer.effect(AssetSync, make$58);
 //#endregion
-//#region src/cli/skills.ts
-const SyncServicesLive = layer$52.pipe(Layer.provideMerge(layer$53), Layer.provideMerge(layer$54), Layer.provideMerge(layer$55.pipe(Layer.provide(layer$62))), Layer.provideMerge(layer$62), Layer.provideMerge(FetchHttpClient.layer));
+//#region src/cli/assets.ts
+const SyncServicesLive = layer$53.pipe(Layer.provideMerge(layer$54), Layer.provideMerge(layer$55), Layer.provideMerge(layer$57.pipe(Layer.provide(layer$63))), Layer.provideMerge(layer$63), Layer.provideMerge(FetchHttpClient.layer));
 const runWithSync = (flags, run) => Effect.gen(function* () {
 	const config = yield* resolveCliAuthConfig(flags, yield* GlobalFlag.LogLevel);
 	return yield* Effect.gen(function* () {
 		return yield* run({
-			sync: yield* SkillSync,
+			sync: yield* AssetSync,
 			link: yield* HubLink
 		});
-	}).pipe(Effect.provide(SyncServicesLive.pipe(Layer.provide(layer$65(config)), Layer.provide(Layer.succeed(References.MinimumLogLevel, "Error")))));
+	}).pipe(Effect.provide(SyncServicesLive.pipe(Layer.provide(layer$66(config)), Layer.provide(Layer.succeed(References.MinimumLogLevel, "Error")))));
 });
 const STATE_LABEL = {
 	synced: "synced",
 	pending: "will update",
 	"local-edit": "will publish",
 	conflict: "CONFLICT",
-	unmanaged: "not shared"
+	unmanaged: "not shared",
+	"hub-only": "on the hub only"
+};
+const SKILL_WORDS = {
+	kind: "skill",
+	command: "skills",
+	singular: "skill",
+	plural: "skills",
+	rootLabel: "Skills",
+	nameDescription: "Name of the skill directory."
+};
+const MEMORY_WORDS = {
+	kind: "memory",
+	command: "memory",
+	singular: "memory file",
+	plural: "memory files",
+	rootLabel: "Memory",
+	nameDescription: "Memory filename, for example CLAUDE.md."
 };
+const MCP_WORDS = {
+	kind: "mcp",
+	command: "mcp",
+	singular: "MCP server",
+	plural: "MCP servers",
+	rootLabel: "MCP",
+	nameDescription: "Registration filename, for example linear.json."
+};
+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
 * confident sentence, so they are worth pinning: "Already up to date" and
 * "nothing changed" must never be printed for a run that failed.
 */
-const formatStatus = (status) => {
+const formatStatus = (status, words = SKILL_WORDS) => {
 	const lines = [];
-	if (!status.configured) lines.push("No hub is configured. Connect one with:  p4 hub connect --url <url> --token <token>");
+	if (!status.configured) lines.push("No hub is configured. Connect one with:  p4c hub connect --url <url> --token <token>");
 	else {
 		lines.push(`Hub:   ${status.hubUrl ?? "unknown"}${status.source === "environment" ? "  (from the environment)" : ""}`);
 		lines.push(`Sync:  ${status.syncMode}`);
-		lines.push(`Share: ${status.shareMode === "all" ? "all skills (new ones share automatically)" : "only the ones you choose"}`);
+		lines.push(`Share: ${status.shareMode === "all" ? `all ${words.plural} (new ones share automatically)` : "only the ones you choose"}`);
 	}
-	if (status.skillsRoot !== null) lines.push(`Skills: ${status.skillsRoot}`);
+	const root = rootFor(status, words.kind);
+	if (root !== null) lines.push(`${words.rootLabel}: ${root}`);
 	if (status.unavailable !== null) lines.push(`Warning: ${status.unavailable}`);
 	lines.push("");
-	if (status.entries.length === 0) lines.push("No skills found.");
-	else for (const entry of status.entries) {
+	const entries = status.entries.filter((entry) => entry.kind === words.kind);
+	if (entries.length === 0) lines.push(`No ${words.plural} found.`);
+	else for (const entry of entries) {
 		const version = entry.version === null ? "" : ` v${entry.version}`;
 		const detail = entry.detail === null ? "" : ` (${entry.detail})`;
 		lines.push(`  ${entry.name.padEnd(28)} ${STATE_LABEL[entry.state] ?? entry.state}${version}${detail}`);
 	}
-	for (const refusal of status.refused) lines.push(`  ${refusal.name.padEnd(28)} cannot sync (${refusal.reason})`);
+	for (const refusal of status.refused.filter((entry) => entry.kind === words.kind)) lines.push(`  ${refusal.name.padEnd(28)} cannot sync (${refusal.reason})`);
 	return lines.join("\n");
 };
+/**
+* A report covers every kind at once, so names are qualified as soon as more
+* than one kind appears in it. `published CLAUDE.md` is ambiguous in a way
+* `published memory CLAUDE.md` is not — a skill directory may legitimately be
+* called `CLAUDE.md`, since the name schema permits dots.
+*/
+const describeRefs = (refs) => {
+	const kinds = new Set(refs.map((ref) => ref.kind));
+	return refs.map((ref) => kinds.size > 1 ? `${ref.kind} ${ref.name}` : ref.name).join(", ");
+};
 const formatReport = (report) => {
 	if (!report.ran) return "No hub is configured; nothing to do.";
 	if (report.unavailable !== null) return `Hub is unreachable (${report.unavailable}); nothing changed.`;
 	const parts = [];
-	if (report.materialized.length > 0) parts.push(`updated ${report.materialized.join(", ")}`);
-	if (report.published.length > 0) parts.push(`published ${report.published.join(", ")}`);
-	if (report.removed.length > 0) parts.push(`removed ${report.removed.join(", ")}`);
+	if (report.materialized.length > 0) parts.push(`updated ${describeRefs(report.materialized)}`);
+	if (report.published.length > 0) parts.push(`published ${describeRefs(report.published)}`);
+	if (report.removed.length > 0) parts.push(`removed ${describeRefs(report.removed)}`);
 	for (const conflict of report.conflicts) parts.push(`CONFLICT on ${conflict.name} (${conflict.reason})`);
 	for (const refusal of report.refused) parts.push(`cannot sync ${refusal.name} (${refusal.reason})`);
 	const summary = parts.length === 0 ? "Already up to date." : parts.join("\n");
 	if (report.unmanaged.length === 0) return summary;
 	const count = report.unmanaged.length;
-	return `${summary}\n\n${count} local skill${count === 1 ? " is" : "s are"} not shared. Share ${count === 1 ? "it" : "them"} with:  p4 skills publish --all`;
+	return `${summary}\n\n${count} local item${count === 1 ? " is" : "s are"} not shared. Share ${count === 1 ? "it" : "them"} with:  p4c skills publish --all`;
 };
 const urlFlag = Flag.string("url").pipe(Flag.withDescription("Base URL of the hub, for example https://hub.example.com."));
-const tokenFlag = Flag.string("token").pipe(Flag.withDescription("Bearer token for this server, from `p4 hub token add`."));
-const skillNameArgument = Argument.string("name").pipe(Argument.withDescription("Name of the skill directory."));
+const tokenFlag = Flag.string("token").pipe(Flag.withDescription("Bearer token for this server, from `p4c hub token add`."));
 const hubConnectCommand = Command.make("connect", {
 	...authLocationFlags,
 	url: urlFlag,
@@ -15589,32 +16165,74 @@ const hubDisconnectCommand = Command.make("disconnect", { ...authLocationFlags }
 	yield* link.disconnect;
 	yield* Console.log(formatStatus(yield* sync.status));
 }))));
-const statusCommand = Command.make("status", { ...authLocationFlags }).pipe(Command.withDescription("Show which skills are shared, changed, or in conflict."), Command.withHandler((flags) => runWithSync(flags, ({ sync }) => sync.status.pipe(Effect.flatMap((s) => Console.log(formatStatus(s)))))));
-const syncCommand = Command.make("sync", { ...authLocationFlags }).pipe(Command.withDescription("Reconcile this machine's shared skills with the hub now."), Command.withHandler((flags) => runWithSync(flags, ({ sync }) => sync.run.pipe(Effect.flatMap((r) => Console.log(formatReport(r)))))));
-const allFlag = Flag.boolean("all").pipe(Flag.withDescription("Share every local skill this machine does not already share."));
-const publishCommand = Command.make("publish", {
-	...authLocationFlags,
-	name: skillNameArgument.pipe(Argument.optional),
-	all: allFlag
-}).pipe(Command.withDescription("Share local skills through the hub, so every machine gets them."), Command.withHandler((flags) => runWithSync(flags, ({ sync }) => Effect.gen(function* () {
-	if (flags.all) return yield* sync.publishAll.pipe(Effect.flatMap((report) => Console.log(formatReport(report))));
-	const name = Option.getOrUndefined(flags.name);
-	if (name === void 0) return yield* Console.error("Name a skill, or pass --all to share every unshared one.");
-	return yield* sync.publish(name).pipe(Effect.flatMap((report) => Console.log(formatReport(report))));
-}))));
-const unpublishCommand = Command.make("unpublish", {
-	...authLocationFlags,
-	name: skillNameArgument
-}).pipe(Command.withDescription("Stop sharing a skill. It stays on this machine and leaves the others."), Command.withHandler((flags) => runWithSync(flags, ({ sync }) => sync.unpublish(flags.name).pipe(Effect.flatMap((report) => Console.log(formatReport(report)))))));
-const shareAllCommand = Command.make("share-all", { ...authLocationFlags }).pipe(Command.withDescription("Share every skill, including new ones, automatically. The default."), Command.withHandler((flags) => runWithSync(flags, ({ sync, link }) => Effect.gen(function* () {
+const makeAssetCommands = (words) => {
+	const nameArgument = Argument.string("name").pipe(Argument.withDescription(words.nameDescription));
+	return {
+		statusCommand: Command.make("status", { ...authLocationFlags }).pipe(Command.withDescription(`Show which ${words.plural} are shared, changed, or in conflict.`), Command.withHandler((flags) => runWithSync(flags, ({ sync }) => sync.status.pipe(Effect.flatMap((status) => Console.log(formatStatus(status, words))))))),
+		syncCommand: Command.make("sync", { ...authLocationFlags }).pipe(Command.withDescription("Reconcile everything this machine shares with the hub now."), Command.withHandler((flags) => runWithSync(flags, ({ sync }) => sync.run.pipe(Effect.flatMap((report) => Console.log(formatReport(report))))))),
+		publishCommand: Command.make("publish", {
+			...authLocationFlags,
+			name: nameArgument.pipe(Argument.optional),
+			all: Flag.boolean("all").pipe(Flag.withDescription("Share everything local this machine does not already share."))
+		}).pipe(Command.withDescription(`Share local ${words.plural} through the hub, so every machine gets them.`), Command.withHandler((flags) => runWithSync(flags, ({ sync }) => Effect.gen(function* () {
+			if (flags.all) return yield* sync.publishAll.pipe(Effect.flatMap((report) => Console.log(formatReport(report))));
+			const name = Option.getOrUndefined(flags.name);
+			if (name === void 0) return yield* Console.error(`Name a ${words.singular}, or pass --all to share every unshared one.`);
+			return yield* sync.publish({
+				kind: words.kind,
+				name
+			}).pipe(Effect.flatMap((report) => Console.log(formatReport(report))));
+		})))),
+		unpublishCommand: Command.make("unpublish", {
+			...authLocationFlags,
+			name: nameArgument
+		}).pipe(Command.withDescription(`Stop sharing a ${words.singular}. It stays on this machine and leaves the others.`), Command.withHandler((flags) => runWithSync(flags, ({ sync }) => sync.unpublish({
+			kind: words.kind,
+			name: flags.name
+		}).pipe(Effect.flatMap((report) => Console.log(formatReport(report))))))),
+		showCommand: Command.make("show", {
+			...authLocationFlags,
+			name: nameArgument
+		}).pipe(Command.withDescription(`Print the hub's copy of a ${words.singular}, and where it lives here.`), Command.withHandler((flags) => runWithSync(flags, ({ sync }) => Effect.gen(function* () {
+			const name = flags.name;
+			const content = yield* sync.read({
+				kind: words.kind,
+				name
+			});
+			if (content.unavailable !== null) return yield* Console.error(`Hub is unreachable (${content.unavailable}).`);
+			if (!content.found) return yield* Console.error(`The hub has no ${words.singular} named ${name}.`);
+			const lines = [`${name}  v${content.version ?? "?"}  updated ${content.updatedAt ?? "?"}`];
+			for (const file of content.files) lines.push("", `--- ${file.path} ---`, file.content.trimEnd());
+			const root = rootFor(yield* sync.status, words.kind);
+			if (root !== null) lines.push("", `Edit it here and the next sync publishes it:  ${root}/${name}`);
+			return yield* Console.log(lines.join("\n"));
+		})))),
+		removeCommand: Command.make("rm", {
+			...authLocationFlags,
+			name: nameArgument,
+			yes: Flag.boolean("yes").pipe(Flag.withDescription("Confirm: this removes it from the hub and from every machine."))
+		}).pipe(Command.withDescription(`Delete a ${words.singular} from the hub and from every machine.`), Command.withHandler((flags) => runWithSync(flags, ({ sync }) => Effect.gen(function* () {
+			if (!flags.yes) return yield* Console.error(`This deletes ${flags.name} from the hub and from every machine that syncs it.\nRe-run with --yes if that is what you want.\nTo stop sharing it from here only:  p4 ${words.command} unpublish ${flags.name}`);
+			const report = yield* sync.deleteFromHub({
+				kind: words.kind,
+				name: flags.name
+			});
+			return yield* Console.log(formatReport(report));
+		}))))
+	};
+};
+const skillCommands = makeAssetCommands(SKILL_WORDS);
+const memoryCommands = makeAssetCommands(MEMORY_WORDS);
+const mcpCommands = makeAssetCommands(MCP_WORDS);
+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));
 }))));
-const shareSelectedCommand = Command.make("share-selected", { ...authLocationFlags }).pipe(Command.withDescription("Share only the skills you name with `publish`. Nothing shares on its own."), Command.withHandler((flags) => runWithSync(flags, ({ sync, link }) => Effect.gen(function* () {
+const shareSelectedCommand = Command.make("share-selected", { ...authLocationFlags }).pipe(Command.withDescription("Share only what you name with `publish`. Nothing shares on its own."), Command.withHandler((flags) => runWithSync(flags, ({ sync, link }) => Effect.gen(function* () {
 	yield* link.setShareMode("selected");
 	yield* Console.log(formatStatus(yield* sync.status));
 }))));
-const pauseCommand = Command.make("pause", { ...authLocationFlags }).pipe(Command.withDescription("Stop syncing automatically. `p4 skills sync` still works."), Command.withHandler((flags) => runWithSync(flags, ({ sync, link }) => Effect.gen(function* () {
+const pauseCommand = Command.make("pause", { ...authLocationFlags }).pipe(Command.withDescription("Stop syncing automatically. `p4c skills sync` still works."), Command.withHandler((flags) => runWithSync(flags, ({ sync, link }) => Effect.gen(function* () {
 	yield* link.setSyncMode("paused");
 	yield* Console.log(formatStatus(yield* sync.status));
 }))));
@@ -15623,15 +16241,41 @@ const resumeCommand = Command.make("resume", { ...authLocationFlags }).pipe(Comm
 	yield* Console.log(formatStatus(yield* sync.status));
 }))));
 const skillsCommand = Command.make("skills", {}).pipe(Command.withDescription("Share agent skills across your machines through the hub."), Command.withSubcommands([
-	statusCommand,
-	syncCommand,
-	publishCommand,
-	unpublishCommand,
+	skillCommands.statusCommand,
+	skillCommands.syncCommand,
+	skillCommands.publishCommand,
+	skillCommands.unpublishCommand,
+	skillCommands.showCommand,
+	skillCommands.removeCommand,
 	pauseCommand,
 	resumeCommand,
 	shareAllCommand,
 	shareSelectedCommand
 ]));
+const memoryCommand = Command.make("memory", {}).pipe(Command.withDescription("Share user memory — CLAUDE.md, AGENTS.md — across your machines."), Command.withSubcommands([
+	memoryCommands.statusCommand,
+	memoryCommands.syncCommand,
+	memoryCommands.publishCommand,
+	memoryCommands.unpublishCommand,
+	memoryCommands.showCommand,
+	memoryCommands.removeCommand
+]));
+/**
+* The sharing half of `p4c mcp`.
+*
+* Registering a server — its command, its URL, its tokens — belongs in the
+* panel, where a form can ask for a secret and put it somewhere that does not
+* sync. These subcommands are the same six every kind gets, and what they move
+* is the definition only.
+*/
+const mcpCommand = Command.make("mcp", {}).pipe(Command.withDescription("Share MCP server registrations across your machines."), Command.withSubcommands([
+	mcpCommands.statusCommand,
+	mcpCommands.syncCommand,
+	mcpCommands.publishCommand,
+	mcpCommands.unpublishCommand,
+	mcpCommands.showCommand,
+	mcpCommands.removeCommand
+]));
 /** Exported for the hub command, which owns `connect`/`disconnect`. */
 const hubLinkCommands = [hubConnectCommand, hubDisconnectCommand];
 //#endregion
@@ -15729,7 +16373,7 @@ const serveHubCommand = Command.make("serve", {
 		fileTokenHashes: hubTokenHashes(tokenFile)
 	});
 	if (rejectedTokenHashes.length > 0) yield* Console.error(`Ignoring ${rejectedTokenHashes.length} malformed entr${rejectedTokenHashes.length === 1 ? "y" : "ies"} in P4CODE_HUB_TOKEN_HASHES; each must be a 64-character SHA-256 hex digest.`);
-	if (config.tokenHashes.size === 0) yield* Console.error("No server tokens are registered, so every request will be rejected.\nMint one with:  p4 hub token add --label studio");
+	if (config.tokenHashes.size === 0) yield* Console.error("No server tokens are registered, so every request will be rejected.\nMint one with:  p4c hub token add --label studio");
 	return yield* runHub.pipe(Effect.provideService(HubConfig, HubConfig.of({
 		dbPath: config.dbPath,
 		host: config.host,
@@ -20307,6 +20951,273 @@ function mergeGitStatusParts(local, remote) {
 	};
 }
 //#endregion
+//#region src/stream/collectUint8StreamText.ts
+const collectUint8StreamText = (input) => {
+	const maxBytes = input.maxBytes ?? Number.POSITIVE_INFINITY;
+	const truncatedMarker = input.truncatedMarker ?? "";
+	return input.stream.pipe(Stream.runFold(() => ({
+		chunks: [],
+		bytes: 0,
+		truncated: false
+	}), (state, chunk) => {
+		if (state.truncated) return state;
+		const remainingBytes = maxBytes - state.bytes;
+		if (remainingBytes <= 0) return {
+			...state,
+			truncated: true
+		};
+		const nextChunk = chunk.byteLength > remainingBytes ? chunk.slice(0, remainingBytes) : chunk;
+		state.chunks.push(nextChunk);
+		const bytes = state.bytes + nextChunk.byteLength;
+		const truncated = chunk.byteLength > remainingBytes;
+		return {
+			chunks: state.chunks,
+			bytes,
+			truncated
+		};
+	}), Effect.map((state) => {
+		const text = Buffer.concat(state.chunks, state.bytes).toString("utf8");
+		return {
+			text: state.truncated && truncatedMarker.length > 0 ? `${text}${truncatedMarker}` : text,
+			bytes: state.bytes,
+			truncated: state.truncated
+		};
+	}));
+};
+//#endregion
+//#region src/processRunner.ts
+const ProcessInvocationFields = {
+	command: Schema$1.String,
+	argumentCount: Schema$1.Number,
+	cwd: Schema$1.optional(Schema$1.String),
+	spawnCwd: Schema$1.optional(Schema$1.String)
+};
+const formatProcessInvocation = (input) => {
+	const executionCwd = input.spawnCwd ?? input.cwd;
+	return executionCwd === void 0 ? `'${input.command}'` : `'${input.command}' in '${executionCwd}'`;
+};
+var ProcessSpawnError = class extends Schema$1.TaggedErrorClass()("ProcessSpawnError", {
+	...ProcessInvocationFields,
+	resolvedCommand: Schema$1.optional(Schema$1.String),
+	resolvedArgumentCount: Schema$1.optional(Schema$1.Number),
+	shell: Schema$1.optional(Schema$1.Boolean),
+	cause: Schema$1.Defect()
+}) {
+	get message() {
+		return `Failed to spawn process ${formatProcessInvocation(this)}`;
+	}
+};
+var ProcessStdinError = class extends Schema$1.TaggedErrorClass()("ProcessStdinError", {
+	...ProcessInvocationFields,
+	stdinBytes: Schema$1.Number,
+	cause: Schema$1.Defect()
+}) {
+	get message() {
+		return `Failed to write stdin for process ${formatProcessInvocation(this)}`;
+	}
+};
+var ProcessOutputLimitError = class extends Schema$1.TaggedErrorClass()("ProcessOutputLimitError", {
+	...ProcessInvocationFields,
+	stream: Schema$1.Literals(["stdout", "stderr"]),
+	maxBytes: Schema$1.Number,
+	observedBytes: Schema$1.Number
+}) {
+	get message() {
+		return `Process ${formatProcessInvocation(this)} ${this.stream} produced ${this.observedBytes} bytes, exceeding the ${this.maxBytes} byte limit`;
+	}
+};
+var ProcessReadError = class extends Schema$1.TaggedErrorClass()("ProcessReadError", {
+	...ProcessInvocationFields,
+	stream: Schema$1.Literals([
+		"stdout",
+		"stderr",
+		"exitCode"
+	]),
+	cause: Schema$1.Defect()
+}) {
+	get message() {
+		return `Failed to read ${this.stream} for process ${formatProcessInvocation(this)}`;
+	}
+};
+var ProcessTimeoutError = class extends Schema$1.TaggedErrorClass()("ProcessTimeoutError", {
+	...ProcessInvocationFields,
+	timeoutMs: Schema$1.Number
+}) {
+	get message() {
+		return `Process ${formatProcessInvocation(this)} timed out after ${this.timeoutMs}ms`;
+	}
+};
+Schema$1.Union([
+	ProcessSpawnError,
+	ProcessStdinError,
+	ProcessOutputLimitError,
+	ProcessReadError,
+	ProcessTimeoutError
+]);
+var ProcessRunner = class extends Context.Service()("@p4code/cli/processRunner") {};
+const DEFAULT_TIMEOUT = "60 seconds";
+const DEFAULT_MAX_OUTPUT_BYTES$2 = 8 * 1024 * 1024;
+const WINDOWS_COMMAND_NOT_FOUND_PATTERNS = [
+	/is not recognized as an internal or external command/i,
+	/n.o . reconhecido como um comando interno/i,
+	/non . riconosciuto come comando interno o esterno/i,
+	/n.est pas reconnu en tant que commande interne/i,
+	/no se reconoce como un comando interno o externo/i,
+	/wird nicht als interner oder externer befehl/i
+];
+function hasWindowsCommandNotFoundMessage(output) {
+	return WINDOWS_COMMAND_NOT_FOUND_PATTERNS.some((pattern) => pattern.test(output));
+}
+const isWindowsCommandNotFound = Effect.fn("processRunner.isWindowsCommandNotFound")(function* (code, stderr) {
+	if ((yield* HostProcessPlatform) !== "win32") return false;
+	if (code === 9009) return true;
+	return hasWindowsCommandNotFoundMessage(stderr);
+});
+const collectText = Effect.fn("processRunner.collectText")(function* (input) {
+	const stream = input.stream.pipe(Stream.mapError((cause) => new ProcessReadError({
+		command: input.command,
+		argumentCount: input.args.length,
+		cwd: input.cwd,
+		spawnCwd: input.spawnCwd,
+		stream: input.streamName,
+		cause
+	})));
+	if (input.outputMode === "truncate") return yield* collectUint8StreamText({
+		stream,
+		maxBytes: input.maxOutputBytes,
+		truncatedMarker: input.truncatedMarker
+	});
+	return yield* stream.pipe(Stream.runFoldEffect(() => ({
+		chunks: [],
+		bytes: 0
+	}), (state, chunk) => {
+		const remainingBytes = input.maxOutputBytes - state.bytes;
+		if (chunk.byteLength > remainingBytes) return Effect.fail(new ProcessOutputLimitError({
+			command: input.command,
+			argumentCount: input.args.length,
+			cwd: input.cwd,
+			spawnCwd: input.spawnCwd,
+			stream: input.streamName,
+			maxBytes: input.maxOutputBytes,
+			observedBytes: state.bytes + chunk.byteLength
+		}));
+		state.chunks.push(chunk);
+		return Effect.succeed({
+			chunks: state.chunks,
+			bytes: state.bytes + chunk.byteLength
+		});
+	}), Effect.map((state) => ({
+		text: Buffer.concat(state.chunks, state.bytes).toString("utf8"),
+		bytes: state.bytes,
+		truncated: false
+	})));
+});
+function finalizeRunProcess(effect, input) {
+	const timeout = Duration.fromInputUnsafe(input.timeout ?? DEFAULT_TIMEOUT);
+	const timeoutBehavior = input.timeoutBehavior ?? "error";
+	return effect.pipe(Effect.scoped, Effect.timeoutOption(timeout), Effect.flatMap((result) => {
+		if (Option.isSome(result)) return Effect.succeed(result.value);
+		if (timeoutBehavior === "timedOutResult") return Effect.succeed({
+			stdout: "",
+			stderr: "",
+			code: null,
+			timedOut: true,
+			stdoutTruncated: false,
+			stderrTruncated: false
+		});
+		return Effect.fail(new ProcessTimeoutError({
+			command: input.command,
+			argumentCount: input.args.length,
+			cwd: input.cwd,
+			spawnCwd: input.spawnCwd,
+			timeoutMs: Duration.toMillis(timeout)
+		}));
+	}));
+}
+const runProcessCore = Effect.fn("processRunner.runProcessCore")(function* (spawner, input) {
+	const maxOutputBytes = input.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES$2;
+	const outputMode = input.outputMode ?? "error";
+	const truncatedMarker = input.truncatedMarker ?? "";
+	const extendEnv = input.env !== void 0;
+	const spawnCommand = yield* resolveSpawnCommand(input.command, input.args, input.env === void 0 ? {} : {
+		env: input.env,
+		extendEnv
+	});
+	const child = yield* spawner.spawn(ChildProcess$1.make(spawnCommand.command, spawnCommand.args, {
+		...input.spawnCwd ?? input.cwd ? { cwd: input.spawnCwd ?? input.cwd } : {},
+		...input.env !== void 0 ? {
+			env: input.env,
+			extendEnv
+		} : {},
+		shell: spawnCommand.shell
+	})).pipe(Effect.mapError((cause) => new ProcessSpawnError({
+		command: input.command,
+		argumentCount: input.args.length,
+		cwd: input.cwd,
+		spawnCwd: input.spawnCwd,
+		resolvedCommand: spawnCommand.command,
+		resolvedArgumentCount: spawnCommand.args.length,
+		shell: spawnCommand.shell,
+		cause
+	})));
+	const stdin = input.stdin;
+	const writeStdin = stdin === void 0 ? Effect.void : Stream.run(Stream.encodeText(Stream.make(stdin)), child.stdin).pipe(Effect.mapError((cause) => new ProcessStdinError({
+		command: input.command,
+		argumentCount: input.args.length,
+		cwd: input.cwd,
+		spawnCwd: input.spawnCwd,
+		stdinBytes: Buffer.byteLength(stdin),
+		cause
+	})));
+	const [stdout, stderr] = yield* Effect.all([
+		collectText({
+			command: input.command,
+			args: input.args,
+			cwd: input.cwd,
+			spawnCwd: input.spawnCwd,
+			streamName: "stdout",
+			stream: child.stdout,
+			maxOutputBytes,
+			outputMode,
+			truncatedMarker
+		}),
+		collectText({
+			command: input.command,
+			args: input.args,
+			cwd: input.cwd,
+			spawnCwd: input.spawnCwd,
+			streamName: "stderr",
+			stream: child.stderr,
+			maxOutputBytes,
+			outputMode,
+			truncatedMarker
+		}),
+		writeStdin
+	], { concurrency: "unbounded" });
+	const exitCode = yield* child.exitCode.pipe(Effect.mapError((cause) => new ProcessReadError({
+		command: input.command,
+		argumentCount: input.args.length,
+		cwd: input.cwd,
+		spawnCwd: input.spawnCwd,
+		stream: "exitCode",
+		cause
+	})));
+	return {
+		stdout: stdout.text,
+		stderr: stderr.text,
+		code: exitCode,
+		timedOut: false,
+		stdoutTruncated: stdout.truncated,
+		stderrTruncated: stderr.truncated
+	};
+});
+const make$57 = Effect.fn("ProcessRunner.make")(function* () {
+	const spawner = yield* ChildProcessSpawner$1.ChildProcessSpawner;
+	const run = (input) => finalizeRunProcess(runProcessCore(spawner, input), input);
+	return ProcessRunner.of({ run });
+});
+const layer$52 = Layer.effect(ProcessRunner, make$57());
+//#endregion
 //#region src/project/RepositoryIdentityResolver.ts
 const DEFAULT_REPOSITORY_IDENTITY_CACHE_CAPACITY = 512;
 const DEFAULT_POSITIVE_CACHE_TTL = Duration.minutes(1);
@@ -20411,7 +21322,7 @@ const make$56 = Effect.fn("RepositoryIdentityResolver.make")(function* (options
 	});
 	return RepositoryIdentityResolver.of({ resolve });
 });
-const layer$51 = Layer.effect(RepositoryIdentityResolver, make$56()).pipe(Layer.provide(layer$57));
+const layer$51 = Layer.effect(RepositoryIdentityResolver, make$56()).pipe(Layer.provide(layer$52));
 //#endregion
 //#region src/orchestration/Layers/ProjectionSnapshotQuery.ts
 const decodeReadModel = Schema$1.decodeUnknownEffect(OrchestrationReadModel);
@@ -23316,6 +24227,7 @@ const make$51 = Effect.fn("cloud.boot_service.make")(function* (input) {
 	});
 	const activateLaunchAgent = Effect.gen(function* () {
 		yield* runStep("unloading the previous service", "launchctl", ["bootout", serviceTarget]).pipe(Effect.ignore);
+		yield* runStep("enabling the service", "launchctl", ["enable", serviceTarget]).pipe(Effect.ignore);
 		yield* runStep("loading the service", "launchctl", [
 			"bootstrap",
 			guiDomain,
@@ -23429,7 +24341,7 @@ const layer$46 = (input) => Layer.effect(BootService, make$51(input));
 //#endregion
 //#region src/service/selfUpdate.ts
 /**
-* Lets a connected client replace this server with another published `p4`
+* Lets a connected client replace this server with another published `p4c`
 * version over RPC — the only update path that works when the user is not at
 * the machine (phone against a home server, relay-managed box). The target
 * version is npm-installed into the pinned runtime and verified before
@@ -23648,7 +24560,7 @@ const make$50 = Effect.fn("cloud.server_self_update.make")(function* (options) {
 	});
 	return ServerSelfUpdate.of({ update });
 });
-const layer$45 = Layer.effect(ServerSelfUpdate, make$50()).pipe(Layer.provide(layer$57));
+const layer$45 = Layer.effect(ServerSelfUpdate, make$50()).pipe(Layer.provide(layer$52));
 //#endregion
 //#region src/environment/ServerEnvironmentLabel.ts
 const ServerEnvironmentLabelCommandProbe = Schema$1.Literals(["macos-computer-name", "linux-pretty-hostname"]);
@@ -23843,7 +24755,7 @@ const make$49 = Effect.gen(function* () {
 * state. It intentionally has no fallback Layer.succeed value: callers must
 * provide the external platform services and a ServerConfig.
 */
-const layer$44 = Layer.effect(ServerEnvironment, make$49).pipe(Layer.provide(layer$57));
+const layer$44 = Layer.effect(ServerEnvironment, make$49).pipe(Layer.provide(layer$52));
 //#endregion
 //#region src/provider/Services/ProviderSessionReaper.ts
 var ProviderSessionReaper = class extends Context.Service()("@p4code/cli/provider/Services/ProviderSessionReaper") {};
@@ -24927,7 +25839,7 @@ const make$48 = Effect.gen(function* () {
 	const lifecycleEvents = yield* ServerLifecycleEvents;
 	const serverSettings = yield* ServerSettingsService;
 	const serverEnvironment = yield* ServerEnvironment;
-	const skillSync = yield* SkillSync;
+	const assetSync = yield* AssetSync;
 	const hubLink = yield* HubLink;
 	const crypto = yield* Crypto.Crypto;
 	const commandGate = yield* makeCommandGate;
@@ -24949,13 +25861,13 @@ const make$48 = Effect.gen(function* () {
 			environmentVariable: error.environmentVariable,
 			cause: error.cause
 		})), Effect.forkScoped));
-		yield* Effect.logDebug("startup phase: syncing user-scope skills");
+		yield* Effect.logDebug("startup phase: syncing user-scope agent assets");
 		yield* runStartupPhase("skills.sync", Effect.gen(function* () {
-			if ((yield* hubLink.current).syncMode !== "auto") return yield* Effect.logDebug("skill sync is paused; skipping the automatic pass");
-			const report = yield* skillSync.run;
+			if ((yield* hubLink.current).syncMode !== "auto") return yield* Effect.logDebug("asset sync is paused; skipping the automatic pass");
+			const report = yield* assetSync.run;
 			if (!report.ran) return;
-			yield* Effect.log("skill sync", {
-				skillsRoot: report.skillsRoot,
+			yield* Effect.log("asset sync", {
+				roots: report.roots,
 				materialized: report.materialized,
 				published: report.published,
 				removed: report.removed,
@@ -25375,7 +26287,7 @@ const ProjectCliRuntimeLive = Layer.mergeAll(layer$42, OrchestrationLayerLive.pi
 const PROJECT_CLI_LIVE_SERVER_TIMEOUT = Duration.seconds(1);
 const withProjectCliSessionToken = (environmentAuth, run) => Effect.acquireUseRelease(environmentAuth.issueSession({
 	scopes: AuthAdministrativeScopes,
-	label: "p4 project cli"
+	label: "p4c project cli"
 }), (issued) => run(issued.token), (issued) => environmentAuth.revokeSession(issued.sessionId).pipe(Effect.ignore({ log: true })));
 const withProjectCliLiveServerTimeout = (effect) => effect.pipe(Effect.timeout(PROJECT_CLI_LIVE_SERVER_TIMEOUT));
 const makeLiveServerClient = (origin) => HttpApiClient.make(EnvironmentHttpApi, { baseUrl: origin });
@@ -25462,7 +26374,7 @@ const runProjectMutation = Effect.fn("runProjectMutation")(function* (flags, run
 			});
 			yield* Console.log(output);
 		}));
-		const offlineRuntimeLayer = ProjectCliRuntimeLive.pipe(Layer.provide(layer$65(config)), Layer.provide(Layer.succeed(References.MinimumLogLevel, minimumLogLevel)));
+		const offlineRuntimeLayer = ProjectCliRuntimeLive.pipe(Layer.provide(layer$66(config)), Layer.provide(Layer.succeed(References.MinimumLogLevel, minimumLogLevel)));
 		return yield* Effect.gen(function* () {
 			const snapshot = yield* getOfflineSnapshot();
 			const orchestrationEngine = yield* OrchestrationEngineService;
@@ -25473,7 +26385,7 @@ const runProjectMutation = Effect.fn("runProjectMutation")(function* (flags, run
 			});
 			yield* Console.log(output);
 		}).pipe(Effect.provide(offlineRuntimeLayer));
-	}).pipe(Effect.provide(Layer.mergeAll(runtimeLayer, layer$42).pipe(Layer.provideMerge(FetchHttpClient.layer), Layer.provide(layer$65(config)), Layer.provide(Layer.succeed(References.MinimumLogLevel, minimumLogLevel)))));
+	}).pipe(Effect.provide(Layer.mergeAll(runtimeLayer, layer$42).pipe(Layer.provideMerge(FetchHttpClient.layer), Layer.provide(layer$66(config)), Layer.provide(Layer.succeed(References.MinimumLogLevel, minimumLogLevel)))));
 });
 const projectAddCommand = Command.make("add", {
 	...projectLocationFlags,
@@ -28768,7 +29680,7 @@ const make$43 = Effect.gen(function* () {
 	});
 	return VcsProcess.of({ run });
 });
-const layer$38 = Layer.effect(VcsProcess, make$43).pipe(Layer.provide(layer$57));
+const layer$38 = Layer.effect(VcsProcess, make$43).pipe(Layer.provide(layer$52));
 //#endregion
 //#region src/vcs/VcsDriver.ts
 var VcsDriver = class extends Context.Service()("@p4code/cli/vcs/VcsDriver") {};
@@ -32549,7 +33461,7 @@ const makeWithOptions$1 = Effect.fn("TerminalManager.makeWithOptions")(function*
 		subscribeMetadata
 	});
 });
-const layer$30 = Layer.effect(TerminalManager, make$35()).pipe(Layer.provide(layer$57));
+const layer$30 = Layer.effect(TerminalManager, make$35()).pipe(Layer.provide(layer$52));
 //#endregion
 //#region src/mcp/McpInvocationContext.ts
 var McpInvocationContext = class extends Context.Service()("@p4code/cli/mcp/McpInvocationContext") {};
@@ -39500,7 +40412,7 @@ const make$9 = Effect.gen(function* () {
 const layer$4 = Layer.effect(SourceControlRepositoryService, make$9);
 //#endregion
 //#region src/ws.ts
-/** Matches `p4 hub token add`, so a token minted here and one minted there are the same thing. */
+/** Matches `p4c hub token add`, so a token minted here and one minted there are the same thing. */
 const HUB_TOKEN_BYTES = 32;
 const isOrchestrationDispatchCommandError = Schema$1.is(OrchestrationDispatchCommandError);
 const nowIso$5 = Effect.map(DateTime.now, DateTime.formatIso);
@@ -39632,6 +40544,13 @@ const RPC_REQUIRED_SCOPE = /* @__PURE__ */ new Map([
 	[WS_METHODS.skillsPublish, AuthOrchestrationOperateScope],
 	[WS_METHODS.skillsPublishAll, AuthOrchestrationOperateScope],
 	[WS_METHODS.skillsUnpublish, AuthOrchestrationOperateScope],
+	[WS_METHODS.assetsRead, AuthOrchestrationReadScope],
+	[WS_METHODS.assetsSave, AuthOrchestrationOperateScope],
+	[WS_METHODS.assetsDelete, AuthOrchestrationOperateScope],
+	[WS_METHODS.mcpList, AuthOrchestrationReadScope],
+	[WS_METHODS.mcpSave, AuthOrchestrationOperateScope],
+	[WS_METHODS.mcpRemove, AuthOrchestrationOperateScope],
+	[WS_METHODS.mcpSetSecret, AuthOrchestrationOperateScope],
 	[WS_METHODS.serverGetSettings, AuthOrchestrationReadScope],
 	[WS_METHODS.serverUpdateSettings, AuthOrchestrationOperateScope],
 	[WS_METHODS.serverDiscoverSourceControl, AuthOrchestrationReadScope],
@@ -39742,7 +40661,8 @@ const makeWsRpcLayer = (currentSession, previewAutomationBroker) => WsRpcGroup.t
 	const lifecycleEvents = yield* ServerLifecycleEvents;
 	const serverSettings = yield* ServerSettingsService;
 	const hubLink = yield* HubLink;
-	const skillSync = yield* SkillSync;
+	const assetSync = yield* AssetSync;
+	const mcpRegistry = yield* McpRegistry;
 	const startup = yield* ServerRuntimeStartup;
 	const workspaceEntries = yield* WorkspaceEntries;
 	const workspaceFileSystem = yield* WorkspaceFileSystem;
@@ -40204,11 +41124,11 @@ const makeWsRpcLayer = (currentSession, previewAutomationBroker) => WsRpcGroup.t
 		}), { "rpc.aggregate": "tasks" }),
 		[WS_METHODS.tasksDelete]: ({ taskId }) => observeRpcEffect$1(WS_METHODS.tasksDelete, taskRepository.deleteById({ taskId }).pipe(Effect.catch(toTaskStoreError("tasks.delete")), Effect.as({})), { "rpc.aggregate": "tasks" }),
 		[WS_METHODS.subscribeTasks]: (_input) => observeRpcStreamEffect$1(WS_METHODS.subscribeTasks, Effect.succeed(taskRepository.streamWithSnapshot.pipe(Stream.catch((cause) => Stream.fromEffect(toTaskStoreError("tasks.subscribe")(cause))))), { "rpc.aggregate": "tasks" }),
-		[WS_METHODS.hubGetSyncStatus]: (_input) => observeRpcEffect$1(WS_METHODS.hubGetSyncStatus, skillSync.status, { "rpc.aggregate": "hub" }),
-		[WS_METHODS.hubConnect]: (input) => observeRpcEffect$1(WS_METHODS.hubConnect, hubLink.connect(input).pipe(Effect.mapError((cause) => new HubLinkError({ detail: cause.message })), Effect.andThen(skillSync.status)), { "rpc.aggregate": "hub" }),
-		[WS_METHODS.hubDisconnect]: (_input) => observeRpcEffect$1(WS_METHODS.hubDisconnect, hubLink.disconnect.pipe(Effect.mapError((cause) => new HubLinkError({ detail: cause.message })), Effect.andThen(skillSync.status)), { "rpc.aggregate": "hub" }),
-		[WS_METHODS.hubSetSyncMode]: ({ mode }) => observeRpcEffect$1(WS_METHODS.hubSetSyncMode, hubLink.setSyncMode(mode).pipe(Effect.mapError((cause) => new HubLinkError({ detail: cause.message })), Effect.andThen(skillSync.status)), { "rpc.aggregate": "hub" }),
-		[WS_METHODS.hubSetShareMode]: ({ mode }) => observeRpcEffect$1(WS_METHODS.hubSetShareMode, hubLink.setShareMode(mode).pipe(Effect.mapError((cause) => new HubLinkError({ detail: cause.message })), Effect.andThen(skillSync.status)), { "rpc.aggregate": "hub" }),
+		[WS_METHODS.hubGetSyncStatus]: (_input) => observeRpcEffect$1(WS_METHODS.hubGetSyncStatus, assetSync.status, { "rpc.aggregate": "hub" }),
+		[WS_METHODS.hubConnect]: (input) => observeRpcEffect$1(WS_METHODS.hubConnect, hubLink.connect(input).pipe(Effect.mapError((cause) => new HubLinkError({ detail: cause.message })), Effect.andThen(assetSync.status)), { "rpc.aggregate": "hub" }),
+		[WS_METHODS.hubDisconnect]: (_input) => observeRpcEffect$1(WS_METHODS.hubDisconnect, hubLink.disconnect.pipe(Effect.mapError((cause) => new HubLinkError({ detail: cause.message })), Effect.andThen(assetSync.status)), { "rpc.aggregate": "hub" }),
+		[WS_METHODS.hubSetSyncMode]: ({ mode }) => observeRpcEffect$1(WS_METHODS.hubSetSyncMode, hubLink.setSyncMode(mode).pipe(Effect.mapError((cause) => new HubLinkError({ detail: cause.message })), Effect.andThen(assetSync.status)), { "rpc.aggregate": "hub" }),
+		[WS_METHODS.hubSetShareMode]: ({ mode }) => observeRpcEffect$1(WS_METHODS.hubSetShareMode, hubLink.setShareMode(mode).pipe(Effect.mapError((cause) => new HubLinkError({ detail: cause.message })), Effect.andThen(assetSync.status)), { "rpc.aggregate": "hub" }),
 		[WS_METHODS.hubMintToken]: (_input) => observeRpcEffect$1(WS_METHODS.hubMintToken, Effect.gen(function* () {
 			const token = yield* crypto.randomBytes(HUB_TOKEN_BYTES).pipe(Effect.map((bytes) => Buffer.from(bytes).toString("base64url")), Effect.orDie);
 			return {
@@ -40218,28 +41138,49 @@ const makeWsRpcLayer = (currentSession, previewAutomationBroker) => WsRpcGroup.t
 		}), { "rpc.aggregate": "hub" }),
 		[WS_METHODS.skillsSync]: (_input) => observeRpcEffect$1(WS_METHODS.skillsSync, Effect.gen(function* () {
 			return {
-				report: yield* skillSync.run,
-				status: yield* skillSync.status
+				report: yield* assetSync.run,
+				status: yield* assetSync.status
 			};
 		}), { "rpc.aggregate": "skills" }),
-		[WS_METHODS.skillsPublish]: ({ name }) => observeRpcEffect$1(WS_METHODS.skillsPublish, Effect.gen(function* () {
+		[WS_METHODS.skillsPublish]: (ref) => observeRpcEffect$1(WS_METHODS.skillsPublish, Effect.gen(function* () {
 			return {
-				report: yield* skillSync.publish(name),
-				status: yield* skillSync.status
+				report: yield* assetSync.publish(ref),
+				status: yield* assetSync.status
 			};
 		}), { "rpc.aggregate": "skills" }),
 		[WS_METHODS.skillsPublishAll]: (_input) => observeRpcEffect$1(WS_METHODS.skillsPublishAll, Effect.gen(function* () {
 			return {
-				report: yield* skillSync.publishAll,
-				status: yield* skillSync.status
+				report: yield* assetSync.publishAll,
+				status: yield* assetSync.status
 			};
 		}), { "rpc.aggregate": "skills" }),
-		[WS_METHODS.skillsUnpublish]: ({ name }) => observeRpcEffect$1(WS_METHODS.skillsUnpublish, Effect.gen(function* () {
+		[WS_METHODS.skillsUnpublish]: (ref) => observeRpcEffect$1(WS_METHODS.skillsUnpublish, Effect.gen(function* () {
 			return {
-				report: yield* skillSync.unpublish(name),
-				status: yield* skillSync.status
+				report: yield* assetSync.unpublish(ref),
+				status: yield* assetSync.status
 			};
 		}), { "rpc.aggregate": "skills" }),
+		[WS_METHODS.assetsRead]: (ref) => observeRpcEffect$1(WS_METHODS.assetsRead, assetSync.read(ref), { "rpc.aggregate": "skills" }),
+		[WS_METHODS.assetsSave]: (input) => observeRpcEffect$1(WS_METHODS.assetsSave, Effect.gen(function* () {
+			return {
+				report: yield* assetSync.save(input),
+				status: yield* assetSync.status
+			};
+		}), { "rpc.aggregate": "skills" }),
+		[WS_METHODS.assetsDelete]: (input) => observeRpcEffect$1(WS_METHODS.assetsDelete, Effect.gen(function* () {
+			return {
+				report: yield* assetSync.deleteFromHub(input),
+				status: yield* assetSync.status
+			};
+		}), { "rpc.aggregate": "skills" }),
+		[WS_METHODS.mcpList]: (_input) => observeRpcEffect$1(WS_METHODS.mcpList, mcpRegistry.list.pipe(Effect.map((servers) => ({ servers }))), { "rpc.aggregate": "mcp" }),
+		[WS_METHODS.mcpSave]: ({ registration }) => observeRpcEffect$1(WS_METHODS.mcpSave, mcpRegistry.save(registration).pipe(Effect.andThen(mcpRegistry.list.pipe(Effect.map((servers) => ({ servers }))))), { "rpc.aggregate": "mcp" }),
+		[WS_METHODS.mcpRemove]: ({ name }) => observeRpcEffect$1(WS_METHODS.mcpRemove, mcpRegistry.remove(name).pipe(Effect.andThen(mcpRegistry.list.pipe(Effect.map((servers) => ({ servers }))))), { "rpc.aggregate": "mcp" }),
+		[WS_METHODS.mcpSetSecret]: ({ name, slot, value }) => observeRpcEffect$1(WS_METHODS.mcpSetSecret, mcpRegistry.setSecret({
+			name,
+			slot,
+			value
+		}).pipe(Effect.andThen(mcpRegistry.list.pipe(Effect.map((servers) => ({ servers }))))), { "rpc.aggregate": "mcp" }),
 		[WS_METHODS.serverGetSettings]: (_input) => observeRpcEffect$1(WS_METHODS.serverGetSettings, serverSettings.getSettings.pipe(Effect.map(redactServerSettingsForClient)), { "rpc.aggregate": "server" }),
 		[WS_METHODS.serverUpdateSettings]: ({ patch }) => observeRpcEffect$1(WS_METHODS.serverUpdateSettings, serverSettings.updateSettings(patch).pipe(Effect.map(redactServerSettingsForClient)), { "rpc.aggregate": "server" }),
 		[WS_METHODS.serverDiscoverSourceControl]: (_input) => observeRpcEffect$1(WS_METHODS.serverDiscoverSourceControl, sourceControlDiscovery.discover, { "rpc.aggregate": "server" }),
@@ -42440,7 +43381,7 @@ const makeOpenCodeRuntime = Effect.gen(function* () {
 	};
 });
 var OpenCodeRuntime = class extends Context.Service()("@p4code/cli/provider/opencodeRuntime") {};
-const OpenCodeRuntimeLive = Layer.effect(OpenCodeRuntime, makeOpenCodeRuntime).pipe(Layer.provide(layer$66));
+const OpenCodeRuntimeLive = Layer.effect(OpenCodeRuntime, makeOpenCodeRuntime).pipe(Layer.provide(layer$67));
 //#endregion
 //#region src/textGeneration/TextGenerationUtils.ts
 const isTextGenerationError$2 = Schema$1.is(TextGenerationError);
@@ -43432,14 +44373,15 @@ const checkClaudeProviderStatus = Effect.fn("checkClaudeProviderStatus")(functio
 	const versionProbe = yield* runClaudeCommand(claudeSettings, ["--version"], resolvedEnvironment).pipe(Effect.timeoutOption(DEFAULT_TIMEOUT_MS), Effect.result);
 	if (Result.isFailure(versionProbe)) {
 		const error = versionProbe.failure;
-		yield* Effect.logWarning("Claude Agent CLI health check failed.", { errorTag: error._tag });
+		const missing = isCommandMissingCause(error);
+		yield* (missing ? Effect.logDebug : Effect.logWarning)("Claude Agent CLI health check failed.", { errorTag: error._tag });
 		return buildServerProvider({
 			presentation: CLAUDE_PRESENTATION,
 			enabled: claudeSettings.enabled,
 			checkedAt,
 			models: allModels,
 			probe: {
-				installed: !isCommandMissingCause(error),
+				installed: !missing,
 				version: null,
 				status: "error",
 				auth: { status: "unknown" },
@@ -45861,6 +46803,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			...ultracode ? { ultracode: true } : {}
 		};
 		const mcpSession = readMcpProviderSession(input.threadId);
+		const externalMcpServers = options?.resolveMcpServers === void 0 ? {} : yield* options.resolveMcpServers;
 		const queryOptions = {
 			...input.cwd ? { cwd: input.cwd } : {},
 			...apiModelId ? { model: apiModelId } : {},
@@ -45881,11 +46824,14 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			env: claudeEnvironment,
 			...input.cwd ? { additionalDirectories: [input.cwd] } : {},
 			...Object.keys(extraArgs).length > 0 ? { extraArgs } : {},
-			...mcpSession ? { mcpServers: { "p4-code": {
-				type: "http",
-				url: mcpSession.endpoint,
-				headers: { Authorization: mcpSession.authorizationHeader }
-			} } } : {}
+			...mcpSession || Object.keys(externalMcpServers).length > 0 ? { mcpServers: {
+				...externalMcpServers,
+				...mcpSession ? { "p4-code": {
+					type: "http",
+					url: mcpSession.endpoint,
+					headers: { Authorization: mcpSession.authorizationHeader }
+				} } : {}
+			} } : {}
 		};
 		yield* Effect.annotateCurrentSpan({
 			"provider.kind": PROVIDER$5,
@@ -46345,6 +47291,7 @@ const ClaudeDriver = {
 		const adapter = yield* makeClaudeAdapter(effectiveConfig, {
 			instanceId,
 			environment: processEnv,
+			resolveMcpServers: (yield* McpRegistry).resolveForSession,
 			...eventLoggers.native ? { nativeEventLogger: eventLoggers.native } : {}
 		});
 		const textGeneration = yield* makeClaudeTextGeneration(effectiveConfig, processEnv);
@@ -72617,14 +73564,15 @@ const checkCursorProviderStatus = Effect.fn("checkCursorProviderStatus")(functio
 	const aboutProbe = yield* runCursorAboutCommand(cursorSettings, environment).pipe(Effect.timeoutOption(ABOUT_TIMEOUT_MS), Effect.result);
 	if (Result.isFailure(aboutProbe)) {
 		const error = aboutProbe.failure;
-		yield* Effect.logWarning("Cursor Agent CLI health check failed.", { errorTag: error._tag });
+		const missing = isCommandMissingCause(error);
+		yield* (missing ? Effect.logDebug : Effect.logWarning)("Cursor Agent CLI health check failed.", { errorTag: error._tag });
 		return buildServerProvider({
 			presentation: CURSOR_PRESENTATION,
 			enabled: cursorSettings.enabled,
 			checkedAt,
 			models: fallbackModels,
 			probe: {
-				installed: !isCommandMissingCause(error),
+				installed: !missing,
 				version: null,
 				status: "error",
 				auth: { status: "unknown" },
@@ -75261,14 +76209,15 @@ const checkGrokProviderStatus = Effect.fn("checkGrokProviderStatus")(function* (
 	const versionResult = yield* runGrokVersionCommand(grokSettings, environment).pipe(Effect.timeoutOption(VERSION_PROBE_TIMEOUT_MS), Effect.result);
 	if (Result.isFailure(versionResult)) {
 		const error = versionResult.failure;
-		yield* Effect.logWarning("Grok CLI health check failed.", { errorTag: error._tag });
+		const missing = isCommandMissingCause(error);
+		yield* (missing ? Effect.logDebug : Effect.logWarning)("Grok CLI health check failed.", { errorTag: error._tag });
 		return buildServerProvider({
 			presentation: GROK_PRESENTATION,
 			enabled: grokSettings.enabled,
 			checkedAt,
 			models: fallbackModels,
 			probe: {
-				installed: !isCommandMissingCause(error),
+				installed: !missing,
 				version: null,
 				status: "error",
 				auth: { status: "unknown" },
@@ -81518,16 +82467,16 @@ const SourceControlRepositoryServiceLayerLive = layer$4.pipe(Layer.provideMerge(
 const ReviewLayerLive = layer$9.pipe(Layer.provideMerge(layer$37), Layer.provideMerge(VcsDriverRegistryLayerLive));
 const VcsLayerLive = Layer.empty.pipe(Layer.provideMerge(layer$36), Layer.provideMerge(VcsDriverRegistryLayerLive), Layer.provideMerge(layer$10.pipe(Layer.provide(VcsDriverRegistryLayerLive))), Layer.provideMerge(GitWorkflowLayerLive), Layer.provideMerge(ReviewLayerLive), Layer.provideMerge(SourceControlRepositoryServiceLayerLive), Layer.provideMerge(layer$11.pipe(Layer.provide(GitWorkflowLayerLive))));
 const CheckpointingLayerLive = Layer.empty.pipe(Layer.provideMerge(layer$33), Layer.provideMerge(layer$34.pipe(Layer.provide(VcsDriverRegistryLayerLive))));
-const PortScannerLayerLive = layer$31.pipe(Layer.provide(layer$57));
+const PortScannerLayerLive = layer$31.pipe(Layer.provide(layer$52));
 const TerminalLayerLive = layer$30.pipe(Layer.provide(PtyAdapterLive), Layer.provide(PortScannerLayerLive));
 const PreviewLayerLive = Layer.empty.pipe(Layer.provideMerge(layer$28), Layer.provideMerge(PortScannerLayerLive));
 const WorkspaceEntriesLayerLive = layer$26.pipe(Layer.provide(layer$42));
 const WorkspaceFileSystemLayerLive = layer$25.pipe(Layer.provide(layer$42), Layer.provide(WorkspaceEntriesLayerLive));
 const WorkspaceLayerLive = Layer.mergeAll(layer$42, WorkspaceEntriesLayerLive, WorkspaceFileSystemLayerLive);
 const ProjectFaviconResolverLayerLive = layer$40.pipe(Layer.provide(layer$42), Layer.provide(layer$41));
-const AuthLayerLive = layer$58.pipe(Layer.provideMerge(PersistenceLayerLive), Layer.provide(layer$62));
+const AuthLayerLive = layer$59.pipe(Layer.provideMerge(PersistenceLayerLive), Layer.provide(layer$63));
 const ProviderRuntimeLayerLive = ProviderSessionReaperLive.pipe(Layer.provideMerge(ProviderLayerLive), Layer.provideMerge(OrchestrationLayerLive));
-const RuntimeDependenciesLive = ReactorLayerLive.pipe(Layer.provideMerge(CheckpointingLayerLive), Layer.provideMerge(SourceControlProviderRegistryLayerLive), Layer.provideMerge(GitLayerLive), Layer.provideMerge(VcsLayerLive), Layer.provideMerge(ProviderRuntimeLayerLive), Layer.provideMerge(Layer.mergeAll(TerminalLayerLive, PreviewLayerLive)), Layer.provideMerge(PersistenceLayerLive), Layer.provideMerge(layer$50), Layer.provideMerge(ProviderRegistryLive), Layer.provideMerge(ProviderInstanceRegistryHydrationLive), Layer.provideMerge(ProviderEventLoggersLive), Layer.provideMerge(OpenCodeRuntimeLive), Layer.provideMerge(layer$55.pipe(Layer.provide(layer$62))), Layer.provideMerge(WorkspaceLayerLive), Layer.provideMerge(ProjectFaviconResolverLayerLive), Layer.provideMerge(layer$51), Layer.provideMerge(layer$44), Layer.provideMerge(AuthLayerLive), Layer.provideMerge(layer$62)).pipe(Layer.provideMerge(layer$8), Layer.provideMerge(layer$7), Layer.provideMerge(layer$6), Layer.provideMerge(layer$47), Layer.provideMerge(layer$49), Layer.provideMerge(layer$48), Layer.provide(layer$66));
+const RuntimeDependenciesLive = ReactorLayerLive.pipe(Layer.provideMerge(CheckpointingLayerLive), Layer.provideMerge(SourceControlProviderRegistryLayerLive), Layer.provideMerge(GitLayerLive), Layer.provideMerge(VcsLayerLive), Layer.provideMerge(ProviderRuntimeLayerLive), Layer.provideMerge(Layer.mergeAll(TerminalLayerLive, PreviewLayerLive)), Layer.provideMerge(PersistenceLayerLive), Layer.provideMerge(layer$50), Layer.provideMerge(ProviderRegistryLive), Layer.provideMerge(ProviderInstanceRegistryHydrationLive), Layer.provideMerge(ProviderEventLoggersLive), Layer.provideMerge(OpenCodeRuntimeLive), Layer.provideMerge(layer$57.pipe(Layer.provide(layer$63))), Layer.provideMerge(WorkspaceLayerLive), Layer.provideMerge(ProjectFaviconResolverLayerLive), Layer.provideMerge(layer$51), Layer.provideMerge(layer$44), Layer.provideMerge(AuthLayerLive), Layer.provideMerge(layer$56), Layer.provideMerge(layer$63)).pipe(Layer.provideMerge(layer$8), Layer.provideMerge(layer$7), Layer.provideMerge(layer$6), Layer.provideMerge(layer$47), Layer.provideMerge(layer$49), Layer.provideMerge(layer$48), Layer.provide(layer$67));
 /**
 * Hub asset sync.
 *
@@ -81535,8 +82484,8 @@ const RuntimeDependenciesLive = ReactorLayerLive.pipe(Layer.provideMerge(Checkpo
 * not-configured shape, and every call reports that rather than failing — so
 * this costs a server with no hub nothing but a layer.
 */
-const SkillSyncLive = layer$52.pipe(Layer.provideMerge(layer$53), Layer.provideMerge(layer$54));
-const RuntimeServicesLive = layer$43.pipe(Layer.provideMerge(SkillSyncLive), Layer.provideMerge(RuntimeDependenciesLive));
+const AssetSyncLive = layer$53.pipe(Layer.provideMerge(layer$54), Layer.provideMerge(layer$55));
+const RuntimeServicesLive = layer$43.pipe(Layer.provideMerge(AssetSyncLive), Layer.provideMerge(RuntimeDependenciesLive));
 const makeRoutesLayer = Layer.mergeAll(Layer.mergeAll(HttpApiBuilder.layer(EnvironmentHttpApi).pipe(Layer.provide(authHttpApiLayer), Layer.provide(orchestrationHttpApiLayer), Layer.provide(serverEnvironmentHttpApiLayer), Layer.provide(environmentAuthenticatedAuthLayer)), otlpTracesProxyRouteLayer, assetRouteLayer, staticAndDevRouteLayer, websocketRpcRouteLayer), layer.pipe(Layer.provide(layer$2))).pipe(Layer.provide(TaskRepositoryLive.pipe(Layer.provide(PersistenceLayerLive))), Layer.provide(ProjectionProjectRepositoryLive.pipe(Layer.provide(PersistenceLayerLive))), Layer.provide(layer$29), Layer.provide(layer$45), Layer.provide(browserApiCorsLayer), Layer.provide(httpCompressionLayer));
 const makeServerLayer = Layer.unwrap(Effect.gen(function* () {
 	const config = yield* ServerConfig$1;
@@ -81601,7 +82550,7 @@ const bootServiceLayer = (config) => layer$46({
 	baseDir: config.baseDir,
 	logsDir: config.logsDir,
 	cliVersion: version
-}).pipe(Layer.provide(layer$57));
+}).pipe(Layer.provide(layer$52));
 /** Install, update, or repair the service using the CLI version running this command. */
 const reconcileService = Effect.fn("cli.service.reconcile")(function* () {
 	const service = yield* BootService;
@@ -81633,37 +82582,26 @@ function formatReconcileSuccess(input) {
 }
 function formatServiceStatus(status, cliVersion) {
 	if (!status.supported) return "P4Code service\n  Status: unavailable on this machine\n  Supported on: Linux with systemd, macOS with launchd";
-	if (!status.installed) return "P4Code service\n  Status: not installed\n  Next: Run `p4 service install`.";
+	if (!status.installed) return "P4Code service\n  Status: not installed\n  Next: Run `p4c service install`.";
 	return [
 		"P4Code service",
 		`  Status: ${status.current ? `installed · @p4code/cli@${cliVersion}` : "needs an update or repair"}`,
 		`  Unit: ${status.unitPath}`,
 		`  Data: ${status.baseDir}`,
 		`  Logs: ${status.logPath}`,
-		...status.current ? [] : ["  Next: Run `p4 service update`."]
+		...status.current ? [] : ["  Next: Run `p4c service update`."]
 	].join("\n");
 }
 const runServiceCommand = Effect.fn("cli.service.run")(function* (flags, run) {
 	const config = yield* resolveCliAuthConfig(flags, yield* GlobalFlag.LogLevel);
 	const baseDirNotice = yield* describeNonDefaultBaseDir(config.baseDir);
 	if (baseDirNotice !== null) yield* Console.error(baseDirNotice);
-	return yield* run.pipe(Effect.tapError((error) => isBootServiceCommandError(error) ? BootService.pipe(Effect.flatMap((service) => Console.error(`Details: ${service.logPath}`))) : Effect.void), Effect.provide(Layer.mergeAll(bootServiceLayer(config), layer$57)));
-});
-/**
-* Runs on every `service install` and `service update`, including the
-* already-current paths. Gating it on "the unit changed" meant a host whose
-* service was already installed — the common case after the first setup — never
-* got completions at all.
-*/
-const reportZshCompletionInstall = Effect.gen(function* () {
-	const completion = yield* installZshCompletion().pipe(Effect.orElseSucceed(() => null));
-	if (completion !== null) yield* Console.log(formatZshCompletionInstall(completion));
+	return yield* run.pipe(Effect.tapError((error) => isBootServiceCommandError(error) ? BootService.pipe(Effect.flatMap((service) => Console.error(`Details: ${service.logPath}`))) : Effect.void), Effect.provide(Layer.mergeAll(bootServiceLayer(config), layer$52)));
 });
 const serviceInstallCommand = Command.make("install", projectLocationFlags).pipe(Command.withDescription("Install P4Code as a background service for this user."), Command.withHandler((flags) => runServiceCommand(flags, Effect.gen(function* () {
 	const result = yield* reconcileService();
 	if (!result.changed) {
 		yield* Console.log(`P4Code service is already installed with @p4code/cli@${version}.`);
-		yield* reportZshCompletionInstall;
 		return;
 	}
 	yield* Console.log(formatReconcileSuccess({
@@ -81672,14 +82610,12 @@ const serviceInstallCommand = Command.make("install", projectLocationFlags).pipe
 		cliVersion: version,
 		platform: yield* HostProcessPlatform
 	}));
-	yield* reportZshCompletionInstall;
 }))));
 const serviceUpdateCommand = Command.make("update", projectLocationFlags).pipe(Command.withDescription("Update or repair the background service so it runs this CLI build, then restart it."), Command.withHandler((flags) => runServiceCommand(flags, Effect.gen(function* () {
 	const result = yield* reconcileService();
 	if (!result.changed) {
 		yield* (yield* BootService).restart;
 		yield* Console.log(`Restarted the P4Code service on @p4code/cli@${version}.`);
-		yield* reportZshCompletionInstall;
 		return;
 	}
 	yield* Console.log(formatReconcileSuccess({
@@ -81688,7 +82624,6 @@ const serviceUpdateCommand = Command.make("update", projectLocationFlags).pipe(C
 		cliVersion: version,
 		platform: yield* HostProcessPlatform
 	}));
-	yield* reportZshCompletionInstall;
 }))));
 const serviceUninstallCommand = Command.make("uninstall", projectLocationFlags).pipe(Command.withDescription("Stop and remove the P4Code background service."), Command.withHandler((flags) => runServiceCommand(flags, Effect.gen(function* () {
 	const removed = yield* (yield* BootService).uninstall;
@@ -81721,7 +82656,7 @@ const serviceCommand = Command.make("service").pipe(Command.withDescription("Man
 ]));
 //#endregion
 //#region src/bin.ts
-const CliRuntimeLayer = Layer.mergeAll(NodeServices.layer, layer$66, FetchHttpClient.layer);
+const CliRuntimeLayer = Layer.mergeAll(NodeServices.layer, layer$67, FetchHttpClient.layer);
 /**
 * Prints an update reminder before dispatching, at most once a day.
 *
@@ -81737,21 +82672,60 @@ const reportUpdateAvailable = Effect.gen(function* () {
 		stateDir: paths.stateDir
 	});
 	if (reminder !== null) yield* Console.error(reminder);
-	const completionsHint = yield* resolveMissingCompletionsHint({ stateDir: paths.stateDir });
-	if (completionsHint !== null) yield* Console.error(completionsHint);
 }).pipe(Effect.ignore);
-const makeCli = () => Command.make("p4", { ...sharedServerCommandFlags }).pipe(Command.withDescription("Run the P4Code server."), Command.withHandler((flags) => runServerCommand(flags)), Command.withSubcommands([
+/**
+* `p4c`, not `p4`.
+*
+* Perforce owns `p4`, and zsh ships `_perforce` claiming it with
+* `#compdef p4 p4d`. Fighting for the name cost a completion installer, a
+* per-run "your completions are missing" hint, and an argument about which
+* fpath directory `compinit` would prefer — all of it maintenance for a
+* conflict we chose. Taking a name nothing else claims deletes the problem
+* rather than managing it.
+*/
+const makeCli = () => Command.make("p4c", { ...sharedServerCommandFlags }).pipe(Command.withDescription("Run the P4Code server."), Command.withHandler((flags) => runServerCommand(flags)), Command.withSubcommands([
 	startCommand,
 	serveCommand,
 	authCommand,
-	completionsCommand,
 	hubCommand,
+	mcpCommand,
+	memoryCommand,
 	projectCommand,
 	serviceCommand,
 	skillsCommand
 ]));
 const cli = makeCli();
-if (import.meta.main) reportUpdateAvailable.pipe(Effect.andThen(Command.run(cli, { version })), Effect.scoped, Effect.provide(CliRuntimeLayer), NodeRuntime.runMain);
+/**
+* A one-line message for an expected failure, without the stack.
+*
+* Every domain error here is a `Schema.TaggedErrorClass` with a `message`
+* getter written for a person — "Background setup failed while loading the
+* service (exit code 5)" — and the surrounding command has usually already
+* printed the log path that holds the detail. Appending twenty frames of
+* bundled `dist/bin.mjs` to that adds nothing anybody can act on.
+*/
+const describeExpectedFailure = (error) => {
+	const message = error?.message;
+	if (typeof message === "string" && message.trim().length > 0) return message;
+	return String(error);
+};
+/**
+* Expected failures print their message; defects keep their stack.
+*
+* The distinction is Effect's own, and it is the right one: a typed failure is
+* a condition the code anticipated and described, so a trace through a
+* bundled file is noise. A defect is a bug, and there the trace is the only
+* thing worth having.
+*
+* `CliError` is re-raised rather than handled, because `runMain` already
+* renders usage and validation failures better than a bare message would —
+* catching them here would replace "unknown flag --foo, did you mean --force"
+* with one flat line.
+*/
+const reportFailuresWithoutStacks = (effect) => effect.pipe(Effect.catchIf((error) => !CliError.isCliError(error), (error) => Console.error(describeExpectedFailure(error)).pipe(Effect.andThen(Effect.sync(() => {
+	process.exitCode = 1;
+})))));
+if (import.meta.main) reportUpdateAvailable.pipe(Effect.andThen(Command.run(cli, { version })), reportFailuresWithoutStacks, Effect.scoped, Effect.provide(CliRuntimeLayer), NodeRuntime.runMain);
 //#endregion
 export { cli, makeCli };