@agentxm/workspace-lint 0.28.4-bootstrap.0

package/dist/src/index.d.ts

@@ -0,0 +1,10 @@
+export type { WorkspaceRuleContext, WorkspaceSubject } from "./workspace-context.js";
+export { CATALOG_GROUP_ORDER, LIVE_ONLY_LINT_CATALOGS, LINT_CATALOGS, REPOSITORY_LINT_CATALOGS, emptyCatalogRuleContexts, lintCatalogsForView, type CatalogContext, type CatalogGroup, type CatalogRuleContexts, type LintView, } from "./catalog-contexts.js";
+export { LintInputSchema, LintJsonDocumentSchema, LintJsonFindingSchema, type LintInput, type LintJsonDocument, type LintJsonFinding, } from "./json-schema.js";
+export { findingsForProjectionFacts } from "./catalog/workspace/projections-current.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, 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 { 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";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.js

@@ -0,0 +1,21 @@
+// Catalog table — the exhaustive group -> rules / group -> contexts mapping
+// the runner drives off.
+export { CATALOG_GROUP_ORDER, LIVE_ONLY_LINT_CATALOGS, LINT_CATALOGS, REPOSITORY_LINT_CATALOGS, emptyCatalogRuleContexts, lintCatalogsForView, } from "./catalog-contexts.js";
+// `--json` document schema + derived types
+export { LintInputSchema, LintJsonDocumentSchema, LintJsonFindingSchema, } from "./json-schema.js";
+export { findingsForProjectionFacts } from "./catalog/workspace/projections-current.js";
+// Lint runner (Phase 5) — reusable primitives the `axm lint` CLI composes
+// over. Keeps the CLI command file a thin surface over flag parsing and
+// rendering per task 5.11.
+export { collectRenderedFindings, countFindings, detectPublishGateDrift, evaluateAllCatalogs, renderFindingsText, resolveLintExitCategory, summarizeEvaluations, toLintHumanBlocks, toLintJsonDocument, } from "./cli.js";
+// Rule catalogs (Phase 3a lands `skillRules`; Phase 3b lands `packRules`;
+// Phase 3c lands `workspaceRules`). Importing this index triggers each
+// catalog's module-load `registerLintRuleIds(...)` call so
+// `axm.json` `lint.rules` keys can reference any exported rule id.
+export { allCatalogErrorRuleIds, allCatalogRuleIds, buildAcquiredInstalledSkillInfo, buildInstalledPackInfo, buildLintWorkspace, buildNativeInstalledSkillInfo, acquiredSkillDisplayRoot, registryNativeSkillDisplayRoot, registryPackDisplayRoot, liveOnlyWorkspaceRules, repositoryWorkspaceRules, workspaceRules, } from "./catalog/index.js";
+// Lint-run policy: root resolution, settings-derived configuration,
+// determined repairs, staged Git-index input, and path remapping.
+export { LintStagingFailed } from "./run/errors.js";
+export { isolatedGitEnvironment, materializeGitIndexWorkspace, } from "./run/staged-workspace.js";
+export { applyDeterminedRepairs, lintConfigFromSettings, loadSettingsDocument, remapLintSummaryPaths, resolveLintRoot, } from "./run/settings.js";
+//# sourceMappingURL=index.js.map

package/dist/src/json-schema.d.ts

@@ -0,0 +1,121 @@
+/**
+ * The `axm lint --json` document, as a schema.
+ *
+ * The shape used to exist only as a hand-written interface in `cli.ts` while
+ * the CLI emitted it through `Schema.Any` — so nothing checked that what the
+ * runner built and what the renderer promised were the same document, and
+ * `--json` consumers had no schema to generate against.
+ *
+ * `LintJsonDocument` and `LintJsonFinding` are now derived from these schemas,
+ * so the emitted document and its contract cannot drift.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Schema from "effect/Schema";
+/**
+ * One finding as emitted under `--json`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const LintJsonFindingSchema: Schema.Struct<{
+    readonly group: Schema.Literals<readonly ["skill", "pack", "subagent", "mcp-server", "hook", "rule", "knowledge", "workspace"]>;
+    readonly kind: Schema.Literal<"advisory">;
+    readonly ruleId: Schema.String;
+    readonly severity: Schema.Literals<readonly ["error", "warning", "info"]>;
+    readonly message: Schema.String;
+    readonly displayRoot: Schema.String;
+    readonly path: Schema.String;
+    readonly subject: Schema.String;
+    readonly authority: Schema.String;
+    readonly observed: Schema.String;
+    readonly expected: Schema.String;
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly file: Schema.String;
+        readonly line: Schema.optional<Schema.Number>;
+        readonly column: Schema.optional<Schema.Number>;
+    }>>;
+}>;
+export declare const LintInputSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly view: Schema.Literal<"workspace">;
+}>, Schema.Struct<{
+    readonly view: Schema.Literal<"git-index">;
+    readonly fingerprint: Schema.String;
+}>]>;
+export type LintInput = typeof LintInputSchema.Type;
+/**
+ * JSON envelope shape returned under `axm lint --json`.
+ *
+ * Matches the registry publish failure envelope structure (`findings[]`,
+ * `displayRoot` per entry, per-finding `path` pre-composed).
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const LintJsonDocumentSchema: Schema.Struct<{
+    readonly input: Schema.Union<readonly [Schema.Struct<{
+        readonly view: Schema.Literal<"workspace">;
+    }>, Schema.Struct<{
+        readonly view: Schema.Literal<"git-index">;
+        readonly fingerprint: Schema.String;
+    }>]>;
+    readonly axmSkillCompatibility: Schema.optionalKey<Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["compatible", "incompatible"]>;
+        readonly cliVersion: Schema.NullOr<Schema.String>;
+        readonly skillVersion: Schema.NullOr<Schema.String>;
+        readonly source: Schema.NullOr<Schema.String>;
+        readonly declaredCliVersion: Schema.NullOr<Schema.String>;
+        readonly declaredCliVersionRange: Schema.NullOr<Schema.String>;
+        readonly reasonCode: Schema.NullOr<Schema.Literals<readonly ["cli-version-unavailable", "axm-skill-missing", "axm-skill-manifest-invalid", "compatibility-metadata-missing", "compatibility-metadata-malformed", "skill-release-mismatch", "skill-release-range-mismatch", "cli-version-incompatible"]>>;
+        readonly detail: Schema.NullOr<Schema.String>;
+        readonly recovery: Schema.Struct<{
+            readonly action: Schema.Literals<readonly ["none", "inspect-cli", "upgrade-cli", "update-registry-skill", "install-bundled-skill", "preserve-authored-skill"]>;
+            readonly targetCliVersion: Schema.NullOr<Schema.String>;
+            readonly targetSkillVersion: Schema.NullOr<Schema.String>;
+            readonly nextAction: Schema.NullOr<Schema.String>;
+            readonly steps: Schema.$Array<Schema.Struct<{
+                readonly boundary: Schema.Literals<readonly ["executable", "workspace", "verification"]>;
+                readonly command: Schema.String;
+                readonly preview: Schema.Boolean;
+            }>>;
+        }>;
+    }>>;
+    readonly findings: Schema.$Array<Schema.Struct<{
+        readonly group: Schema.Literals<readonly ["skill", "pack", "subagent", "mcp-server", "hook", "rule", "knowledge", "workspace"]>;
+        readonly kind: Schema.Literal<"advisory">;
+        readonly ruleId: Schema.String;
+        readonly severity: Schema.Literals<readonly ["error", "warning", "info"]>;
+        readonly message: Schema.String;
+        readonly displayRoot: Schema.String;
+        readonly path: Schema.String;
+        readonly subject: Schema.String;
+        readonly authority: Schema.String;
+        readonly observed: Schema.String;
+        readonly expected: Schema.String;
+        readonly location: Schema.optional<Schema.Struct<{
+            readonly file: Schema.String;
+            readonly line: Schema.optional<Schema.Number>;
+            readonly column: Schema.optional<Schema.Number>;
+        }>>;
+    }>>;
+    readonly summary: Schema.Struct<{
+        readonly total: Schema.Number;
+        readonly errors: Schema.Number;
+        readonly warnings: Schema.Number;
+        readonly infos: Schema.Number;
+        readonly exitCategory: Schema.Literals<readonly ["clean", "warnings", "errors"]>;
+    }>;
+    readonly driftBanner: Schema.$Array<Schema.String>;
+}>;
+/**
+ * One finding as emitted under `--json`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type LintJsonFinding = typeof LintJsonFindingSchema.Type;
+/**
+ * The `--json` document.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type LintJsonDocument = typeof LintJsonDocumentSchema.Type;
+//# sourceMappingURL=json-schema.d.ts.map

package/dist/src/json-schema.js

@@ -0,0 +1,99 @@
+/**
+ * The `axm lint --json` document, as a schema.
+ *
+ * The shape used to exist only as a hand-written interface in `cli.ts` while
+ * the CLI emitted it through `Schema.Any` — so nothing checked that what the
+ * runner built and what the renderer promised were the same document, and
+ * `--json` consumers had no schema to generate against.
+ *
+ * `LintJsonDocument` and `LintJsonFinding` are now derived from these schemas,
+ * so the emitted document and its contract cannot drift.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Schema from "effect/Schema";
+import { CATALOG_GROUP_ORDER } from "./catalog-contexts.js";
+import { AxmSkillCompatibilitySchema } from "@agentxm/extension-workspace";
+const LintJsonLocationSchema = Schema.Struct({
+    file: Schema.String,
+    line: Schema.optional(Schema.Number),
+    column: Schema.optional(Schema.Number),
+}).annotate({
+    identifier: "LintJsonLocation",
+    title: "Lint Finding Location",
+    description: "Document-relative location a finding points at.",
+});
+/**
+ * One finding as emitted under `--json`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const LintJsonFindingSchema = Schema.Struct({
+    group: Schema.Literals(CATALOG_GROUP_ORDER).annotate({
+        identifier: "LintFindingGroup",
+        title: "Lint Finding Group",
+        description: "Rule catalog the finding came from.",
+    }),
+    kind: Schema.Literal("advisory"),
+    ruleId: Schema.String,
+    severity: Schema.Literals(["error", "warning", "info"]),
+    message: Schema.String,
+    displayRoot: Schema.String,
+    path: Schema.String,
+    subject: Schema.String,
+    authority: Schema.String,
+    observed: Schema.String,
+    expected: Schema.String,
+    location: Schema.optional(LintJsonLocationSchema),
+}).annotate({
+    identifier: "LintJsonFinding",
+    title: "Lint Finding",
+    description: "A single lint finding with its rule, severity, and rendered path.",
+});
+const LintJsonSummarySchema = Schema.Struct({
+    total: Schema.Number,
+    errors: Schema.Number,
+    warnings: Schema.Number,
+    infos: Schema.Number,
+    exitCategory: Schema.Literals(["clean", "warnings", "errors"]).annotate({
+        identifier: "LintExitCategory",
+        title: "Lint Exit Category",
+        description: "Whether the run was clean, produced warnings, or produced errors.",
+    }),
+}).annotate({
+    identifier: "LintJsonSummary",
+    title: "Lint Summary",
+    description: "Finding counts by severity plus the derived exit category.",
+});
+export const LintInputSchema = Schema.Union([
+    Schema.Struct({ view: Schema.Literal("workspace") }),
+    Schema.Struct({
+        view: Schema.Literal("git-index"),
+        fingerprint: Schema.String.check(Schema.isPattern(/^sha256:[0-9a-f]{64}$/)),
+    }),
+]).annotate({
+    identifier: "LintInput",
+    title: "Lint Input",
+    description: "Filesystem identity evaluated by the lint run.",
+});
+/**
+ * JSON envelope shape returned under `axm lint --json`.
+ *
+ * Matches the registry publish failure envelope structure (`findings[]`,
+ * `displayRoot` per entry, per-finding `path` pre-composed).
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const LintJsonDocumentSchema = Schema.Struct({
+    input: LintInputSchema,
+    axmSkillCompatibility: Schema.optionalKey(AxmSkillCompatibilitySchema),
+    findings: Schema.Array(LintJsonFindingSchema),
+    summary: LintJsonSummarySchema,
+    driftBanner: Schema.Array(Schema.String),
+}).annotate({
+    identifier: "LintJsonDocument",
+    title: "Lint Document",
+    description: "Machine-readable result of an `axm lint` run.",
+});
+//# sourceMappingURL=json-schema.js.map

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

@@ -0,0 +1,23 @@
+/**
+ * Typed failures for lint-run staging and settings loading. The producer owns
+ * the category choice and user-facing wording; the application boundary
+ * converts the carried fields into its error envelope verbatim.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Schema from "effect/Schema";
+declare const LintStagingFailed_base: Schema.Class<LintStagingFailed, Schema.TaggedStruct<"LintStagingFailed", {
+    readonly category: Schema.Literals<readonly ["validation", "internal"]>;
+    readonly title: Schema.optional<Schema.String>;
+    readonly detail: Schema.String;
+    readonly cause: Schema.optional<Schema.Unknown>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A lint input-staging step (such as materializing the Git index snapshot)
+ * could not proceed. `category`, `title`, and `detail` carry the boundary
+ * rendering 1:1.
+ */
+export declare class LintStagingFailed extends LintStagingFailed_base {
+}
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/src/run/errors.js

@@ -0,0 +1,21 @@
+/**
+ * Typed failures for lint-run staging and settings loading. The producer owns
+ * the category choice and user-facing wording; the application boundary
+ * converts the carried fields into its error envelope verbatim.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Schema from "effect/Schema";
+/**
+ * A lint input-staging step (such as materializing the Git index snapshot)
+ * could not proceed. `category`, `title`, and `detail` carry the boundary
+ * rendering 1:1.
+ */
+export class LintStagingFailed extends Schema.TaggedError()("LintStagingFailed", {
+    category: Schema.Literals(["validation", "internal"]),
+    title: Schema.optional(Schema.String),
+    detail: Schema.String,
+    cause: Schema.optional(Schema.Unknown),
+}) {
+}
+//# sourceMappingURL=errors.js.map

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

@@ -0,0 +1,63 @@
+/**
+ * Lint-run policy over workspace settings and roots: where a lint run is
+ * anchored, which configured rule overrides apply, which repairs are already
+ * determined by authoritative local state, and how staged-snapshot paths map
+ * back to the workspace the user named. The CLI keeps argument parsing,
+ * rendering, and exit mapping.
+ *
+ * @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 type { LintConfig } from "@agentxm/registry-protocol/unstable/lint/config";
+import { type Settings } from "@agentxm/workspace-state";
+import { type WorkspaceScope } from "@agentxm/extension-model/unstable/workspace-scope";
+import type { LintSummary } from "../cli.js";
+export type PathRemapper = Pick<Path.Path, "isAbsolute" | "join" | "relative">;
+/** Replace temporary staged-snapshot roots without changing lint semantics. */
+export declare const remapLintSummaryPaths: (summary: LintSummary, sourceRoot: string, displayRoot: string, path: PathRemapper) => LintSummary;
+/**
+ * Resolve the workspace root for a lint run.
+ *
+ * - `--scope=project` (default): use the optional `<path>` argument if
+ *   provided, otherwise the caller-supplied `cwd`.
+ * - `--scope=user`: use the resolved user home; the read model locates its
+ *   `.axm/workspace/` workspace. Ignores `<path>`.
+ *
+ * XDG layout: v1 honors `AXM_USER_HOME` as an override; full
+ * `XDG_DATA_HOME`/`XDG_CONFIG_HOME` integration is deferred to a follow-up
+ * (see design doc §10 Open Items #10).
+ */
+export declare const resolveLintRoot: (args: {
+    readonly pathArg: Option.Option<string>;
+    readonly scope: WorkspaceScope;
+    readonly cwd: string;
+    readonly userHome: string;
+}) => string;
+/**
+ * Decode the authoritative settings document. Returns `None` when the file is missing, empty,
+ * or unparseable, so lint still runs — the relevant
+ * `workspace/settings-schema-valid` rule produces the user-facing finding for a
+ * bad settings file. Callers derive `lint.rules` and the `--fix` inputs from
+ * the one decode.
+ */
+export declare const loadSettingsDocument: (workspaceRoot: string, scope: WorkspaceScope) => Effect.Effect<Option.Option<Settings>, never, FileSystem.FileSystem | Path.Path>;
+export declare const lintConfigFromSettings: (settings: Option.Option<Settings>) => LintConfig;
+/**
+ * Apply the repairs whose desired state is already determined by authoritative
+ * local state. Instruction targets are content-derived from their canonical
+ * source, so regenerating them expresses no preference.
+ *
+ * This delegates to the same reconciliation `axm sync` performs rather than
+ * defining a second desired state. A workspace that has not enabled
+ * instruction-file management has nothing determined to restore, so `--fix`
+ * leaves it untouched.
+ */
+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>;
+//# sourceMappingURL=settings.d.ts.map

package/dist/src/run/settings.js

@@ -0,0 +1,139 @@
+/**
+ * Lint-run policy over workspace settings and roots: where a lint run is
+ * anchored, which configured rule overrides apply, which repairs are already
+ * determined by authoritative local state, and how staged-snapshot paths map
+ * back to the workspace the user named. The CLI keeps argument parsing,
+ * rendering, and exit mapping.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Data from "effect/Data";
+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 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 { 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) => {
+    if (!path.isAbsolute(value))
+        return value;
+    const relative = path.relative(sourceRoot, value);
+    if (relative.startsWith("..") || path.isAbsolute(relative))
+        return value;
+    return relative === "" ? displayRoot : path.join(displayRoot, relative);
+};
+/** Replace temporary staged-snapshot roots without changing lint semantics. */
+export const remapLintSummaryPaths = (summary, sourceRoot, displayRoot, path) => ({
+    ...summary,
+    findings: summary.findings.map((entry) => {
+        const remappedDisplayRoot = remapAbsolutePath(entry.displayRoot, sourceRoot, displayRoot, path);
+        const location = entry.finding.location;
+        const remappedLocation = location === undefined
+            ? undefined
+            : {
+                ...location,
+                file: remapAbsolutePath(location.file, sourceRoot, displayRoot, path),
+            };
+        return {
+            ...entry,
+            displayRoot: remappedDisplayRoot,
+            path: composePath(remappedDisplayRoot, remappedLocation),
+            finding: remappedLocation === undefined
+                ? entry.finding
+                : { ...entry.finding, location: remappedLocation },
+        };
+    }),
+});
+/**
+ * Resolve the workspace root for a lint run.
+ *
+ * - `--scope=project` (default): use the optional `<path>` argument if
+ *   provided, otherwise the caller-supplied `cwd`.
+ * - `--scope=user`: use the resolved user home; the read model locates its
+ *   `.axm/workspace/` workspace. Ignores `<path>`.
+ *
+ * XDG layout: v1 honors `AXM_USER_HOME` as an override; full
+ * `XDG_DATA_HOME`/`XDG_CONFIG_HOME` integration is deferred to a follow-up
+ * (see design doc §10 Open Items #10).
+ */
+export const resolveLintRoot = (args) => {
+    if (args.scope === "user") {
+        return args.userHome;
+    }
+    return Option.match(args.pathArg, {
+        onNone: () => args.cwd,
+        onSome: (p) => p,
+    });
+};
+const decodeSettings = (input) => {
+    const result = Schema.decodeUnknownResult(SettingsSchema)(input, {
+        onExcessProperty: "ignore",
+        errors: "all",
+    });
+    return Result.isSuccess(result) ? Option.some(result.success) : Option.none();
+};
+class SettingsUnreadable extends Data.TaggedError("SettingsUnreadable") {
+}
+/**
+ * Decode the authoritative settings document. Returns `None` when the file is missing, empty,
+ * or unparseable, so lint still runs — the relevant
+ * `workspace/settings-schema-valid` rule produces the user-facing finding for a
+ * bad settings file. Callers derive `lint.rules` and the `--fix` inputs from
+ * the one decode.
+ */
+export const loadSettingsDocument = (workspaceRoot, scope) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const settingsPath = scope === "user"
+        ? path.join(workspaceRoot, AXM_DIR_NAME, USER_WORKSPACE_DIRECTORY, "axm.json")
+        : path.join(workspaceRoot, "axm.json");
+    const exists = yield* fs.exists(settingsPath).pipe(Effect.catch(() => Effect.succeed(false)));
+    if (!exists) {
+        return Option.none();
+    }
+    const raw = yield* fs.readFileString(settingsPath).pipe(Effect.catch(() => Effect.succeed("")));
+    if (raw.length === 0) {
+        return Option.none();
+    }
+    const parsed = Effect.try({
+        try: () => JSON.parse(raw),
+        catch: () => new SettingsUnreadable(),
+    });
+    const parsedOpt = yield* parsed.pipe(Effect.map(Option.some), Effect.catch(() => Effect.succeed(Option.none())));
+    if (Option.isNone(parsedOpt)) {
+        return Option.none();
+    }
+    return decodeSettings(parsedOpt.value);
+});
+export const lintConfigFromSettings = (settings) => Option.match(settings, {
+    onNone: () => ({}),
+    onSome: (s) => s.lint ?? {},
+});
+/**
+ * Apply the repairs whose desired state is already determined by authoritative
+ * local state. Instruction targets are content-derived from their canonical
+ * source, so regenerating them expresses no preference.
+ *
+ * This delegates to the same reconciliation `axm sync` performs rather than
+ * defining a second desired state. A workspace that has not enabled
+ * instruction-file management has nothing determined to restore, so `--fix`
+ * leaves it untouched.
+ */
+export const applyDeterminedRepairs = (args) => Effect.gen(function* () {
+    if (Option.isNone(args.settings))
+        return;
+    const instructionFiles = args.settings.value.instructionFiles;
+    if (instructionFiles === undefined || instructionFiles === false)
+        return;
+    yield* reconcileInstructionTargets({
+        workspaceRoot: args.workspaceRoot,
+        scope: args.scope,
+        configuredAgents: args.settings.value.agents ?? [],
+        config: resolveInstructionsConfig(instructionFiles),
+    });
+});
+//# sourceMappingURL=settings.js.map

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

@@ -0,0 +1,31 @@
+/**
+ * Materialize the repository index as an isolated, read-only lint workspace.
+ *
+ * Git checkout commands apply working-tree filters and line-ending conversion,
+ * so they cannot represent the index byte-for-byte. This module enumerates
+ * stage-0 entries, reads every unique blob through one `git cat-file --batch`
+ * process, and recreates the indexed modes in a scoped temporary directory.
+ */
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import { LintStagingFailed } from "./errors.js";
+export interface StagedWorkspace {
+    readonly gitRoot: string;
+    readonly snapshotRoot: string;
+    readonly workspaceRoot: string;
+    readonly displayWorkspaceRoot: string;
+    readonly fingerprint: string;
+}
+/** Remove repository-local variables inherited from Git hook processes. */
+export declare const isolatedGitEnvironment: () => Record<string, string>;
+export declare const materializeGitIndexWorkspace: (startPath: string, options?: {
+    readonly selectRepositoryRoot?: boolean;
+} | undefined) => Effect.Effect<{
+    gitRoot: string;
+    snapshotRoot: string;
+    workspaceRoot: string;
+    displayWorkspaceRoot: string;
+    fingerprint: string;
+}, LintStagingFailed, FileSystem.FileSystem | Path.Path | import("effect/Scope").Scope | import("effect/unstable/process/ChildProcessSpawner").ChildProcessSpawner>;
+//# sourceMappingURL=staged-workspace.d.ts.map