@agentxm/workspace-projection 0.29.1 → 0.29.4

package/dist/src/agent-output-observation.d.ts

@@ -10,6 +10,7 @@
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
+import { type SkillEntry, type WorkspaceLayout } from "@agentxm/workspace-state";
 import type { PerAgentType } from "@agentxm/extension-model/unstable/extensions/common";
 import type { WorkspaceScope } from "@agentxm/extension-model/unstable/workspace-scope";
 import { CodingAgentRepository } from "./agents/coding-agent-repository.js";
@@ -36,6 +37,11 @@ export interface ObserveAgentOutputsArgs {
     readonly desiredAgentIds: ReadonlySet<string>;
     readonly expectedNames: Readonly<Record<PerAgentType, ReadonlySet<string>>>;
     readonly skillOwnershipRoots: ReadonlyArray<string>;
+    /** Local declarations, including disabled skills; independent of graph resolution. */
+    readonly authoredSkills: {
+        readonly layout: WorkspaceLayout;
+        readonly entries: Readonly<Record<string, SkillEntry>>;
+    };
 }
 /** Observe every known agent output without writing to the workspace. */
 export declare const observeAgentOutputs: (args: ObserveAgentOutputsArgs) => Effect.Effect<AgentOutputInventory, never, CodingAgentRepository | FileSystem.FileSystem | Path.Path>;
@@ -55,5 +61,6 @@ export declare const observeWorkspaceOwnershipIssues: (args: {
     readonly scope: WorkspaceScope;
     readonly configuredAgentIds: ReadonlySet<string>;
     readonly skillOwnershipRoots: ReadonlyArray<string>;
+    readonly authoredSkills: ObserveAgentOutputsArgs["authoredSkills"];
 }) => Effect.Effect<ReadonlyArray<WorkspaceOwnershipIssue>, never, CodingAgentRepository | FileSystem.FileSystem | Path.Path>;
 //# sourceMappingURL=agent-output-observation.d.ts.map

package/dist/src/agent-output-observation.js

@@ -10,6 +10,8 @@
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
+import * as Option from "effect/Option";
+import { resolveWorkspaceExtensionRef, } from "@agentxm/workspace-state";
 import { AGENTS as CAPABILITY_AGENTS } from "@agentxm/extension-model/unstable/agent-capabilities";
 import { CodingAgentRepository } from "./agents/coding-agent-repository.js";
 import { extensionNameFromFilename, hasAxmManagedMarker, safeReadDirectory, safeReadFileString, } from "./managed-file-discovery.js";
@@ -32,6 +34,26 @@ const groupContainers = (containers) => {
     }));
 };
 const containerIsDesired = (claimantAgentIds, desiredAgentIds) => claimantAgentIds.some((agentId) => desiredAgentIds.has(agentId));
+/** A declared source package is not an agent output eligible for retirement. */
+const isAuthoredSkillPackage = (args, artifactPath, name) => Effect.gen(function* () {
+    const path = yield* Path.Path;
+    const entry = args.entries[name];
+    if (args.layout.scope !== "project" ||
+        entry?.source !== "workspace" ||
+        entry.origin === "bundled" ||
+        artifactPath !== path.join(args.layout.authoredRoot("skill"), name))
+        return false;
+    // Failed validation supplies no exclusion: the output remains visible to
+    // ownership diagnostics and the package's own canonical-content diagnostics.
+    const source = yield* resolveWorkspaceExtensionRef({
+        settingsName: name,
+        source: entry.source,
+        expectedType: "skill",
+        layout: args.layout,
+        scope: args.layout.scope,
+    }).pipe(Effect.option);
+    return Option.isSome(source);
+});
 /** Observe every known agent output without writing to the workspace. */
 export const observeAgentOutputs = (args) => Effect.gen(function* () {
     const fs = yield* FileSystem.FileSystem;
@@ -61,6 +83,8 @@ export const observeAgentOutputs = (args) => Effect.gen(function* () {
             else {
                 const stat = yield* fs.stat(artifactPath).pipe(Effect.option);
                 if (stat._tag === "Some" && stat.value.type === "Directory") {
+                    if (yield* isAuthoredSkillPackage(args.authoredSkills, artifactPath, entry))
+                        continue;
                     const content = yield* safeReadFileString(fs, path.join(artifactPath, "SKILL.md"));
                     if (hasAxmManagedMarker(content))
                         proof = "managed-banner";
@@ -214,6 +238,7 @@ export const observeWorkspaceOwnershipIssues = (args) => observeAgentOutputs({
         hook: new Set(),
     },
     skillOwnershipRoots: args.skillOwnershipRoots,
+    authoredSkills: args.authoredSkills,
 }).pipe(Effect.map((observed) => observed.unownedFootprints.map((output) => ({
     kind: output.extensionType === "hook"
         ? "hook-ownership-ambiguous"

package/dist/src/mcps/inspection.d.ts

@@ -9,7 +9,7 @@ import * as Effect from "effect/Effect";
 import { type McpConfigTarget } from "@agentxm/extension-model/unstable/agent-capabilities";
 import { type McpInspectionError } from "./errors.js";
 import type { McpServerEntry } from "@agentxm/workspace-state";
-export type AgentMcpInspectionStatus = "unsupported" | "absent" | "match" | "drift" | "unmanaged";
+export type AgentMcpInspectionStatus = "unsupported" | "blocked" | "absent" | "match" | "drift" | "unmanaged";
 export interface AgentMcpServerInspection {
     readonly agentId: string;
     readonly path: string;
@@ -47,6 +47,8 @@ export declare const inspectMcpServerAcrossAgents: (args: {
     readonly agentIds: ReadonlyArray<string>;
     readonly serverName: string;
     readonly entry: McpServerEntry;
+    readonly canonicalPaths?: ReadonlyArray<string>;
+    readonly state?: "projected" | "current";
 }) => Effect.Effect<ReadonlyArray<AgentMcpServerInspection>, McpInspectionError, FileSystem.FileSystem | Path.Path>;
 export declare const collectManagedAgentMcpServers: (args: CollectManagedAgentMcpServersArgs) => Effect.Effect<ReadonlyArray<ManagedAgentMcpServer>, McpInspectionError, FileSystem.FileSystem | Path.Path>;
 //# sourceMappingURL=inspection.d.ts.map

package/dist/src/mcps/inspection.js

@@ -10,7 +10,8 @@ import * as Option from "effect/Option";
 import { parse } from "jsonc-parser";
 import { CONFIGURABLE_AGENTS_BY_ID, } from "@agentxm/extension-model/unstable/agent-capabilities";
 import {} from "./errors.js";
-import { groupConfiguredMcpTargets, inferInlineRemoteTransport, isAxmManagedMcpEntry, managedKeyedBlockNames, managedYamlNames as readManagedYamlNames, McpConfigInvalid, McpConfigIoFailed, McpDefinitionInvalid, McpOwnershipMarkerInvalid, McpSharedTargetConflict, parseTomlValue, projectExpectedEntry, readYamlEntry, reconcileKeyedBlock, resolveAgentMcpConfigTargetPath, resolveSharedMcpTarget, stringifyTomlKey, } from "@agentxm/agent-integration";
+import { decodeMcpServerManifestAt, groupConfiguredMcpTargets, inferInlineRemoteTransport, isAxmManagedMcpEntry, managedKeyedBlockNames, managedYamlNames as readManagedYamlNames, McpConfigInvalid, McpConfigIoFailed, McpDefinitionInvalid, McpOwnershipMarkerInvalid, McpSharedTargetConflict, parseTomlValue, projectExpectedEntry, readYamlEntry, reconcileKeyedBlock, resolveAgentMcpConfigTargetPath, resolveMcpServer, resolveSharedMcpTarget, stringifyTomlKey, validateManifestMcpServerTargets, } from "@agentxm/agent-integration";
+import { MCP_SERVER_MANIFEST_FILENAME } from "@agentxm/extension-model/unstable/mcps/manifest-schema";
 import { diffAgentEntry } from "./drift.js";
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const hasMcpConfig = (capability) => capability.axm.writer !== null && "transports" in capability.native;
@@ -198,16 +199,17 @@ const inspectAgentMcpServerInternal = (args) => Effect.gen(function* () {
             reason: `${args.agentId} has no ${args.scope} MCP config target`,
         };
     }
-    const projected = args.entry.command === undefined && args.entry.url === undefined
-        ? { _tag: "managed" }
-        : projectExpectedEntry({
-            serverName: args.serverName,
-            entry: args.entry,
-            stdio: config.stdio,
-            remote: config.remote,
-            activationField: config.activationField,
-            envExpansion: capability.native.mcpEnvExpansion,
-        });
+    const projected = args.projection?.expected ??
+        (args.entry.command === undefined && args.entry.url === undefined
+            ? { _tag: "managed" }
+            : projectExpectedEntry({
+                serverName: args.serverName,
+                entry: args.entry,
+                stdio: config.stdio,
+                remote: config.remote,
+                activationField: config.activationField,
+                envExpansion: capability.native.mcpEnvExpansion,
+            }));
     const absolutePath = yield* resolveAgentMcpConfigTargetPath(args.workspaceRoot, target);
     if (projected._tag === "unsupported") {
         return {
@@ -220,6 +222,17 @@ const inspectAgentMcpServerInternal = (args) => Effect.gen(function* () {
             reason: `${args.agentId} ${projected.reason}`,
         };
     }
+    if (args.state === "projected") {
+        return {
+            agentId: args.agentId,
+            path: target.path,
+            absolutePath,
+            status: "match",
+            fields: [],
+            warnings: args.projection?.warnings ?? (projected._tag === "projected" ? projected.warnings : []),
+            ...(projected._tag === "projected" ? { expected: projected.entry } : {}),
+        };
+    }
     const actual = yield* inspectActual({
         target,
         configPath: absolutePath,
@@ -233,7 +246,7 @@ const inspectAgentMcpServerInternal = (args) => Effect.gen(function* () {
         absolutePath,
         status: actual.status,
         fields: actual.fields,
-        warnings: projected._tag === "projected" ? projected.warnings : [],
+        warnings: args.projection?.warnings ?? (projected._tag === "projected" ? projected.warnings : []),
         ...(projected._tag === "projected" ? { expected: projected.entry } : {}),
         ...(actual.actual === undefined ? {} : { actual: actual.actual }),
     };
@@ -255,6 +268,140 @@ const inspectionTransportForEntry = (entry) => {
 };
 export const inspectMcpServerAcrossAgents = (args) => Effect.gen(function* () {
     if (args.entry.command === undefined && args.entry.url === undefined) {
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+        let canonicalPath;
+        for (const candidate of args.canonicalPaths ?? []) {
+            const resolved = path.resolve(args.workspaceRoot, candidate);
+            const manifestPath = path.join(resolved, MCP_SERVER_MANIFEST_FILENAME);
+            if (yield* fs.exists(manifestPath).pipe(Effect.catch(() => Effect.succeed(false)))) {
+                canonicalPath = resolved;
+                break;
+            }
+        }
+        if (canonicalPath !== undefined) {
+            const manifest = yield* decodeMcpServerManifestAt(path.join(canonicalPath, MCP_SERVER_MANIFEST_FILENAME));
+            yield* validateManifestMcpServerTargets({
+                manifest,
+                agentIds: args.agentIds,
+                scope: args.scope,
+                serverName: args.serverName,
+                values: args.entry.env,
+                enabled: true,
+            });
+            const projectedTargets = new Map();
+            for (const group of groupConfiguredMcpTargets({
+                agentIds: args.agentIds,
+                scope: args.scope,
+            })) {
+                const firstRunnable = group.members
+                    .flatMap((member) => {
+                    if (!isCapabilityAgentId(member.agentId))
+                        return [];
+                    const capability = CONFIGURABLE_AGENTS_BY_ID[member.agentId].capabilities["mcp-server"];
+                    if (!hasMcpConfig(capability))
+                        return [];
+                    const resolution = resolveMcpServer({
+                        manifest,
+                        localName: args.serverName,
+                        capability,
+                        values: args.entry.env,
+                        enabled: true,
+                    });
+                    return resolution._tag === "resolved" || resolution._tag === "needs-input"
+                        ? [resolution]
+                        : [];
+                })
+                    .at(0);
+                if (firstRunnable === undefined)
+                    continue;
+                const shared = resolveSharedMcpTarget({
+                    members: group.members,
+                    transport: firstRunnable.transport,
+                });
+                if (shared._tag === "conflict") {
+                    return yield* new McpSharedTargetConflict({ reason: shared.reason });
+                }
+                for (const member of group.members) {
+                    projectedTargets.set(member.agentId, { config: shared.config, target: member.target });
+                }
+            }
+            return yield* Effect.forEach(args.agentIds, (agentId) => Effect.gen(function* () {
+                if (!isCapabilityAgentId(agentId)) {
+                    return yield* inspectAgentMcpServer({ ...args, agentId });
+                }
+                const capability = CONFIGURABLE_AGENTS_BY_ID[agentId].capabilities["mcp-server"];
+                if (!hasMcpConfig(capability)) {
+                    return yield* inspectAgentMcpServer({ ...args, agentId });
+                }
+                const nativeConfig = capability.axm.writer.config;
+                const projection = projectedTargets.get(agentId);
+                const config = projection?.config ?? nativeConfig;
+                const target = projection?.target ??
+                    nativeConfig.targets.find(({ scope }) => scope === args.scope);
+                if (target === undefined) {
+                    return yield* inspectAgentMcpServer({ ...args, agentId });
+                }
+                const absolutePath = yield* resolveAgentMcpConfigTargetPath(args.workspaceRoot, target);
+                const projectedCapability = {
+                    ...capability,
+                    axm: { ...capability.axm, writer: { config } },
+                };
+                const resolution = resolveMcpServer({
+                    manifest,
+                    localName: args.serverName,
+                    capability: projectedCapability,
+                    values: args.entry.env,
+                    enabled: true,
+                });
+                if (resolution._tag === "no-distribution" || resolution._tag === "nothing-runnable") {
+                    return {
+                        agentId,
+                        path: target.path,
+                        absolutePath,
+                        status: "unsupported",
+                        fields: [],
+                        warnings: [],
+                        reason: resolution.reason,
+                    };
+                }
+                if (resolution._tag === "needs-input") {
+                    return {
+                        agentId,
+                        path: target.path,
+                        absolutePath,
+                        status: "blocked",
+                        fields: [],
+                        warnings: resolution.warnings,
+                        reason: resolution.warnings.join("; "),
+                    };
+                }
+                if (args.state === "projected") {
+                    return {
+                        agentId,
+                        path: target.path,
+                        absolutePath,
+                        status: "match",
+                        fields: [],
+                        warnings: resolution.warnings,
+                        expected: resolution.entry,
+                    };
+                }
+                return yield* inspectAgentMcpServerInternal({
+                    workspaceRoot: args.workspaceRoot,
+                    scope: args.scope,
+                    agentId,
+                    serverName: args.serverName,
+                    entry: args.entry,
+                    projection: {
+                        config,
+                        target,
+                        expected: { _tag: "projected", entry: resolution.entry, warnings: [] },
+                        warnings: resolution.warnings,
+                    },
+                });
+            }), { concurrency: "unbounded" });
+        }
         return yield* Effect.forEach(args.agentIds, (agentId) => inspectAgentMcpServer({
             workspaceRoot: args.workspaceRoot,
             scope: args.scope,
@@ -278,6 +425,7 @@ export const inspectMcpServerAcrossAgents = (args) => Effect.gen(function* () {
             agentId: member.agentId,
             serverName: args.serverName,
             entry: args.entry,
+            ...(args.state === undefined ? {} : { state: args.state }),
             projection: {
                 config: resolution.config,
                 target: member.target,
@@ -290,12 +438,13 @@ export const inspectMcpServerAcrossAgents = (args) => Effect.gen(function* () {
     return yield* Effect.forEach(args.agentIds, (agentId) => {
         const resolved = byAgentId.get(agentId);
         return resolved === undefined
-            ? inspectAgentMcpServer({
+            ? inspectAgentMcpServerInternal({
                 workspaceRoot: args.workspaceRoot,
                 scope: args.scope,
                 agentId,
                 serverName: args.serverName,
                 entry: args.entry,
+                ...(args.state === undefined ? {} : { state: args.state }),
             })
             : Effect.succeed(resolved);
     }, { concurrency: "unbounded" });

package/package.json

@@ -4,24 +4,25 @@
     "url": "https://github.com/agentxm/axm/issues"
   },
   "dependencies": {
-    "@agentxm/agent-integration": "^0.29.1",
-    "@agentxm/extension-content": "^0.29.1",
-    "@agentxm/extension-model": "^0.29.1",
-    "@agentxm/extension-sources": "^0.29.1",
-    "@agentxm/workspace-state": "^0.29.1",
-    "@agentxm/workspace-transactions": "^0.29.1",
-    "effect": "4.0.0-rc.112",
+    "@agentxm/agent-integration": "^0.29.4",
+    "@agentxm/extension-content": "^0.29.4",
+    "@agentxm/extension-model": "^0.29.4",
+    "@agentxm/extension-sources": "^0.29.4",
+    "@agentxm/workspace-state": "^0.29.4",
+    "@agentxm/workspace-transactions": "^0.29.4",
+    "effect": "4.0.0-rc.115",
     "jsonc-parser": "^3.3.1",
     "semver": "^7.8.5"
   },
   "description": "AXM workspace projection: ownership units, projection planning and participants, managed-file ownership grammar, invariant facts, and the read-side reconciliation facts for the axm CLI. Unstable and unsupported — use the axm.sh CLI.",
   "devDependencies": {
-    "@effect/platform-node": "4.0.0-rc.112",
-    "@effect/vitest": "4.0.0-rc.112",
+    "@effect/platform-node": "4.0.0-rc.115",
+    "@effect/vitest": "4.0.0-rc.115",
+    "@fast-check/vitest": "^0.5.0",
     "@types/semver": "^7.7.1",
     "@typescript/native": "npm:typescript@^7.0.2",
     "typescript": "npm:@typescript/typescript6@^6.0.2",
-    "vitest": "^4.1.10"
+    "vitest": "^5.0.0"
   },
   "engines": {
     "node": ">=22.19.0"
@@ -63,5 +64,5 @@
   },
   "sideEffects": false,
   "type": "module",
-  "version": "0.29.1"
+  "version": "0.29.4"
 }