@agentxm/workspace-lint 0.30.1 → 0.30.2

package/dist/src/catalog/workspace/agent-content-has-settings.d.ts

@@ -0,0 +1,4 @@
+import type { AdvisoryRule } from "@agentxm/extension-content/lint";
+import type { WorkspaceRuleContext } from "../../workspace-context.js";
+export declare const agentContentHasSettingsRule: AdvisoryRule<WorkspaceRuleContext>;
+//# sourceMappingURL=agent-content-has-settings.d.ts.map

package/dist/src/catalog/workspace/agent-content-has-settings.js

@@ -0,0 +1,51 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Result from "effect/Result";
+import { workspaceDisplayPath } from "./display-paths.js";
+import { EMPTY_LINT_FINDINGS } from "./helpers/empty.js";
+import { agentsDisplay } from "./helpers/agent-scope-display.js";
+const RULE_ID = "workspace/agent-content-has-settings";
+const describeEntry = (entry, display) => {
+    if (entry.kind === "instructions")
+        return `Agent instruction file ${display}`;
+    const count = entry.entryCount ?? 0;
+    const entries = `${count} ${count === 1 ? "entry" : "entries"}`;
+    switch (entry.kind) {
+        case "skill":
+            return `Agent skills directory ${display} with ${entries}`;
+        case "subagent":
+            return `Agent subagents directory ${display} with ${entries}`;
+        case "mcp-server":
+            return `Agent MCP configuration ${display} with ${entries}`;
+        case "hook":
+            return `Agent hook configuration ${display} with ${entries}`;
+    }
+};
+export const agentContentHasSettingsRule = {
+    id: RULE_ID,
+    description: "Agent content in a project folder is explained by project workspace settings.",
+    kind: "advisory",
+    severity: "warning",
+    check: (context) => {
+        const { agentContent } = context;
+        if (context.subject.scope !== "project" || agentContent === undefined)
+            return Effect.succeed(EMPTY_LINT_FINDINGS);
+        return Effect.gen(function* () {
+            const settings = yield* Effect.result(context.workspace.state.raw("settings"));
+            if (Result.isSuccess(settings) && Option.isSome(settings.success))
+                return EMPTY_LINT_FINDINGS;
+            const entries = yield* agentContent;
+            return entries.map((entry) => {
+                const display = workspaceDisplayPath(context.subject.root, entry.path);
+                return {
+                    kind: "advisory",
+                    ruleId: RULE_ID,
+                    severity: "warning",
+                    message: `${describeEntry(entry, display)} for ${agentsDisplay(entry.agentIds)} exists in a folder without project workspace settings (axm.json).`,
+                    location: { file: display },
+                };
+            });
+        });
+    },
+};
+//# sourceMappingURL=agent-content-has-settings.js.map

package/dist/src/catalog/workspace/authored-package-declared.d.ts

@@ -0,0 +1,4 @@
+import type { AdvisoryRule } from "@agentxm/extension-content/lint";
+import type { WorkspaceRuleContext } from "../../workspace-context.js";
+export declare const authoredPackageDeclaredRule: AdvisoryRule<WorkspaceRuleContext>;
+//# sourceMappingURL=authored-package-declared.d.ts.map

package/dist/src/catalog/workspace/authored-package-declared.js

@@ -0,0 +1,26 @@
+import * as Effect from "effect/Effect";
+import { extensionTypeSentenceLabels, toExtensionTypePlural, } from "@agentxm/extension-model/unstable/extensions/common";
+import { settingsDisplayPath, workspaceDisplayPath } from "./display-paths.js";
+import { EMPTY_LINT_FINDINGS } from "./helpers/empty.js";
+const RULE_ID = "workspace/authored-package-declared";
+export const authoredPackageDeclaredRule = {
+    id: RULE_ID,
+    description: "Authored packages in standard authoring folders are declared in workspace settings.",
+    kind: "advisory",
+    severity: "warning",
+    check: (context) => context.authoredPackages === undefined
+        ? Effect.succeed(EMPTY_LINT_FINDINGS)
+        : context.authoredPackages.pipe(Effect.map((packages) => packages
+            .filter((authored) => !authored.declared)
+            .map((authored) => {
+            const display = workspaceDisplayPath(context.subject.root, authored.path);
+            return {
+                kind: "advisory",
+                ruleId: RULE_ID,
+                severity: "warning",
+                message: `Authored ${extensionTypeSentenceLabels[authored.type]} '${authored.owner}/${toExtensionTypePlural(authored.type)}/${authored.name}' version ${authored.version} at ${display} is not declared in ${settingsDisplayPath(context.subject.scope)}.`,
+                location: { file: display },
+            };
+        }))),
+};
+//# sourceMappingURL=authored-package-declared.js.map

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

@@ -2,6 +2,8 @@ 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;
+/** A path under the workspace root, relative to it; any other path unchanged. */
+export declare const workspaceDisplayPath: (root: string, file: string) => string;
 export declare const canonicalDisplayRoot: (scope: WorkspaceScope) => string;
 export {};
 //# sourceMappingURL=display-paths.d.ts.map

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

@@ -1,4 +1,9 @@
 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";
+/** A path under the workspace root, relative to it; any other path unchanged. */
+export const workspaceDisplayPath = (root, file) => {
+    const prefix = `${root}/`;
+    return file.startsWith(prefix) ? file.slice(prefix.length) : file;
+};
 export const canonicalDisplayRoot = (scope) => scope === "project" ? "agent_extensions" : ".axm/workspace/agent_extensions";
 //# sourceMappingURL=display-paths.js.map

package/dist/src/catalog/workspace/helpers/agent-scope-display.d.ts

@@ -0,0 +1,7 @@
+import type { AgentOutputObservation } from "@agentxm/workspace-projection";
+/** A path under the user home as `~/<relative>`; any other path unchanged. */
+export declare const userDisplayPath: (home: string, file: string) => string;
+/** Up to three agent ids by name, otherwise their count. */
+export declare const agentsDisplay: (agentIds: ReadonlyArray<string>) => string;
+export declare const outputTypeLabel: (type: AgentOutputObservation["extensionType"]) => string;
+//# sourceMappingURL=agent-scope-display.d.ts.map

package/dist/src/catalog/workspace/helpers/agent-scope-display.js

@@ -0,0 +1,10 @@
+import { extensionTypeSentenceLabels } from "@agentxm/extension-model/unstable/extensions/common";
+/** A path under the user home as `~/<relative>`; any other path unchanged. */
+export const userDisplayPath = (home, file) => {
+    const prefix = `${home}/`;
+    return file.startsWith(prefix) ? `~/${file.slice(prefix.length)}` : file;
+};
+/** Up to three agent ids by name, otherwise their count. */
+export const agentsDisplay = (agentIds) => agentIds.length <= 3 ? agentIds.join(", ") : `${agentIds.length} agents`;
+export const outputTypeLabel = (type) => extensionTypeSentenceLabels[type];
+//# sourceMappingURL=agent-scope-display.js.map

package/dist/src/catalog/workspace/install-root-entries-recognized.d.ts

@@ -0,0 +1,4 @@
+import type { AdvisoryRule } from "@agentxm/extension-content/lint";
+import type { WorkspaceRuleContext } from "../../workspace-context.js";
+export declare const installRootEntriesRecognizedRule: AdvisoryRule<WorkspaceRuleContext>;
+//# sourceMappingURL=install-root-entries-recognized.d.ts.map

package/dist/src/catalog/workspace/install-root-entries-recognized.js

@@ -0,0 +1,23 @@
+import * as Effect from "effect/Effect";
+import { workspaceDisplayPath } from "./display-paths.js";
+import { EMPTY_LINT_FINDINGS } from "./helpers/empty.js";
+const RULE_ID = "workspace/install-root-entries-recognized";
+export const installRootEntriesRecognizedRule = {
+    id: RULE_ID,
+    description: "Install root entries are installed packages or AXM staging.",
+    kind: "advisory",
+    severity: "warning",
+    check: (context) => context.installRoot === undefined
+        ? Effect.succeed(EMPTY_LINT_FINDINGS)
+        : context.installRoot.pipe(Effect.map((inventory) => inventory.unrecognized.map((entry) => {
+            const display = workspaceDisplayPath(context.subject.root, entry.path);
+            return {
+                kind: "advisory",
+                ruleId: RULE_ID,
+                severity: "warning",
+                message: `Unrecognized ${entry.entryKind} ${display} in the ${context.subject.scope}-scope install root is not an installed package or AXM staging.`,
+                location: { file: display },
+            };
+        }))),
+};
+//# sourceMappingURL=install-root-entries-recognized.js.map

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

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

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

@@ -0,0 +1,27 @@
+import * as Effect from "effect/Effect";
+import { extensionTypeSentenceLabels, toExtensionTypePlural, } from "@agentxm/extension-model/unstable/extensions/common";
+import { workspaceDisplayPath } from "./display-paths.js";
+import { EMPTY_LINT_FINDINGS } from "./helpers/empty.js";
+const RULE_ID = "workspace/installed-but-not-configured";
+const identityOf = (entry) => entry.owner === undefined
+    ? entry.name
+    : `${entry.owner}/${toExtensionTypePlural(entry.type)}/${entry.name}`;
+export const installedButNotConfiguredRule = {
+    id: RULE_ID,
+    description: "Installed packages in the install root are reached by desired state.",
+    kind: "advisory",
+    severity: "warning",
+    check: (context) => context.installRoot === undefined
+        ? Effect.succeed(EMPTY_LINT_FINDINGS)
+        : context.installRoot.pipe(Effect.map((inventory) => inventory.leftovers.map((entry) => {
+            const display = workspaceDisplayPath(context.subject.root, entry.path);
+            return {
+                kind: "advisory",
+                ruleId: RULE_ID,
+                severity: "warning",
+                message: `Installed ${extensionTypeSentenceLabels[entry.type]} '${identityOf(entry)}' is not configured in ${context.subject.scope} scope: canonical path ${display}, source directory ${entry.sourceDirectory ?? "none"}, ${entry.lockKey === undefined ? "no lock row" : "lock row present"}.`,
+                location: { file: display },
+            };
+        }))),
+};
+//# sourceMappingURL=installed-but-not-configured.js.map

package/dist/src/catalog/workspace/project-outputs-not-shadowed.d.ts

@@ -0,0 +1,4 @@
+import type { AdvisoryRule } from "@agentxm/extension-content/lint";
+import type { WorkspaceRuleContext } from "../../workspace-context.js";
+export declare const projectOutputsNotShadowedRule: AdvisoryRule<WorkspaceRuleContext>;
+//# sourceMappingURL=project-outputs-not-shadowed.d.ts.map

package/dist/src/catalog/workspace/project-outputs-not-shadowed.js

@@ -0,0 +1,49 @@
+import * as Effect from "effect/Effect";
+import { workspaceDisplayPath } from "./display-paths.js";
+import { EMPTY_LINT_FINDINGS } from "./helpers/empty.js";
+import { agentsDisplay, outputTypeLabel, userDisplayPath } from "./helpers/agent-scope-display.js";
+const RULE_ID = "workspace/project-outputs-not-shadowed";
+/** Types whose agent outputs are named directory or file entries an agent loads by name. */
+const NAMED_OUTPUT_TYPES = new Set(["skill", "subagent"]);
+export const projectOutputsNotShadowedRule = {
+    id: RULE_ID,
+    description: "Project agent outputs have no same-named user-scope output for the same agent.",
+    kind: "advisory",
+    severity: "warning",
+    check: (context) => {
+        const { agentOutputs, userScope } = context;
+        if (context.subject.scope !== "project" ||
+            agentOutputs === undefined ||
+            userScope === undefined)
+            return Effect.succeed(EMPTY_LINT_FINDINGS);
+        return Effect.gen(function* () {
+            const project = yield* agentOutputs;
+            const user = yield* userScope;
+            const findings = [];
+            for (const output of project.outputs) {
+                if (!NAMED_OUTPUT_TYPES.has(output.extensionType))
+                    continue;
+                for (const other of user.outputs) {
+                    if (other.extensionType !== output.extensionType ||
+                        other.entryName !== output.entryName ||
+                        other.containerPath === output.containerPath)
+                        continue;
+                    const shared = output.claimantAgentIds.filter((id) => other.claimantAgentIds.includes(id));
+                    if (shared.length === 0)
+                        continue;
+                    const display = workspaceDisplayPath(context.subject.root, output.path);
+                    const label = outputTypeLabel(output.extensionType);
+                    findings.push({
+                        kind: "advisory",
+                        ruleId: RULE_ID,
+                        severity: "warning",
+                        message: `Project ${label} '${output.entryName}' at ${display} has a same-named user-scope ${label} at ${userDisplayPath(user.home, other.path)} for ${agentsDisplay(shared)}; the agent decides which one it loads.`,
+                        location: { file: display },
+                    });
+                }
+            }
+            return findings;
+        });
+    },
+};
+//# sourceMappingURL=project-outputs-not-shadowed.js.map

package/dist/src/catalog/workspace/user-outputs-have-settings.d.ts

@@ -0,0 +1,4 @@
+import type { AdvisoryRule } from "@agentxm/extension-content/lint";
+import type { WorkspaceRuleContext } from "../../workspace-context.js";
+export declare const userOutputsHaveSettingsRule: AdvisoryRule<WorkspaceRuleContext>;
+//# sourceMappingURL=user-outputs-have-settings.d.ts.map

package/dist/src/catalog/workspace/user-outputs-have-settings.js

@@ -0,0 +1,35 @@
+import * as Effect from "effect/Effect";
+import { EMPTY_LINT_FINDINGS } from "./helpers/empty.js";
+import { outputTypeLabel, userDisplayPath } from "./helpers/agent-scope-display.js";
+const RULE_ID = "workspace/user-outputs-have-settings";
+const proofText = {
+    "storage-root-symlink": "links into AXM storage",
+    "managed-banner": "carries an AXM ownership marker",
+    "managed-mcp-entry": "is an AXM-managed MCP entry",
+    "managed-hook-group": "is an AXM-managed hook group",
+};
+export const userOutputsHaveSettingsRule = {
+    id: RULE_ID,
+    description: "AXM-owned user-scope agent outputs have readable user workspace settings.",
+    kind: "advisory",
+    severity: "warning",
+    check: (context) => context.userScope === undefined
+        ? Effect.succeed(EMPTY_LINT_FINDINGS)
+        : context.userScope.pipe(Effect.map((user) => user.settingsReadable
+            ? EMPTY_LINT_FINDINGS
+            : user.outputs.flatMap((output) => {
+                if (output.ownership !== "owned" || output.proof === undefined)
+                    return [];
+                const display = userDisplayPath(user.home, output.path);
+                return [
+                    {
+                        kind: "advisory",
+                        ruleId: RULE_ID,
+                        severity: "warning",
+                        message: `User-scope agent ${outputTypeLabel(output.extensionType)} ${display} ${proofText[output.proof]}, but the user workspace has no readable settings at ${userDisplayPath(user.home, user.settingsPath)}.`,
+                        location: { file: display },
+                    },
+                ];
+            }))),
+};
+//# sourceMappingURL=user-outputs-have-settings.js.map

package/dist/src/catalog/workspace.js

@@ -41,7 +41,13 @@ import { axmSkillDeclaredRule } from "./workspace/axm-skill-declared.js";
 import { axmSkillCompatibleRule } from "./workspace/axm-skill-compatible.js";
 import { hookOwnershipAmbiguousRule } from "./workspace/hook-ownership-ambiguous.js";
 import { managedFileUnownedRule } from "./workspace/managed-file-unowned.js";
+import { installedButNotConfiguredRule } from "./workspace/installed-but-not-configured.js";
+import { authoredPackageDeclaredRule } from "./workspace/authored-package-declared.js";
+import { installRootEntriesRecognizedRule } from "./workspace/install-root-entries-recognized.js";
 import { sourceEndpointsAlignedRule } from "./workspace/source-endpoints-aligned.js";
+import { projectOutputsNotShadowedRule } from "./workspace/project-outputs-not-shadowed.js";
+import { userOutputsHaveSettingsRule } from "./workspace/user-outputs-have-settings.js";
+import { agentContentHasSettingsRule } from "./workspace/agent-content-has-settings.js";
 /**
  * Ordered repository-safe `workspace/*` rule catalog. Declaration order is
  * the evaluation order within a single `evaluateContexts` call. It groups
@@ -90,6 +96,12 @@ export const liveOnlyWorkspaceRules = [
     projectionContributorsRenderedRule,
     hookOwnershipAmbiguousRule,
     managedFileUnownedRule,
+    installedButNotConfiguredRule,
+    authoredPackageDeclaredRule,
+    installRootEntriesRecognizedRule,
+    projectOutputsNotShadowedRule,
+    userOutputsHaveSettingsRule,
+    agentContentHasSettingsRule,
     mcpServerAgentDriftRule,
     mcpServerAgentOrphanedRule,
     skillsArtifactsCorrectRule,
@@ -117,6 +129,12 @@ export const workspaceRules = [
     projectionContributorsRenderedRule,
     hookOwnershipAmbiguousRule,
     managedFileUnownedRule,
+    installedButNotConfiguredRule,
+    authoredPackageDeclaredRule,
+    installRootEntriesRecognizedRule,
+    projectOutputsNotShadowedRule,
+    userOutputsHaveSettingsRule,
+    agentContentHasSettingsRule,
     skillsDeclarationsValidRule,
     packsDeclarationsValidRule,
     configuredButNotInstalledRule,

package/dist/src/run/agent-scopes.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Agent facts that cross the selected scope's boundary.
+ *
+ * A coding agent reads the user scope and the project folder together, so a
+ * lint run reports what the other side contributes to the same agent context:
+ * the user scope's agent outputs and whether its workspace has readable
+ * settings, and agent content in a project folder that has no workspace
+ * settings to explain it.
+ *
+ * @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 { CodingAgentRepository, type AgentOutputObservation } from "@agentxm/workspace-projection";
+/** The user scope as a project-scope run's agents also see it. */
+export interface UserScopeObservation {
+    readonly home: string;
+    readonly settingsPath: string;
+    readonly settingsReadable: boolean;
+    readonly outputs: ReadonlyArray<AgentOutputObservation>;
+}
+/** One agent-native file or directory in a project folder. */
+export interface AgentContentEntry {
+    readonly kind: "instructions" | AgentOutputObservation["extensionType"];
+    readonly path: string;
+    /** Entries inside a directory container; absent for a single file. */
+    readonly entryCount?: number;
+    readonly agentIds: ReadonlyArray<string>;
+}
+/**
+ * Observe the user scope's agent outputs under `userHome`.
+ *
+ * Containers resolve relative to `userHome` rather than the process home, so
+ * the observation follows the home the run selected. Anything under the user
+ * AXM home counts as AXM storage, including storage left by an earlier layout.
+ */
+export declare const observeUserScope: (userHome: string) => Effect.Effect<UserScopeObservation, never, CodingAgentRepository | FileSystem.FileSystem | Path.Path>;
+/**
+ * Observe agent instruction files and non-empty agent output containers in a
+ * project folder, grouped by path with the agents that read each one.
+ */
+export declare const observeProjectAgentContent: (args: {
+    readonly projectRoot: string;
+    readonly outputs: ReadonlyArray<AgentOutputObservation>;
+}) => Effect.Effect<ReadonlyArray<AgentContentEntry>, never, FileSystem.FileSystem | Path.Path>;
+//# sourceMappingURL=agent-scopes.d.ts.map

package/dist/src/run/agent-scopes.js

@@ -0,0 +1,112 @@
+/**
+ * Agent facts that cross the selected scope's boundary.
+ *
+ * A coding agent reads the user scope and the project folder together, so a
+ * lint run reports what the other side contributes to the same agent context:
+ * the user scope's agent outputs and whether its workspace has readable
+ * settings, and agent content in a project folder that has no workspace
+ * settings to explain it.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Option from "effect/Option";
+import * as Path from "effect/Path";
+import { AGENTS } from "@agentxm/extension-model/unstable/agents/registry";
+import { decodeAbsolutePathSync } from "@agentxm/extension-model/unstable/path-types";
+import { CodingAgentRepository, observeAgentOutputs, } from "@agentxm/workspace-projection";
+import { resolveUserWorkspaceLayout } from "@agentxm/workspace-state";
+import { loadSettingsDocument } from "./settings.js";
+const NO_EXPECTED_NAMES = {
+    skill: new Set(),
+    subagent: new Set(),
+    "mcp-server": new Set(),
+    hook: new Set(),
+};
+/**
+ * Observe the user scope's agent outputs under `userHome`.
+ *
+ * Containers resolve relative to `userHome` rather than the process home, so
+ * the observation follows the home the run selected. Anything under the user
+ * AXM home counts as AXM storage, including storage left by an earlier layout.
+ */
+export const observeUserScope = (userHome) => Effect.gen(function* () {
+    const layout = yield* resolveUserWorkspaceLayout(decodeAbsolutePathSync(userHome));
+    const settings = yield* loadSettingsDocument(userHome, "user");
+    const inventory = yield* observeAgentOutputs({
+        workspaceRoot: userHome,
+        scope: "project",
+        desiredAgentIds: new Set(),
+        expectedNames: NO_EXPECTED_NAMES,
+        skillOwnershipRoots: [layout.axmHome],
+        authoredSkills: { layout, entries: {} },
+    });
+    return {
+        home: userHome,
+        settingsPath: layout.settingsPath,
+        settingsReadable: Option.isSome(settings),
+        outputs: inventory.outputs,
+    };
+});
+const instructionPath = (descriptor) => {
+    const instructions = descriptor.instructions;
+    if (instructions === undefined)
+        return undefined;
+    switch (instructions.kind) {
+        case "agents-md":
+            return "AGENTS.md";
+        case "own-file":
+            return instructions.file;
+        case "rules-dir":
+            return instructions.dir;
+    }
+};
+/**
+ * Observe agent instruction files and non-empty agent output containers in a
+ * project folder, grouped by path with the agents that read each one.
+ */
+export const observeProjectAgentContent = (args) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const instructionAgents = new Map();
+    for (const descriptor of Object.values(AGENTS)) {
+        const relative = instructionPath(descriptor);
+        if (relative === undefined)
+            continue;
+        const agents = instructionAgents.get(relative) ?? new Set();
+        agents.add(descriptor.id);
+        instructionAgents.set(relative, agents);
+    }
+    const instructions = yield* Effect.forEach([...instructionAgents], ([relative, agents]) => fs.exists(path.join(args.projectRoot, relative)).pipe(Effect.orElseSucceed(() => false), Effect.map((exists) => exists
+        ? [
+            {
+                kind: "instructions",
+                path: path.join(args.projectRoot, relative),
+                agentIds: [...agents].sort(),
+            },
+        ]
+        : [])), { concurrency: 8 });
+    const containers = new Map();
+    for (const output of args.outputs) {
+        const container = containers.get(output.containerPath) ?? {
+            kind: output.extensionType,
+            count: 0,
+            agents: new Set(),
+        };
+        container.count += 1;
+        for (const agentId of output.claimantAgentIds)
+            container.agents.add(agentId);
+        containers.set(output.containerPath, container);
+    }
+    return [
+        ...instructions.flat(),
+        ...[...containers].map(([containerPath, container]) => ({
+            kind: container.kind,
+            path: containerPath,
+            entryCount: container.count,
+            agentIds: [...container.agents].sort(),
+        })),
+    ].sort((left, right) => left.path.localeCompare(right.path));
+});
+//# sourceMappingURL=agent-scopes.js.map

package/dist/src/run/authored-packages.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Authored packages in each type's standard authoring folder.
+ *
+ * A directory there is an authored package only when its manifest resolves
+ * with the identity its path names; anything else is a lookalike and is not
+ * observed here. Declaration is read from local settings, including disabled
+ * entries, so an undeclared package is visible without resolving desired
+ * state. User scope has no authoring folders.
+ *
+ * @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 ExtensionType } from "@agentxm/extension-model/unstable/extensions/common";
+import { type Settings, type WorkspaceLayout } from "@agentxm/workspace-state";
+/** One valid authored package at its authoring location. */
+export interface AuthoredPackageObservation {
+    readonly type: ExtensionType;
+    readonly name: string;
+    readonly owner: string;
+    readonly version: string;
+    /** Absolute authoring path. */
+    readonly path: string;
+    /** Whether settings declare this type and name with a workspace source. */
+    readonly declared: boolean;
+}
+export declare const observeAuthoredPackages: (args: {
+    readonly layout: WorkspaceLayout;
+    readonly settings: Settings;
+}) => Effect.Effect<ReadonlyArray<AuthoredPackageObservation>, never, FileSystem.FileSystem | Path.Path>;
+//# sourceMappingURL=authored-packages.d.ts.map

package/dist/src/run/authored-packages.js

@@ -0,0 +1,58 @@
+/**
+ * Authored packages in each type's standard authoring folder.
+ *
+ * A directory there is an authored package only when its manifest resolves
+ * with the identity its path names; anything else is a lookalike and is not
+ * observed here. Declaration is read from local settings, including disabled
+ * entries, so an undeclared package is visible without resolving desired
+ * state. User scope has no authoring folders.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Option from "effect/Option";
+import * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
+import { ExtensionNameSchema, extensionTypes, } from "@agentxm/extension-model/unstable/extensions/common";
+import { resolveWorkspaceExtensionRef, settingsEntries, } from "@agentxm/workspace-state";
+export const observeAuthoredPackages = (args) => Effect.gen(function* () {
+    const layout = args.layout;
+    if (layout.scope !== "project")
+        return [];
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const perType = yield* Effect.forEach(extensionTypes, (type) => Effect.gen(function* () {
+        const root = layout.authoredRoot(type);
+        const names = yield* fs.readDirectory(root).pipe(Effect.orElseSucceed(() => []));
+        const observed = [];
+        for (const name of [...names].sort()) {
+            if (!Schema.is(ExtensionNameSchema)(name))
+                continue;
+            const packagePath = path.join(root, name);
+            const isLink = yield* fs.readLink(packagePath).pipe(Effect.as(true), Effect.orElseSucceed(() => false));
+            if (isLink)
+                continue;
+            const ref = yield* resolveWorkspaceExtensionRef({
+                settingsName: name,
+                source: "workspace",
+                expectedType: type,
+                layout,
+                scope: "project",
+            }).pipe(Effect.option);
+            if (Option.isNone(ref))
+                continue;
+            observed.push({
+                type,
+                name,
+                owner: ref.value.owner,
+                version: ref.value.version,
+                path: packagePath,
+                declared: settingsEntries[type].entries(args.settings)[name]?.source === "workspace",
+            });
+        }
+        return observed;
+    }));
+    return perType.flat();
+});
+//# sourceMappingURL=authored-packages.js.map

package/dist/src/run/lint-workspace.d.ts

@@ -26,7 +26,7 @@ import * as Path from "effect/Path";
 import type { WorkspaceScope } from "@agentxm/extension-model/unstable/workspace-scope";
 import { AxmSkillCompatibilityPolicy } from "@agentxm/cli-maintenance/official-skill/application";
 import { CodingAgentRepository, WorkspaceInvariantFacts } from "@agentxm/workspace-projection";
-import { WorkspaceMutations, acceptedCanonicalObservation } from "@agentxm/workspace-state";
+import { LockfileReader, WorkspaceMutations, acceptedCanonicalObservation } from "@agentxm/workspace-state";
 import { buildLintWorkspace } from "../catalog/index.js";
 import type { LintView } from "../catalog-contexts.js";
 import { type LintExitCategory, type LintSummary } from "../cli.js";
@@ -95,7 +95,7 @@ export interface LintWorkspaceResult {
     readonly outcome: "success" | "fail";
 }
 /** Every service a lint run reads the workspace and its projections through. */
-export type LintWorkspaceRequirements = AxmSkillCompatibilityPolicy | CodingAgentRepository | FileSystem.FileSystem | Path.Path | WorkspaceInvariantFacts | WorkspaceMutations;
+export type LintWorkspaceRequirements = AxmSkillCompatibilityPolicy | CodingAgentRepository | FileSystem.FileSystem | LockfileReader | Path.Path | WorkspaceInvariantFacts | WorkspaceMutations;
 /** Every failure a lint run can settle into. */
 export type LintWorkspaceFailure = LintStagingFailed | Effect.Error<ReturnType<typeof buildLintWorkspace>> | Effect.Error<ReturnType<typeof acceptedCanonicalObservation>> | Effect.Error<ReturnType<typeof applyDeterminedRepairs>>;
 /** Report the workspace's facts without changing it. */

package/dist/src/run/lint-workspace.js

@@ -28,9 +28,11 @@ import { buildPackRuleContexts, buildSkillRuleContexts } from "@agentxm/extensio
 import { decodeAbsolutePathSync } from "@agentxm/extension-model/unstable/path-types";
 import { AxmSkillCompatibilityPolicy } from "@agentxm/cli-maintenance/official-skill/application";
 import { CodingAgentRepository, WorkspaceInvariantFacts, expectedProjectionNames, observeAgentOutputs, observeWorkspaceOwnershipIssues, } from "@agentxm/workspace-projection";
-import { WorkspaceMutations, acceptedCanonicalObservation, } from "@agentxm/workspace-state";
+import { LockfileReader, WorkspaceMutations, acceptedCanonicalObservation, observeInstallRoot, } from "@agentxm/workspace-state";
 import { buildLintWorkspace } from "../catalog/index.js";
 import { evaluateAllCatalogs, resolveLintExitCategory, summarizeEvaluations, toLintJsonDocument, } from "../cli.js";
+import { observeAuthoredPackages } from "./authored-packages.js";
+import { observeProjectAgentContent, observeUserScope, } from "./agent-scopes.js";
 import { LintStagingFailed } from "./errors.js";
 import { applyDeterminedRepairs, lintConfigFromSettings, loadSettingsDocument, remapLintSummaryPaths, resolveLintRoot, } from "./settings.js";
 import { materializeGitIndexWorkspace } from "./staged-workspace.js";
@@ -135,6 +137,32 @@ const runLint = (selection, options) => Effect.gen(function* () {
         skillOwnershipRoots,
         authoredSkills,
     });
+    // Cross-scope agent facts. The agents that read this workspace also read
+    // the user scope; a project folder that is the user home has no separate
+    // user scope, and a Git-index snapshot has no live agent folders.
+    const liveView = selection.input.view === "workspace";
+    const realRoot = (root) => fileSystem.realPath(root).pipe(Effect.orElseSucceed(() => path.resolve(root)));
+    const projectIsUserHome = selection.scope === "project" &&
+        (yield* realRoot(selection.workspaceRoot)) === (yield* realRoot(userHome));
+    const userScope = liveView && !projectIsUserHome
+        ? Option.some(yield* observeUserScope(userHome))
+        : Option.none();
+    const agentContent = liveView && selection.scope === "project" && !projectIsUserHome && Option.isNone(settings)
+        ? Option.some(yield* observeProjectAgentContent({
+            projectRoot: workspace.baseDir,
+            outputs: agentOutputs.outputs,
+        }))
+        : Option.none();
+    // Install-root and authoring-folder facts. An unreadable lockfile leaves
+    // the install root unobserved; its own rule reports the lockfile.
+    const installRoot = yield* observeInstallRoot({
+        layout: workspace.layout,
+        graph: desiredGraph,
+        locks: yield* LockfileReader,
+    }).pipe(Effect.option);
+    const authoredPackages = Option.isSome(settings)
+        ? yield* observeAuthoredPackages({ layout: workspace.layout, settings: settings.value })
+        : [];
     const canonicalObservations = Effect.gen(function* () {
         const graph = yield* workspace.getDesiredStateGraph();
         return yield* Effect.forEach(graph.nodes, (node) => acceptedCanonicalObservation({
@@ -163,6 +191,14 @@ const runLint = (selection, options) => Effect.gen(function* () {
                     ...workspaceContext,
                     ownership: Effect.succeed(ownership),
                     agentOutputs: Effect.succeed(agentOutputs),
+                    ...(Option.isSome(installRoot)
+                        ? { installRoot: Effect.succeed(installRoot.value) }
+                        : {}),
+                    authoredPackages: Effect.succeed(authoredPackages),
+                    ...(Option.isSome(userScope) ? { userScope: Effect.succeed(userScope.value) } : {}),
+                    ...(Option.isSome(agentContent)
+                        ? { agentContent: Effect.succeed(agentContent.value) }
+                        : {}),
                     health: {
                         desiredState: workspace.getDesiredStateGraph(),
                         canonicalObservations,

package/dist/src/testing.js

@@ -65,6 +65,7 @@ export const lintWorkspaceServices = (args) => {
     const state = WorkspaceStateLive({
         scope: "project",
         projectRoot: decodeAbsolutePathSync(args.workspaceRoot),
+        allowUninitialized: true,
     });
     const agents = Layer.provideMerge(Layer.mergeAll(CodingAgentRepositoryLive, ConfiguredAgentOutcomesProviderTest), state);
     return Layer.provideMerge(Layer.mergeAll(WorkspaceInvariantFactsLive.pipe(Layer.provide(NativeWriteAuthorityLive)), makeAxmSkillCompatibilityPolicyLayer(args.cliVersion ?? null)), agents);

package/dist/src/workspace-context.d.ts

@@ -14,7 +14,9 @@ import type { ExtensionType } from "@agentxm/extension-model/unstable/extensions
 import type { Handle } from "@agentxm/extension-model/unstable/extensions/handle";
 import type { PackDependencyReachability, AgentOutputInventory, WorkspaceOwnershipIssue, InstructionProjectionSnapshot } from "@agentxm/workspace-projection";
 import type { ProjectionInvariantFact } from "@agentxm/workspace-projection";
-import type { CanonicalObservation } from "@agentxm/workspace-state";
+import type { CanonicalObservation, InstallRootInventory } from "@agentxm/workspace-state";
+import type { AuthoredPackageObservation } from "./run/authored-packages.js";
+import type { AgentContentEntry, UserScopeObservation } from "./run/agent-scopes.js";
 import type { DesiredExtensionNode, DesiredStateGraph } from "@agentxm/workspace-state";
 import type { LockfileReadError, SettingsReadError } from "@agentxm/workspace-state";
 import type { WorkspaceReadModel } from "@agentxm/workspace-state";
@@ -50,6 +52,14 @@ export interface WorkspaceRuleContext {
     readonly ownership?: Effect.Effect<ReadonlyArray<WorkspaceOwnershipIssue>>;
     /** Owned and unowned agent-native outputs observed from resolved containers. */
     readonly agentOutputs?: Effect.Effect<AgentOutputInventory>;
+    /** The scope's install root: installed packages, leftovers, and unrecognized entries. */
+    readonly installRoot?: Effect.Effect<InstallRootInventory>;
+    /** Valid authored packages in each type's standard authoring folder (project scope). */
+    readonly authoredPackages?: Effect.Effect<ReadonlyArray<AuthoredPackageObservation>>;
+    /** The user scope's agent outputs and settings readability; absent when it is the project itself. */
+    readonly userScope?: Effect.Effect<UserScopeObservation>;
+    /** Agent-native content in a project folder without workspace settings. */
+    readonly agentContent?: Effect.Effect<ReadonlyArray<AgentContentEntry>>;
     /**
      * Installed non-pack extension manifests, keyed by nothing — rules walk the
      * list. Landed for `workspace/recommended-packs-retained`, which needs the

package/package.json

@@ -4,15 +4,15 @@
     "url": "https://github.com/agentxm/axm/issues"
   },
   "dependencies": {
-    "@agentxm/agent-integration": "^0.30.1",
-    "@agentxm/cli-maintenance": "^0.30.1",
-    "@agentxm/extension-content": "^0.30.1",
-    "@agentxm/extension-model": "^0.30.1",
-    "@agentxm/extension-resolution": "^0.30.1",
-    "@agentxm/extension-sources": "^0.30.1",
-    "@agentxm/workspace-operations": "^0.30.1",
-    "@agentxm/workspace-projection": "^0.30.1",
-    "@agentxm/workspace-state": "^0.30.1",
+    "@agentxm/agent-integration": "^0.30.2",
+    "@agentxm/cli-maintenance": "^0.30.2",
+    "@agentxm/extension-content": "^0.30.2",
+    "@agentxm/extension-model": "^0.30.2",
+    "@agentxm/extension-resolution": "^0.30.2",
+    "@agentxm/extension-sources": "^0.30.2",
+    "@agentxm/workspace-operations": "^0.30.2",
+    "@agentxm/workspace-projection": "^0.30.2",
+    "@agentxm/workspace-state": "^0.30.2",
     "effect": "4.0.0-rc.115"
   },
   "description": "AXM workspace-lint feature: workspace facts, lint rules, findings, normalization, and bounded fix planning for the axm CLI. Unstable and unsupported — use the axm.sh CLI.",
@@ -57,5 +57,5 @@
   },
   "sideEffects": false,
   "type": "module",
-  "version": "0.30.1"
+  "version": "0.30.2"
 }