@agentxm/workspace-lint 0.28.4-bootstrap.0

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/dist/src/catalog/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Catalog barrel — aggregates the per-namespace rule catalogs for consumers
+ * that want the full v1 rule set.
+ *
+ * Phase 3a lands `skillRules`; Phase 3b lands `packRules`; Phase 3c will
+ * append `workspaceRules` without touching existing imports.
+ *
+ * `allCatalogRuleIds` is the concatenation used by the rule-id snapshot test
+ * (`./rule-ids.snapshot.test.ts`). Per-catalog consumers (registry publish,
+ * `axm lint`) should import the specific catalog they need so the other
+ * catalogs tree-shake out.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+export { liveOnlyWorkspaceRules, repositoryWorkspaceRules, workspaceRules } from "./workspace.js";
+export { buildLintWorkspace, buildNativeInstalledSkillInfo, buildAcquiredInstalledSkillInfo, buildInstalledPackInfo, acquiredSkillDisplayRoot, registryNativeSkillDisplayRoot, registryPackDisplayRoot, type BuildLintWorkspaceArgs, type BuildInstalledPackInfoArgs, type BuildAcquiredInstalledSkillInfoArgs, type BuildInstalledSkillInfoNativeArgs, type LintWorkspace, type LintWorkspaceView, } from "./workspace-read-model/lint-workspace.js";
+/**
+ * Concatenated rule-id array across every currently-exported catalog, in the
+ * order catalogs were introduced (Phase 3a: `skillRules`; Phase 3b:
+ * `packRules`; Phase 3c: `workspaceRules`).
+ *
+ * Used by the rule-id snapshot test; production callers should not depend on
+ * this value.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const allCatalogRuleIds: ReadonlyArray<string>;
+/** Error-severity rule identities that require an exhaustive recovery contract. */
+export declare const allCatalogErrorRuleIds: ReadonlyArray<string>;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/catalog/index.js

@@ -0,0 +1,60 @@
+/**
+ * Catalog barrel — aggregates the per-namespace rule catalogs for consumers
+ * that want the full v1 rule set.
+ *
+ * Phase 3a lands `skillRules`; Phase 3b lands `packRules`; Phase 3c will
+ * append `workspaceRules` without touching existing imports.
+ *
+ * `allCatalogRuleIds` is the concatenation used by the rule-id snapshot test
+ * (`./rule-ids.snapshot.test.ts`). Per-catalog consumers (registry publish,
+ * `axm lint`) should import the specific catalog they need so the other
+ * catalogs tree-shake out.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import { skillRules } from "@agentxm/registry-protocol/unstable/lint/catalog/skill";
+import { packRules } from "@agentxm/registry-protocol/unstable/lint/catalog/pack";
+import { subagentRules } from "@agentxm/registry-protocol/unstable/lint/catalog/subagent";
+import { mcpServerRules } from "@agentxm/registry-protocol/unstable/lint/catalog/mcp-server";
+import { hookRules } from "@agentxm/registry-protocol/unstable/lint/catalog/hook";
+import { ruleRules } from "@agentxm/registry-protocol/unstable/lint/catalog/rule";
+import { knowledgeRules } from "@agentxm/registry-protocol/unstable/lint/catalog/knowledge";
+import { workspaceRules } from "./workspace.js";
+export { liveOnlyWorkspaceRules, repositoryWorkspaceRules, workspaceRules } from "./workspace.js";
+// Phase 3c workspace read-model builder helpers.
+export { buildLintWorkspace, buildNativeInstalledSkillInfo, buildAcquiredInstalledSkillInfo, buildInstalledPackInfo, acquiredSkillDisplayRoot, registryNativeSkillDisplayRoot, registryPackDisplayRoot, } from "./workspace-read-model/lint-workspace.js";
+/**
+ * Concatenated rule-id array across every currently-exported catalog, in the
+ * order catalogs were introduced (Phase 3a: `skillRules`; Phase 3b:
+ * `packRules`; Phase 3c: `workspaceRules`).
+ *
+ * Used by the rule-id snapshot test; production callers should not depend on
+ * this value.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const allCatalogRuleIds = [
+    ...skillRules.map((r) => r.id),
+    ...packRules.map((r) => r.id),
+    ...subagentRules.map((r) => r.id),
+    ...mcpServerRules.map((r) => r.id),
+    ...hookRules.map((r) => r.id),
+    ...ruleRules.map((r) => r.id),
+    ...knowledgeRules.map((r) => r.id),
+    ...workspaceRules.map((r) => r.id),
+];
+/** Error-severity rule identities that require an exhaustive recovery contract. */
+export const allCatalogErrorRuleIds = [
+    ...skillRules,
+    ...packRules,
+    ...subagentRules,
+    ...mcpServerRules,
+    ...hookRules,
+    ...ruleRules,
+    ...knowledgeRules,
+    ...workspaceRules,
+]
+    .filter((rule) => rule.severity === "error")
+    .map((rule) => rule.id);
+//# sourceMappingURL=index.js.map

package/dist/src/catalog/workspace/agents-detected-declared.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `workspace/agents-detected-declared` — every agent footprint detected on
+ * disk appears in `settings.agents[]`.
+ *
+ * Per the lint design:
+ *
+ *   Project scope only (early-returns at user scope). For each detected
+ *   agent whose id is missing from settings.agents[], emit one finding.
+ *
+ * Project scope only: detection relies on scanning workspace-root-adjacent
+ * agent dirs (`.claude/`, `.cursor/`, …). At user scope the detection target
+ * is ambiguous, so the rule early-returns `[]`.
+ *
+ * Advisory, warning — the user may be intentionally using an agent AXM
+ * doesn't manage.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { WorkspaceRuleContext } from "../../workspace-context.js";
+import type { AdvisoryRule } from "@agentxm/registry-protocol/unstable/lint/rule";
+export declare const agentsDetectedDeclaredRule: AdvisoryRule<WorkspaceRuleContext>;
+//# sourceMappingURL=agents-detected-declared.d.ts.map

package/dist/src/catalog/workspace/agents-detected-declared.js

@@ -0,0 +1,61 @@
+/**
+ * `workspace/agents-detected-declared` — every agent footprint detected on
+ * disk appears in `settings.agents[]`.
+ *
+ * Per the lint design:
+ *
+ *   Project scope only (early-returns at user scope). For each detected
+ *   agent whose id is missing from settings.agents[], emit one finding.
+ *
+ * Project scope only: detection relies on scanning workspace-root-adjacent
+ * agent dirs (`.claude/`, `.cursor/`, …). At user scope the detection target
+ * is ambiguous, so the rule early-returns `[]`.
+ *
+ * Advisory, warning — the user may be intentionally using an agent AXM
+ * doesn't manage.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Result from "effect/Result";
+import { settingsDisplayPath } from "./display-paths.js";
+import { EMPTY_ADVISORY_FINDINGS } from "./helpers/empty.js";
+const RULE_ID = "workspace/agents-detected-declared";
+export const agentsDetectedDeclaredRule = {
+    id: RULE_ID,
+    description: "Agents detected on disk are declared in `settings.agents[]`.",
+    kind: "advisory",
+    severity: "warning",
+    check: (context) => Effect.gen(function* () {
+        // Scope-aware early-return — detection only applies at project scope.
+        if (context.subject.scope === "user") {
+            return EMPTY_ADVISORY_FINDINGS;
+        }
+        const scoped = context.workspace;
+        const settingsResult = yield* Effect.result(scoped.state.settings);
+        if (Result.isFailure(settingsResult)) {
+            return EMPTY_ADVISORY_FINDINGS;
+        }
+        if (Option.isNone(settingsResult.success)) {
+            return EMPTY_ADVISORY_FINDINGS;
+        }
+        const detected = yield* scoped.agents.detected;
+        const findings = [];
+        for (const detection of detected) {
+            if (detection.status !== "unmanaged-present") {
+                continue;
+            }
+            findings.push({
+                kind: "advisory",
+                ruleId: RULE_ID,
+                severity: "warning",
+                message: `Agent '${detection.agentId}' is present on disk but missing from \`settings.agents[]\`.`,
+                location: { file: settingsDisplayPath(context.subject.scope) },
+            });
+        }
+        return findings;
+    }),
+};
+//# sourceMappingURL=agents-detected-declared.js.map

package/dist/src/catalog/workspace/agents-recognized.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `workspace/agents-recognized` — every agent id in `settings.agents[]` is
+ * in AXM's known-agent catalog.
+ *
+ * Per the lint design "Foundation" row:
+ *
+ *   Agent recognition invariant — unknown IDs can't be materialized into.
+ *   Absorbs doctor `agents-configured.unrecognized`. Known-agent catalog
+ *   lives at `packages/extension-model/src/unstable/agents/types.ts`.
+ *
+ * Cascade: the rule walks `settings.agents[]` and checks each id against
+ * the set returned by `workspace.scope(scope).agents.known`. Unknown ids
+ * each emit one finding — the cascade is per-entity, not per-cascade-arm.
+ *
+ * Advisory — fixing an unrecognized id is a user-authored settings edit.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { WorkspaceRuleContext } from "../../workspace-context.js";
+import type { AdvisoryRule } from "@agentxm/registry-protocol/unstable/lint/rule";
+export declare const agentsRecognizedRule: AdvisoryRule<WorkspaceRuleContext>;
+//# sourceMappingURL=agents-recognized.d.ts.map

package/dist/src/catalog/workspace/agents-recognized.js

@@ -0,0 +1,64 @@
+/**
+ * `workspace/agents-recognized` — every agent id in `settings.agents[]` is
+ * in AXM's known-agent catalog.
+ *
+ * Per the lint design "Foundation" row:
+ *
+ *   Agent recognition invariant — unknown IDs can't be materialized into.
+ *   Absorbs doctor `agents-configured.unrecognized`. Known-agent catalog
+ *   lives at `packages/extension-model/src/unstable/agents/types.ts`.
+ *
+ * Cascade: the rule walks `settings.agents[]` and checks each id against
+ * the set returned by `workspace.scope(scope).agents.known`. Unknown ids
+ * each emit one finding — the cascade is per-entity, not per-cascade-arm.
+ *
+ * Advisory — fixing an unrecognized id is a user-authored settings edit.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Result from "effect/Result";
+import { EMPTY_ADVISORY_FINDINGS } from "./helpers/empty.js";
+import { settingsDisplayPath } from "./display-paths.js";
+const RULE_ID = "workspace/agents-recognized";
+export const agentsRecognizedRule = {
+    id: RULE_ID,
+    description: "Every `settings.agents[]` entry names a supported agent.",
+    kind: "advisory",
+    severity: "error",
+    check: (context) => Effect.gen(function* () {
+        const scoped = context.workspace;
+        const settingsPath = settingsDisplayPath(context.subject.scope);
+        // `state.settings` returns the decoded `Settings` already; the
+        // `SettingsReadError` family (io / parse / decode) is owned by
+        // `workspace/initialized` and `workspace/settings-schema-valid`, so
+        // we silently bail on any failure here.
+        const settings = yield* Effect.result(scoped.state.settings);
+        if (Result.isFailure(settings))
+            return EMPTY_ADVISORY_FINDINGS;
+        if (Option.isNone(settings.success))
+            return EMPTY_ADVISORY_FINDINGS;
+        const declared = settings.success.value.agents ?? [];
+        if (declared.length === 0)
+            return EMPTY_ADVISORY_FINDINGS;
+        const knownAgents = yield* scoped.agents.known;
+        const knownIds = new Set(knownAgents.map((agent) => agent.id));
+        const findings = [];
+        for (const id of declared) {
+            if (knownIds.has(id))
+                continue;
+            findings.push({
+                kind: "advisory",
+                ruleId: RULE_ID,
+                severity: "error",
+                message: `Agent id '${id}' in \`settings.agents[]\` is not supported. ` +
+                    `Edit \`${settingsPath}\` and remove '${id}' from \`agents\`, or replace it there with the intended agent id.`,
+                location: { file: settingsPath },
+            });
+        }
+        return findings;
+    }),
+};
+//# sourceMappingURL=agents-recognized.js.map

package/dist/src/catalog/workspace/axm-skill-compatible.d.ts

@@ -0,0 +1,4 @@
+import type { WorkspaceRuleContext } from "../../workspace-context.js";
+import type { AdvisoryRule } from "@agentxm/registry-protocol/unstable/lint/rule";
+export declare const axmSkillCompatibleRule: AdvisoryRule<WorkspaceRuleContext>;
+//# sourceMappingURL=axm-skill-compatible.d.ts.map

package/dist/src/catalog/workspace/axm-skill-compatible.js

@@ -0,0 +1,51 @@
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+import { formatAxmSkillCompatibilityTarget } from "@agentxm/extension-workspace";
+import { canonicalDisplayRoot } from "./display-paths.js";
+import { EMPTY_ADVISORY_FINDINGS } from "./helpers/empty.js";
+const RULE_ID = "workspace/axm-skill-compatible";
+export const axmSkillCompatibleRule = {
+    id: RULE_ID,
+    description: "The official AXM skill is compatible with the running AXM CLI.",
+    kind: "advisory",
+    severity: "error",
+    check: (context) => Effect.gen(function* () {
+        if (context.axmSkillCompatibility === undefined)
+            return EMPTY_ADVISORY_FINDINGS;
+        const compatibilityResult = yield* Effect.result(context.axmSkillCompatibility);
+        if (Result.isFailure(compatibilityResult)) {
+            return [
+                {
+                    kind: "advisory",
+                    ruleId: RULE_ID,
+                    severity: "error",
+                    message: `The official AXM skill compatibility state is unreadable: ${compatibilityResult.failure._tag}. Repair the workspace state, then rerun lint.`,
+                    location: {
+                        file: context.subject.scope === "project"
+                            ? "skills/axm"
+                            : `${canonicalDisplayRoot(context.subject.scope)}/@agentxm/skills/axm`,
+                    },
+                },
+            ];
+        }
+        const compatibility = compatibilityResult.success;
+        if (compatibility.status === "compatible")
+            return EMPTY_ADVISORY_FINDINGS;
+        const recovery = compatibility.recovery.nextAction;
+        const target = formatAxmSkillCompatibilityTarget(compatibility.recovery);
+        return [
+            {
+                kind: "advisory",
+                ruleId: RULE_ID,
+                severity: "error",
+                message: `${compatibility.detail ?? "The official AXM skill is incompatible with this AXM CLI."} Reason: ${compatibility.reasonCode ?? "unknown"}. Target: ${target}.${recovery === null ? "" : ` Next: \`${recovery}\`.`}`,
+                location: {
+                    file: context.subject.scope === "project"
+                        ? "skills/axm"
+                        : `${canonicalDisplayRoot(context.subject.scope)}/@agentxm/skills/axm`,
+                },
+            },
+        ];
+    }),
+};
+//# sourceMappingURL=axm-skill-compatible.js.map

package/dist/src/catalog/workspace/configured-but-not-installed.d.ts

@@ -0,0 +1,4 @@
+import type { WorkspaceRuleContext } from "../../workspace-context.js";
+import type { AdvisoryRule } from "@agentxm/registry-protocol/unstable/lint/rule";
+export declare const configuredButNotInstalledRule: AdvisoryRule<WorkspaceRuleContext>;
+//# sourceMappingURL=configured-but-not-installed.d.ts.map

package/dist/src/catalog/workspace/configured-but-not-installed.js

@@ -0,0 +1,88 @@
+// @effect-diagnostics anyUnknownInErrorContext:off — lint converts opaque observation failures into fact-only findings at this boundary
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+import { extensionTypeSentenceLabels, } from "@agentxm/extension-model/unstable/extensions/common";
+import { canonicalDisplayRoot, settingsDisplayPath } from "./display-paths.js";
+import { categorizeEntry } from "./helpers/source-categorize.js";
+const RULE_ID = "workspace/configured-but-not-installed";
+/**
+ * Every read-model family whose rows this rule walks.
+ *
+ * Total over `ExtensionType`: the rule used to read five of the nine families
+ * and silently said nothing about a configured-but-absent context package,
+ * rule, hook, or knowledge bundle. Keyed off the type table, a new extension
+ * type now fails compile here until its coverage is decided.
+ */
+const INSTALLED_ROWS_BY_TYPE = {
+    skill: (workspace) => workspace.skills.installed,
+    "mcp-server": (workspace) => workspace.mcpServers.installed,
+    subagent: (workspace) => workspace.subagents.installed,
+    rule: (workspace) => workspace.rules.installed,
+    hook: (workspace) => workspace.hooks.installed,
+    knowledge: (workspace) => workspace.knowledge.installed,
+    pack: (workspace) => workspace.packs.installed,
+};
+/**
+ * Read order. Findings render in this order, so it is declared rather than
+ * derived from object key order.
+ */
+const READ_ORDER = [
+    "skill",
+    "mcp-server",
+    "subagent",
+    "rule",
+    "hook",
+    "knowledge",
+    "pack",
+];
+const extensionLabel = (type) => extensionTypeSentenceLabels[type];
+const hasCanonicalContent = (actual) => actual.some((entry) => entry.origin._tag.startsWith("canonical-axm-") ||
+    entry.origin._tag.startsWith("external-axm-"));
+const findingFor = (row, scope) => ({
+    kind: "advisory",
+    ruleId: RULE_ID,
+    severity: "error",
+    message: row.installationOrigin._tag === "direct" &&
+        row.installationOrigin.declared.entry.source !== undefined &&
+        categorizeEntry(row.key.name, row.installationOrigin.declared.entry.source).kind === "workspace"
+        ? `${extensionLabel(row.key.type)} '${row.key.name}' declares a workspace source, but its authored canonical package is missing from the configured authored root.`
+        : `${extensionLabel(row.key.type)} '${row.key.name}' is desired, but its canonical content is missing from ${canonicalDisplayRoot(scope)}.`,
+    location: { file: settingsDisplayPath(scope) },
+});
+const hasLintableInstallSource = (row) => {
+    if (row.installationOrigin._tag === "pack-member")
+        return true;
+    const source = row.installationOrigin.declared.entry.source;
+    if (source === undefined)
+        return false;
+    const categorized = categorizeEntry(row.key.name, source);
+    return (categorized.kind === "registry" ||
+        categorized.kind === "workspace" ||
+        categorized.kind === "non-registry");
+};
+const checkRows = (rows, scope) => rows.flatMap((row) => {
+    if (row.activation === "disabled")
+        return [];
+    if (row.installationOrigin._tag !== "direct" && row.installationOrigin._tag !== "pack-member") {
+        return [];
+    }
+    if (!hasLintableInstallSource(row))
+        return [];
+    if (hasCanonicalContent(row.actual))
+        return [];
+    return [findingFor(row, scope)];
+});
+const readRows = (effect) => Effect.gen(function* () {
+    const result = yield* Effect.result(effect);
+    if (Result.isFailure(result))
+        return [];
+    return result.success;
+});
+export const configuredButNotInstalledRule = {
+    id: RULE_ID,
+    description: "Configured extensions have canonical content in the scope's canonical roots.",
+    kind: "advisory",
+    severity: "error",
+    check: (context) => Effect.map(Effect.forEach(READ_ORDER, (type) => readRows(INSTALLED_ROWS_BY_TYPE[type](context.workspace)), { concurrency: "unbounded" }), (families) => families.flatMap((rows) => checkRows(rows, context.subject.scope))),
+};
+//# sourceMappingURL=configured-but-not-installed.js.map

package/dist/src/catalog/workspace/desired-state-reconcilable.d.ts

@@ -0,0 +1,4 @@
+import type { WorkspaceRuleContext } from "../../workspace-context.js";
+import type { AdvisoryRule } from "@agentxm/registry-protocol/unstable/lint/rule";
+export declare const desiredStateReconcilableRule: AdvisoryRule<WorkspaceRuleContext>;
+//# sourceMappingURL=desired-state-reconcilable.d.ts.map

package/dist/src/catalog/workspace/desired-state-reconcilable.js

@@ -0,0 +1,96 @@
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+import { extensionConstraintFactText, makeExtensionConstraintInvariantFact, } from "@agentxm/extension-workspace";
+import { isWorkspaceSourceLocator } from "@agentxm/extension-model/unstable/sources/workspace";
+const RULE_ID = "workspace/desired-state-reconcilable";
+export const desiredStateReconcilableRule = {
+    id: RULE_ID,
+    description: "Desired-state declarations and observations are mutually reconcilable.",
+    kind: "advisory",
+    severity: "error",
+    check: (context) => Effect.gen(function* () {
+        if (context.health === undefined)
+            return [];
+        const graph = yield* Effect.result(context.health.desiredState);
+        if (Result.isFailure(graph))
+            return [];
+        const graphFindings = graph.success.problems.map((problem) => {
+            if ("pack" in problem) {
+                const observed = problem.type === "pack-manifest-content-mismatch"
+                    ? ` Accepted version=${problem.acceptedVersion} content=${problem.acceptedContentIdentity}; observed status=${problem.status}${problem.observedVersion === undefined ? "" : ` version=${problem.observedVersion} content=${problem.observedContentIdentity}`}.`
+                    : "";
+                return {
+                    kind: "advisory",
+                    ruleId: RULE_ID,
+                    severity: "error",
+                    message: `Pack '${problem.pack}' does not currently form a reconcilable desired-state route.${observed}`,
+                    location: { file: "axm.json" },
+                };
+            }
+            return {
+                kind: "advisory",
+                ruleId: RULE_ID,
+                severity: "error",
+                message: problem.type === "workspace-owner-missing"
+                    ? `${problem.extensionType} '${problem.name}' uses source 'workspace', but axm.json does not declare an owner.`
+                    : problem.type === "projection-collision"
+                        ? `${problem.extensionType} '${problem.name}' has competing desired identities: ${problem.identities.join(", ")}.`
+                        : `${problem.extensionType} '${problem.name}' has incompatible constraints: ${problem.contributors
+                            .map((contributor) => contributor.source === "pack"
+                            ? `${contributor.dependingPack ?? "unknown Pack"} range=${contributor.range} location=${contributor.location}`
+                            : `settings range=${contributor.range} location=${contributor.location}`)
+                            .join(", ")}. Decision=blocked; reason=no-satisfying-version.`,
+                location: { file: "axm.json" },
+            };
+        });
+        if (context.health.canonicalObservations === undefined)
+            return graphFindings;
+        const observations = yield* Effect.result(context.health.canonicalObservations);
+        if (Result.isFailure(observations))
+            return graphFindings;
+        const observationFindings = observations.success.flatMap(({ desired, observation }) => {
+            if (observation.status === "usable" ||
+                observation.status === "not-applicable" ||
+                observation.status === "missing") {
+                return [];
+            }
+            const identity = desired.identity.replace(/^workspace:/, "");
+            const label = `${observation.type} '${identity}'`;
+            if (observation.status === "constraint-mismatch") {
+                const blockedByConflict = graph.success.problems.some((problem) => problem.type === "constraint-conflict" &&
+                    problem.extensionType === desired.type &&
+                    problem.name === desired.name);
+                if (blockedByConflict)
+                    return [];
+                const fact = makeExtensionConstraintInvariantFact(desired, observation);
+                return [
+                    {
+                        kind: "advisory",
+                        ruleId: RULE_ID,
+                        severity: "error",
+                        message: `${extensionConstraintFactText(fact)}; decision=reconcilable.`,
+                        location: { file: observation.path ?? "axm.json" },
+                    },
+                ];
+            }
+            if (observation.status === "locally-modified" &&
+                desired.source !== undefined &&
+                isWorkspaceSourceLocator(desired.source)) {
+                return [];
+            }
+            return [
+                {
+                    kind: "advisory",
+                    ruleId: RULE_ID,
+                    severity: "error",
+                    message: observation.status === "materialization-mismatch"
+                        ? `${label} differs from its accepted materialized package-tree integrity.`
+                        : `${label} has canonical state ${observation.status}.`,
+                    location: { file: observation.path ?? "axm.json" },
+                },
+            ];
+        });
+        return [...graphFindings, ...observationFindings];
+    }),
+};
+//# sourceMappingURL=desired-state-reconcilable.js.map

package/dist/src/catalog/workspace/display-paths.d.ts

@@ -0,0 +1,7 @@
+import type { WorkspaceRuleContext } from "../../workspace-context.js";
+type WorkspaceScope = WorkspaceRuleContext["subject"]["scope"];
+export declare const settingsDisplayPath: (scope: WorkspaceScope) => string;
+export declare const lockfileDisplayPath: (scope: WorkspaceScope) => string;
+export declare const canonicalDisplayRoot: (scope: WorkspaceScope) => string;
+export {};
+//# sourceMappingURL=display-paths.d.ts.map

package/dist/src/catalog/workspace/display-paths.js

@@ -0,0 +1,4 @@
+export const settingsDisplayPath = (scope) => scope === "project" ? "axm.json" : ".axm/workspace/axm.json";
+export const lockfileDisplayPath = (scope) => scope === "project" ? "axm-lock.yaml" : ".axm/workspace/axm-lock.yaml";
+export const canonicalDisplayRoot = (scope) => scope === "project" ? "agent_extensions" : ".axm/workspace/agent_extensions";
+//# sourceMappingURL=display-paths.js.map