@agentxm/workspace-projection 0.28.14-preview.1789139351.5cd4595aa

package/LICENSE

@@ -0,0 +1,110 @@
+# Functional Source License, Version 1.1, MIT Future License
+
+## Abbreviation
+
+FSL-1.1-MIT
+
+## Notice
+
+Copyright 2025-2026 AgentXM, Inc.
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the MIT license that is effective on the second anniversary of the date we make
+the Software available. On or after that date, you may use the Software under
+the MIT license, in which case the following will apply:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,17 @@
+# @agentxm/workspace-projection
+
+The AXM workspace projection capability: the ownership-unit registry, projection
+planning and its participant registry, managed-file ownership grammar and
+provenance banners, managed-region reconciliation, instruction targets, workspace
+invariant facts, and the read-side reconciliation facts (MCP drift, hook agent
+outcomes, Knowledge discovery and instruction entries, agent-output observation)
+that lint, sync, and inspection consume without re-deriving them.
+
+The package root is the public API; the coding-agent repository layer, the
+participant-free invariant-facts layer, and the native-write authority that lets
+`@agentxm/agent-integration` write under the enclosing workspace transaction live
+behind `./live`. Deterministic ports for feature tests live behind `./testing`.
+The surface is unsupported and may change in any release. Ordinary users should
+use the [`axm` CLI](https://axm.sh) instead.
+
+Part of the [AgentXM](https://agentxm.ai) toolchain.

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

@@ -0,0 +1,59 @@
+/**
+ * Read-only inventory of agent-native outputs and their ownership proofs.
+ *
+ * Output containers may be shared by several coding agents. An output is
+ * desired when at least one claimant for its resolved container is desired and
+ * its managed unit name is expected for that extension type.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+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";
+import { type WorkspaceOwnershipIssue } from "./managed-file-discovery.js";
+export type AgentOutputOwnershipProof = "storage-root-symlink" | "managed-banner" | "managed-mcp-entry" | "managed-hook-group";
+export interface AgentOutputObservation {
+    readonly extensionType: PerAgentType;
+    readonly containerPath: string;
+    readonly path: string;
+    readonly entryName: string;
+    readonly claimantAgentIds: ReadonlyArray<string>;
+    readonly ownership: "owned" | "unowned";
+    readonly proof?: AgentOutputOwnershipProof;
+    readonly desired: boolean;
+}
+export interface AgentOutputInventory {
+    readonly outputs: ReadonlyArray<AgentOutputObservation>;
+    readonly ownedResidue: ReadonlyArray<AgentOutputObservation>;
+    readonly unownedFootprints: ReadonlyArray<AgentOutputObservation>;
+}
+export interface ObserveAgentOutputsArgs {
+    readonly workspaceRoot: string;
+    readonly scope: WorkspaceScope;
+    readonly desiredAgentIds: ReadonlySet<string>;
+    readonly expectedNames: Readonly<Record<PerAgentType, ReadonlySet<string>>>;
+    readonly skillOwnershipRoots: ReadonlyArray<string>;
+}
+/** 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>;
+/**
+ * The ownership problems a workspace's agent-native outputs present, with no
+ * expectation of what should be there.
+ *
+ * Reporting ownership is a different question from reconciling it: the
+ * reporter must not need a desired graph, because the workspaces most in need
+ * of the answer are the ones whose desired state cannot be resolved. Every
+ * expected-name set is therefore empty, and the answer is only about proof —
+ * a file that sits where AXM writes but carries no ownership marker, and a
+ * hook command pointed at an AXM canonical path without one.
+ */
+export declare const observeWorkspaceOwnershipIssues: (args: {
+    readonly workspaceRoot: string;
+    readonly scope: WorkspaceScope;
+    readonly configuredAgentIds: ReadonlySet<string>;
+    readonly skillOwnershipRoots: ReadonlyArray<string>;
+}) => Effect.Effect<ReadonlyArray<WorkspaceOwnershipIssue>, never, CodingAgentRepository | FileSystem.FileSystem | Path.Path>;
+//# sourceMappingURL=agent-output-observation.d.ts.map

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

@@ -0,0 +1,226 @@
+/**
+ * Read-only inventory of agent-native outputs and their ownership proofs.
+ *
+ * Output containers may be shared by several coding agents. An output is
+ * desired when at least one claimant for its resolved container is desired and
+ * its managed unit name is expected for that extension type.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+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";
+import { collectManagedAgentMcpServers } from "./mcps/inspection.js";
+import { readAmbiguousHookCommands, readManagedHookUnits } from "@agentxm/agent-integration";
+const isWithin = (path, parent, child) => {
+    const relative = path.relative(path.resolve(parent), path.resolve(child));
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+};
+const groupContainers = (containers) => {
+    const grouped = new Map();
+    for (const container of containers) {
+        const claimants = grouped.get(container.path) ?? new Set();
+        claimants.add(container.agentId);
+        grouped.set(container.path, claimants);
+    }
+    return [...grouped].map(([path, claimants]) => ({
+        path,
+        claimantAgentIds: [...claimants].sort(),
+    }));
+};
+const containerIsDesired = (claimantAgentIds, desiredAgentIds) => claimantAgentIds.some((agentId) => desiredAgentIds.has(agentId));
+/** Observe every known agent output without writing to the workspace. */
+export const observeAgentOutputs = (args) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const agentRepo = yield* CodingAgentRepository;
+    const agents = yield* agentRepo.all;
+    const outputs = [];
+    const ownershipRoots = yield* Effect.forEach(args.skillOwnershipRoots, (root) => fs.realPath(root).pipe(Effect.orElseSucceed(() => path.resolve(root))));
+    const skillContainers = yield* Effect.forEach(agents, (agent) => agent.resolveEffectiveSkillsDir({ workspaceRoot: args.workspaceRoot }).pipe(Effect.map((resolved) => resolved._tag === "supported"
+        ? [{ path: path.resolve(resolved.dir), agentId: agent.id }]
+        : []), Effect.catch(() => Effect.succeed([])))).pipe(Effect.map((containers) => containers.flat()));
+    for (const container of groupContainers(skillContainers)) {
+        const desiredContainer = containerIsDesired(container.claimantAgentIds, args.desiredAgentIds);
+        for (const entry of yield* safeReadDirectory(fs, container.path)) {
+            const artifactPath = path.join(container.path, entry);
+            const linkTarget = yield* fs.readLink(artifactPath).pipe(Effect.option);
+            let proof;
+            if (linkTarget._tag === "Some") {
+                const resolvedTarget = path.resolve(container.path, linkTarget.value);
+                const canonicalTarget = yield* fs
+                    .realPath(resolvedTarget)
+                    .pipe(Effect.orElseSucceed(() => resolvedTarget));
+                if (ownershipRoots.some((root) => isWithin(path, root, canonicalTarget))) {
+                    proof = "storage-root-symlink";
+                }
+            }
+            else {
+                const stat = yield* fs.stat(artifactPath).pipe(Effect.option);
+                if (stat._tag === "Some" && stat.value.type === "Directory") {
+                    const content = yield* safeReadFileString(fs, path.join(artifactPath, "SKILL.md"));
+                    if (hasAxmManagedMarker(content))
+                        proof = "managed-banner";
+                }
+            }
+            outputs.push({
+                extensionType: "skill",
+                containerPath: container.path,
+                path: artifactPath,
+                entryName: entry,
+                claimantAgentIds: container.claimantAgentIds,
+                ownership: proof === undefined ? "unowned" : "owned",
+                ...(proof === undefined ? {} : { proof }),
+                desired: desiredContainer && args.expectedNames.skill.has(entry),
+            });
+        }
+    }
+    const subagentContainers = yield* Effect.forEach(agents, (agent) => agent
+        .resolveEffectiveSubagentsDir({ workspaceRoot: args.workspaceRoot, scope: args.scope })
+        .pipe(Effect.map((resolved) => resolved._tag === "supported"
+        ? [{ path: path.resolve(resolved.dir), agentId: agent.id }]
+        : []), Effect.catch(() => Effect.succeed([])))).pipe(Effect.map((containers) => containers.flat()));
+    for (const container of groupContainers(subagentContainers)) {
+        const desiredContainer = containerIsDesired(container.claimantAgentIds, args.desiredAgentIds);
+        for (const entry of yield* safeReadDirectory(fs, container.path)) {
+            const artifactPath = path.join(container.path, entry);
+            const stat = yield* fs.stat(artifactPath).pipe(Effect.option);
+            if (stat._tag === "None" || stat.value.type !== "File")
+                continue;
+            const content = yield* safeReadFileString(fs, artifactPath);
+            const managed = hasAxmManagedMarker(content);
+            const entryName = extensionNameFromFilename(entry);
+            outputs.push({
+                extensionType: "subagent",
+                containerPath: container.path,
+                path: artifactPath,
+                entryName,
+                claimantAgentIds: container.claimantAgentIds,
+                ownership: managed ? "owned" : "unowned",
+                ...(managed ? { proof: "managed-banner" } : {}),
+                desired: desiredContainer && args.expectedNames.subagent.has(entryName),
+            });
+        }
+    }
+    const capabilityAgentIds = CAPABILITY_AGENTS.map(({ id }) => id);
+    const managedMcpServers = yield* collectManagedAgentMcpServers({
+        workspaceRoot: args.workspaceRoot,
+        scope: args.scope,
+        agentIds: capabilityAgentIds,
+    }).pipe(Effect.catch(() => Effect.succeed([])));
+    const mcpGroups = new Map();
+    for (const server of managedMcpServers) {
+        const key = `${server.absolutePath}\u0000${server.serverName}`;
+        const group = mcpGroups.get(key) ?? {
+            path: server.absolutePath,
+            name: server.serverName,
+            claimants: new Set(),
+        };
+        group.claimants.add(server.agentId);
+        mcpGroups.set(key, group);
+    }
+    for (const group of mcpGroups.values()) {
+        const claimants = [...group.claimants].sort();
+        outputs.push({
+            extensionType: "mcp-server",
+            containerPath: group.path,
+            path: `${group.path}#${group.name}`,
+            entryName: group.name,
+            claimantAgentIds: claimants,
+            ownership: "owned",
+            proof: "managed-mcp-entry",
+            desired: containerIsDesired(claimants, args.desiredAgentIds) &&
+                args.expectedNames["mcp-server"].has(group.name),
+        });
+    }
+    const hookContainers = new Map();
+    for (const agent of CAPABILITY_AGENTS) {
+        const writer = agent.capabilities.hook.axm.writer;
+        if (writer === null)
+            continue;
+        for (const file of writer.configFiles.filter((candidate) => candidate.scope === args.scope && candidate.format === "json")) {
+            const configPath = path.resolve(args.workspaceRoot, file.path);
+            const key = `${configPath}\u0000${writer.settingsKey}`;
+            const group = hookContainers.get(key) ?? {
+                path: configPath,
+                settingsKey: writer.settingsKey,
+                claimants: new Set(),
+            };
+            group.claimants.add(agent.id);
+            hookContainers.set(key, group);
+        }
+    }
+    for (const group of hookContainers.values()) {
+        const exists = yield* fs.exists(group.path).pipe(Effect.catch(() => Effect.succeed(false)));
+        if (!exists)
+            continue;
+        const raw = yield* safeReadFileString(fs, group.path);
+        const claimants = [...group.claimants].sort();
+        const units = yield* readManagedHookUnits(group.path, group.settingsKey, raw).pipe(Effect.catch(() => Effect.succeed([])));
+        for (const unit of units) {
+            outputs.push({
+                extensionType: "hook",
+                containerPath: group.path,
+                path: `${group.path}#${unit.name}`,
+                entryName: unit.name,
+                claimantAgentIds: claimants,
+                ownership: "owned",
+                proof: "managed-hook-group",
+                desired: containerIsDesired(claimants, args.desiredAgentIds) &&
+                    args.expectedNames.hook.has(unit.name),
+            });
+        }
+        const ambiguous = yield* readAmbiguousHookCommands(group.path, group.settingsKey, raw).pipe(Effect.catch(() => Effect.succeed([])));
+        for (const command of ambiguous) {
+            outputs.push({
+                extensionType: "hook",
+                containerPath: group.path,
+                path: group.path,
+                entryName: command,
+                claimantAgentIds: claimants,
+                ownership: "unowned",
+                desired: false,
+            });
+        }
+    }
+    return {
+        outputs,
+        ownedResidue: outputs.filter((output) => output.ownership === "owned" && !output.desired),
+        unownedFootprints: outputs.filter((output) => output.ownership === "unowned"),
+    };
+});
+/**
+ * The ownership problems a workspace's agent-native outputs present, with no
+ * expectation of what should be there.
+ *
+ * Reporting ownership is a different question from reconciling it: the
+ * reporter must not need a desired graph, because the workspaces most in need
+ * of the answer are the ones whose desired state cannot be resolved. Every
+ * expected-name set is therefore empty, and the answer is only about proof —
+ * a file that sits where AXM writes but carries no ownership marker, and a
+ * hook command pointed at an AXM canonical path without one.
+ */
+export const observeWorkspaceOwnershipIssues = (args) => observeAgentOutputs({
+    workspaceRoot: args.workspaceRoot,
+    scope: args.scope,
+    desiredAgentIds: args.configuredAgentIds,
+    expectedNames: {
+        skill: new Set(),
+        subagent: new Set(),
+        "mcp-server": new Set(),
+        hook: new Set(),
+    },
+    skillOwnershipRoots: args.skillOwnershipRoots,
+}).pipe(Effect.map((observed) => observed.unownedFootprints.map((output) => ({
+    kind: output.extensionType === "hook"
+        ? "hook-ownership-ambiguous"
+        : "managed-file-unowned",
+    path: output.path,
+    detail: output.extensionType === "hook"
+        ? `Hook command targets an AXM canonical extension path without x-axm ownership metadata: ${output.entryName}`
+        : `Agent ${output.extensionType} artifact has no AXM ownership proof.`,
+}))));
+//# sourceMappingURL=agent-output-observation.js.map

package/dist/src/agents/coding-agent-repository.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The coding-agent repository service.
+ *
+ * The per-agent adapter contract (`CodingAgent`) is native format mechanics
+ * and lives in `@agentxm/agent-integration`; deciding which agents a
+ * workspace projects onto is a core decision, so the repository that answers
+ * it lives here.
+ *
+ * The settings-derived members keep `WorkspaceMutations` in `R`. The decisions
+ * themselves are pure over the configured agent IDs (`selection.ts`), so a
+ * caller that already holds those IDs never needs the service at all.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type * as Effect from "effect/Effect";
+import * as ServiceMap from "effect/Context";
+import type { CodingAgent } from "@agentxm/agent-integration";
+import type { AgentId } from "@agentxm/extension-model/unstable/agents/types";
+import type { WorkspaceMutations, WorkspaceSettingsReadFailure } from "@agentxm/workspace-state";
+/** Repository for coding-agent implementations. */
+export interface CodingAgentRepositoryService {
+    readonly get: (id: AgentId) => Effect.Effect<CodingAgent>;
+    readonly all: Effect.Effect<ReadonlyArray<CodingAgent>>;
+    readonly getConfiguredAgents: () => Effect.Effect<ReadonlyArray<CodingAgent>, WorkspaceSettingsReadFailure, WorkspaceMutations>;
+    readonly getMaterializationAgents: () => Effect.Effect<ReadonlyArray<CodingAgent>, WorkspaceSettingsReadFailure, WorkspaceMutations>;
+    readonly getUnknownConfiguredAgentIds: () => Effect.Effect<ReadonlyArray<string>, WorkspaceSettingsReadFailure, WorkspaceMutations>;
+}
+declare const CodingAgentRepository_base: ServiceMap.ServiceClass<CodingAgentRepository, "@agentxm/workspace-projection/agents/CodingAgentRepository", CodingAgentRepositoryService>;
+export declare class CodingAgentRepository extends CodingAgentRepository_base {
+}
+export {};
+//# sourceMappingURL=coding-agent-repository.d.ts.map

package/dist/src/agents/coding-agent-repository.js

@@ -0,0 +1,19 @@
+/**
+ * The coding-agent repository service.
+ *
+ * The per-agent adapter contract (`CodingAgent`) is native format mechanics
+ * and lives in `@agentxm/agent-integration`; deciding which agents a
+ * workspace projects onto is a core decision, so the repository that answers
+ * it lives here.
+ *
+ * The settings-derived members keep `WorkspaceMutations` in `R`. The decisions
+ * themselves are pure over the configured agent IDs (`selection.ts`), so a
+ * caller that already holds those IDs never needs the service at all.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as ServiceMap from "effect/Context";
+export class CodingAgentRepository extends ServiceMap.Service()("@agentxm/workspace-projection/agents/CodingAgentRepository") {
+}
+//# sourceMappingURL=coding-agent-repository.js.map

package/dist/src/agents/repository.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Coding-agent repository: which agents this workspace projects onto.
+ *
+ * Selecting the configured and materialization agents is a workspace
+ * decision made from settings; the decision itself is pure (`selection.ts`)
+ * and the per-agent adapters come from `@agentxm/agent-integration`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Layer from "effect/Layer";
+import { CodingAgentRepository, type CodingAgentRepositoryService } from "./coding-agent-repository.js";
+export declare const DefaultCodingAgentRepository: CodingAgentRepositoryService;
+export declare const CodingAgentRepositoryLive: Layer.Layer<CodingAgentRepository, never, never>;
+//# sourceMappingURL=repository.d.ts.map

package/dist/src/agents/repository.js

@@ -0,0 +1,25 @@
+/**
+ * Coding-agent repository: which agents this workspace projects onto.
+ *
+ * Selecting the configured and materialization agents is a workspace
+ * decision made from settings; the decision itself is pure (`selection.ts`)
+ * and the per-agent adapters come from `@agentxm/agent-integration`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { codingAgentForId } from "@agentxm/agent-integration";
+import { WorkspaceMutations } from "@agentxm/workspace-state";
+import { CodingAgentRepository, } from "./coding-agent-repository.js";
+import { allCodingAgents, configuredCodingAgents, materializationCodingAgents, unknownConfiguredAgentIds, } from "./selection.js";
+const configuredAgentIds = () => WorkspaceMutations.pipe(Effect.flatMap((ws) => ws.getConfiguredAgents()));
+export const DefaultCodingAgentRepository = {
+    get: (id) => Effect.succeed(codingAgentForId(id)),
+    all: Effect.sync(allCodingAgents),
+    getConfiguredAgents: () => configuredAgentIds().pipe(Effect.map(configuredCodingAgents)),
+    getMaterializationAgents: () => configuredAgentIds().pipe(Effect.map(materializationCodingAgents)),
+    getUnknownConfiguredAgentIds: () => configuredAgentIds().pipe(Effect.map(unknownConfiguredAgentIds)),
+};
+export const CodingAgentRepositoryLive = Layer.succeed(CodingAgentRepository, DefaultCodingAgentRepository);
+//# sourceMappingURL=repository.js.map

package/dist/src/agents/selection.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Which agents a workspace projects onto, decided from the configured agent
+ * IDs alone.
+ *
+ * Every function here is pure over the IDs settings declares, so planning,
+ * facts, and reporting share one decision instead of each re-reading settings.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import { type CodingAgent } from "@agentxm/agent-integration";
+import type { AgentId } from "@agentxm/extension-model/unstable/agents/types";
+/** The agent every workspace projects onto, whatever it configures. */
+export declare const UNIVERSAL_AGENT_ID: "universal";
+export declare const isKnownAgentId: (id: string) => id is AgentId;
+/** Every adapter AXM ships, in catalog order. */
+export declare const allCodingAgents: () => ReadonlyArray<CodingAgent>;
+/**
+ * The configured agents AXM can project onto: known, configurable, in the
+ * order the workspace declared them. Unknown and non-configurable IDs are
+ * reported separately rather than silently dropped.
+ */
+export declare const configuredCodingAgents: (configuredAgentIds: ReadonlyArray<string>) => ReadonlyArray<CodingAgent>;
+/** The universal agent followed by every configured agent. */
+export declare const materializationCodingAgents: (configuredAgentIds: ReadonlyArray<string>) => ReadonlyArray<CodingAgent>;
+/** Configured IDs this AXM build does not recognise. */
+export declare const unknownConfiguredAgentIds: (configuredAgentIds: ReadonlyArray<string>) => ReadonlyArray<string>;
+//# sourceMappingURL=selection.d.ts.map

package/dist/src/agents/selection.js

@@ -0,0 +1,33 @@
+/**
+ * Which agents a workspace projects onto, decided from the configured agent
+ * IDs alone.
+ *
+ * Every function here is pure over the IDs settings declares, so planning,
+ * facts, and reporting share one decision instead of each re-reading settings.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import { codingAgentForId } from "@agentxm/agent-integration";
+import { AGENTS } from "@agentxm/extension-model/unstable/agents/registry";
+import { AGENT_IDS, isConfigurableAgentId } from "@agentxm/extension-model/unstable/agents/types";
+/** The agent every workspace projects onto, whatever it configures. */
+export const UNIVERSAL_AGENT_ID = "universal";
+export const isKnownAgentId = (id) => Object.hasOwn(AGENTS, id);
+/** Every adapter AXM ships, in catalog order. */
+export const allCodingAgents = () => AGENT_IDS.map((id) => codingAgentForId(id));
+/**
+ * The configured agents AXM can project onto: known, configurable, in the
+ * order the workspace declared them. Unknown and non-configurable IDs are
+ * reported separately rather than silently dropped.
+ */
+export const configuredCodingAgents = (configuredAgentIds) => configuredAgentIds
+    .filter((id) => isKnownAgentId(id) && isConfigurableAgentId(id))
+    .map((id) => codingAgentForId(id));
+/** The universal agent followed by every configured agent. */
+export const materializationCodingAgents = (configuredAgentIds) => [
+    codingAgentForId(UNIVERSAL_AGENT_ID),
+    ...configuredCodingAgents(configuredAgentIds),
+];
+/** Configured IDs this AXM build does not recognise. */
+export const unknownConfiguredAgentIds = (configuredAgentIds) => configuredAgentIds.filter((id) => !isKnownAgentId(id));
+//# sourceMappingURL=selection.js.map

package/dist/src/constraint-invariant-fact.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Shared invariant facts for desired extension version constraints.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import { type ExtensionType } from "@agentxm/extension-model/unstable/extensions";
+import type { PackDependencyAuthority, PackDependencyReachability } from "./packs/dependency-reachability.js";
+import type { CanonicalConstraintContributor, CanonicalConstraintMismatchObservation } from "@agentxm/workspace-state";
+import type { DesiredExtensionNode } from "@agentxm/workspace-state";
+export declare const EXTENSION_CONSTRAINT_INVARIANT_PREDICATE: "workspace/extension-constraints-satisfied";
+export interface ExtensionConstraintFactContributor extends CanonicalConstraintContributor {
+    readonly authority?: PackDependencyAuthority;
+}
+export interface ExtensionConstraintInvariantFact {
+    readonly predicate: typeof EXTENSION_CONSTRAINT_INVARIANT_PREDICATE;
+    readonly subject: {
+        readonly type: ExtensionType;
+        readonly name: string;
+        readonly identity: string;
+        readonly path?: string;
+    };
+    readonly authority: {
+        readonly source: "desired-state-graph" | "prospective-publish-selection";
+        readonly locator: string;
+        readonly constraints: ReadonlyArray<ExtensionConstraintFactContributor>;
+    };
+    readonly observation: {
+        readonly status: "constraint-mismatch";
+        readonly acceptedVersion?: string;
+        readonly observedVersion?: string;
+        readonly candidateVersion?: string;
+        readonly violations?: ReadonlyArray<ExtensionConstraintFactContributor>;
+    };
+    readonly expectation: {
+        readonly status: "satisfied";
+        readonly ranges: ReadonlyArray<string>;
+    };
+}
+export interface ProspectiveExtensionConstraintCandidate {
+    readonly fqn: string;
+    readonly type: ExtensionType;
+    readonly version: string;
+    readonly dependencies?: Readonly<Record<string, string>>;
+}
+/**
+ * Evaluate prospective selected versions against the locally represented Pack
+ * constraints. Selected Pack manifests replace their current local declaration
+ * for this fact evaluation, matching the state that a coordinated publication
+ * would establish.
+ */
+export declare const makeProspectiveExtensionConstraintFacts: (args: {
+    readonly candidates: ReadonlyArray<ProspectiveExtensionConstraintCandidate>;
+    readonly reachability: ReadonlyArray<PackDependencyReachability>;
+}) => ReadonlyArray<ExtensionConstraintInvariantFact>;
+export type ExtensionConstraintPlanningDecision = {
+    readonly readiness: "ready";
+    readonly reason: "satisfying-version-resolved";
+    readonly version: string;
+} | {
+    readonly readiness: "blocked";
+    readonly reason: "no-satisfying-version" | "candidate-violates-constraints";
+    readonly candidateVersion?: string;
+};
+export declare const makeExtensionConstraintInvariantFact: (desired: DesiredExtensionNode, observation: CanonicalConstraintMismatchObservation) => ExtensionConstraintInvariantFact;
+export declare const planExtensionConstraintFact: (fact: ExtensionConstraintInvariantFact, candidateVersion: string | undefined) => ExtensionConstraintPlanningDecision;
+/** Stable human and machine-display detail shared by lint and sync. */
+export declare const extensionConstraintFactText: (fact: ExtensionConstraintInvariantFact) => string;
+//# sourceMappingURL=constraint-invariant-fact.d.ts.map