@agentxm/workspace-state 0.28.4 → 0.28.6

package/dist/src/workspace/desired-state-graph.js

@@ -13,6 +13,7 @@ import { configuredAuthoredDirectory } from "./layout.js";
 import { SETTINGS_FILENAME } from "@agentxm/extension-model/unstable/workspace-files";
 import { ACQUIRED_EXTENSIONS_DIR } from "./constants.js";
 import { intersectVersionConstraints } from "@agentxm/extension-model/unstable/version-constraints";
+import { mcpRegistryResolutionKey } from "./mcp-source-identity.js";
 export const isInlineDesiredExtension = (node) => node.authority === "inline";
 export const isSourcedDesiredExtension = (node) => node.authority !== "inline";
 const nodeKey = (type, name) => `${type}:${name}`;
@@ -26,7 +27,17 @@ const registryLocator = (source) => {
     const ref = source.slice(separator + 1);
     return ref.startsWith("@") ? { sourceName: source.slice(0, separator), ref } : undefined;
 };
-const sourceIdentity = (type, name, source, settings) => {
+const withVersionConstraint = (source, constraint) => {
+    const locator = registryLocator(source);
+    if (locator === undefined)
+        return source;
+    const parsed = parseRegistrySourceRef(locator.ref);
+    if (parsed === undefined)
+        return source;
+    const prefix = source.startsWith("@") ? "" : `${locator.sourceName}:`;
+    return `${prefix}${parsed.owner}/${parsed.type}/${parsed.name}@${constraint}`;
+};
+const sourceIdentity = (type, name, source, settings, registryAuthorities) => {
     if (isWorkspaceSourceLocator(source)) {
         return settings.owner === undefined
             ? { identity: source }
@@ -35,8 +46,15 @@ const sourceIdentity = (type, name, source, settings) => {
     const locator = registryLocator(source);
     const parsed = locator === undefined ? undefined : parseRegistrySourceRef(locator.ref);
     if (parsed !== undefined && parsed.type === toExtensionTypePlural(type)) {
+        const registryAuthority = locator === undefined ? undefined : registryAuthorities[locator.sourceName];
         return {
-            identity: `${parsed.owner}/${parsed.type}/${parsed.name}`,
+            identity: type === "mcp-server" && registryAuthority !== undefined
+                ? mcpRegistryResolutionKey({
+                    authority: registryAuthority,
+                    owner: parsed.owner,
+                    name: parsed.name,
+                })
+                : `${parsed.owner}/${parsed.type}/${parsed.name}`,
             ...(parsed.versionRange === undefined ? {} : { constraint: parsed.versionRange }),
         };
     }
@@ -83,6 +101,7 @@ export const collectDesiredConstraintContributors = (_path, origins) => origins
                 source: "settings",
                 range: origin.constraint,
                 location: SETTINGS_FILENAME,
+                ...(origin.localName === undefined ? {} : { localName: origin.localName }),
             },
         ];
     }
@@ -113,7 +132,7 @@ const parsePackManifest = (raw) => {
     const decoded = Schema.decodeUnknownResult(PackManifestSchema)(parsed);
     return Result.isSuccess(decoded) ? decoded.success : undefined;
 };
-export const buildDesiredStateGraph = ({ baseDir, settings, layout, prospectivePacks = [], }) => Effect.gen(function* () {
+export const buildDesiredStateGraph = ({ baseDir, settings, layout, prospectivePacks = [], registryAuthorities = {}, }) => Effect.gen(function* () {
     const fs = yield* FileSystem.FileSystem;
     const path = yield* Path.Path;
     const candidates = [];
@@ -124,7 +143,7 @@ export const buildDesiredStateGraph = ({ baseDir, settings, layout, prospectiveP
             const bundled = type === "skill" && entry.origin === "bundled";
             const identity = bundled
                 ? { identity: `bundled:@agentxm/skills/${name}` }
-                : sourceIdentity(type, name, entry.source, settings);
+                : sourceIdentity(type, name, entry.source, settings, registryAuthorities);
             if (!bundled && isWorkspaceSourceLocator(entry.source) && settings.owner === undefined) {
                 problems.push({ type: "workspace-owner-missing", extensionType: type, name });
             }
@@ -138,6 +157,7 @@ export const buildDesiredStateGraph = ({ baseDir, settings, layout, prospectiveP
                 ...(identity.constraint === undefined ? {} : { constraint: identity.constraint }),
                 origin: {
                     type: "settings",
+                    localName: name,
                     authority: "sourced",
                     source: entry.source,
                     enabled: entry.enabled,
@@ -155,11 +175,16 @@ export const buildDesiredStateGraph = ({ baseDir, settings, layout, prospectiveP
                 identity: `@workspace/mcps/${name}`,
                 authority: "inline",
                 enabled: entry.enabled,
-                origin: { type: "settings", authority: "inline", enabled: entry.enabled },
+                origin: {
+                    type: "settings",
+                    localName: name,
+                    authority: "inline",
+                    enabled: entry.enabled,
+                },
             });
             continue;
         }
-        const identity = sourceIdentity("mcp-server", name, entry.source, settings);
+        const identity = sourceIdentity("mcp-server", name, entry.source, settings, registryAuthorities);
         if (isWorkspaceSourceLocator(entry.source) && settings.owner === undefined) {
             problems.push({ type: "workspace-owner-missing", extensionType: "mcp-server", name });
         }
@@ -173,6 +198,7 @@ export const buildDesiredStateGraph = ({ baseDir, settings, layout, prospectiveP
             ...(identity.constraint === undefined ? {} : { constraint: identity.constraint }),
             origin: {
                 type: "settings",
+                localName: name,
                 authority: "sourced",
                 source: entry.source,
                 enabled: entry.enabled,
@@ -207,6 +233,7 @@ export const buildDesiredStateGraph = ({ baseDir, settings, layout, prospectiveP
             ...(identity.constraint === undefined ? {} : { constraint: identity.constraint }),
             origin: {
                 type: "settings",
+                localName: identity.name,
                 authority: "sourced",
                 source: entry.source,
                 enabled: entry.enabled !== false,
@@ -267,10 +294,18 @@ export const buildDesiredStateGraph = ({ baseDir, settings, layout, prospectiveP
             const parsed = parseExtensionFqnParts(fqn);
             if (parsed === undefined || parsed.type === "pack")
                 continue;
+            const dependencyIdentity = parsed.type === "mcp-server" &&
+                registryAuthorities[configuredRegistrySource] !== undefined
+                ? mcpRegistryResolutionKey({
+                    authority: registryAuthorities[configuredRegistrySource],
+                    owner: parsed.owner,
+                    name: parsed.name,
+                })
+                : `${parsed.owner}/${toExtensionTypePlural(parsed.type)}/${parsed.name}`;
             candidates.push({
                 type: parsed.type,
                 name: parsed.name,
-                identity: `${parsed.owner}/${toExtensionTypePlural(parsed.type)}/${parsed.name}`,
+                identity: dependencyIdentity,
                 authority: "sourced",
                 source: `${fqn}@${constraint}`,
                 enabled: entry.enabled !== false,
@@ -344,7 +379,21 @@ export const buildDesiredStateGraph = ({ baseDir, settings, layout, prospectiveP
             origins,
         });
     }
+    const mcpClosuresByIdentity = new Map();
     for (const node of nodes.values()) {
+        if (node.type === "mcp-server" && isSourcedDesiredExtension(node)) {
+            const existing = mcpClosuresByIdentity.get(node.identity);
+            mcpClosuresByIdentity.set(node.identity, {
+                identity: node.identity,
+                localNames: [...(existing?.localNames ?? []), node.name].sort(),
+                constraints: [
+                    ...(existing?.constraints ?? []),
+                    ...node.constraints.filter((constraint) => !(existing?.constraints ?? []).includes(constraint)),
+                ],
+                origins: [...(existing?.origins ?? []), ...node.origins],
+            });
+            continue;
+        }
         if (intersectVersionConstraints(node.constraints) === undefined) {
             problems.push({
                 type: "constraint-conflict",
@@ -355,16 +404,36 @@ export const buildDesiredStateGraph = ({ baseDir, settings, layout, prospectiveP
             });
         }
     }
+    const mcpSourceClosures = [...mcpClosuresByIdentity.values()].sort((left, right) => left.identity.localeCompare(right.identity));
+    for (const closure of mcpSourceClosures) {
+        if (intersectVersionConstraints(closure.constraints) === undefined) {
+            problems.push({
+                type: "constraint-conflict",
+                extensionType: "mcp-server",
+                name: closure.localNames.join(", "),
+                constraints: closure.constraints,
+                contributors: collectDesiredConstraintContributors(path, closure.origins),
+            });
+        }
+    }
     const typeOrder = new Map(extensionTypes.map((type, index) => [type, index]));
     const orderedNodes = [...nodes.values()]
         .map((node) => {
         if (isInlineDesiredExtension(node))
             return node;
-        const constraint = intersectVersionConstraints(node.constraints);
+        const constraints = node.type === "mcp-server"
+            ? (mcpClosuresByIdentity.get(node.identity)?.constraints ?? node.constraints)
+            : node.constraints;
+        const constraint = intersectVersionConstraints(constraints);
         return {
             ...node,
-            source: node.identity.startsWith("@") && node.constraints.length > 0 && constraint !== undefined
-                ? `${node.identity}@${constraint}`
+            constraints,
+            source: constraints.length > 0 && constraint !== undefined
+                ? node.type === "mcp-server"
+                    ? withVersionConstraint(node.source, constraint)
+                    : node.identity.startsWith("@")
+                        ? `${node.identity}@${constraint}`
+                        : node.source
                 : node.source,
         };
     })
@@ -378,6 +447,7 @@ export const buildDesiredStateGraph = ({ baseDir, settings, layout, prospectiveP
     return {
         complete: problems.length === 0,
         nodes: orderedNodes,
+        mcpSourceClosures,
         problems,
     };
 });

package/dist/src/workspace/mcp-entry-semantics.d.ts

@@ -1,17 +1,14 @@
 /**
  * Settings-semantics predicates for MCP server entries.
  *
- * Pure derivations over workspace-owned MCP entry shapes: per-agent targeting
- * of a configured settings entry, and AXM ownership/provenance metadata
- * embedded in agent-native MCP config entries.
+ * Pure derivations over workspace-owned MCP entry shapes: AXM
+ * ownership/provenance metadata embedded in agent-native MCP config entries.
  *
  * @experimental This API is unstable and may change without notice.
  * @packageDocumentation
  */
 import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
-import type { McpServerEntry } from "../settings/schema.js";
-export declare const isMcpServerApplicableToAgent: (entry: McpServerEntry, agentId: string) => boolean;
 export declare const AXM_MCP_METADATA_KEY = "x-axm";
 export declare const AxmMcpMetadataSchema: Schema.Union<readonly [Schema.Struct<{
     readonly v: Schema.Literal<1>;

package/dist/src/workspace/mcp-entry-semantics.js

@@ -1,16 +1,14 @@
 /**
  * Settings-semantics predicates for MCP server entries.
  *
- * Pure derivations over workspace-owned MCP entry shapes: per-agent targeting
- * of a configured settings entry, and AXM ownership/provenance metadata
- * embedded in agent-native MCP config entries.
+ * Pure derivations over workspace-owned MCP entry shapes: AXM
+ * ownership/provenance metadata embedded in agent-native MCP config entries.
  *
  * @experimental This API is unstable and may change without notice.
  * @packageDocumentation
  */
 import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
-export const isMcpServerApplicableToAgent = (entry, agentId) => entry.agents === undefined || entry.agents.some((candidate) => candidate === agentId);
 export const AXM_MCP_METADATA_KEY = "x-axm";
 const ResolvableSourceTypeSchema = Schema.Literals([
     "github",

package/dist/src/workspace/mcp-source-identity.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Canonical identity for one accepted MCP source-resolution closure.
+ *
+ * Connection names deliberately do not participate: several local MCP
+ * connections may share this identity and therefore one accepted resolution.
+ */
+import type { Handle } from "@agentxm/extension-model/unstable/extensions/handle";
+import type { ExtensionName } from "@agentxm/extension-model/unstable/extensions/common";
+import type { McpServerLockEntry } from "../lockfile/schema.js";
+export declare const mcpRegistryResolutionKey: (args: {
+    readonly authority: URL | string;
+    readonly owner: Handle | string;
+    readonly name: ExtensionName | string;
+}) => string;
+/** Deterministic lock-map key for every currently accepted MCP source class. */
+export declare const mcpResolutionKey: (entry: McpServerLockEntry) => string;
+//# sourceMappingURL=mcp-source-identity.d.ts.map

package/dist/src/workspace/mcp-source-identity.js

@@ -0,0 +1,40 @@
+/**
+ * Canonical identity for one accepted MCP source-resolution closure.
+ *
+ * Connection names deliberately do not participate: several local MCP
+ * connections may share this identity and therefore one accepted resolution.
+ */
+const normalizeAuthority = (authority) => {
+    const raw = authority instanceof URL ? authority.href : authority;
+    try {
+        const normalized = new URL(raw).href;
+        return normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+    }
+    catch {
+        return raw.endsWith("/") ? raw.slice(0, -1) : raw;
+    }
+};
+const encodeIdentityPart = (value) => encodeURIComponent(value);
+export const mcpRegistryResolutionKey = (args) => `registry:${encodeIdentityPart(normalizeAuthority(args.authority))}:${args.owner}/mcps/${args.name}`;
+/** Deterministic lock-map key for every currently accepted MCP source class. */
+export const mcpResolutionKey = (entry) => {
+    switch (entry.type) {
+        case "registry":
+            return mcpRegistryResolutionKey({
+                authority: entry.endpoint,
+                owner: entry.owner,
+                name: entry.name,
+            });
+        case "github":
+        case "gitlab":
+        case "bitbucket":
+            return `${entry.type}:${encodeIdentityPart(normalizeAuthority(entry.endpoint))}:${entry.owner}/${entry.repo}:${entry.packageOwner ?? ""}/mcps/${entry.packageName}`;
+        case "azurerepos":
+            return `azurerepos:${encodeIdentityPart(normalizeAuthority(entry.endpoint))}:${entry.organization}/${entry.project}/${entry.repo}:${entry.packageOwner ?? ""}/mcps/${entry.packageName}`;
+        case "git":
+            return `git:${encodeIdentityPart(normalizeAuthority(entry.url))}:${entry.packageOwner ?? ""}/mcps/${entry.packageName}`;
+        case "local":
+            return `local:${encodeIdentityPart(entry.path)}:${entry.packageOwner ?? ""}/mcps/${entry.packageName}`;
+    }
+};
+//# sourceMappingURL=mcp-source-identity.js.map

package/dist/src/workspace/read-model/__fixtures__/builder.js

@@ -362,7 +362,7 @@ const validSettingsContents = {
     skills: { "managed-tool": { source: "github:owner/repo", enabled: true } },
 };
 const validLockfileContents = {
-    lockfileVersion: 6,
+    lockfileVersion: 7,
     skills: {
         "managed-tool": {
             type: "github",

package/dist/src/workspace/read-model/errors.d.ts

@@ -59,8 +59,18 @@ export declare class LockfileDecodeError extends LockfileDecodeError_base<{
     readonly raw: unknown;
 }> {
 }
-/** Lockfile-read failure union (IO, parse, decode). */
-export type LockfileReadError = LockfileIoError | LockfileParseError | LockfileDecodeError;
+declare const LockfileVersionUnsupported_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "LockfileVersionUnsupported";
+} & Readonly<A>;
+/** A syntactically valid lockfile declares a version this CLI cannot read. */
+export declare class LockfileVersionUnsupported extends LockfileVersionUnsupported_base<{
+    readonly path: string;
+    readonly observedVersion: number;
+    readonly supportedVersion: number;
+}> {
+}
+/** Lockfile-read failure union (IO, parse, decode, unsupported version). */
+export type LockfileReadError = LockfileIoError | LockfileParseError | LockfileDecodeError | LockfileVersionUnsupported;
 declare const WorkspaceRootEscape_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
     readonly _tag: "WorkspaceRootEscape";
 } & Readonly<A>;

package/dist/src/workspace/read-model/errors.js

@@ -18,6 +18,9 @@ export class LockfileParseError extends Data.TaggedError("LockfileParseError") {
 /** Lockfile schema decode failure; `raw` carries the parsed value. */
 export class LockfileDecodeError extends Data.TaggedError("LockfileDecodeError") {
 }
+/** A syntactically valid lockfile declares a version this CLI cannot read. */
+export class LockfileVersionUnsupported extends Data.TaggedError("LockfileVersionUnsupported") {
+}
 /** Provider-construction error: workspace root escapes the configured allowed root. */
 export class WorkspaceRootEscape extends Data.TaggedError("WorkspaceRootEscape") {
 }

package/dist/src/workspace/read-model/extensions/mcp-server.js

@@ -10,6 +10,7 @@
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { decodeExtensionNameSync, } from "@agentxm/extension-model/unstable/extensions/common";
+import { parseSourceQualifiedRegistrySourcePatternParts } from "@agentxm/extension-model/unstable/extensions";
 import { filterMapOccurrences } from "./actual-helpers.js";
 import { canonicalAxmPackageRoot } from "./package-root.js";
 import { makeProjectedSubjectCells, projectInstalledExtensions, } from "./projection.js";
@@ -24,18 +25,39 @@ const declaredFromSettings = (settings) => {
         entry,
     }));
 };
-const resolvedFromLockfile = (lockfile) => {
-    if (lockfile.mcpServers === undefined)
-        return [];
-    return Object.entries(lockfile.mcpServers).map(([name, lockEntry]) => ({
-        name: decodeExtensionNameSync(name),
-        lockEntry,
-    }));
+const resolvedFromState = (settings, lockfile, packs) => {
+    const locked = Object.values(lockfile.mcpServers ?? {});
+    const resolved = [];
+    const names = new Set();
+    for (const [localName, entry] of Object.entries(settings.mcpServers ?? {})) {
+        if (entry.kind === "inline")
+            continue;
+        const parsed = parseSourceQualifiedRegistrySourcePatternParts(entry.source);
+        const lockEntry = locked.find((candidate) => parsed !== undefined && candidate.type === "registry"
+            ? candidate.sourceName === parsed.sourceName &&
+                candidate.owner === parsed.owner &&
+                candidate.name === parsed.name
+            : candidate.workspaceName === localName);
+        if (lockEntry === undefined)
+            continue;
+        names.add(localName);
+        resolved.push({ name: decodeExtensionNameSync(localName), lockEntry });
+    }
+    for (const member of packs.flatMap((pack) => pack.mcpServers)) {
+        if (names.has(member.name))
+            continue;
+        const lockEntry = locked.find((candidate) => candidate.workspaceName === member.name);
+        if (lockEntry === undefined)
+            continue;
+        names.add(member.name);
+        resolved.push({ name: member.name, lockEntry });
+    }
+    return resolved;
 };
-const canonicalToActual = (occ, scope) => {
+const canonicalToActual = (occ, scope, localName = occ.name) => {
     const packageRoot = canonicalAxmPackageRoot(occ);
     return {
-        key: { scope, type: "mcp-server", name: occ.name },
+        key: { scope, type: "mcp-server", name: localName },
         origin: occ.origin === "canonical-axm"
             ? { _tag: "canonical-axm-mcp-server" }
             : { _tag: "external-axm-mcp-server" },
@@ -94,11 +116,24 @@ const mcpServerPolicy = (scope) => ({
 export const makeMcpServerExtensionsApi = (deps) => Effect.gen(function* () {
     const { scope, loaders, scanners, installedPacks, diagnostics } = deps;
     const declared = loaders.settings.pipe(Effect.map((opt) => Option.map(opt, declaredFromSettings)));
-    const resolved = loaders.lockfile.pipe(Effect.map((opt) => Option.map(opt, resolvedFromLockfile)));
+    const resolved = Effect.all({
+        settings: loaders.settings.pipe(Effect.catch(() => Effect.succeed(Option.none()))),
+        lockfile: loaders.lockfile,
+        packs: installedPacks.pipe(Effect.catch(() => Effect.succeed([]))),
+    }).pipe(Effect.map(({ settings, lockfile, packs }) => Option.all({ settings, lockfile }).pipe(Option.map(({ settings: decodedSettings, lockfile: decodedLockfile }) => resolvedFromState(decodedSettings, decodedLockfile, packs)))));
     const actual = Effect.gen(function* () {
         const canonical = yield* scanners.canonical;
         const mcpConfig = yield* scanners.mcpConfig;
-        const fromCanonical = filterMapOccurrences(canonical, "mcp-server", (occ) => canonicalToActual(occ, scope));
+        const accepted = yield* resolved.pipe(Effect.catch(() => Effect.succeed(Option.none())));
+        const resolvedEntries = Option.getOrElse(accepted, () => []);
+        const fromCanonical = filterMapOccurrences(canonical, "mcp-server", (occ) => occ).flatMap((occ) => {
+            const matchingNames = resolvedEntries
+                .filter((entry) => entry.lockEntry.type === "registry" && entry.lockEntry.name === occ.name)
+                .map((entry) => entry.name);
+            return matchingNames.length === 0
+                ? [canonicalToActual(occ, scope)]
+                : matchingNames.map((name) => canonicalToActual(occ, scope, name));
+        });
         const fromMcpConfig = mcpConfig.map((occ) => mcpConfigToActual(occ, scope));
         return [...fromCanonical, ...fromMcpConfig];
     });

package/dist/src/workspace/read-model/state.js

@@ -3,10 +3,10 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
 import YAML from "yaml";
-import { LockfileSchema } from "../../lockfile/schema.js";
+import { LOCKFILE_VERSION, LockfileSchema } from "../../lockfile/schema.js";
 import { formatSchemaIssuesToLines } from "@agentxm/extension-model/unstable/schema-issues";
 import { SettingsSchema } from "../../settings/schema.js";
-import { LockfileDecodeError, LockfileIoError, LockfileParseError, SettingsDecodeError, SettingsIoError, SettingsParseError, } from "./errors.js";
+import { LockfileDecodeError, LockfileIoError, LockfileParseError, LockfileVersionUnsupported, SettingsDecodeError, SettingsIoError, SettingsParseError, } from "./errors.js";
 // ---------------------------------------------------------------------------
 // Raw bytes loaders (shared by the decoded loaders and the public raw cells)
 // ---------------------------------------------------------------------------
@@ -71,6 +71,22 @@ const loadLockfile = (rawCell) => Effect.gen(function* () {
         try: () => YAML.parse(bytes),
         catch: (cause) => new LockfileParseError({ path, raw: bytes, cause }),
     });
+    if (typeof parsed === "object" &&
+        parsed !== null &&
+        !Array.isArray(parsed) &&
+        Object.hasOwn(parsed, "lockfileVersion")) {
+        const observedVersion = Reflect.get(parsed, "lockfileVersion");
+        if (typeof observedVersion === "number" &&
+            Number.isSafeInteger(observedVersion) &&
+            observedVersion > 0 &&
+            observedVersion !== LOCKFILE_VERSION) {
+            return yield* Effect.fail(new LockfileVersionUnsupported({
+                path,
+                observedVersion,
+                supportedVersion: LOCKFILE_VERSION,
+            }));
+        }
+    }
     const decoded = yield* Schema.decodeUnknownEffect(LockfileSchema)(parsed).pipe(Effect.mapError((error) => new LockfileDecodeError({
         path,
         issues: formatSchemaIssuesToLines(error.issue),

package/dist/src/workspace/read-model/types.d.ts

@@ -63,7 +63,7 @@ export interface InstalledPackRef {
  *
  * The failure channels are intentionally narrow: `declared` only fails with
  * `SettingsReadError` (3 tags), `resolved` only fails with
- * `LockfileReadError` (3 tags), and `actual` never fails — workspace-root
+ * `LockfileReadError` (4 tags), and `actual` never fails — workspace-root
  * path-escape is validated once at provider construction (Layer-level), not
  * per cell.
  */

package/dist/src/workspace/read-model-record-readers.js

@@ -7,7 +7,7 @@
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { installableExtensionTypes, } from "@agentxm/extension-model/unstable/extensions/installable-types";
-import { isAxmManagedMcpEntry, isMcpServerApplicableToAgent } from "./mcp-entry-semantics.js";
+import { isAxmManagedMcpEntry } from "./mcp-entry-semantics.js";
 import { createDefaultSettings } from "../settings/index.js";
 import { configuredAgentLifecycleOutcomes } from "./configured-agent-outcomes.js";
 import { projectExtensionInventory, } from "./read-model/extensions/inventory.js";
@@ -298,7 +298,6 @@ export const makeReadModelRecordReaders = (args) => {
             const configuredAgents = settings.agents ?? [];
             const finalizeInventory = (inventory) => {
                 const withOutcomes = inventory.items.map((row) => {
-                    const mcpEntry = row.type === "mcp-server" ? settings.mcpServers?.[row.name] : undefined;
                     return {
                         ...row,
                         agentOutcomes: row.classification.lifecycle === "unmanaged"
@@ -312,11 +311,6 @@ export const makeReadModelRecordReaders = (args) => {
                                 targetState: row.enabled === false ? "disabled" : "enabled",
                                 installed: row.installed,
                                 observedAgentIds: row.agents,
-                                ...(mcpEntry === undefined
-                                    ? {}
-                                    : {
-                                        applicableAgentIds: configuredAgents.filter((agentId) => isMcpServerApplicableToAgent(mcpEntry, agentId)),
-                                    }),
                             }),
                     };
                 });

package/dist/src/workspace/service-interface.d.ts

@@ -33,7 +33,6 @@ import type { ExtensionInventory } from "./read-model/extensions/inventory.js";
 import type { ResolvedKnowledgeDiscoveryConfig } from "../knowledge/discovery-config.js";
 import type { DesiredStateGraph, ProspectivePackRef } from "./desired-state-graph.js";
 import type { AbsolutePath } from "@agentxm/extension-model/unstable/path-types";
-import type { ConfigurableAgentId } from "@agentxm/extension-model/unstable/agent-capabilities";
 import type { WorkspaceLayout } from "./layout.js";
 import type { ExtensionPathSource } from "./extension-paths.js";
 /**
@@ -212,11 +211,12 @@ export interface SetSubagentArgs {
  */
 export interface SetMcpServerArgs {
     readonly name: string;
+    /** Canonical source-resolution key. Unlike name, this is not connection-scoped. */
+    readonly resolutionKey: string;
     readonly lockEntry: McpServerLockEntry;
     readonly versionRange: Option.Option<string>;
     readonly env?: Readonly<Record<string, string>>;
     readonly enabled?: boolean;
-    readonly agents?: ReadonlyArray<ConfigurableAgentId>;
 }
 /**
  * Arguments for `setRule` -- bundles the rule name with the lock entry.
@@ -408,8 +408,10 @@ export interface WorkspaceMutationsService {
     readonly removeSubagentLock: (name: string) => Effect.Effect<void, WorkspaceLockfileMutationFailure>;
     /** Read lockfile and return the MCP servers lock map. */
     readonly getLockedMcpServers: () => Effect.Effect<McpServersLockMap, WorkspaceLockfileReadFailure>;
-    /** Read lockfile and return the entry for a specific MCP server, or Option.none(). */
-    readonly getLockedMcpServer: (name: string) => Effect.Effect<Option.Option<McpServerLockEntry>, WorkspaceLockfileReadFailure>;
+    /** Read lockfile and return an MCP accepted resolution by source-resolution identity. */
+    readonly getLockedMcpServer: (resolutionKey: string) => Effect.Effect<Option.Option<McpServerLockEntry>, WorkspaceLockfileReadFailure>;
+    /** Resolve a local MCP connection name to its shared accepted resolution. */
+    readonly getLockedMcpServerForConnection: (localName: string) => Effect.Effect<Option.Option<McpServerLockEntry>, WorkspaceStateReadFailure>;
     /** Update desired MCP settings and any external accepted resolution atomically. */
     readonly setMcpServer: (args: SetMcpServerArgs) => Effect.Effect<void, WorkspaceStateMutationFailure>;
     /** Add or update an MCP server in lockfile only (skip settings). Used for pack dependencies. Serialized by semaphore. */
@@ -469,11 +471,11 @@ export interface WorkspaceMutationsOptions {
     readonly allowUninitialized?: boolean;
 }
 /**
- * Error loading workspace mutations: scoped settings reads, layout
- * resolution, and the initialization gate.
+ * Error loading workspace mutations: scoped settings and lockfile reads,
+ * layout resolution, and the initialization gate.
  *
  * @experimental This API is unstable and may change without notice.
  */
-export type WorkspaceMutationsError = WorkspaceSettingsReadFailure | WorkspaceLayoutError | WorkspaceNotInitialized;
+export type WorkspaceMutationsError = WorkspaceSettingsReadFailure | WorkspaceLockfileReadFailure | WorkspaceLayoutError | WorkspaceNotInitialized;
 export {};
 //# sourceMappingURL=service-interface.d.ts.map