@agentxm/workspace-lint 0.28.11 → 0.28.13

package/dist/src/catalog-contexts.js

@@ -18,13 +18,13 @@
  * @experimental This API is unstable and may change without notice.
  * @packageDocumentation
  */
-import { hookRules } from "@agentxm/registry-protocol/unstable/lint/catalog/hook";
-import { knowledgeRules } from "@agentxm/registry-protocol/unstable/lint/catalog/knowledge";
-import { mcpServerRules } from "@agentxm/registry-protocol/unstable/lint/catalog/mcp-server";
-import { packRules } from "@agentxm/registry-protocol/unstable/lint/catalog/pack";
-import { ruleRules } from "@agentxm/registry-protocol/unstable/lint/catalog/rule";
-import { skillRules } from "@agentxm/registry-protocol/unstable/lint/catalog/skill";
-import { subagentRules } from "@agentxm/registry-protocol/unstable/lint/catalog/subagent";
+import { hookRules } from "@agentxm/extension-content/lint";
+import { knowledgeRules } from "@agentxm/extension-content/lint";
+import { mcpServerRules } from "@agentxm/extension-content/lint";
+import { packRules } from "@agentxm/extension-content/lint";
+import { ruleRules } from "@agentxm/extension-content/lint";
+import { skillRules } from "@agentxm/extension-content/lint";
+import { subagentRules } from "@agentxm/extension-content/lint";
 import { liveOnlyWorkspaceRules, repositoryWorkspaceRules, workspaceRules, } from "./catalog/index.js";
 /**
  * Every rule catalog, keyed by group.

package/dist/src/cli.d.ts

@@ -21,7 +21,7 @@
  *   5.9).
  *
  * Lint-intent → canonical `Operation` adapter composition happens in the CLI
- * handler (`packages/cli/src/root/lint/handler.ts`), which re-resolves each
+ * handler (`apps/cli/src/root/lint/handler.ts`), which re-resolves each
  * intent's `source` via the `resolveConfigured*` helpers and hands the
  * resulting canonical Operation to the per-extension plan-step builder. The
  * runner here stays accessor-free.
@@ -30,13 +30,13 @@
  * @packageDocumentation
  */
 import * as Effect from "effect/Effect";
-import type { LintConfig } from "@agentxm/registry-protocol/unstable/lint/config";
-import { platformCanonicalLintConfig } from "@agentxm/registry-protocol/unstable/lint/config";
-import type { Evaluated } from "@agentxm/registry-protocol/unstable/lint/evaluate";
+import type { LintConfig } from "@agentxm/extension-content/lint";
+import { platformCanonicalLintConfig } from "@agentxm/extension-content/lint";
+import type { Evaluated } from "@agentxm/extension-content/lint";
 import type { LintInput, LintJsonDocument } from "./json-schema.js";
-import type { LintFinding, Severity } from "@agentxm/registry-protocol/unstable/lint/rule";
-import type { AxmSkillCompatibility } from "@agentxm/extension-workspace";
+import type { LintFinding, Severity } from "@agentxm/extension-content/lint";
 import { type CatalogContext, type CatalogGroup, type CatalogRuleContexts, type LintView } from "./catalog-contexts.js";
+import { type AxmSkillCompatibility } from "@agentxm/extension-resolution";
 /**
  * A single finding annotated with the context that produced it.
  *

package/dist/src/cli.js

@@ -21,7 +21,7 @@
  *   5.9).
  *
  * Lint-intent → canonical `Operation` adapter composition happens in the CLI
- * handler (`packages/cli/src/root/lint/handler.ts`), which re-resolves each
+ * handler (`apps/cli/src/root/lint/handler.ts`), which re-resolves each
  * intent's `source` via the `resolveConfigured*` helpers and hands the
  * resulting canonical Operation to the per-extension plan-step builder. The
  * runner here stays accessor-free.
@@ -30,10 +30,11 @@
  * @packageDocumentation
  */
 import * as Effect from "effect/Effect";
-import { composePath } from "@agentxm/registry-protocol/unstable/lint/compose-path";
-import { platformCanonicalLintConfig } from "@agentxm/registry-protocol/unstable/lint/config";
-import { evaluateContexts } from "@agentxm/registry-protocol/unstable/lint/evaluate";
+import { composePath } from "@agentxm/extension-content/lint";
+import { platformCanonicalLintConfig } from "@agentxm/extension-content/lint";
+import { evaluateContexts } from "@agentxm/extension-content/lint";
 import { CATALOG_GROUP_ORDER, lintCatalogsForView, } from "./catalog-contexts.js";
+import {} from "@agentxm/extension-resolution";
 // -----------------------------------------------------------------------------
 // Evaluation
 // -----------------------------------------------------------------------------

package/dist/src/index.d.ts

@@ -4,8 +4,9 @@ export { LintInputSchema, LintJsonDocumentSchema, LintJsonFindingSchema, type Li
 export { findingsForProjectionOwnership } from "./catalog/workspace/projection-ownership-valid.js";
 export { findingsForProjectionExclusions } from "./catalog/workspace/projection-contributors-rendered.js";
 export { collectRenderedFindings, countFindings, detectPublishGateDrift, evaluateAllCatalogs, renderFindingsText, resolveLintExitCategory, summarizeEvaluations, toLintHumanBlocks, toLintJsonDocument, type FindingCounts, type GroupEvaluations, type LintHumanBlock, type LintHumanDiagnostic, type LintHumanReporter, type LintExitCategory, type LintSummary, type RenderFindingsArgs, type RenderedFinding, } from "./cli.js";
-export { allCatalogErrorRuleIds, allCatalogRuleMetadata, allCatalogRuleIds, buildAcquiredInstalledSkillInfo, buildInstalledPackInfo, buildLintWorkspace, buildNativeInstalledSkillInfo, acquiredSkillDisplayRoot, registryNativeSkillDisplayRoot, registryPackDisplayRoot, liveOnlyWorkspaceRules, repositoryWorkspaceRules, workspaceRules, type BuildInstalledPackInfoArgs, type BuildAcquiredInstalledSkillInfoArgs, type BuildInstalledSkillInfoNativeArgs, type BuildLintWorkspaceArgs, type LintWorkspace, type LintWorkspaceView, } from "./catalog/index.js";
+export { allCatalogErrorRuleIds, allCatalogRuleMetadata, allCatalogRuleIds, buildAcquiredInstalledSkillInfo, buildInstalledPackInfo, buildLintWorkspace, buildNativeInstalledSkillInfo, acquiredSkillDisplayRoot, registryNativeSkillDisplayRoot, registryPackDisplayRoot, liveOnlyWorkspaceRules, repositoryWorkspaceRules, workspaceRules, type BuildInstalledPackInfoArgs, type BuildAcquiredInstalledSkillInfoArgs, type BuildInstalledSkillInfoNativeArgs, type BuildLintWorkspaceArgs, type LintWorkspaceBuild, type LintWorkspaceView, } from "./catalog/index.js";
 export { LintStagingFailed } from "./run/errors.js";
 export { isolatedGitEnvironment, materializeGitIndexWorkspace, type StagedWorkspace, } from "./run/staged-workspace.js";
 export { applyDeterminedRepairs, lintConfigFromSettings, loadSettingsDocument, remapLintSummaryPaths, resolveLintRoot, type PathRemapper, } from "./run/settings.js";
+export { LintWorkspace, admitLintRequest, fixLintWorkspace, lintSelectionRoot, queryLintWorkspace, type LintSelection, type LintWorkspaceFailure, type LintWorkspaceRequest, type LintWorkspaceRequirements, type LintWorkspaceResult, } from "./run/lint-workspace.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.js

@@ -16,4 +16,7 @@ export { allCatalogErrorRuleIds, allCatalogRuleMetadata, allCatalogRuleIds, buil
 export { LintStagingFailed } from "./run/errors.js";
 export { isolatedGitEnvironment, materializeGitIndexWorkspace, } from "./run/staged-workspace.js";
 export { applyDeterminedRepairs, lintConfigFromSettings, loadSettingsDocument, remapLintSummaryPaths, resolveLintRoot, } from "./run/settings.js";
+// The lint application API: admit a request, then report the workspace's
+// facts (or repair the determined ones first).
+export { LintWorkspace, admitLintRequest, fixLintWorkspace, lintSelectionRoot, queryLintWorkspace, } from "./run/lint-workspace.js";
 //# sourceMappingURL=index.js.map

package/dist/src/json-schema.js

@@ -14,7 +14,7 @@
  */
 import * as Schema from "effect/Schema";
 import { CATALOG_GROUP_ORDER } from "./catalog-contexts.js";
-import { AxmSkillCompatibilitySchema } from "@agentxm/extension-workspace";
+import { AxmSkillCompatibilitySchema } from "@agentxm/extension-resolution";
 const LintJsonLocationSchema = Schema.Struct({
     file: Schema.String,
     line: Schema.optional(Schema.Number),

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

@@ -0,0 +1,144 @@
+/**
+ * Linting a workspace: admitting the request, gathering the facts every rule
+ * catalog decides against, and reporting what the workspace actually is.
+ *
+ * Lint answers one question — is this workspace's state coherent — and it
+ * answers it from facts, not from a plan. The facts come from the workspace
+ * read model, the shared projection capability, and the content rule
+ * catalogs; assembling them here rather than in an adapter is what makes the
+ * answer the same however lint is invoked. In particular the reconciliation
+ * facts (ownership proofs and realized agent outputs) come from
+ * `@agentxm/workspace-projection`, the capability the reconciliation feature
+ * also reads them from, so lint and sync cannot disagree about what AXM owns.
+ *
+ * Two decisions about lint's inputs live here because they are decisions
+ * about what lint can honestly report, not about flag grammar: repairing
+ * determined state means writing to the working tree, so it cannot be
+ * combined with a Git-index view that is a snapshot of something else; and a
+ * Git index is a property of a repository, so it cannot be combined with the
+ * user scope.
+ *
+ * @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 { WorkspaceScope } from "@agentxm/extension-model/unstable/workspace-scope";
+import { AxmSkillCompatibilityPolicy } from "@agentxm/extension-resolution";
+import { CodingAgentRepository, WorkspaceInvariantFacts } from "@agentxm/workspace-projection";
+import { 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";
+import type { LintInput, LintJsonDocument } from "../json-schema.js";
+import { LintStagingFailed } from "./errors.js";
+import { applyDeterminedRepairs } from "./settings.js";
+export interface LintWorkspaceRequest {
+    /** An explicit workspace directory to lint; the working directory otherwise. */
+    readonly path?: string;
+    readonly scope: WorkspaceScope;
+    readonly view: LintView;
+    /** Repair the state whose desired value is already determined, then report. */
+    readonly fix: boolean;
+    readonly cwd: string;
+    readonly userHome: string;
+}
+/**
+ * The workspace lint will read, and the view it reads it through. For a
+ * Git-index run this names the materialized snapshot rather than the working
+ * tree, together with the root findings are reported against.
+ */
+export interface LintSelection {
+    readonly workspaceRoot: string;
+    /** The home the alternate scope's root is validated against. */
+    readonly userHome: string;
+    readonly scope: WorkspaceScope;
+    readonly input: LintInput;
+    /** The root findings are reported against, when it differs from the one read. */
+    readonly displayWorkspaceRoot?: string;
+    readonly fix: boolean;
+}
+/**
+ * Admit a lint request: refuse the input combinations lint cannot honestly
+ * answer, and materialize the Git index when that is the selected view.
+ */
+export declare const admitLintRequest: (request: LintWorkspaceRequest) => Effect.Effect<{
+    workspaceRoot: string;
+    userHome: string;
+    scope: "project";
+    input: {
+        view: "git-index";
+        fingerprint: string;
+    };
+    displayWorkspaceRoot: string;
+    fix: false;
+} | {
+    workspaceRoot: string;
+    userHome: string;
+    scope: "project" | "user";
+    input: {
+        view: "workspace";
+        fingerprint?: never;
+    };
+    fix: boolean;
+    displayWorkspaceRoot?: never;
+}, LintStagingFailed, FileSystem.FileSystem | Path.Path | import("effect/Scope").Scope | import("effect/unstable/process/ChildProcessSpawner").ChildProcessSpawner>;
+/** The absolute root a selection names, for the workspace layer the run needs. */
+export declare const lintSelectionRoot: (selection: LintSelection) => string & import("effect/Brand").Brand<"AbsolutePath">;
+export interface LintWorkspaceResult {
+    /** The machine document: findings, counts, input, and compatibility state. */
+    readonly document: LintJsonDocument;
+    readonly summary: LintSummary;
+    /** The severity verdict before any process mapping. */
+    readonly exitCategory: LintExitCategory;
+    /** Whether this run passes, under the run's strictness. */
+    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;
+/** 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. */
+export declare const queryLintWorkspace: (selection: LintSelection, options: {
+    readonly strict: boolean;
+}) => Effect.Effect<LintWorkspaceResult, LintWorkspaceFailure, LintWorkspaceRequirements>;
+/**
+ * Repair the state whose desired value the workspace already determines, then
+ * report what remains. Only determined state is repaired: a target whose
+ * content is derived from a canonical source expresses no preference, so
+ * regenerating it cannot overwrite a choice.
+ */
+export declare const fixLintWorkspace: (selection: LintSelection, options: {
+    readonly strict: boolean;
+}) => Effect.Effect<LintWorkspaceResult, LintWorkspaceFailure, LintWorkspaceRequirements>;
+/** The workspace lint use case. */
+export declare const LintWorkspace: {
+    readonly admit: (request: LintWorkspaceRequest) => Effect.Effect<{
+        workspaceRoot: string;
+        userHome: string;
+        scope: "project";
+        input: {
+            view: "git-index";
+            fingerprint: string;
+        };
+        displayWorkspaceRoot: string;
+        fix: false;
+    } | {
+        workspaceRoot: string;
+        userHome: string;
+        scope: "project" | "user";
+        input: {
+            view: "workspace";
+            fingerprint?: never;
+        };
+        fix: boolean;
+        displayWorkspaceRoot?: never;
+    }, LintStagingFailed, FileSystem.FileSystem | Path.Path | import("effect/Scope").Scope | import("effect/unstable/process/ChildProcessSpawner").ChildProcessSpawner>;
+    readonly query: (selection: LintSelection, options: {
+        readonly strict: boolean;
+    }) => Effect.Effect<LintWorkspaceResult, LintWorkspaceFailure, LintWorkspaceRequirements>;
+    readonly fix: (selection: LintSelection, options: {
+        readonly strict: boolean;
+    }) => Effect.Effect<LintWorkspaceResult, LintWorkspaceFailure, LintWorkspaceRequirements>;
+};
+//# sourceMappingURL=lint-workspace.d.ts.map

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

@@ -0,0 +1,204 @@
+/**
+ * Linting a workspace: admitting the request, gathering the facts every rule
+ * catalog decides against, and reporting what the workspace actually is.
+ *
+ * Lint answers one question — is this workspace's state coherent — and it
+ * answers it from facts, not from a plan. The facts come from the workspace
+ * read model, the shared projection capability, and the content rule
+ * catalogs; assembling them here rather than in an adapter is what makes the
+ * answer the same however lint is invoked. In particular the reconciliation
+ * facts (ownership proofs and realized agent outputs) come from
+ * `@agentxm/workspace-projection`, the capability the reconciliation feature
+ * also reads them from, so lint and sync cannot disagree about what AXM owns.
+ *
+ * Two decisions about lint's inputs live here because they are decisions
+ * about what lint can honestly report, not about flag grammar: repairing
+ * determined state means writing to the working tree, so it cannot be
+ * combined with a Git-index view that is a snapshot of something else; and a
+ * Git index is a property of a repository, so it cannot be combined with the
+ * user scope.
+ *
+ * @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 { buildPackRuleContexts, buildSkillRuleContexts } from "@agentxm/extension-content/lint";
+import { decodeAbsolutePathSync } from "@agentxm/extension-model/unstable/path-types";
+import { AxmSkillCompatibilityPolicy } from "@agentxm/extension-resolution";
+import { CodingAgentRepository, WorkspaceInvariantFacts, expectedProjectionNames, observeAgentOutputs, observeWorkspaceOwnershipIssues, } from "@agentxm/workspace-projection";
+import { WorkspaceMutations, acceptedCanonicalObservation, } from "@agentxm/workspace-state";
+import { buildLintWorkspace } from "../catalog/index.js";
+import { evaluateAllCatalogs, resolveLintExitCategory, summarizeEvaluations, toLintJsonDocument, } from "../cli.js";
+import { LintStagingFailed } from "./errors.js";
+import { applyDeterminedRepairs, lintConfigFromSettings, loadSettingsDocument, remapLintSummaryPaths, resolveLintRoot, } from "./settings.js";
+import { materializeGitIndexWorkspace } from "./staged-workspace.js";
+/**
+ * Admit a lint request: refuse the input combinations lint cannot honestly
+ * answer, and materialize the Git index when that is the selected view.
+ */
+export const admitLintRequest = (request) => Effect.gen(function* () {
+    if (request.fix && request.view === "git-index") {
+        return yield* new LintStagingFailed({
+            category: "validation",
+            detail: "--fix cannot be combined with --view git-index because the index snapshot is not the working tree",
+        });
+    }
+    if (request.view === "git-index" && request.scope === "user") {
+        return yield* new LintStagingFailed({
+            category: "validation",
+            detail: "--view git-index cannot be combined with --scope user because Git indexes are project-scoped",
+        });
+    }
+    if (request.view === "git-index") {
+        const snapshot = yield* materializeGitIndexWorkspace(request.path ?? request.cwd, {
+            selectRepositoryRoot: request.path === undefined,
+        });
+        return {
+            workspaceRoot: snapshot.workspaceRoot,
+            userHome: request.userHome,
+            scope: "project",
+            input: { view: "git-index", fingerprint: snapshot.fingerprint },
+            displayWorkspaceRoot: snapshot.displayWorkspaceRoot,
+            fix: false,
+        };
+    }
+    return {
+        workspaceRoot: resolveLintRoot({
+            pathArg: request.path === undefined ? Option.none() : Option.some(request.path),
+            scope: request.scope,
+            cwd: request.cwd,
+            userHome: request.userHome,
+        }),
+        userHome: request.userHome,
+        scope: request.scope,
+        input: { view: "workspace" },
+        fix: request.fix,
+    };
+});
+/** The absolute root a selection names, for the workspace layer the run needs. */
+export const lintSelectionRoot = (selection) => decodeAbsolutePathSync(selection.workspaceRoot);
+const runLint = (selection, options) => Effect.gen(function* () {
+    const fileSystem = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const workspace = yield* WorkspaceMutations;
+    const agentRepository = yield* CodingAgentRepository;
+    const axmSkillCompatibilityPolicy = yield* AxmSkillCompatibilityPolicy;
+    const invariantFacts = yield* WorkspaceInvariantFacts;
+    const settings = yield* loadSettingsDocument(selection.workspaceRoot, selection.scope);
+    // Repair before observing, so the report reflects the reconciled state.
+    if (selection.fix) {
+        yield* applyDeterminedRepairs({
+            workspaceRoot: selection.workspaceRoot,
+            scope: selection.scope,
+            settings,
+        });
+    }
+    const config = lintConfigFromSettings(settings);
+    const userHome = selection.scope === "user" ? selection.workspaceRoot : selection.userHome;
+    const { rule: workspaceContext, view } = yield* buildLintWorkspace({
+        platform: { fs: fileSystem, path },
+        workspaceRoot: selection.workspaceRoot,
+        userHome,
+        scope: selection.scope,
+        gitIndexView: selection.input.view === "git-index",
+        axmSkillCompatibilityPolicy,
+        owner: workspace.getConfiguredOwner().pipe(Effect.catch(() => Effect.succeed(Option.none()))),
+        projections: { facts: invariantFacts.projectionFacts },
+    });
+    // Reconciliation facts: what AXM owns, and what it realized for the agents
+    // this workspace configures. Both come from the shared projection
+    // capability, never from the reconciliation feature.
+    const configuredAgents = yield* workspace.getConfiguredAgents();
+    const skillOwnershipRoots = workspace.layout.scope === "project"
+        ? [workspace.layout.acquiredRoot, workspace.layout.authoredRoot("skill")]
+        : [workspace.layout.acquiredRoot];
+    const ownership = yield* observeWorkspaceOwnershipIssues({
+        workspaceRoot: workspace.baseDir,
+        scope: workspace.scope,
+        configuredAgentIds: new Set(configuredAgents),
+        skillOwnershipRoots,
+    });
+    const desiredGraph = yield* workspace.getDesiredStateGraph();
+    const materializationAgentIds = new Set((yield* agentRepository.getMaterializationAgents()).map(({ id }) => id));
+    const agentOutputs = yield* observeAgentOutputs({
+        workspaceRoot: workspace.baseDir,
+        scope: workspace.scope,
+        desiredAgentIds: materializationAgentIds,
+        expectedNames: expectedProjectionNames(desiredGraph),
+        skillOwnershipRoots,
+    });
+    const canonicalObservations = Effect.gen(function* () {
+        const graph = yield* workspace.getDesiredStateGraph();
+        return yield* Effect.forEach(graph.nodes, (node) => acceptedCanonicalObservation({
+            workspace,
+            type: node.type,
+            name: node.name,
+        }).pipe(Effect.flatMap((accepted) => Option.isNone(accepted)
+            ? new LintStagingFailed({
+                category: "internal",
+                detail: `Desired extension disappeared while linting: ${node.type}:${node.name}`,
+            })
+            : Effect.succeed({ desired: node, observation: accepted.value.observation }))), { concurrency: 16 });
+    }).pipe(Effect.provideService(FileSystem.FileSystem, fileSystem), Effect.provideService(Path.Path, path));
+    const evaluations = yield* evaluateAllCatalogs({
+        view: selection.input.view,
+        contexts: {
+            skill: buildSkillRuleContexts(view),
+            pack: buildPackRuleContexts(view),
+            subagent: view.subagentContexts,
+            "mcp-server": view.mcpServerContexts,
+            rule: view.ruleContexts,
+            hook: view.hookContexts,
+            knowledge: view.knowledgeContexts,
+            workspace: [
+                {
+                    ...workspaceContext,
+                    ownership: Effect.succeed(ownership),
+                    agentOutputs: Effect.succeed(agentOutputs),
+                    health: {
+                        desiredState: workspace.getDesiredStateGraph(),
+                        canonicalObservations,
+                    },
+                },
+            ],
+        },
+        config,
+    });
+    const rawSummary = summarizeEvaluations(evaluations, config);
+    const summary = selection.displayWorkspaceRoot === undefined
+        ? rawSummary
+        : remapLintSummaryPaths(rawSummary, selection.workspaceRoot, selection.displayWorkspaceRoot, path);
+    const axmSkillCompatibility = workspaceContext.axmSkillCompatibility === undefined
+        ? undefined
+        : Option.getOrUndefined(Option.flatten(yield* workspaceContext.axmSkillCompatibility.pipe(Effect.option)));
+    const exitCategory = summary.exitCategory;
+    const outcome = resolveLintExitCategory({ category: exitCategory, strict: options.strict });
+    return {
+        document: toLintJsonDocument({
+            summary,
+            input: selection.input,
+            ...(axmSkillCompatibility === undefined ? {} : { axmSkillCompatibility }),
+        }),
+        summary,
+        exitCategory,
+        outcome,
+    };
+});
+/** Report the workspace's facts without changing it. */
+export const queryLintWorkspace = (selection, options) => runLint({ ...selection, fix: false }, options);
+/**
+ * Repair the state whose desired value the workspace already determines, then
+ * report what remains. Only determined state is repaired: a target whose
+ * content is derived from a canonical source expresses no preference, so
+ * regenerating it cannot overwrite a choice.
+ */
+export const fixLintWorkspace = (selection, options) => runLint({ ...selection, fix: true }, options);
+/** The workspace lint use case. */
+export const LintWorkspace = {
+    admit: admitLintRequest,
+    query: queryLintWorkspace,
+    fix: fixLintWorkspace,
+};
+//# sourceMappingURL=lint-workspace.js.map

package/dist/src/run/settings.d.ts

@@ -11,7 +11,7 @@ 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 type { LintConfig } from "@agentxm/registry-protocol/unstable/lint/config";
+import type { LintConfig } from "@agentxm/extension-content/lint";
 import { type Settings } from "@agentxm/workspace-state";
 import { type WorkspaceScope } from "@agentxm/extension-model/unstable/workspace-scope";
 import type { LintSummary } from "../cli.js";
@@ -59,5 +59,5 @@ export declare const applyDeterminedRepairs: (args: {
     readonly workspaceRoot: string;
     readonly scope: WorkspaceScope;
     readonly settings: Option.Option<Settings>;
-}) => Effect.Effect<void, import("@agentxm/extension-workspace").InstructionMaintenanceFailure, FileSystem.FileSystem | Path.Path>;
+}) => Effect.Effect<void, import("@agentxm/workspace-projection").InstructionMaintenanceFailure, FileSystem.FileSystem | Path.Path>;
 //# sourceMappingURL=settings.d.ts.map

package/dist/src/run/settings.js

@@ -14,8 +14,8 @@ import * as Option from "effect/Option";
 import * as Path from "effect/Path";
 import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
-import { reconcileInstructionTargets, resolveInstructionsConfig, } from "@agentxm/extension-workspace";
-import { composePath } from "@agentxm/registry-protocol/unstable/lint/compose-path";
+import { reconcileInstructionTargets, resolveInstructionsConfig, } from "@agentxm/workspace-projection";
+import { composePath } from "@agentxm/extension-content/lint";
 import { AXM_DIR_NAME, SettingsSchema, USER_WORKSPACE_DIRECTORY, } from "@agentxm/workspace-state";
 import {} from "@agentxm/extension-model/unstable/workspace-scope";
 const remapAbsolutePath = (value, sourceRoot, displayRoot, path) => {

package/dist/src/testing.d.ts

@@ -0,0 +1,153 @@
+/**
+ * @agentxm/workspace-lint deterministic test fixtures.
+ *
+ * A lint run reads a real workspace through the state, agent-repository and
+ * invariant-fact services, so a fixture here composes those over a throwaway
+ * directory rather than answering for them. What it does supply is the two
+ * things a lint example cannot state for itself without becoming brittle: a
+ * configured rule set in which exactly one catalog rule is live, so no
+ * unrelated finding can decide the scenario, and a workspace whose files are
+ * written as the product writes them.
+ *
+ * `ProjectionParticipants` stays in the layer's requirements on purpose. Which
+ * extension types contribute projections is a fact this package may not
+ * invent — `@agentxm/workspace-lint` does not depend on the materialization
+ * managers — so the caller states it, either with the real registry from
+ * `@agentxm/extension-materialization/live` or with a deliberate stand-in from
+ * `@agentxm/workspace-projection/testing`.
+ *
+ * Production source never imports this module.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import type * as Path from "effect/Path";
+import type * as HttpClient from "effect/unstable/http/HttpClient";
+import type { ProjectionParticipants } from "@agentxm/workspace-projection";
+import type { WorkspaceMutationsError } from "@agentxm/workspace-state";
+import type { LintWorkspaceRequirements } from "./run/lint-workspace.js";
+/** The severities a workspace may configure a catalog rule at. */
+export type ConfiguredLintSeverity = "off" | "info" | "warn" | "error";
+/**
+ * A rule configuration in which exactly one catalog rule is live and every
+ * other is `off`. A lint example that asserts on one rule's finding needs
+ * this: without it an unrelated rule's finding can decide the run's exit
+ * category and the example proves nothing about its own subject.
+ *
+ * Pass `undefined` for `severity` to leave the named rule at its catalog
+ * default while every other rule is silenced. An unknown rule id throws, so a
+ * renamed rule fails the example rather than silently matching nothing.
+ */
+export declare const isolatedLintRules: (ruleId: string, severity: ConfiguredLintSeverity | undefined) => Readonly<Record<string, ConfiguredLintSeverity>>;
+export interface LintWorkspaceFixtureOptions {
+    /** Settings document written to `axm.json`; `agents` defaults to empty. */
+    readonly settings?: Readonly<Record<string, unknown>>;
+    /** Files written into the workspace root, keyed by workspace-relative path. */
+    readonly files?: Readonly<Record<string, string>>;
+    /** The CLI version the official-skill compatibility policy evaluates against. */
+    readonly cliVersion?: string | null;
+}
+/**
+ * Every workspace-facing service a lint run reads through. The platform
+ * services stay the caller's, so a test runs lint over the same file system
+ * the product runs on; `ProjectionParticipants` stays in the requirements
+ * because which extension types contribute projections is not this package's
+ * fact to invent.
+ */
+export type LintWorkspaceServices = Layer.Layer<Exclude<LintWorkspaceRequirements, FileSystem.FileSystem | Path.Path>, WorkspaceMutationsError, FileSystem.FileSystem | Path.Path | HttpClient.HttpClient | ProjectionParticipants>;
+export interface LintWorkspaceFixture {
+    readonly root: string;
+    readonly writeFile: (relativePath: string, contents: string) => void;
+    readonly readFile: (relativePath: string) => string;
+    readonly exists: (relativePath: string) => boolean;
+    readonly remove: (relativePath: string) => void;
+    /** Rewrites `axm.json` wholesale, as an operator editing settings would. */
+    readonly writeSettings: (settings: Readonly<Record<string, unknown>>) => void;
+    /**
+     * Link one workspace path at another, the way the product realizes an
+     * extension into an agent's directory: a relative directory symlink from
+     * the agent entry to the canonical source.
+     */
+    readonly link: (linkPath: string, targetPath: string) => void;
+    /**
+     * Every entry under the workspace, sorted by path: a file as its contents, a
+     * directory as `directory`, a symbolic link as `symlink:<target>`. A lint
+     * run that changed anything — including a link's target — changes this.
+     */
+    readonly snapshot: () => ReadonlyArray<readonly [string, string]>;
+    /** Every workspace-facing service a lint run over this workspace reads through. */
+    readonly layer: LintWorkspaceServices;
+    readonly cleanup: () => void;
+}
+/**
+ * Every workspace-facing service a lint run over one root reads through. A
+ * Git-index run lints a materialized snapshot rather than the working tree, so
+ * the root a run's services are built over is decided by the admitted
+ * selection, not by the directory a fixture created.
+ */
+export declare const lintWorkspaceServices: (args: {
+    readonly workspaceRoot: string;
+    /** The CLI version the official-skill compatibility policy evaluates against. */
+    readonly cliVersion?: string | null;
+}) => LintWorkspaceServices;
+/** A throwaway initialized workspace with the services a lint run reads it through. */
+export declare const makeLintWorkspace: (options?: LintWorkspaceFixtureOptions) => LintWorkspaceFixture;
+/** Where a project workspace keeps the official AXM skill's canonical package. */
+export declare const OFFICIAL_AXM_SKILL_PACKAGE_ROOT = "agent_extensions/agentxm/@agentxm/skills/axm";
+/** Where a workspace that authors its own `axm` skill keeps it. */
+export declare const AUTHORED_AXM_SKILL_PACKAGE_ROOT = "skills/axm";
+/** The agent directory entry `claude-code` reads a project skill from. */
+export declare const CLAUDE_CODE_SKILLS_DIR = ".claude/skills";
+/**
+ * The states lint distinguishes for the official AXM skill: not declared at
+ * all, declared under another owner's name, or declared as the official skill
+ * and then missing, registry-sourced at an incompatible release,
+ * version-skewed, workspace-authored, compatible (including a prerelease
+ * inside the declared range), or unreadable.
+ */
+export type OfficialAxmSkillState = "undeclared" | "non-official" | "official-missing" | "official-registry" | "official-skewed" | "official-authored" | "official-compatible" | "official-compatible-prerelease" | "official-unreadable";
+/** The two rules that decide what lint says about the official AXM skill. */
+export declare const OFFICIAL_AXM_SKILL_RULE_IDS: readonly ["workspace/axm-skill-declared", "workspace/axm-skill-compatible"];
+/**
+ * A rule configuration in which only the two official-skill rules are live.
+ * An official-skill example is about what lint concludes from the declaration
+ * and the installed package, so no unrelated rule may decide its run.
+ */
+export declare const isolateOfficialAxmSkillRules: () => Readonly<Record<string, ConfiguredLintSeverity>>;
+/** The CLI release every official-skill fixture but the prerelease one runs as. */
+export declare const FIXTURE_CLI_VERSION = "1.2.3";
+/** The prerelease CLI release the in-range prerelease fixture runs as. */
+export declare const FIXTURE_PRERELEASE_CLI_VERSION = "1.3.0-preview.1";
+/** The canonical package files a materialized official AXM skill is made of. */
+export declare const officialAxmSkillPackage: (args: {
+    readonly packageRoot: string;
+    readonly version: string;
+    /** `null` writes no `SKILL.md` at all, as a truncated materialization leaves it. */
+    readonly metadata: {
+        readonly cliVersion: string;
+        readonly cliVersionRange: string;
+    } | null;
+    readonly withSkillMd?: boolean;
+}) => Readonly<Record<string, string>>;
+/** A lint workspace whose official AXM skill is arranged in one named state. */
+export interface OfficialAxmSkillWorkspace extends LintWorkspaceFixture {
+    /** The CLI release this workspace's compatibility policy evaluates against. */
+    readonly cliVersion: string;
+}
+export interface OfficialAxmSkillWorkspaceOptions {
+    /** Settings merged over the state's own; `lint.rules` belongs here. */
+    readonly settings?: Readonly<Record<string, unknown>>;
+    /** Coding agents the workspace configures. Defaults to `claude-code`. */
+    readonly agents?: ReadonlyArray<string>;
+    /** Extra files written into the workspace root. */
+    readonly files?: Readonly<Record<string, string>>;
+}
+/**
+ * A throwaway workspace whose official AXM skill is arranged in the named
+ * state, with the compatibility policy pinned to the CLI release that state
+ * is about.
+ */
+export declare const makeOfficialAxmSkillWorkspace: (state: OfficialAxmSkillState, options?: OfficialAxmSkillWorkspaceOptions) => OfficialAxmSkillWorkspace;
+//# sourceMappingURL=testing.d.ts.map