@agentxm/workspace-lint 0.28.4-bootstrap.0

package/dist/src/catalog/workspace/helpers/empty.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Typed empty constants used by workspace rules to satisfy return types
+ * without resorting to `[]` + type assertion. Using a shared `const` avoids
+ * repeated `as ReadonlyArray<T>` assertions (banned by the repo style guide)
+ * while keeping the inferred type stable.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { AdvisoryFinding, LintFinding } from "@agentxm/registry-protocol/unstable/lint/rule";
+import type { Operation } from "@agentxm/workspace-operations";
+/** Shared empty AdvisoryFinding array. */
+export declare const EMPTY_ADVISORY_FINDINGS: ReadonlyArray<AdvisoryFinding>;
+/** Shared empty LintFinding array. */
+export declare const EMPTY_LINT_FINDINGS: ReadonlyArray<LintFinding>;
+/** Shared empty Operation array. */
+export declare const EMPTY_OPERATIONS: ReadonlyArray<Operation<string, unknown>>;
+//# sourceMappingURL=empty.d.ts.map

package/dist/src/catalog/workspace/helpers/empty.js

@@ -0,0 +1,16 @@
+/**
+ * Typed empty constants used by workspace rules to satisfy return types
+ * without resorting to `[]` + type assertion. Using a shared `const` avoids
+ * repeated `as ReadonlyArray<T>` assertions (banned by the repo style guide)
+ * while keeping the inferred type stable.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+/** Shared empty AdvisoryFinding array. */
+export const EMPTY_ADVISORY_FINDINGS = [];
+/** Shared empty LintFinding array. */
+export const EMPTY_LINT_FINDINGS = [];
+/** Shared empty Operation array. */
+export const EMPTY_OPERATIONS = [];
+//# sourceMappingURL=empty.js.map

package/dist/src/catalog/workspace/helpers/finding.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Shared finding helpers for workspace lint rules.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { FindingBase } from "@agentxm/registry-protocol/unstable/lint/rule";
+/** Structural identity used by rule `fix` lookups. */
+export declare const isSameFinding: (left: FindingBase, right: FindingBase) => boolean;
+//# sourceMappingURL=finding.d.ts.map

package/dist/src/catalog/workspace/helpers/finding.js

@@ -0,0 +1,11 @@
+/**
+ * Shared finding helpers for workspace lint rules.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+/** Structural identity used by rule `fix` lookups. */
+export const isSameFinding = (left, right) => left.ruleId === right.ruleId &&
+    left.message === right.message &&
+    left.location?.file === right.location?.file;
+//# sourceMappingURL=finding.js.map

package/dist/src/catalog/workspace/helpers/source-categorize.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Shared source categorization for workspace declaration rules.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+/** Shared normalized view of a declared source string. */
+export interface Categorized {
+    readonly name: string;
+    readonly source: string;
+    readonly kind: "registry" | "workspace" | "bare" | "non-registry" | "registry-no-owner";
+    readonly registryFqn?: string;
+}
+/** Classify a declaration source into registry / bare / non-registry buckets. */
+export declare const categorizeEntry: (name: string, source: string) => Categorized;
+//# sourceMappingURL=source-categorize.d.ts.map

package/dist/src/catalog/workspace/helpers/source-categorize.js

@@ -0,0 +1,51 @@
+/**
+ * Shared source categorization for workspace declaration rules.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import { parseRegistrySourceRef } from "@agentxm/extension-model/unstable/extensions/registry-source";
+import { parseFqn } from "@agentxm/extension-model/unstable/extensions/fqn";
+import { isWorkspaceSourceLocator } from "@agentxm/extension-model/unstable/sources/workspace";
+import * as Result from "effect/Result";
+const BARE_NAME_RE = /^[a-z0-9][a-z0-9-]*(?:@[^\s/:]+)?$/i;
+const NON_REGISTRY_MARKERS = [
+    /^\.\//,
+    /^\.\.\//,
+    /^\//,
+    /^file:\/\//,
+    /:\/\//,
+    /^[a-z][a-z0-9+.-]*:/i,
+];
+const isClearlyNonRegistrySource = (source) => NON_REGISTRY_MARKERS.some((pattern) => pattern.test(source));
+/** Classify a declaration source into registry / bare / non-registry buckets. */
+export const categorizeEntry = (name, source) => {
+    if (isWorkspaceSourceLocator(source)) {
+        const parsed = parseFqn(source.slice("workspace:".length));
+        return Result.isSuccess(parsed)
+            ? {
+                name,
+                source,
+                kind: "workspace",
+                registryFqn: `${parsed.success.owner}/${parsed.success.type}/${parsed.success.name}`,
+            }
+            : { name, source, kind: "workspace" };
+    }
+    const parsed = parseRegistrySourceRef(source);
+    if (parsed !== undefined) {
+        return {
+            name,
+            source,
+            kind: "registry",
+            registryFqn: `${parsed.owner}/${parsed.type}/${parsed.name}`,
+        };
+    }
+    if (isClearlyNonRegistrySource(source)) {
+        return { name, source, kind: "non-registry" };
+    }
+    if (BARE_NAME_RE.test(source)) {
+        return { name, source, kind: "bare" };
+    }
+    return { name, source, kind: "registry-no-owner" };
+};
+//# sourceMappingURL=source-categorize.js.map

package/dist/src/catalog/workspace/hook-ownership-ambiguous.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 hookOwnershipAmbiguousRule: AdvisoryRule<WorkspaceRuleContext>;
+//# sourceMappingURL=hook-ownership-ambiguous.d.ts.map

package/dist/src/catalog/workspace/hook-ownership-ambiguous.js

@@ -0,0 +1,25 @@
+import * as Effect from "effect/Effect";
+import { EMPTY_LINT_FINDINGS } from "./helpers/empty.js";
+const RULE_ID = "workspace/hook-ownership-ambiguous";
+const relativeToRoot = (root, file) => {
+    const prefix = `${root}/`;
+    return file.startsWith(prefix) ? file.slice(prefix.length) : file;
+};
+export const hookOwnershipAmbiguousRule = {
+    id: RULE_ID,
+    description: "Hook entries that resemble AXM output carry explicit ownership metadata.",
+    kind: "advisory",
+    severity: "warning",
+    check: (context) => context.ownership === undefined
+        ? Effect.succeed(EMPTY_LINT_FINDINGS)
+        : context.ownership.pipe(Effect.map((issues) => issues
+            .filter((issue) => issue.kind === "hook-ownership-ambiguous")
+            .map((issue) => ({
+            kind: "advisory",
+            ruleId: RULE_ID,
+            severity: "warning",
+            message: issue.detail,
+            location: { file: relativeToRoot(context.subject.root, issue.path) },
+        })))),
+};
+//# sourceMappingURL=hook-ownership-ambiguous.js.map

package/dist/src/catalog/workspace/initialized.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `workspace/initialized` — the scope's settings authority exists.
+ *
+ * Per the lint design "Foundation" row:
+ *
+ *   WorkspaceMutations bootstrap invariant. Absorbs doctor `workspace-ready.*` checks.
+ *
+ * Applies to every workspace read model (both scopes). Owns the presence arm;
+ * `workspace/settings-schema-valid` owns the contents arm and early-returns
+ * when `axm.json` is missing, so a fresh workspace surfaces exactly one
+ * finding from this rule.
+ *
+ * Advisory-only — scaffolding a workspace is a multi-step `axm setup` command;
+ * keeping it a suggestion scopes autofix to Operation-expressible mutations.
+ *
+ * @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 initializedRule: AdvisoryRule<WorkspaceRuleContext>;
+//# sourceMappingURL=initialized.d.ts.map

package/dist/src/catalog/workspace/initialized.js

@@ -0,0 +1,58 @@
+/**
+ * `workspace/initialized` — the scope's settings authority exists.
+ *
+ * Per the lint design "Foundation" row:
+ *
+ *   WorkspaceMutations bootstrap invariant. Absorbs doctor `workspace-ready.*` checks.
+ *
+ * Applies to every workspace read model (both scopes). Owns the presence arm;
+ * `workspace/settings-schema-valid` owns the contents arm and early-returns
+ * when `axm.json` is missing, so a fresh workspace surfaces exactly one
+ * finding from this rule.
+ *
+ * Advisory-only — scaffolding a workspace is a multi-step `axm setup` command;
+ * keeping it a suggestion scopes autofix to Operation-expressible mutations.
+ *
+ * @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";
+const RULE_ID = "workspace/initialized";
+const AXM_REL = ".axm";
+export const initializedRule = {
+    id: RULE_ID,
+    description: "The workspace includes its scope-specific settings authority.",
+    kind: "advisory",
+    severity: "error",
+    check: (context) => Effect.gen(function* () {
+        const scoped = context.workspace;
+        const settingsPath = settingsDisplayPath(context.subject.scope);
+        const settingsRaw = yield* Effect.result(scoped.state.raw("settings"));
+        const axmDirExists = yield* context.axmDirExists;
+        const findings = [];
+        if (Result.isFailure(settingsRaw) || Option.isNone(settingsRaw.success)) {
+            if (context.subject.scope === "user" && !axmDirExists) {
+                findings.push({
+                    kind: "advisory",
+                    ruleId: RULE_ID,
+                    severity: "error",
+                    message: "The workspace does not contain an `.axm/` state directory.",
+                    location: { file: AXM_REL },
+                });
+                return findings;
+            }
+            findings.push({
+                kind: "advisory",
+                ruleId: RULE_ID,
+                severity: "error",
+                message: "The workspace settings file is missing.",
+                location: { file: settingsPath },
+            });
+        }
+        return findings;
+    }),
+};
+//# sourceMappingURL=initialized.js.map

package/dist/src/catalog/workspace/instructions-agent-supported.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 instructionsAgentSupportedRule: AdvisoryRule<WorkspaceRuleContext>;
+//# sourceMappingURL=instructions-agent-supported.d.ts.map

package/dist/src/catalog/workspace/instructions-agent-supported.js

@@ -0,0 +1,38 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { EMPTY_ADVISORY_FINDINGS } from "./helpers/empty.js";
+const RULE_ID = "workspace/instructions-agent-supported";
+const relativeToRoot = (root, file) => {
+    if (file === root)
+        return "";
+    const prefix = `${root}/`;
+    return file.startsWith(prefix) ? file.slice(prefix.length) : file;
+};
+export const instructionsAgentSupportedRule = {
+    id: RULE_ID,
+    description: "Configured agents support automatic instruction propagation.",
+    kind: "advisory",
+    severity: "warning",
+    check: (context) => Effect.gen(function* () {
+        if (context.instructions === undefined)
+            return EMPTY_ADVISORY_FINDINGS;
+        const snapshot = yield* context.instructions.snapshot;
+        if (Option.isNone(snapshot))
+            return EMPTY_ADVISORY_FINDINGS;
+        const findings = [];
+        for (const item of snapshot.value.status.items) {
+            if (item.health !== "unsupported" && item.mechanism !== "adapter")
+                continue;
+            findings.push({
+                kind: "advisory",
+                ruleId: RULE_ID,
+                severity: "warning",
+                message: `${item.agentName} does not support automatic instruction-file propagation. ` +
+                    "Manage that agent's instruction file manually.",
+                location: { file: relativeToRoot(context.subject.root, item.targetFile) },
+            });
+        }
+        return findings;
+    }),
+};
+//# sourceMappingURL=instructions-agent-supported.js.map

package/dist/src/catalog/workspace/instructions-gitignore-current.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 instructionsGitignoreCurrentRule: AdvisoryRule<WorkspaceRuleContext>;
+//# sourceMappingURL=instructions-gitignore-current.d.ts.map

package/dist/src/catalog/workspace/instructions-gitignore-current.js

@@ -0,0 +1,49 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { EMPTY_LINT_FINDINGS } from "./helpers/empty.js";
+const RULE_ID = "workspace/instructions-gitignore-current";
+const relativeToRoot = (root, file) => {
+    if (file === root)
+        return "";
+    const prefix = `${root}/`;
+    return file.startsWith(prefix) ? file.slice(prefix.length) : file;
+};
+export const instructionsGitignoreCurrentRule = {
+    id: RULE_ID,
+    description: "Instruction-file gitignore entries match the configured policy.",
+    kind: "advisory",
+    severity: "info",
+    check: (context) => Effect.gen(function* () {
+        if (context.instructions === undefined)
+            return EMPTY_LINT_FINDINGS;
+        const snapshot = yield* context.instructions.snapshot;
+        if (Option.isNone(snapshot))
+            return EMPTY_LINT_FINDINGS;
+        const status = snapshot.value.gitignore;
+        if (status.trackedAliases.length > 0) {
+            return [
+                {
+                    kind: "advisory",
+                    ruleId: RULE_ID,
+                    severity: "info",
+                    message: `Managed ignore entries cover paths already present in the Git index (${status.trackedAliases.join(", ")}); set gitignoreAliases: false to reconcile tracked instruction aliases.`,
+                    location: { file: relativeToRoot(context.subject.root, status.file) },
+                },
+            ];
+        }
+        if (status.current)
+            return EMPTY_LINT_FINDINGS;
+        return [
+            {
+                kind: "advisory",
+                ruleId: RULE_ID,
+                severity: "info",
+                message: status.desired
+                    ? "Instruction-file ignore entries are missing or stale."
+                    : "Instruction-file ignore entries are disabled but a managed block remains.",
+                location: { file: relativeToRoot(context.subject.root, status.file) },
+            },
+        ];
+    }),
+};
+//# sourceMappingURL=instructions-gitignore-current.js.map

package/dist/src/catalog/workspace/instructions-source-present.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 instructionsSourcePresentRule: AdvisoryRule<WorkspaceRuleContext>;
+//# sourceMappingURL=instructions-source-present.d.ts.map

package/dist/src/catalog/workspace/instructions-source-present.js

@@ -0,0 +1,41 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { EMPTY_ADVISORY_FINDINGS } from "./helpers/empty.js";
+const RULE_ID = "workspace/instructions-source-present";
+const relativeToRoot = (root, file) => {
+    if (file === root)
+        return "";
+    const prefix = `${root}/`;
+    return file.startsWith(prefix) ? file.slice(prefix.length) : file;
+};
+export const instructionsSourcePresentRule = {
+    id: RULE_ID,
+    description: "The configured instruction source file exists.",
+    kind: "advisory",
+    severity: "error",
+    check: (context) => Effect.gen(function* () {
+        if (context.instructions === undefined)
+            return EMPTY_ADVISORY_FINDINGS;
+        const snapshot = yield* context.instructions.snapshot;
+        if (Option.isNone(snapshot))
+            return EMPTY_ADVISORY_FINDINGS;
+        const sourceFiles = new Set([
+            ...snapshot.value.status.missingSources,
+            ...snapshot.value.status.items
+                .filter((item) => item.health === "missing-source")
+                .map((item) => item.sourceFile),
+        ]);
+        const findings = [];
+        for (const sourceFile of sourceFiles) {
+            findings.push({
+                kind: "advisory",
+                ruleId: RULE_ID,
+                severity: "error",
+                message: "The configured instruction source file is missing.",
+                location: { file: relativeToRoot(context.subject.root, sourceFile) },
+            });
+        }
+        return findings;
+    }),
+};
+//# sourceMappingURL=instructions-source-present.js.map

package/dist/src/catalog/workspace/instructions-target-current.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 instructionsTargetCurrentRule: AdvisoryRule<WorkspaceRuleContext>;
+//# sourceMappingURL=instructions-target-current.d.ts.map

package/dist/src/catalog/workspace/instructions-target-current.js

@@ -0,0 +1,51 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { EMPTY_LINT_FINDINGS } from "./helpers/empty.js";
+const RULE_ID = "workspace/instructions-target-current";
+const relativeToRoot = (root, file) => {
+    if (file === root)
+        return "";
+    const prefix = `${root}/`;
+    return file.startsWith(prefix) ? file.slice(prefix.length) : file;
+};
+const targetHealth = new Set(["missing-target", "drift"]);
+/**
+ * A projected target whose desired state is fully determined by its source:
+ * absent, or an AXM-owned copy that drifted. Anything unowned at the same
+ * path — authored content, a foreign or dangling symlink — is a collision,
+ * reported by `workspace/instructions-target-unowned`, never as regenerable
+ * drift. A missing source is reported by `workspace/instructions-source-present`.
+ */
+const isTargetFinding = (item) => (item.mechanism === "symlink" || item.mechanism === "copy") &&
+    targetHealth.has(item.health) &&
+    item.ownership !== "unowned";
+const messageFor = (item) => item.health === "missing-target"
+    ? `The ${item.agentName} instruction file is missing.`
+    : `The AXM-managed ${item.agentName} instruction copy differs from the source file.`;
+export const instructionsTargetCurrentRule = {
+    id: RULE_ID,
+    description: "Configured agent instruction target files are current.",
+    kind: "advisory",
+    severity: "warning",
+    check: (context) => Effect.gen(function* () {
+        if (context.instructions === undefined)
+            return EMPTY_LINT_FINDINGS;
+        const snapshot = yield* context.instructions.snapshot;
+        if (Option.isNone(snapshot))
+            return EMPTY_LINT_FINDINGS;
+        const findings = [];
+        for (const item of snapshot.value.status.items) {
+            if (!isTargetFinding(item))
+                continue;
+            findings.push({
+                kind: "advisory",
+                ruleId: RULE_ID,
+                severity: "warning",
+                message: messageFor(item),
+                location: { file: relativeToRoot(context.subject.root, item.targetFile) },
+            });
+        }
+        return findings;
+    }),
+};
+//# sourceMappingURL=instructions-target-current.js.map

package/dist/src/catalog/workspace/instructions-target-stale.d.ts

@@ -0,0 +1,9 @@
+import type { WorkspaceRuleContext } from "../../workspace-context.js";
+import type { AdvisoryRule } from "@agentxm/registry-protocol/unstable/lint/rule";
+/**
+ * An AXM-owned alias the current plan no longer desires — left behind by a
+ * removed source root, a removed agent, or a changed source filename. Its
+ * ownership is proven by inspection, so removal is fully determined.
+ */
+export declare const instructionsTargetStaleRule: AdvisoryRule<WorkspaceRuleContext>;
+//# sourceMappingURL=instructions-target-stale.d.ts.map

package/dist/src/catalog/workspace/instructions-target-stale.js

@@ -0,0 +1,41 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { EMPTY_LINT_FINDINGS } from "./helpers/empty.js";
+const RULE_ID = "workspace/instructions-target-stale";
+const relativeToRoot = (root, file) => {
+    if (file === root)
+        return "";
+    const prefix = `${root}/`;
+    return file.startsWith(prefix) ? file.slice(prefix.length) : file;
+};
+/**
+ * An AXM-owned alias the current plan no longer desires — left behind by a
+ * removed source root, a removed agent, or a changed source filename. Its
+ * ownership is proven by inspection, so removal is fully determined.
+ */
+export const instructionsTargetStaleRule = {
+    id: RULE_ID,
+    description: "No AXM-owned instruction alias outlives the plan that created it.",
+    kind: "advisory",
+    severity: "warning",
+    check: (context) => Effect.gen(function* () {
+        if (context.instructions === undefined)
+            return EMPTY_LINT_FINDINGS;
+        const snapshot = yield* context.instructions.snapshot;
+        if (Option.isNone(snapshot))
+            return EMPTY_LINT_FINDINGS;
+        const findings = [];
+        for (const item of snapshot.value.status.staleTargets) {
+            findings.push({
+                kind: "advisory",
+                ruleId: RULE_ID,
+                severity: "warning",
+                message: `The AXM-owned ${item.agentName} instruction ${item.observedForm === "copy" ? "copy" : "symlink"} ` +
+                    "is no longer desired by the current instruction configuration.",
+                location: { file: relativeToRoot(context.subject.root, item.targetFile) },
+            });
+        }
+        return findings;
+    }),
+};
+//# sourceMappingURL=instructions-target-stale.js.map

package/dist/src/catalog/workspace/instructions-target-unowned.d.ts

@@ -0,0 +1,10 @@
+import type { WorkspaceRuleContext } from "../../workspace-context.js";
+import type { AdvisoryRule } from "@agentxm/registry-protocol/unstable/lint/rule";
+/**
+ * An unowned file at a planned instruction target is a collision, not drift:
+ * AXM cannot prove it produced the content, so no reconciliation may replace
+ * it and `axm sync` refuses until a person decides. The finding names the
+ * path and the decision; it carries no repair.
+ */
+export declare const instructionsTargetUnownedRule: AdvisoryRule<WorkspaceRuleContext>;
+//# sourceMappingURL=instructions-target-unowned.d.ts.map

package/dist/src/catalog/workspace/instructions-target-unowned.js

@@ -0,0 +1,59 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { EMPTY_LINT_FINDINGS } from "./helpers/empty.js";
+const RULE_ID = "workspace/instructions-target-unowned";
+const occupantFor = (item) => {
+    switch (item.observedForm) {
+        case "directory":
+            return "directory";
+        case "symlink":
+            return "symlink";
+        case "broken-link":
+            return "dangling symlink";
+        default:
+            return "file";
+    }
+};
+const relativeToRoot = (root, file) => {
+    if (file === root)
+        return "";
+    const prefix = `${root}/`;
+    return file.startsWith(prefix) ? file.slice(prefix.length) : file;
+};
+/**
+ * An unowned file at a planned instruction target is a collision, not drift:
+ * AXM cannot prove it produced the content, so no reconciliation may replace
+ * it and `axm sync` refuses until a person decides. The finding names the
+ * path and the decision; it carries no repair.
+ */
+export const instructionsTargetUnownedRule = {
+    id: RULE_ID,
+    description: "Planned instruction targets are free of files AXM does not own.",
+    kind: "advisory",
+    severity: "warning",
+    check: (context) => Effect.gen(function* () {
+        if (context.instructions === undefined)
+            return EMPTY_LINT_FINDINGS;
+        const snapshot = yield* context.instructions.snapshot;
+        if (Option.isNone(snapshot))
+            return EMPTY_LINT_FINDINGS;
+        const findings = [];
+        for (const item of snapshot.value.status.items) {
+            if (item.mechanism !== "symlink" && item.mechanism !== "copy")
+                continue;
+            if (item.ownership !== "unowned")
+                continue;
+            findings.push({
+                kind: "advisory",
+                ruleId: RULE_ID,
+                severity: "warning",
+                message: `An unowned ${occupantFor(item)} occupies the ${item.agentName} instruction target; ` +
+                    "AXM will not modify it. Remove or rename it, or make it the canonical source with " +
+                    "`axm instructions enable --file`.",
+                location: { file: relativeToRoot(context.subject.root, item.targetFile) },
+            });
+        }
+        return findings;
+    }),
+};
+//# sourceMappingURL=instructions-target-unowned.js.map

package/dist/src/catalog/workspace/knowledge-state-valid.d.ts

@@ -0,0 +1,5 @@
+/** Reports invalid observed state for desired Knowledge bundles. */
+import type { WorkspaceRuleContext } from "../../workspace-context.js";
+import type { AdvisoryRule } from "@agentxm/registry-protocol/unstable/lint/rule";
+export declare const knowledgeStateValidRule: AdvisoryRule<WorkspaceRuleContext>;
+//# sourceMappingURL=knowledge-state-valid.d.ts.map

package/dist/src/catalog/workspace/knowledge-state-valid.js

@@ -0,0 +1,65 @@
+/** Reports invalid observed state for desired Knowledge bundles. */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Result from "effect/Result";
+import { canonicalDisplayRoot, settingsDisplayPath } from "./display-paths.js";
+const RULE_ID = "workspace/knowledge-state-valid";
+export const knowledgeStateValidRule = {
+    id: RULE_ID,
+    description: "Desired Knowledge content has usable canonical state.",
+    kind: "advisory",
+    severity: "error",
+    check: (context) => Effect.gen(function* () {
+        const [unmanaged, resolved] = yield* Effect.all([
+            Effect.result(context.workspace.knowledge.unmanaged),
+            Effect.result(context.workspace.knowledge.resolved),
+        ]);
+        const resolvedNames = Result.isFailure(resolved)
+            ? new Set()
+            : new Set(Option.getOrElse(resolved.success, () => []).map(({ name }) => name));
+        const unmanagedFindings = Result.isFailure(unmanaged)
+            ? []
+            : unmanaged.success.flatMap(({ key, actual }) => resolvedNames.has(key.name) ||
+                !actual.contentRoot
+                    .replaceAll("\\", "/")
+                    .includes(context.subject.scope === "project"
+                    ? "/agent_extensions/"
+                    : "/.axm/workspace/agent_extensions/")
+                ? []
+                : [
+                    {
+                        kind: "advisory",
+                        ruleId: RULE_ID,
+                        severity: "error",
+                        message: `Knowledge bundle '${key.name}' has canonical content without an accepted AXM ownership fact.`,
+                        location: { file: canonicalDisplayRoot(context.subject.scope) },
+                    },
+                ]);
+        if (context.health?.canonicalObservations === undefined)
+            return unmanagedFindings;
+        const observations = yield* Effect.result(context.health.canonicalObservations);
+        if (Result.isFailure(observations))
+            return unmanagedFindings;
+        const observedFindings = observations.success.flatMap(({ desired, observation }) => {
+            if (desired.type !== "knowledge" ||
+                observation.status === "usable" ||
+                observation.status === "not-applicable" ||
+                observation.status === "locally-modified") {
+                return [];
+            }
+            return [
+                {
+                    kind: "advisory",
+                    ruleId: RULE_ID,
+                    severity: "error",
+                    message: `Knowledge bundle '${desired.name}' has canonical state ${observation.status}.`,
+                    location: {
+                        file: observation.path ?? settingsDisplayPath(context.subject.scope),
+                    },
+                },
+            ];
+        });
+        return [...unmanagedFindings, ...observedFindings];
+    }),
+};
+//# sourceMappingURL=knowledge-state-valid.js.map

package/dist/src/catalog/workspace/lockfile-valid.d.ts

@@ -0,0 +1,5 @@
+/** Reports whether accepted external-resolution state is readable and present when required. */
+import type { WorkspaceRuleContext } from "../../workspace-context.js";
+import type { AdvisoryRule } from "@agentxm/registry-protocol/unstable/lint/rule";
+export declare const lockfileValidRule: AdvisoryRule<WorkspaceRuleContext>;
+//# sourceMappingURL=lockfile-valid.d.ts.map